this agruments 克隆

  // var hang = {
        //     wife1 : {name : 'xiaozhang'},
        //     wife2 : {name : 'xiaowen'},
        //     wife3 : {name : 'xiaoqiang'},
        //     sayWife : function(num){
        //         return this['wife' + num];
        //     }
        // }



    /*对象的枚举
        for in

    */

var obj = {
        name : '13',
        age : '123',
        sex : 'male',
        height : '180',
        weight : 75
    }
    for(var prop in obj) {    
        console.log(obj.prop);                          //遍历对象用的
    }
    var obj1 = {
        a : 123,
        b : 234,
        c : 345
    }
    var key;
    for(key in obj1){
        obj.prop ++;
    }


    //在枚举里面，只有这样写obj[prop]
    /*
        var obj = {
            name : '13',
            age : '123',
            sex : 'male',
            height : '180',
            weight : 75
        }
        for(var prop in obj){
            console.log(obj[prop]);
        }
    */

//在枚举里面，只有这样写obj[prop]

hasOwnProperty//过滤行方法 不要原型上面的属性;

	var obj = {
            name : '13',
            age : '123',
            sex : 'male',
            height : '180',
            weight : 75,
            __proto__ : {
                lastName : "deng"
            }
        }
        for(var prop in obj) {
            if(obj.hasOwnProperty(prop)) {    //过滤行方法 不要原型上面的属性;
                console.log(obj[prop])
            }
        }
    
        'height' in obj //true
        'lastName' in obj//true

this

function test(c) {
	//new的时候 var this = Object.creat(test.prototype);
	//{
	//__proto__: test.prototype	
	//}
	var a = 123;
	function b() {}

}
/*
AO {
	arguments : [1],
	this : window,
	c : 1,
	a : undefined,
	b : function () {} 
}
*/
test(1);
new test();   
//预编译里面 this -->指向window;
//谁调用函数,this就指向的是谁;

arguments function test(){
	console.log(arguments.callee);
}
test();

arguments.callee 指向的就是函数
上面函数的输出就是函数本身；
例如：(没有函数名的递归函数)

var num = (function(n){
	if(n == 1) {
		return 1;
	}
	return n * arguments.callee(n - 1);  //此时没有函数名的函数被调用就要用到 arguments.callee
 }(100))

clone

	var obj = {
		name : "abc",
		age : 123,
		sex : 'female'
	}
	var obj1 = {}
	function clone(origin, target) {
		var target = target || {};
		for (var prop in origin) {
			target[prop] = origin[prop];
		}
		return target;
	}
	clone(obj, obj1);

	var obj = {
		name : "abc",
		age : 123,
		sex : 'female',
		card : ['visa','unionpay']
	}
	var obj1 = {
		card : [obj.card[0],obj.card[1]]
	}

遍历对象 for(var prop in obj)

1.判断是不是原始值 typeof() object

2.判断是数组还是对象 instanceof toString constructor

3.建立相应的数组或对象

递归

深层克隆：

var obj = {
			name : "zhang",
			age : 19,
			sex : 'male',
			card : ['dudu', 'lala']
		}
		var obj1={};
		 //深层克隆
		 function deepClone(origin, target) {
		 		var target = target || {}, //没传target时;
		 			toStr = Object.prototype.toString,
		 			arrStr = "[object Array]";
		 		for(var prop in origin) {
		 			if(origin.hasOwnProperty(prop)) {  //不要原型链的内容 所以当返回值为 true 时再进行下一步
		 				if(typeof(origin[prop]) == 'object') {  
		 					if(toStr.call(origin[prop]) == arrStr) {
		 						target[prop] = [];
		 					}else{
		 						target[prop] = {};
		 					}
		 					deepClone(origin[prop], target[prop]);
		 				}else{
		 					target[prop] = origin[prop];
		 				}
		 			}
		 		}
		 }

完善：：：

var obj = {
			name : "zhang",
			age : 19,
			sex : 'male',
			card : ['dudu', 'lala']
		}
		var obj1={};
		 //深层克隆
		 function deepClone(origin, target) {
		 		var target = target || {},
		 			toStr = Object.prototype.toString,
		 			arrStr = "[object Array]";
		 		for(var prop in origin) {
		 			if(origin.hasOwnProperty(prop)) {  //不要原型链的内容 所以当返回值为 true 时再进行下一步
		 				if(origin[prop] !=="null" && typeof(origin[prop]) == 'object') {    //绝对不等于是 ！==  绝对等于是===
		 					if(toStr.call(origin[prop]) == arrStr) {
		 						target[prop] = [];
		 					}else{
		 						target[prop] = {};
		 					}
		 					deepClone(origin[prop], target[prop]);
		 				}else{
		 					target[prop] = origin[prop];
		 				}
		 			}
		 		}
		 		return target; // 没传target
		 }

三目运算符 : a ? 1 : 2 先判断a是否为真，为真的话返回冒号前面的式子的值，为假的话就返回冒号后面的式子的值;

加上三目运算符 然后简化为:

	var obj = {
			name : "zhang",
			age : 19,
			sex : 'male',
			card : ['dudu', 'lala']
		}
		var obj1={};
		 //深层克隆
		 function deepClone(origin, target) {
		 		var target = target || {},
		 			toStr = Object.prototype.toString,
		 			arrStr = "[object Array]";
		 		for(var prop in origin) {
		 			if(origin.hasOwnProperty(prop)) {  //不要原型链的内容 所以当返回值为 true 时再进行下一步
		 				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; // 没传target
		 }

类数组

索引要为索引（数字）属性，必须有 lenght 属性，最好加上 push