var a = 1
var b = a
b++
console.log(a) //1
console.log(b) //2
字符串类型
var q = 'copy'
var s = q
s += '1'
console.log(q)//copy
console.log(s)//copy1
布尔类型
var e = false
var w = e
w = true
console.log(e) //false
console.log(w) //true
数组
splice 截取 会改变原数组
//地址的引用 浅拷贝
var array = [1,2,3,4,5]
var newArray = array
var thArray = newArray.splice(1,3)
console.log(thArray) //[2,3,4]
console.log(newArray) //[1,5]
console.log(array) //[1,5]
//循环到原始类型进行深拷贝
var arr = ['a','b','c','d','e']
var newArr = []
for(var i=0i<arr.lengthi++){
newArr.push(arr[i])
}
var thArr = newArr.splice(1,3)
console.log(thArr) //["b", "c", "d"]
console.log(newArr) //["a", "e"]
console.log(arr) //["a", "b", "c", "d", "e"]
对象
//地址的引用 浅拷贝
var obj = {name:'abc',id:'1'}
var newObj = obj
newObj.name='abcde'
console.log(obj) //{name:'abcde',id:'1'}
console.log(obj) //{name:'abcde',id:'1'}
//循环到原始类型进行深拷贝
var object = {name:'321',id:'1'}
var newObject= {}
for (var j in object){
newObject[j]=object[j]
}
newObject.name='abcde'
console.log(newObject) //{name:'abcde',id:'1'}
console.log(object) //{name:'321',id:'1'}
数字 字符串 布尔类型 为原始类型，是值引用
数组 对象类型 为地址引用
值引用为深拷贝
地址引用循环到原始类型可进行深拷贝
var nameArray = ['张三','李四']
var descArray = ['张三是男生','李四也是男生']
var allArray = []
var tableObj={}
for(let i=0i<nameArray.lengthi++){
tableObj.name=nameArray[i]
tableObj.desc=descArray[i]
allArray.push(tableObj)
}
console.log(allArray) //{name: "李四", desc: "李四也是男生"}
//{name: "李四", desc: "李四也是男生"}
var nameArray = ['张三','李四']
var descArray = ['张三是男生','李四也是男生']
var allArray = []
for(let i=0i<nameArray.lengthi++){
var tableObj={}
tableObj.name=nameArray[i]
tableObj.desc=descArray[i]
allArray.push(tableObj)
}
console.log(allArray) //{name: "张三", desc: "张三是男生"}
//{name: "李四", desc: "李四也是男生"}
第一个函数的输出应该是 张三 李四，第二个函数的输出应该是两个李四
第一个函数很容易理解：构造函数生成了一个共有属性name，然后new了2个新函数，分别定义了自己的name，输出当然是自己的name值；
第二个函数设计到一个引用。
你先看下这个例子：
var a=1var b=a
a=2
console.log(b) //1
//当a的引用是在本地的时候b等于a，a改变自己的value，b不发生改变。
var a={name:999}
var b=a
a.name = 1000
console.log(b.name) //1000
//当a的引用是一个对象时，引用并不是在本地，其实a指向的是一个内存地址，
//b=a表示，b也和a一样指向了这个内存地址。
//a.name 当a改变所指向的内存地址的值时，同时也影响到了b的值，所以b输出1000 而不是输出999
回头看你的第二个函数
构造函数Fun拥有一个共有属性info，info中有2个键值队，当你new了新函数后，用a.info其实是改变了info的引用对象，
同样b.info第二次改变了info的引用对象，因为a，b指向同一个内存地址 所以每次改变都会导致2个变量的值同时发生变更，于是输出了2个李四
是不一样的，可以这么说，同一个构造函数，无论在哪儿实例化对象，在内存中的地址是不一样的，没实例化一次，就会对应新的内存地址。你可以在构造函数中，声明一个随机数变量：如var suiji = Math.random() 然后实例化对象，输出这个变量，那肯定不是一样的，说明不是一块内存地址。
