js 学习笔记(二)

js 学习笔记

更可靠的let

function foo() {
    function bar(a) {
        i = 3; 
        console.log(a + i);
    }
    for (let i = 0; i < 10; i++) {
        bar(i * 2);
    }
}
foo();
//bar 内部的i 很容易将外部用var声明的i覆盖掉 导致无限循环
//当然大部分情况 我们会这么写  声明一个闭包来承载新的i
 for(var i=0;i<10;i++){
    (function(a){
        var i=3;
        console.log(a+i);
    })(i*2)
}

//错误的使用仍然会导致作用域的污染
var i=0;
setInterval(function(){
    console.log(i);
},100);
(function(){
    setTimeout(function(){
        i=1;
    },1000)
})()

require(['underscore'],function (_){
    for(let i=0;i<10;i++){
        _.delay(function(){console.log(i)},1000);
    }
})
//显然 用let 进行异步回调更为简单

//还可以这么玩  可见let是多么实用
require(['underscore'],function (_){
    for(let i=0;i<10;i++){
        for(let i=0;i<10;i++)
            _.delay(function(){console.log(i)},1000);
    }
})

const

用于不可变 变量的声明
更准确地来说 const 声明的变量只可以被初始化一次
和其他语言一样 这样写 依然合法

//[]
const arr=[];
arr.push(arr);
console.log(arr);

//{}
const obj={};

obj['say_2']=function(){
    console.log(2);
}
obj.say_2();//2
console.log(obj);
console.log(obj.prototype)
console.log(obj._proto_);

函数优先

同样是 使用在调用之后声明的
但是如果是 函数的话就能正常打印出内容
如果是变量的话则是undefined

console.log(a);
var a=1; 


console.log(foo);
function foo(){
    alert(1);
}

this 中的优先级

显示绑定>隐式绑定

var foo=function(){
    console.log(this.a);
}
var obj1={
    a:1,
    foo:foo
}
var obj2={
    a:2
}
foo.call(obj2);//2
obj1.foo();//1
obj1.foo.call(obj2);//2

new绑定>隐式绑定

var foo=function(a){
    this.a=a;
}
var obj1={
    foo:foo
}
var obj2={};

obj1.foo(1);
console.log(obj1.a);//1
foo.call(obj2,2);
console.log(obj2.a);//2
obj1.foo.call(obj2,3);
console.log(obj2.a);//3
console.log(obj1.a);//1
//以上任然是说明 显示绑定>隐式绑定
var bar=new obj1.foo(4);
console.log(bar.a)//4  这里体现了  new绑定>隐式绑定
console.log(obj1.a)//1