Javascript Garden

console.log(false.toString()); //false
console.log([1,2,3].toString()); //1,2,3

function Foo(){ }
Foo.bar=1;
console.log(Foo.bar);//1

//console.log(2..toString());//报错
console.log(2..toString());//2
console.log(2 .toString());//2
console.log((2).toString());//2
//变通方法可以让数字的字面量看起来像对象

var foo={name: ‘kitten‘} 
console.log(foo.name);//kitten 
console.log(foo[‘name‘]);//kitten 
 
var get=‘name‘; 
console.log(foo[get]);//kitten 
 
//console.log(foo.1234);//报错console.log(foo[‘1234‘]);//undefined

var obj={ 
    bar:1, 
    foo:2, 
    baz:3 
}; 
obj.bar=undefined; 
obj.foo=null; 
delete obj.baz; 
 
for(var i in obj){ 
    if(obj.hasOwnProperty(i)){ 
        console.log(i, ‘‘+obj[i]); 
    } 
} 
//输出： 
//bar undefined 
//foo null

Object.prototype.bar=1; 
var foo= {moo:2}; 
for(var i in foo){ 
    console.log(i); //moo bar 
}
 

for(var i in foo) { 
    if (foo.hasOwnProperty(i)) { 
        console.log(i);//moo 
    } 
}
 

Foo.method = function() { 
    function test() { 
        // this 将会被设置为全局对象（译者注：浏览器环境中也就是 window 对象） 
    } 
    test(); 
} 
 

Foo.method = function() { 
    var that = this; 
    //为了在 test 中获取对 Foo 对象的引用，我们需要在 method 函数内部创建一个局部变量指向 Foo 对象。 
    function test() { 
        // 使用 that 来指向 Foo 对象 
    } 
    test(); 
}

for(var i = 0; i < 10; i++) { 
    setTimeout(function() { 
        console.log(i);//输出10 十次 
    }, 1000); 
} 
//ps：当 console.log 被调用的时候，匿名函数保持对外部变量 i 的引用，此时 for循环已经结束， i 的值被修改成了 10. 
 
 
 
for(var i = 0; i < 10; i++) { 
    (function(e) { 
        setTimeout(function() { 
            console.log(e); 
        }, 1000);//输出0到9 
    })(i); 
} 
//ps：自执行匿名函数。外部的匿名函数会立即执行，并把 i 作为它的参数，此时函数内 e 变量就拥有了 i 的一个拷贝。 
// 当传递给 setTimeout 的匿名函数执行时，它就拥有了对 e 的引用，而这个值是不会被循环改变的。


for(var i = 0; i < 10; i++) { 
    setTimeout((function(e) {  //从匿名函数返回一个函数 
        return function() { 
            console.log(e); 
        } 
    })(i), 1000) 
}

  Array.prototype.slice.call(arguments); (性能欠佳)


//(1)下面是将参数从一个函数传递到另一个函数的推荐做法。function foo() { 
    bar.apply(null, arguments); 
} 
function bar(a, b, c) { 
    // 干活
} 



//(2)另一个技巧是同时使用 call 和 apply，创建一个快速的解绑定包装器。function Foo() {} 
 
Foo.prototype.method = function(a, b, c) { 
    console.log(this, a, b, c); 
}; 
 
// 创建一个解绑定的 "method" 
// 输入参数为: this, arg1, arg2...argN 
Foo.method = function() { 
 
    // 结果: Foo.prototype.method.call(this, arg1, arg2... argN) 
    Function.call.apply(Foo.prototype.method, arguments); 
}; 
/ 
    Foo.method = function() { 
        var args = Array.prototype.slice.call(arguments); 
        Foo.prototype.method.apply(args[0], args.slice(1)); 
    };