Sunny

# 包装类

# 包装类生成过程

数据的值基本上分两种，一种为原始值，一种为引用值。

引用值就是一种对象，里面包括数组，函数，对象

原始值和引用值区别

1.存储位置不一样 2.原始值没有属性和方法

var str = "abc";
    console.log(str.length);    //3
1
2

之所以该原始值(字符串)能够使用length方法是因为运行的时候系统会new String();构造出一个字符串对象来，然后把字符串的内容填充成abc。new String('abc').length 写的是str.length,其实执行的是

console.log(new String('abc').length);

这个系统隐式的过程就叫做包装类

# 原型

原型必须是基于构造函数的，没有构造函数原型没有意义,任何一个函数包括构造函数都会有一个prototype,这个prototype是这个函数构造出对象的公有祖先

Person.peototype.lastName = 'deng';
        // var this = {
        //     __proto__ : person.prototype
        // }
    function Person() {

    }
    var person = new Person();
    console.log(person.lastName) //deng
1
2
3
4
5
6
7
8
9
详解

person现在可以用prototype上面的任何东西包括latname。为什么能用prototype。因为在new的过程中隐式创建了一个this对象，this对象里面有一个__proto__，proto属性指向的是这个构造函数的原型person.prototype，

如果开始访问person的属性，person会先看自己有没有，如果自己没有(这里指Person(){}里面没有),它会沿着自己的proto找到构造函数的prototype

# object.create()

object.create()是创建对象的，对象必须有原型。object.create()创建出的对象,需要指定这个对象的原型是谁(参数).

    var demo = {
        lastName : "deng"
    }
    var obj = Object.create(demo);
    obj = {
        __proto__ : demo 
    }
1
2
3
4
5
6
7

obj在自己身上找不到属性的话会在demo身上找,因为demo现在是obj的原型。

一旦经历了var 的操作,所得出的属性window，这种属性叫做不可配置的属性,不可配置的属性 delete不掉

# this call

// 1. 预编译时this -- > window
// 2. 谁调用的 this 指向谁
// 3. call apply
// 4. 全局里this指向window
    function test() {
        console.log(this);
    }
    test() //window
    test.call()
//其实test()就是隐式的test.call(),
//只不过是test.call里面没传参数
//如果传了参数了此时打this就是该参数
1
2
3
4
5
6
7
8
9
10
11
12

# 谁调用的this this指向谁

    var name = 'window';
    var obj = {
        name : "obj",
        say : function () {
            console.log(this.name);
        }
    }
    obj.say.call(window)    
//此时this指向的window 所以在windw上找this  window
    fun.call(obj)       //obj
1
2
3
4
5
6
7
8
9
10

提示

undefined和null隐式类型转换，就是和数字比较不了。

不转换 不大于0不小于0不等于0，它们两个却相等

继承 最好的方式就是圣杯模式

# 闭包

    function a () {
        function b () {
        }
    }
1
2
3
4

闭包的表象:一个函数套着一个函数，把被嵌套的那个函数保存到了套它函数的外部,就形成了闭包。

# 引用值类型转换

不用去考虑

[] + ""      ""
[] == [];   //false  因为每一个引用值都有一个独立的地址
1
2

# 深度克隆原理

        var obj = {
        name : "abc",
        wife :  {
            name : "xiaoliu",
            son :   {
            name : "xiaowang"
                }
            }
    }
    var obj1 = {
        name : obj.name,
        wife : {}
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

原理

把obj里面的属性通过for in循环遍历到obj1里面

把wife写成一个空对象,把obj里面的wife里面的引用值的属性遍历到obj1的wife里面去，通过递归的方式。

← try catch&&ES5 →