场景引入
项目中我们可能会用到某个包含了多个对象的集合数组，这时候我们想要更新替换数组中某一个对象的值，举个例子我们可能会这么做：
假如我们有两个数组 list1 和 list2 ：
let list1=[
{id:1,name:'张三'},
{id:2,name:'李四'},
{id:3,name:'小刘'},
]
let list2=[
{id:2,name:'小红'},
{id:3,name:'王麻子'}
]
我们用对两个数组进forEach对比属性id，尝试更新list1的值：
list1.forEach((item1,index1)=>{
list2.forEach((item2,index2)=>{
if(item1.id==item2.id){
item1=item2
}
})
})
console.log('list1',list1)
我们期望得到的结果（希望list1可以根据list2的数据进行替换更新）：
list1 [ { id: 1, name: '张三' }, { id: 2, name: '小红' }, { id: 3, name: '王麻子' } ]
但实际得到的结果（数组并无任何变化）：
list1 [ { id: 1, name: '张三' }, { id: 2, name: '李四' }, { id: 3, name: '小刘' } ]
这就奇怪了，item1=item2为什么不会改变list1数组的值呢。。。？
换一种写法：
list1.forEach((item1,index1)=>{
list2.forEach((item2,index2)=>{
if(item1.id==item2.id){
list1[index1]=item2
}
})
})
console.log('list1',list1)
// 打印结果 ： list1 [ { id: 1, name: '张三' }, { id: 2, name: '小红' }, { id: 3, name: '王麻子' } ]
神奇的发现 list1[index1]=item2这样才能使list1数组改变。。。
再来一个神奇的例子：
var valueArr = "aaa ,bbb ,ccc".split(',');
valueArr.forEach(function (el) {
el = el.trim();
.......
});
实际上元素的空格并没有去掉，如果用户输入的值中有空格，那就呵呵哒了
灵异事件？？？
别急，听我慢慢道来。。这个东西曾经也困扰了我挺久。。
首先要清楚的是，什么是按值传递？什么又是按引用传递？
按值传递（call by value）（传内存拷贝）：
方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。
按引用传递（call by refrence）（传内存指针）：
也称为传地址。方法调用时，实际参数是对象(或数组)，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数。
两种传递方式都有各自的问题：按值传递由于每次都需要克隆副本，对一些复杂类型，性能较低；按引用传递会使函数调用的追踪更加困难，有时也会引起一些微妙的BUG。
基本类型按值传递
基本类型包括：Undefined，Null，Boolean，Number、String
下面直接看例子：
var a = 1;
function foo(val) {
val = 2;
}
foo(a);
console.log(a); // 输出结果为：1
分析以上代码，a是基本类型，存储在栈中，函数foo的的形参只是变量a的拷贝，调用函数时会在栈中新建一个变量val，并将变量a的值赋值给变量val，但是变量val和变量a并无关联，所以对变量val的修改操作并不会影响到变量a。
引用类型传递方式
引用类型包括：Object，Array，Date，RegExp，Function，......
我们先看下面的代码：
var person = {name:'MJ'};
function foo(obj) {
obj.name = 'EP';
}
foo(person);
console.log(person.name); // 输出结果为：EP
对象person被修改了！这说明obj跟person指向的是同一个对象，可以肯定不是按值传递的了，那么就是引用传递了吗？从这个例子来看确实很像，我们再对上面的例子做下修改，如下：
var person = {name: "MJ"};
function foo(obj) {
obj = new Object(); // 修改部分
obj.name = "EP";
}
foo(person);
console.log(person.name); // 输出结果为：MJ
var person = {name: "MJ"};
function foo(obj) {
obj = {name: "EP"}; // 修改部分
}
foo(person);
console.log(person.name); // 输出结果为：MJ
两种方式输出结果都是是MJ，也就是说person对象并未被修改，如此可以确定，js的引用类型也不是按引用传递。既不是按值传递，又不是按引用传递，那是按什么传递呢？
按共享传递（call by sharing）：
准确的说，JS中的基本类型按值传递，引用类型按共享传递(call by sharing，也叫按对象传递、按对象共享传递)。最早由Barbara Liskov. 在1974年的GLU语言中提出。该求值策略被用于Python、Java、Ruby、JS等多种语言。
该策略的重点是：调用函数传参时，函数接受对象实参引用的副本(既不是按值传递的对象副本，也不是按引用传递的隐式引用)。 它和按引用传递的不同在于：在共享传递中对函数形参的赋值，不会影响实参的值。
接下来我们分析下上面的代码，为什么person没有被修改？
我们都知道对象保存在堆中，person持有堆中对象的引用，在调用foo函数时，函数接收的实际是person持有的对象（下面称之为原对象）引用的副本，这样obj和person都指向了同一个地方（也就是原对象在堆中存放的地址），而函数中的obj = new Object()和obj = {name: "EP"} 操作其实都是在堆中创建了一个新对象，并让obj持有该对象的引用，这样obj与原对象之间的关系就断开了，转而与新对象建立了关系，所以对obj的修改并不会影响到原对象。
总结：
在JS中，基本类型按值传递，引用类型按共享传递
最后稍微理解下堆和栈的概念
了解到这里，也就不难解释最前面文章开头两个神奇例子：
【先来说说一个例子】
item1=Item2为什么不可以，list1[index1]=item2可以。。。
因为Item1是个形参对象，属于引用类型中的Object，所以按共享传递。
原本形参item1和实参list1[index1]的值他们都指向了list1内部的同一个堆中的内存地址，但表达式 item1=Item2 等价于类似item1= {id:2,name:'小红'} 这样的表达式，相当于 item1= new Object()重新声明了一个新的对象，在堆中创建了一个新对象，在内存里新开辟一片空间，这样item1就把内存地址重新指向到了新创建的内存地址，并拷贝了一份item2的值到新创建的内存地址，这样item1与原对象list1[index1]之间的关系就断开了，转而与新对象建立了关系，所以对item1的修改并不会影响到list1中的原对象。但是如果直接对list1[index1]=item2进行操作，由于list1[index1]是实参对象，赋值的时候不会在像item1形参对象那样再去创建新的内存空间，指向还是原来list1的地址，因此list1中的原对象会被修改。
item1和list1[index1]原本的地址内存关系：
item1=Item2后的地址内存关系：
【再说说第二个例子】
el = el.trim();因为el是形参字符串，属于基本类型中的String，所以按值传递。
形参变量el只是实参变量valueArr的拷贝，调用函数时会在栈中新建一个形参变量el，并将实参变量valueArr的值赋值给形参变量el，所以变量valueArr和变量el并无关联，所以对形参变量el的修改操作并不会影响到实参变量valueArr。
总而言之，
函数内的el是一份新的内存，与调用函数之前定义的变量毫无关系。函数内无论怎么修改这个参数，外部定义的valueArr的值始终不变
参考文献：
https://www.jianshu.com/p/fefa1e2288f8
https://blog.csdn.net/wopelo/article/details/71517489
https://blog.csdn.net/u010014880/article/details/80260119
https://www.cnblogs.com/lmjZone/p/7977844.html
https://www.cnblogs.com/fundebug/p/10727895.html
