10.arguments，克隆，三目运算符，数组，类数组

                     /*arguments，克隆，三目运算符，数组，类数组*/
                               /*arguments，克隆*/
//克隆 [04:14 --> 26:25]

// var obj = {

//     name : "aaa",
//     age : 12,
//     card : ['visa', 'master'],
//     wife : {
//         name : "bbb",
//         son : {
//             name : "ccc"
//         }
//     }
// }

// var obj1 = {
//     name : obj.name,
//     age : 12,
//     card : [obj.card[0],obj.card[1]],
//     wife : {
//         name : "bbb",
//         son : {
//             name : "ccc"
//         }
//     }
// }

/*
遍历对象 for(var prop in obj)
1.判断是不是原始值   typeof() object  
2.判断是数组还是对象  toString
3.建立相应的对象或者数组
递归


*/

// function deepClone(origin, target) {
    
//     var target = target || {},
//     toStr = Object.prototype.toString,
//     arrStr = "[object Array]";

//     for (var prop in origin) {
//         if (origin.hasOwnProperty(prop)) {

//             if (origin[prop] !== "null" && typeof(origin[prop]) == 'object') {
                
                // if (toStr.call(origin[prop] == arrStr)) {
                //     target[prop] = [];
                // }else{
                //     target[prop] = {};
                // }

//                 target[prop] = toStr.call(origin[prop]) == arrStr ? [] : {}; //三目运算符

//                 deepClone(origin[prop],target[prop]);
//             }else{
//                 target[prop] = origin[prop];
//             }                
//         }           
//     }
//     return target;
// }       


                     /*三目运算符*/
// 条件判断？是 : 否 并且会返回值
// var num = 1 > 0 ? 2 + 2 : 1 + 1;

                    //数组
/*
数组的定义
    new Array(lenth/content)
字面量
    var arr = [];  //数组字面量
    var arr = new Array();

数组的读和写  
    arr[num]  //不可以溢出读
    arr[num] = xxx; //可以溢出写      
*/

/*
数组常用的方法
    改变原数组
    push : 在数组的最后一位添加数据,
    pop : 会把数组最后一位剪切出来,pop只可以剪切一位,
    shift : 在数组前面删除数据,
    unshift : 在数组的前面添加数据,
    sort : 给数组里的数排序, [40:00 -->59:00]   
    var arr = [1, 2, 3, 4, 7, 20]; [43:00 --> 45:00]
    1.必须写两个形参
    2.看返回值 1)当返回值为负数时，那么前面的数放在前面
              2)为正数，那么放在后面
              3)为0时，不动
    arr.sort(function (a, b) {0
                return
            }())

    
 
    reverse : 它会把原数组返回来,
    splice : 从第几位开始，截取多少长度，在切口处添加新的数据 [30:00 --> ]

不改变原数组
    concat,
    join : arr.join("(这里必须是字符串原始值，最后它会把你加的符号让数组中的每一个连接起来成为一个字符串)")
    split : 和join互逆的,
    toString,
    slice : 从该位开始截取，截取到该位，里面不写就是整个截取
*/

// 系统push方法 [18:00 --> ]
// var arr = [1, 2, 3]
// Array.prototype.push = function () {
//     for (var i = 0; i < arguments.length; i++) {
//         const element = array[i];
//         this[this.length] = arguments[i];
//     }
//     return this;
// }


                               /*类数组*/
/*
类数组
    1.可以利用属性名模拟数组的特性
    2.可以动态的length属性
    3.如果强行让类数组调用push方法，则会根据length属性值得位置进行属性扩充

    属性要为索引(数字)属性，必须有length属性，最好加上push
*/

//例题1：[07:30 --> 15:15]
// var obj = {
//     "2" : 'a',
//     "3" : 'b',
//     "length" : 2,
//     "push" : Array.prototype.push
// }
// obj.push('c');
// obj.push('d');
// obj --> 

// 封装type

// 数组去重