对象

• 复杂数据类型会将数据本体存在堆内存中，变量名存储在堆内存中，变量名内部存储着指向堆内存的地址

     var obj={
            a:1,
            b:2,
            c:3,
            d:4,
            e:5,
            f:6,
            g:7,
            h:8
           }
  
        console.log(obj)
        console.log(obj.a);
        console.log(obj.h);
  
        obj.a=10;
        obj.h=100;
        
        
       // 当获取obj时，就会根据这个变量存储的引用地址，
       在堆中查找到地址所对应的对象，并且调用该对象的结果
       
       将obj中引用地址赋值给了o1这个变量
       这种情况会将对象共有给o1，也就是说o1和obj共有一个对象，
       当修改任何变量所对应的属性值时，相当于直接修改了该对象
       相对的变量获取的这个对象也是改变的
         var o1=obj;
         o1.b=100;
         console.log(obj.b);
         
         
  

对象引用地址的运用

 例子1
    var o1={a:1,b:2};
    var o2=o1;

    重新设置了o1的新的引用地址，不会改变o2的引用地址
    o1={c:3,d:4};
    console.log(o2);// {a: 1, b: 2} 
    
    
  例子2   
     var o1={a:1};
     var o2=o1;

     o2.a=10;
     console.log(o1.a);//10  因为o1和o2是同一个引用地址，
                             改变o2的属性打印o1时，就会得到同样改变后的属性值
   例子3                              
     var o1={a:1};
     var o2=o1;

     o1={b:2}; //重新设值改变地址
     console.log(o1.a);//undefined   
     console.log(o2.a);//1 没有改变
     console.log(o2.b);//undefined
     
   例子4 
    修改了o1.b的属性，给b设置为一个对象，o2也就会有b这个属性
    var o1={a:1};
    var o2=o1;
    o1.b={a:3};

    console.log(o2);//{a:1,b:{a:3}}
    
   例子5
    var o1={a:1};
    var o2=o1;
    o1=o1.b={b:10};                   //同时赋值  一个是给o1的引用地址下面的b属性赋值，
                                       一个是给o1这个变量重新赋值一个新地址
    console.log(o2,o1);
    o2 {a:1,b:{b:10}} // 旧地止里面的一个属性改了。
    o1 {b:10} //新地址

内存泄漏

    var o={a:1};
    o={a:10}; //重新设个引用地址

    {a:1} 这个对象仍然会在堆中继续存在 流浪的孤儿 孤儿对象
    当产生大量孤儿对象，而且还在实时的生成新的孤儿对象。而这些孤儿对象没有得到释放，就叫做内存泄漏


    var o={a:1};
    o=null;
    o={a:2};

    系统中有一个垃圾回收机制 
    当给o设置为null，堆中的这个对象认为自身的引用关系被瓦解了，没有别的变量引用自己，垃圾回收车过去的时候就会回收
    null主要用于接触对象的引用关系


    var o={a:1};
    var o1=o;

    o=null;
    o={a:10};
    因为o1还在引用这个{a:1}的引用地址，所以不会因为o设置为null，被回收
    如果想要回收必须将两个变量都设置为null