js笔记（暑假8）

72.类数组：属性要为索引（数字）属性，必须有length（类数组关键点）属性，最好加上push
1.是对象，可以当作数组来用，把数组和对象拼接到一起，但并不是所有的方法都能用的，有的需要自己填。
例1：
    var obj = {
        "0" : 'a',
        "1" : 'b',
        "2" : 'c',
        "length" :3,
        "push" : Array.prototype.push,
        "splice" : Array.prototype.splice,
    }
例2：
    var obj = {
        "2" : 'a',
        "3" : 'b',
        "length" :2,
        "push" : Array.prototype.push,
    }
    obj.push('c');
    obj.push('d');
/*    Array.prototype.push = function (target){
        obj[obj.length] = target;
        obj.length ++;
    }*/
返回结果：{2: "c", 3: "d", length: 4}
例3：
    var obj = {
        "0" : 'a',
        "1" : 'b',
        "2" : 'c',
        name : 'L',
        age : 21,
        length : 3,
        push : Array.prototype.push,
        splice : Array.prototype.splice,
    }
obj.length   返回   3
obj.name     返回   "L"
for(var prop in obj){ console.log(obj[prop])}         返回           obj全部属性值

例4：封装type 
大致思路： 
先判断   原始值引用值
原始值：再分为null和其他，null单独判断，其他利用typeof判断再返回类型就行
引用值：函数直接返回就行，再判断对象，数组，和包装类对象等利用Object.prototype.toString.call();
function type (target){
    var template = {
        "[object Array]" : "array",
        "[object Object]" : "object",
        "[object Number]" : "number - object",
        "[object Boolean]" : "boolean - object",
        "[object String]" : "string - object",

    }
    if(target === null){
        return "null";
    }
    else if(typeof(target) == "object"){
        var str = Object.prototype.toString .call(target);
        return template[str];
    }
    else {
        return typeof(target);
    }
}
简化：
    var ret = typeof(target)； 然后把所有的 typeof(target)换成ret就行，只需判断一次就行

例5重要：数组去重
大致思路：将数组的属性值作为对象的属性名，将对象属性值赋一个非false的数，然后进行循环。

    var arr = [1,1,1,1,1,2,2,2,2,2,1,1,1,1,0,0,0,0,0];
/*    var temp = {
        "1" : "abc",
        "2" : "abc",
    }
    temp[1] --> undefined
    temp[1] --> "abc"
    temp[2] --> undefined
*/
    Array.prototype.unique = function (target){
        var temp = {}
            arr = [];
            len = this.length;
        for(var i = 0 ;i < len; i++){
            if(!temp[this[i]]){
                temp[this[i]] = "abc";
                arr.push(this[i]);
            }
        }
        return arr;
    }

如果：将"abc"改成"this[i]"就达不到0去重的效果了，因为temp[this[i]] 结果为0 ,那么取非是true，在判断条件哪里，0可以一直执行，所以错了。
    var arr = [1,1,1,1,1,2,2,2,2,2,1,1,1,1,0,0,0,0,0];
    Array.prototype.unique = function (target){
        var temp = {}
            arr = [];
            len = this.length;
        for(var i = 0 ;i < len; i++){
            if(!temp[this[i]]){
                temp[this[i]] = this[i];
                arr.push(this[i]);
            }
        }
        return arr;
    }

第13节数组去重，习题，答疑复习
原始值与引用值两大区别：
1.存储地址不一样
2.原始值没有属性和方法

引出问题1：
 var  str = "abc"
 console.log(str.length);
内部转化原因：
会在内部生成字符串对象new String('abc')
然后执行时执行的其实是new String('abc').length
以上隐式包装的过程就称为包装类。

引出问题2:
var  number = 123;
num.abc = "abc";
console.log(num.abc);
内部转化：
会在内部生成new Number(num).abc = 'abc';  --> delete
然后再下一步访问是因为你上一个已经销毁了，然而这里有要调用，所以系统又构造出了一个new Number(num).abc 这个里面什么也没存，所以返回undefined

