- 基本类型值（数值、布尔、字符串、null和undefined ）：保存在栈内存中的简单数据段。栈的特性就是里面的东西可以放进去拿出来。
var a = 1 //先声明a，声明的意义就是逻辑上在内存里开辟一个栈区块，身份是a，赋值a=1就是这个栈开始占用实体内存了，写入了代表1的编码。
如果栈内存里的数据很大很多，或者后续有新改动，会影响到其他栈内存的，而且数据大的变量为了操作方便，科学，才有了引用类型一说。
- 引用类型（对象、数组、函数、正则）：指保存在堆内存中的对象，变量中保存的实际上只是一个指针，这个指针执行内存中的另一个位置，由该位置保存对象。
这句话意思有点别扭，分析清楚就行了——
引用类型变量想要呈现，表达，达到的目的是：堆内存中的内容，而不是这个变量自己声明后内存里自身的内容。
变量自身的内容是指向堆内存的指标，类似于a链接，相当于一个通道。
不过跟console.log有些类似了，不光指向目标堆内存，还会运行。在逻辑上，变量自身内容是通过它实体内容——指标指向的堆内存的内容，这就是引用的真谛了。
我想要的是引用的内容，变量本身是个传送门。
var a
var b
var obj
var obj2
a =1
b = 2
var obj = {
name : "ruoyu",
sex :'male',
age : 30,
friend: {
name : 'hello',
age : 100
}
}
var newObj = { }
b = a //原本a栈内存1，b栈内存2，这个操作就是把a栈存的东西覆盖到b栈里。
console.log(b) //输出1
var obj2 = obj //obj2只是声明了，本身只有object的属性，没有内容的，这时候把obj的值赋过来，也就是把obj的实体内容——那个指标给复制了过来。但是，这时候要明白，obj占了一个独有的栈内存，obj2也占了一个独有的，虽然栈里面的内容都相同，但不要混淆了。
这时候进行如下操作——
obj.name="jirengu" //输出jirengu
再查看obj2
obj2 // name的属性也变成jirengu了。一个堆内存的数据共享于所有指向它的变量，变化都是同步的。
对比而言，栈内存是相互独立的，比如刚才b=a了，我再操作——
a =3
b //输出还是1，互相独立。
再看下一个例子：
var obj3 = {name :"hello"} //声明，然后开辟一个堆内存，内容是，，，，，，然后指向这个堆内存。
var obj4 = { name:'hello'} //声明，然后开辟一个堆内存，内容是，，，，，，然后指向这个堆内存。
obj3 === obj4 //判断完全等于，类型一样，堆内容展示的也一样哦，貌似相等。但是两者的栈内存的指标内容是不一样的，也就是说，指向的堆内存不是同一个，跟上一个例子是互补的。判断的标准就是它们的数据类型和栈内存的内容。
这里的意思就是，只要声明一个引用对象，并赋予实体内容，那这个时候，就会开辟一块堆内存，并生成一个新的指标。
再来一个题——
function sum() {
console.log('sum...')
} //声明sum,声明一个函数，并创建它的堆内存，并把指标给sum的栈内存。
var sum2 = sum //声明sum2，并在它的栈内存中输入sum的栈内存内容。
sum2( ) // 声明函数sum2(),首先会立即执行sum2本身，这个可以立刻执行的函数，前面讲过了。输出sum...
基本类型就是：一个堆内存跟几个变量产生关系的情况；
不同的变量跟不同的堆内存产生关系的情况。
函数的参数传递——
function inc(n){
n++
} //声明inc,并创建函数的堆内存和指标
var a = 10 // 声明a，栈内存代表10的码
inc(a) //执行函数，函数内部没有a,向函数上层找，找到了a=10,然后运行函数，这时候要明白了，a在这里的作用是什么？是赋值给n,函数的自变量是n,运行的参与者是n。n自增得11,11是inc(a)的值。而a，全局下a=10。
console.log(a) // 输出10
这里的意思就是函数参数的传递，从函数外部传入到内部的话，外部的参数仅仅是赋予了一个值，不会受函数执行而影响自身的。
function incObj(obj){
obj.n++
} //这时候，函数内所有的obj值都是指向{n : 10}这个堆 。运行是在堆内存的数据上操作的，所以堆结果已经变了，11。
var o ={n : 10} //找到o了，这时候要明白函数的obj是个临时变量，它也有栈内存，这时候就是把o的栈的内容复制过来，这时候obj就指向{n : 10}了。
incObj(o) //赋值obj=o，找o,函数内没有，往上层
console.log(o) //o本身指标是不变的，还是指向那个堆地址，但是堆的数据变化了，所以输出变成了11。
function squireArr(arr){
for(var i =0; i< arr.length; i++){
arr[i] = arr[i] * arr[i]
}
} //与上一个同样的原理，在指向的数组数据上操作，最终数组本身也会变化。
var arr = [2,1,3,6] //把临时变量arr指向 [2,1,3,6]
squireArr(arr)
console.log(arr) //[4,1,9,36]
下面这个就不一样了：
function squireArr2(arr) {
var newArr = [ ]
for(var i =0; i< arr.length; i++){
newArr[i] = arr[i] * arr[i]
} //通过调用arr数组的值，也是在arr数组的数据上执行的，但是执行的结果是newArr[i] 而不是arr[i]，也就是说执行不改变arr数组。
return newArr //创建了一个新数组，返回的结果也是这个新数组。
}
var arr2 =squireArr2( arr)
console.log(arr2)
squireArr2( arr)
对象的拷贝——
赋值只能让类型，展示内容还有指标相同，在逻辑运行上，赋值的双方还是共用一个堆内存，而且一个变量运行改变了堆内存数据，另一个变量也会受到影响的，想要的结果是什么？相当于克隆，所有的内涵都一样，但是就是互相独立存在的个体。
浅拷贝：
function shallowCopy(oldobj){
var newObj ={ } //声明新的
for(var i in oldObj) { //for里的条件就是便利oldObj的每一个属性
if(oldObj.hasOwnProperty(i)){
newObj[i] = oldObj [i]
} //只要oldObj的堆内存的数据是自己独有的就把值赋予给 newObj的对应的参数，这只能把一些基本类型数值赋予过去，对于其中的引用类型数据，只能赋值到一个指向标，所以只能共用同一个出处的堆数据，而不是自己独有的。所以是浅拷贝。
}
return newObj
}
深拷贝：
function deepCopy(oldObj){
var newObj = { }
for(var key in oldObj){ //同样是先遍历所有属性
if(typyof oldObj[key] === 'object') {
newObj[key] = deepCopy(oldObj[key]) //针对引用类型做了递归处理
}else {
newObj[key] = oldObj[key] //直接赋值
}
}
return newObj
}
