Javascript闭包

在Javascript中，如果一个对象不再被引用，那么这个对象就会被GC回收，否则这个对象一直会保存在内存中。

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

A不会被GC回收，会一直保存在内存中。

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

(function(){})()是一个表达式，而这个表达式本身是一个匿名函数，所以在这个表达式后面加()就表示执行这个匿名函数

因此，上面这段代码执行过程就可以分解如下：

var f = function(document){
    var viewport;
    var obj = {
        init:function(id){
            viewport = document.querySelector("#"+id);
        },
        addChild:function(child){
            viewport.appendChild(child);
        },
        removeChild:function(child){
            viewport.removeChild(child);
        }
    }
    window.jView = obj;
};
f(document);
2016/1/10 posted in  JavaScript

Javascript call和apply

function Animal(name,weight){
       this.name = name;
       this.weight = weight;
  }

  function Cat(){
       Animal.call(this,'cat','50');
       //Animal.apply(this,['cat','50']);

       this.say = function(){
           console.log("I am " + this.name+",my weight is " + this.weight);
       }
  }

  var cat = new Cat();
  cat.say();//I am cat,my weight is 50

执行Cat()时，先在其调用对象this的执行环境调用Animal()，相当于this.Animal()。this.Animal()执行完以后，this上就产生了name和weight属性
2016/1/10 posted in  JavaScript

Javascript原型和原型链

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

在JS中，每当创建一个函数对象f1时，该对象中都会内置一些属性，其中包括prototype和__proto__，prototype即原型对象，它记录着f1的一些属性和方法。

需要注意的是，prototype对f1是不可见的；也就是说f1不会查找prototype中的属性和方法

prototype中定义的属性和方法都是留给自己的后台用的，子类完全可以访问prototype中的属性和方法

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

obj -> f.prototype -> Object.prototype -> null
2016/1/10 posted in  JavaScript

Javascript new的运行机制

var cat = new Animal("cat");

这段代码的内部做了很多工作：

new Animal("cat") = {

var obj = {};

obj.__proto__ = Animal.prototype;

var result = Animal.call(obj,"cat");

return typeof result === 'obj'? result : obj;
}

把obj的__proto__ 指向Animal的原型对象prototype，此时便建立了obj对象的原型链：obj->Animal.prototype->Object.prototype->null

cat.name -> 在过程（3）中，obj对象就产生了name属性。因此cat.name就是这里的obj.name

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

cat.say -> cat会先查找自身的say方法，没有找到便会沿着原型链查找，在上述例子中，我们在Animal的prototype上定义了say,因此在原型链上找到了say方法。
2016/1/10 posted in  JavaScript

Javascript作用域

作用域链

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();

特殊情况

foo = "window";
function first(){
    var foo = "first";
    function second(){
       var foo = "second";
       console.log(foo);
    }
    function third(obj){
       console.log(foo); //first
       with (obj){
           console.log(foo); //obj
       }
       console.log(foo); //first
    }
    var obj = {foo:'obj'};
    third(obj);
}
first();

在执行third()时，传递了一个obj对象，obj中有属性foo，在执行with语句时，JS引擎将obj放置在了原链表的头部，于是形成的作用域如下：

obj -> third -> first -> window

this关键字

在一个函数中，this总是指向当前函数的所有者对象，this总是在运行时才能确定其具体的指向，也才能知道它的调用对象。

Reference

http://www.cnblogs.com/onepixel/p/5036369.html

2016/1/10 posted in  JavaScript

Copyright © 2016 Powered by MWeb,  Theme used GitHub CSS.