javascript学习笔记

2016/04/03

1. 原型对象和原型链

prototype的主要作用是继承,prototype中定义的属性和方法是留给自己的“后代”用的。子类可以完全访问prototype中的属性和方法

function f(){}
f.prototype.foo = "abc";
console.log(f.foo); //undefined

通过例子可以看出,自身是访问不到自己的prototype

__proto__通常是把父类的prototype赋值给它,这样的话,就可以通过这种父类的prototype赋值给新对象的__proto__属性的形式,一代代传承

function f(){}
f.prototype.foo = "abc";
var obj = new f();
console.log(obj.foo); //abc

obj对象拥有这样一个原型链以后,当obj.foo执行时,obj会先查找自身是否有该属性,但不会查找自己的prototype,当找不到foo时,obj就沿着原型链依次去查找…

function Animal(name){
    this.name = name;
}
Animal.color = "black";
Animal.prototype.say = function(){
    console.log("I'm " + this.name);
};
var cat = new Animal("cat");

console.log(
   cat.name,  //cat
   cat.color //undefined
);
cat.say(); //I'm cat

console.log(
   Animal.name, //Animal
   Animal.color //back
);
Animal.say(); //Animal.say is not a function

cat.color -> cat会先查找自身的color,没有找到便会沿着原型链查找,在上述例子中,我们仅在Animal对象上定义了color,并没有在其原型链上定义,因此找不到。 cat.say -> cat会先查找自身的say方法,没有找到便会沿着原型链查找,在上述例子中,我们在Animal的prototype上定义了say,因此在原型链上找到了say方法。

1. 原型链的形成真正是靠__proto__ 而非prototype,当JS引擎执行对象的方法时,先查找对象本身是否存在该方法,如果不存在,会在原型链上查找,但不会查找自身的prototype

2. 一个对象的__proto__记录着自己的原型链,决定了自身的数据类型,改变__proto__就等于改变对象的数据类型。

3. 函数的prototype不属于自身的原型链,它是子类创建的核心,决定了子类的数据类型,是连接子类原型链的桥梁。

4. 在原型对象上定义方法和属性的目的是为了被子类继承和使用。

2. 作用域

JS中有种特殊情况 如果一个变量没有使用var声明,window便拥有了该属性,因此这个变量的作用域不属于某一个函数体,而是window对象

functtion varscope(){
    foo = "I‘m in function";
    console.log(foo);//I‘m in function
}
varscope();
console.log(window.foo);//I‘m in function

作用域链就是一个函数体中嵌套了多层函数体,并在不同的函数体中定义同一变量,当其中一个函数访问这个变量时,便会形成一条作用域链

foo = "window";
function first(){
    var foo = "first";
    function second(){
        var foo = "second",
        console.log(foo);
    }
    function third(){
        console.log(foo);
    }
    second();   //second
    third();    //first
}
first();

当执行second时,JS引擎会将second的作用域放置链表头部,其次是first的作用域,最后是window对象 second形成的作用域链:second->first->window third形成的作用域链:third->first->window

var foo = "window";
var obj = {
    foo : "obj",
    getFoo : function(){
        return function(){
            return this.foo;
        };
    }
};
var f = obj.getFoo();
f(); //window

在实例化obj.getFoo方法的时候,在getFoo方法作用域里,this代表getFoo函数 但是在输出的时候,又定义了一个匿名函数,所以this就代表了这个匿名函数 相当于赋值给f的是这个匿名的函数,所以找到的是window,即

var foo = "window";
var f = function(){
    return this.foo;
}

3. 闭包

当一个内部函数被其外部函数之外的变量引用时,就形成了闭包

function A(){
    var count = 0;
    function B(){
       count ++;
       console.log(count);
    }
    return B;
}
var c = A();
c();// 1
c();// 2
c();// 3

因为被引用所以,A对象不会被GC回收(GC回收的机制是:如果一个对象不再被引用,那么这个对象就会被GC回收,否则这个对象一直会保存在内存中)

var f = function(document){
    var viewport;
    var obj = {
        init:function(id){
            viewport = document.querySelector("#"+id);
        },
        addChild:function(){
            viewport.appendChild(child);
        },
        removeChild:function(child){
            viewport.removeChild(child);
        }
    }
}
f(document);

obj 是在 f 中定义的一个对象,这个对象中定义了一系列方法, 执行window.jView = obj 就是在 window 全局对象定义了一个变量 jView,并将这个变量指向 obj 对象,即全局变量 jView 引用了 obj . 而 obj 对象中的函数又引用了 f 中的变量 viewport ,因此 f 中的 viewport 不会被GC回收,会一直保存到内存中,所以这种写法满足闭包的条件。

参考的博客文一像素博客

Post Directory