深度克隆
    深层克隆可以保证当源数据发生改动时，克隆后的数据不会根据源数据的改动发生改动

    1.         // 遍历对象 for(var prop in obj)
    2.         // 1.判断是不是原始值 typeof() object
    3.         // 2.判断是数组还是对象 instanceof toString constructor
    4.         // 3.建立相应的数组与对象
    5.         // 递归
    6.         function deepClong(orgin, target) {
    7.             var target = target || {};
    8.             var toStr = Object.prototype.toString,
    9.                 arrStr = "[object Array]";
    10.             for (var prop in orgin) {
    11.                 //判断是否为原型链上的
    12.                 if (orgin.hasOwnProperty(prop)) {
    13.                     // 判断是否为null 且 是否为对象
    14.                     if (orgin[prop] !== null && typeof(orgin[prop]) == 'object') {
    15.                         target[prop] = toStr.call(orgin[prop]) == arrStr ? [] : {};
    16.                         deepClong(orgin[prop], target[prop]); //递归
    18.                     } else {
    19.                         target[prop] = orgin[prop]; //递归出口
    20.                     }
    21.                 }
    22.             }
    23.             return target;
    24.         }

    袁老师的克隆

    1.         function objClone  (obj,deep){
    2.             if(Array.isArray(obj)){
    3.                 if(deep){
    4.                     var newArr = [];
    5.                     for(var i = 0 ; i < obj.length ; i++){
    6.                         newArr.push(objClone(obj[i],deep))
    7.                     }
    8.                     return newArr
    9.                 }else{
    10.                     return obj.slice()
    11.                 }
    12.                 return newArr;
    13.             }else if( typeof obj  === 'object'){
    14.                 var newObj = {};
    15.                 for(var prop in obj){
    16.                     if(deep){
    17.                         newObj[prop] = objClone(obj[prop],deep)
    18.                     }else{
    19.                         newObj[prop] =obj[prop];
    20.                     }
    21.                 }
    22.                 return newObj;
    23.             }else{
    24.                 return obj
    25.             }
    26.         }

    纯函数
    纯函数不依赖，修改器作用域之外的变量的函数

    1.         function add(num1,num2){
    2.             return num1 + num2;
    3.         }
    4.                 这就是最简易的纯函数

    不是纯函数就像克隆中，源数据改动，其函数内的也跟着改动