//实例对象继承

//对象继承
 var Chinese = {
     nation: '中国人'
 };

 function object(obj) {
     function F() {}
     F.prototype = obj;
     return new F();
 }

 var Doctor = object(Chinese);
 Doctor.carree = '医生';  //增加私有属性
 console.log(Doctor);
 console.log(Doctor.nation);  // '中国人'
 console.log(Doctor.carree); // '医生'

Doctor.__proto__ === Chinese;   // true   Doctor的原型正是指向了Chinese对象

对象的浅拷贝(引用数据类型存的地址一样，执行同一个内存地址)

 function extendCopy(obj) {
    var o  = {};
    if (typeof obj === 'object') {
         for  (var key in obj) {
              o[key] = obj[key];
          }
    }
     return o;
 }


var obj1 = {
    name: 'clh',
    age: 23,
    like: ['js','css']
};

var obj2 = extendCopy(obj1);
console.log(obj1);  // name: 'clh', age:23 like: ['js', 'css']
console.log(obj2); // name: 'clh', age:23 like: ['js', 'css']

obj2.like.push('常连海');
console.log(obj1.like); // name: 'clh', age:23 like: ['js', 'css','常连海']
console.log(obj1.like === obj2.like);  //true 他们俩个指向的内存地址一样，一个改变，另一个也会发生相应的改变

特点:  
 直接进行拷贝，对于基本数据类型可以，但是对于引用数据类型(object,function),只是把地址给引用过去了，当改变一个会，另一个随之改变，不好，所以之后出来了深拷贝

对 象的深拷贝(引用数据类型存的地址不一样，互不影响)

function deelCopy(p, c) {   //p-->>要拷贝的对象, c-->>类型, 是数组，还是对象，数组的话开始传入[], 对象的话传入{}
   c =  c || {};
   if (typeof p === 'object') {
       for (var key in p) {
          if (typeof p[key] === 'object') {
                c[key] = p[key].constructor ===  Array ? []: {};
                 deelCopy(p[key], c[key]);
           } else {
                c[key] = p[key];
             }
       }
   }
 return c;
 }
var ary1 = [
    {name: 'clh', age: 23},
    {name: 'wd', age: 25}
];
var obj1  = {
     name: 'clh',
     age: 23,
     like: [1, 2, 3, 4, 5, 6]
};

var ary2 = deelCopy(ary1, []);
cosole.log(ary2);
ary2[0] === ary1[0]; // false 内存地址不一样

ary2.push({name: '王东' ,age: 34});
console.log(ary1);

var obj2 = deelCopy(obj1, {});
console.log(obj2);
 console.log(obj1.like === obj2.like); //false 内存地址不一样
obj2.like = 'book_js';
console.log(obj1);  //里面的like没有发生改变

在我们做项目的时候，经常会存储数据，这时候就用到了对象的深拷贝