基本类型和引用类型

• 基本类型值（数值、布尔、字符串、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
}