不可配置的属性：一旦经历了var的操作，所得出的属性，window，这种属性叫做不可配置的属性不可配置的属性，delete不掉
不可配置的属性： var num = 123; delete num --> flase
可配置的属性：    obj.num = 123; delete num --> true     

Object.create(prototype,definedProperty) （了解）

this:
1.预编译 this --> window
2.谁调用 this 指向谁
3.call apply
4.全局 this --> window
例1：
    function test(){
        var num = 123;
        function a(){

        }
    }
    test();   < == > test.call()
//test执行就会生成以下内容
  -- >AO{
        arguments.{},
        this : window,
        num : undefined,
        a : function (){}
    }
例2：
    function test(){
        console.log(this);
    }
    test.call({name : "deng"}); 
//test.call({name : "deng"});执行就会生成以下内容
   -- >AO{
        arguments.{},
        this : {name :"deng"},
        num : undefined,
        a : function (){}
    }

例3：
    var name = 'window';
    var obj = {
        name : 'obj',
        say : function (){
            console.log(this.name);
        }
    }
    obj.say.call(window);
//只要有call出现就打破一切规则，this就指向传进去的东西。

例4：
    var name = 'window';
    var obj = {
        name : 'obj',
        say : function (){
            console.log(this.name);
        }
    }
    var fun = obj.say;
    fun();
//相当于这个函数在全局范围内自调用，相当于把say那个函数引用拿出来了

闭包：只要是将内部函数保存到了外部就一定形成闭包，不管什么方式，只要保存到了外部就必然生成闭包，不一定是return的方式
    var obj = {}
    function a (){
        var aa= 123;
        function  b (){
            console.log(aa);
        }
        obj.fun = b;
    }
    a();
//b被保存到了外部，并且一直拿着a的执行期上下文，死死不放手，a消失了，b还活的好好的，照样能访问a里的变量

例1：
    function Person (){
//        var this = {
//        makeMoney : function (){}
//        offer : function (){}
// }
        var money = 100;
        this.name = name;
        this.makeMoney = function (){
            money ++;
        }
        this.offer = function (){
            money --;
        }
//        return this
    }
    var person = new Person();
//经过new之后就会在Person内部产生this，然后将this返回，连带着this对象上打包的两个方法都返回到了外部，这样，这两个方法就和Person生成的执行期上下文形成了闭包
//这样这两个方法就能操作同一个money，money保存到了Person里面并且外部不可访问，因为money在Person方法也就是makeMoney和offer的作用域链中
//money就作为Person的私有化变量来存在。

[] + ""  --> ""
[] + 1  -->  "1"
[] - 1  --> -1
[] == [] -- > false    因为每个引用值都有一个独特的地址
//以上都进行了隐式类型转换

深度克隆原理：
   var obj = {
        name : "abc",
        wife : {
            name : "xiaoliu",
            son :{
                name : "xiaodeng",
            }
        }
    }

    var obj1 = {
        name : obj.name,
        wife : {
            name : obj.wife.name,
            son : {
                name : obj.wife.son.name,
            }
        }
    }
//首先obj1 空对象
第一个属性：原始值直接赋值，
第二个属性：引用值->对象类型->新建对象
第二个属性中第一个属性：原始值直接赋值
第二个属性中第二个属性：引用值->对象类型->新建对象
依次就是深度克隆原理

undefined   和null   和0
并不是所有东西比较都会进行隐式类型转换的，尤其是大于小于号这里
系统规定：undefined和null就是不能和数 像0什么的进行比较。

例题：
    (function (x){
        //var x
        delete x;
        return x;
    }(1))
//相当于var x 是删不掉的 所以返回1。

例题：
    function test(){
        console.log(typeof(arguments));
    }
    test();
//返回object

例题：
    var h = function a(){
        return 23;
    }
    console.log(typeof(a));
//报错 h才是函数名，调用h才执行

然后的例题就是另一个文档中了