澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

周全分析,你不知底的javaScript笔记

2019-06-16 作者:澳门新萄京赌场网址   |   浏览(98)

JavaScript 中的 this 全面解析

2017/05/26 · JavaScript · this

原文出处: Simon_ITer   

GitHub地址:

this的指向问题应该是让每一个前端er都头疼的问题,我也一样,曾经遇到甚至都是一顿乱猜。最近在研读一些书籍如《你不知道的JavaScript》和《JavaScript语言精粹与编程实践》,让我对this的问题豁然开朗。故写下此篇文章,分享一下我的心得。

上一篇文章中讲了下this的作用和部分绑定规则[JavaScript中this关键字(上)

简书](

this绑定规则:

3 .显示绑定:

在静态绑定中可以看到,必须在一个对象内部包含一个指向函数的属性,并通过这个属性间接的去引用函数,从而把this隐式的绑定到这个对象上。

如果不想在对象内部包含函数的引用,而想在某个对象上强制调用函数,这就是显示绑定,怎么做才能做到显示绑定呢?js中所有的函数都有一些公有的方法,比如call(),apply(),bind()这三种方法。那这三种方法该怎么用?首先,这三个方法的第一个参数都可以接受一个对象,它们会把对象绑定到this上,接着在调用函数时指定this,这种方法称为显示绑定。这三者的区别是:call()的第二个参数开始接受的是单独的参数,例如:xxx.call(obj,argument1,argument2);apply()的第二个参数开始则接受一个参数数组,例如:xxx.apply(obj,[args1,args2]);bind的第二个参数以及以后的参数加上绑定函数运行时本身的参数按照顺序作为原函数的参数来调用原函数。

4.new绑定

用new的话一般是用于初始化构造函数(类)的时候用的多一些,比如我最近在写svg的时候就用到构造函数(类)。使用方法如下:

澳门新萄京官方网站 1

实例1

澳门新萄京官方网站 2

实例2

在实例1中可以看到有一个svg的类,使用的时候用new就可以了。

new做了什么样的操作呢?

  1. 创建(或者说构造)一个全新的对象。

  2. 这个新对象会被执行 [[ 原型 ]] 连接。

  3. 这个新对象会绑定到函数调用的 this 。

  4. 如果函数没有返回其他对象,那么 new 表达式中的函数调用会自动返回这个新对象。

如上面两张图,在使用new来调用Svg(...)时,会构造一个新对象并把它绑定到Svg()调用中的this上。

周全分析,你不知底的javaScript笔记。现在我们已经大概了解了函数中调用this绑定的四条规则,我们需要做的就是找到函数的调用位置并判断使用了那条规则。但如果某个调用位置可以应用多条规则该怎么办?接下来我们将探索一下绑定规则的优先级。

毫无疑问,默认绑定的优先级是四条规则中最低的,我们先不考虑它

隐式绑定和显示绑定哪个优先级更高?上代码

澳门新萄京官方网站 3

实例3

可以看到,显示绑定的优先级更高,也就是说在判断时应当先考虑是否优先应用显示绑定

那隐式绑定和new绑定哪个高呢?

澳门新萄京官方网站 4

实例4

可以看到new绑定要比隐式绑定优先级高,那new绑定和显示绑定谁的优先级更高呢?

先回忆一下bind()是如何工作的,bind()会创建一个新的包装函数,这个函数会忽略它当前的this绑定(无论绑定的对象是什么),并把提供的对象绑定到this上。这样看起来要比new绑定的优先级更高,无法使用new来控制this的绑定。

澳门新萄京官方网站 5

实例5

从实例5中可以看到,bar被绑定到了obj1上,但new bar(3)并没有像预计的那样把obj1.a修改为3,相反,new修改了硬绑定调用bar()的this,因为使用new的来进行绑定,会得到一个名字为baz的新对象,并且baz.a的值是3。

所以绑定规则的优先级是:

new绑定 > 显示绑定 >隐式绑定 >默认绑定

不过规则总有例外,在某些特定的场景中this的绑定行为会出乎意料。

1.忽略this

不知道大家有没有遇到过这种情况:

function foo() {

console.log( this.a );

}

var a = 2;

foo.call( null ); // 2

如果把undefined或者null传入到call,apply或者bind中,这些值在调用时会被忽略,this会使用到默认规则。

什么情况下会传入null呢?

一种常见的做法就是使用apply来"展开"一个数组,并当做参数传入一个函数

function foo(a,b) {

console.log( "a:" a ", b:" b );

}

foo.apply( null, [2, 3] ); // a:2, b:3

如果函数并不关心this的话,仍然需要传入一个站位值,比如null.

但是,如果函数确实使用了this,那默认绑定规则会把this绑定到全局对象(window)

2.间接引用

比如在赋值时发生的间接引用:

function foo() {

console.log(this.a);

}

vara=2;

varo={a:3,foo:foo};

varp={a:4};

o.foo();// 3

(p.foo=o.foo)();// 2

p.foo=o.foo的返回值是目标函数的引用,因此调用位置是foo()而不是p.foo()或者o.foo(),间接引用时,this也会采取默认绑定的规则。

3.箭头函数

es6中提供了一个特殊函数类型:箭头函数,它不适用于上面介绍的四种规则,实际上它是根据外层(函数或者全局)的作用域来决定this的。

function foo() {

// 返回一个箭头函数

return (a) => {

//this 继承自 foo()

console.log( this.a );

};

}

var obj1 = {

a:2

};

var obj2 = {

a:3

};

var bar = foo.call( obj1 );

bar.call( obj2 ); // 2, 不是 3 !

箭头函数最常用的地方在于回调函数中,例如事件处理或者定时器中。

总结:

要判断一个函数中的this指向,就需要找到这个函数的直接调用位置,找到后可以根据规则来判断this的绑定对象

1.new调用会绑定到新创建的对象

2.call或者apply或者bind则绑定到指定的对象

3.上下文调用则绑定到对应的上下文对象

4.默认规则:严格模式下绑定到undefined,否则绑定到全局对象

箭头函数并不会使用到以上四种规则,而是根据当前的词法作用域来决定this,也就是说,箭头函数会继承外层函数调用的this绑定。

this和对象原型

this全面解析

默认绑定 (Default Binding)

隐式绑定

关于this,一般来说,谁调用了方法,该方法的this就指向谁,如:

function foo(){ console.log(this.a) } var a = 3; var obj = { a: 2, foo: foo }; obj.foo(); // 输出2,因为是obj调用的foo,所以foo的this指向了obj,而obj.a = 2

1
2
3
4
5
6
7
8
9
10
11
12
function foo(){
    console.log(this.a)
}
 
var a = 3;
 
var obj = {
    a: 2,
    foo: foo
};
 
obj.foo(); // 输出2,因为是obj调用的foo,所以foo的this指向了obj,而obj.a = 2

如果存在多次调用,对象属性引用链只有上一层或者说最后一层在调用位置中起作用,如:

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function foo() {
    console.log( this.a )
}
 
var obj2 = {
    a: 42,
    foo: foo
}
 
var obj1 = {
    a: 2,
    obj2: obj2
}
 
obj1.obj2.foo(); // 42

this是一个很特别的关键字,被自动定义在所有函数的作用域中

调用位置

在理解 this 的绑定过程之前,首先要理解调用位置:调用位置就是函数在代码中被调用的位置(而不是声明的位置)。函数调用位置的不同会造成 this 绑定对象的不同

最重要的是要分析调用栈(就是为了到达当前执行位置所调用的所有函数)。我们关心的调用位置就在当前正在执行的函数的前一个调用中。

function baz() {

// 当前调用栈是:baz

// 因此,当前调用位置是全局作用域

console.log( "baz" );

bar(); // <-- bar 的调用位置

}

function bar() {

// 当前调用栈是 baz -> bar

// 因此,当前调用位置在 baz 中

周全分析,你不知底的javaScript笔记。console.log( "bar" );

foo(); // <-- foo 的调用位置

}

function foo() {

// 当前调用栈是 baz -> bar -> foo

// 因此,当前调用位置在 bar 中

console.log( "foo" );

}

baz(); // <-- baz 的调用位置

这个是最简单的绑定,最常用的调用类型:独立函数调用

隐式丢失

一个最常见的this绑定问题就是被隐式绑定的函数会丢失绑定对象,也就是说他回应用默认绑定,从而把this绑定到全局对象或者undefined上,取决于是否是严格模式。

function foo() { console.log( this.a ) } var obj1 = { a: 2, foo: foo } var bar = obj1.foo; // 函数别名! var a = "oops, global"; // a是全局对象的属性 bar(); // "oops, global"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
function foo() {
    console.log( this.a )
}
 
var obj1 = {
    a: 2,
    foo: foo
}
 
var bar = obj1.foo; // 函数别名!
 
var a = "oops, global"; // a是全局对象的属性
 
bar(); // "oops, global"

虽然bar是obj.foo的一个引用,但是实际上,它引用的是foo函数本身,因此此时的bar()其实是一个不带任何修饰的函数调用,因此应用了默认绑定

一个更微妙、更常见并且更出乎意料的情况发生在传入回调函数时

function foo() { console.log( this.a ) } function doFoo( fn ){ // fn 其实引用的是 foo fn(); //

1
2
3
4
5
6
7
function foo() {
    console.log( this.a )
}
 
function doFoo( fn ){
    // fn 其实引用的是 foo
    fn(); //

参数传递其实就是一种隐式赋值,因此我们传入函数时也会被隐式赋值,所以结果和上一个例子一样,如果把函数传入语言内置的函数而不是传入自己声明的函数(如setTimeout等),结果也是一样的

// foo.count 是0,字面理解是错误的

调用规则

functionfoo(){console.log(this.a );}vara =2;foo();// 2

显式绑定

简单的说,就是指定this,如:call、apply、bind、new绑定等

    function foo(num) {

   1.默认绑定

        独立函数调用。可以把这条规则看作是无法应用

        function foo() {

           console.log( this.a );

         }

         var a = 2;

         foo(); // 2

首先foo()在全局作用域中被调用,根据调用域(call-site),此时this绑定到了全局,所以结果很明显。

硬绑定

function foo( something ) { console.log( this.a, something) return this.a something } var obj = { a: 2 } var bar = function() { return foo.apply( obj, arguments) } var b = bar(3); // 2 3 console.log(b); // 5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function foo( something ) {
    console.log( this.a, something)
    return this.a something
}
 
var obj = {
    a: 2
}
 
var bar = function() {
    return foo.apply( obj, arguments)
}
 
var b = bar(3); // 2 3
console.log(b); // 5

这里简单做一下解释: 在bar函数中,foo使用apply函数绑定了obj,也就是说foo中的this将指向obj,与此同时,使用arguments(不限制传入参数的数量)作为参数传入foo函数中;所以在运行bar(3)的时候,首先输出obj.a也就是2和传入的3,然后foo返回了两者的相加值,所以b的值为5

同样,本例也可以使用bind:

function foo( something ) { console.log( this.a, something) return this.a something } var obj = { a: 2 } var bar = foo.bind(obj) var b = bar(3); // 2 3 console.log(b); // 5

1
2
3
4
5
6
7
8
9
10
11
12
13
function foo( something ) {
    console.log( this.a, something)
    return this.a something
}
 
var obj = {
    a: 2
}
 
var bar = foo.bind(obj)
 
var b = bar(3); // 2 3
console.log(b); // 5

        console.log("foo:" num);

    2.隐式绑定

        对象属性引用链中只有最顶层或者说最后一层会影响调用位置。

function foo() {

console.log( this.a );

}

var obj2 = {

a: 42,

foo: foo

};

var obj1 = {

a: 2,

obj2: obj2

};

obj1.obj2.foo(); // 42

但在严格模式下,默认绑定不起作用

new绑定

在传统面向类的语言中,使用new初始化类的时候会调用类中的构造函数,但是JS中new的机制实际上和面向类和语言完全不同。

使用new来调用函数,或者说发生构造函数调用时,会自动执行下面的操作:

  • 创建(或者说构造)一个全新的对象
  • 这个新对象会被执行[[Prototype]]连接
  • 这个新对象会绑定到函数调用的this
  • 如果函数没有返回其他对象,那么new表达式中的函数会自动返回这个新对象 如:

function foo(a){ this.a = a } var bar = new foo(2); console.log(bar.a); // 2

1
2
3
4
5
6
function foo(a){
    this.a = a
}
 
var bar = new foo(2);
console.log(bar.a); // 2

使用new来调用foo(…)时,我们会构造一个新对象并把它绑定到foo(…)调用中的this上。new是最后一种可以影响函数调用时this绑定行为的方法,我们称之为new绑定。

        this.count ;

隐式丢失

function foo() {

console.log( this.a );

}

var obj = {

a: 2,

foo: foo

};

var bar = obj.foo; // 函数别名!

var a = "oops, global"; // a 是全局对象的属性

bar(); // "oops, global" 

虽然 bar 是 obj.foo 的一个引用,但是实际上,它引用的是 foo 函数本身,因此此时的bar() 其实是一个不带任何修饰的函数调用,因此应用了默认绑定。

functionfoo(){    "use strict";console.log(this.a );}vara =2;foo();// TypeError: `this` is `undefined`

this的优先级

毫无疑问,默认绑定的优先级是四条规则中最低的,所以我们可以先不考虑它。

隐式绑定和显式绑定哪个优先级更高?我们来测试一下:

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
function foo(a){
    console.log(this.a)
}
 
var obj1 = {
    a: 2,
    foo: foo
}
 
var obj2 = {
    a: 3,
    foo: foo
}
 
obj1.foo(); // 2
obj2.foo(); // 3
 
obj1.foo.call(obj2); // 3
obj2.foo.call(obj1); // 2

可以看到,显式绑定优先级更高,也就是说在判断时应当先考虑是否可以存在显式绑定。

现在我们要搞清楚new绑定隐式绑定的优先级谁高谁低 :

function foo(something){ this.a = something } var obj1 = { foo: foo } var obj2 = {} obj1.foo(2); console.log(obj1.a); // 2 obj1.foo.call(obj2,3); console.log(obj2.a); // 3 var bar = new obj1.foo(4) console.log(obj1.a); // 2 console.log(bar.a); // 4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
function foo(something){
    this.a = something
}
 
var obj1 = {
    foo: foo
}
 
var obj2 = {}
 
obj1.foo(2);
console.log(obj1.a); // 2
 
obj1.foo.call(obj2,3);
console.log(obj2.a); // 3
 
var bar = new obj1.foo(4)
console.log(obj1.a); // 2
console.log(bar.a); // 4

可以看到new绑定隐式绑定优先级高。但是new绑定显式绑定谁的优先级更高呢?

function foo(something){ this.a = something } var obj1 = {} var bar = foo.bind(obj1); bar(2); console.log(obj1.a); // 2 var baz = new bar(3); console.log(obj1.a); // 2 console.log(baz.a); // 3

1
2
3
4
5
6
7
8
9
10
11
12
13
function foo(something){
    this.a = something
}
 
var obj1 = {}
 
var bar = foo.bind(obj1);
bar(2);
console.log(obj1.a); // 2
 
var baz = new bar(3);
console.log(obj1.a); // 2
console.log(baz.a); // 3

可以看到,new绑定修改了硬绑定中的this,所以new绑定的优先级比显式绑定更高。

之所以要在new中使用硬绑定函数,主要目的是预先设置函数的一些参数,这样在使用new进行初始化时就可以只传入其余的参数。bind(…)的功能之一就是可以把除了第一个参数(第一个参数用于绑定this)之外的其他参数都传给下层的函数(这种技术称为“部分应用”,是“柯里化”的一种)。举例来说:

function foo(p1,p2){ this.val = p1 p2; } // 之所以使用null是因为在本例中我们并不关心硬绑定的this是什么 // 反正使用new时this会被修改 var bar = foo.bind(null,'p1'); var baz = new bar('p2'); baz.val; // p1p2 }

1
2
3
4
5
6
7
8
9
10
11
12
function foo(p1,p2){
    this.val = p1 p2;
}
 
// 之所以使用null是因为在本例中我们并不关心硬绑定的this是什么
// 反正使用new时this会被修改
var bar = foo.bind(null,'p1');
 
var baz = new bar('p2');
 
baz.val; // p1p2
}

柯里化:在直觉上,柯里化声称“如果你固定某些参数,你将得到接受余下参数的一个函数”。所以对于有两个变量的函数yx,如果固定了 y = 2,则得到有一个变量的函数 2x

    }

3.显式绑定

function foo() {

console.log( this.a );

}

var obj = {

a:2

};

foo.call( obj ); // 2

    硬绑定

    API调用的“上下文”

    都是用CALL APPLY;

4 .new绑定

   用 new 来调用,这种函数调用被称为构造函数调用

   使用 new 来调用函数,或者说发生构造函数调用时,会自动执行下面的操作。

  1. 创建(或者说构造)一个全新的对象。

  2. 这个新对象会被执行 [[ 原型 ]] 连接。

  3. 这个新对象会绑定到函数调用的 this。

  4. 如果函数没有返回其他对象,那么 new 表达式中的函数调用会自动返回这个新对象。

显式绑定 (Explicit Binding)

This在箭头函数中的应用

箭头函数不使用this的四种标准规则,而是根据外层(函数或者全局)作用域来决定this。

我们来看一下箭头函数的词法作用域:

function foo() { // 返回一个箭头函数 return (a) => { // this继承自foo() console.log(this.a) }; } var obj1 = { a: 2 }; var obj2 = { a: 3 }; var bar = foo.call(obj1); bar.call(obj2); // 2, 不是3!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function foo() {
    // 返回一个箭头函数
    return (a) => {
        // this继承自foo()
        console.log(this.a)
    };
}
 
var obj1 = {
    a: 2
};
 
var obj2 = {
    a: 3
};
 
var bar = foo.call(obj1);
bar.call(obj2); // 2, 不是3!

foo()内部创建的箭头函数会捕获调用时foo()的this。由于foo()的this绑定到obj1,bar(引用箭头函数)的this也会绑定到obj1,箭头函数的绑定无法被修改。(new也不行!)

    foo.count = 0;

优先级

1. 函数是否在 new 中调用(new 绑定)?如果是的话 this 绑定的是新创建的对象。

    var bar = new foo()

2. 函数是否通过 call、apply(显式绑定)或者硬绑定调用?如果是的话,this 绑定的是指定的对象。

var bar = foo.call(obj2)

3. 函数是否在某个上下文对象中调用(隐式绑定)?如果是的话,this 绑定的是那个上下文对象。

var bar = obj1.foo()

4. 如果都不是的话,使用默认绑定。如果在严格模式下,就绑定到 undefined,否则绑定到全局对象。

var bar = foo()

显式绑定用到了call()和apply()方法,因为可以直接指定this的绑定对象,因此称之为显式绑定。

总结

如果要判断一个运行中的函数的this绑定,就需要找到这个函数的直接调用位置。找到之后就可以顺序应用下面这四条规则来判断this的绑定对象。

  1. 由new调用?绑定到新创建的对象。
  2. 由call或者apply(或者bind)调用?绑定到指定的对象。
  3. 由上下文对象调用?绑定到那个上下文对象。
  4. 默认:在严格模式下绑定到undefined,否则绑定到全局对象。

1 赞 1 收藏 评论

澳门新萄京官方网站 6

    var i;

被忽略的this

如果你把 null 或者 undefined 作为 this 的绑定对象传入 call、apply 或者 bind

functionfoo(){console.log(this.a );}varobj = {a:2};foo.call( obj );// 2

    for(i=0;i<10;i ){

箭头函数

  1. 只使用词法作用域并完全抛弃错误 this 风格的代码;

  2. 完全采用 this 风格,在必要时使用 bind(..),尽量避免使用 self = this 和箭头函数。

通过foo.call(),我们可以在调用foo时强制把它this绑定到obj上。

        if(i>5){

硬绑定(Hard Binding)

            foo(i)

因为我们强制把foo的this绑定到了obj,无论之后如何调用bar,之后的操作并不会覆盖之前的,它总会在obj上调用foo。

        }

functionfoo(){console.log(this.a );}varobj = {a:2};varbar =function(){    foo.call( obj );};bar();// 2setTimeout( bar,100);// 2// `bar` hard binds `foo`'s `this` to `obj`// so that it cannot be overridenbar.call(window);// 2

    }

硬绑定的应用场景就是创建一个包裹函数,负责接收参数并返回值:

    console.log(foo.count)  //0

functionfoo(something){console.log(this.a, something );returnthis.a something;}varobj = {a:2};varbar =function(){returnfoo.apply( obj,arguments);};varb = bar(3);// 2 3console.log( b );// 5

          

另一种使用方法是创建一个可以重复使用的辅助函数

 // 使用词法作用域解决问题

functionfoo(something){console.log(this.a, something );returnthis.a something;}// simple `bind` helperfunctionbind(fn, obj){returnfunction(){returnfn.apply( obj,arguments);    };}varobj = {a:2};varbar = bind( foo, obj );varb = bar(3);// 2 3console.log( b );// 5

function foo(num) {

由于硬绑定是非常常用的,所以ES5提供了内置方法Function.prototype.bind()

    console.log("foo:" num);

functionfoo(something){console.log(this.a, something );returnthis.a something;}varobj = {a:2};varbar = foo.bind( obj );varb = bar(3);// 2 3console.log( b );// 5

    data.count ;

new Binding

}

使用new来调用foo()时,我们会构造一个新对象并把它绑定到foo()调用中的this上。

var data = {

functionfoo(n){this.studentNum = n;this.name ='cnio'}varbar =newfoo(1)console.log(bar)// foo {studentNum: 1, name: "cnio"}

    count:0

如果foo原型链上也有内容,比如添加

};

foo.prototype.getName =function(){returnthis.name;}

var i;

在控制台打印出的proto中,就有getName属性。

for(i=0;i<10;i ){

使用new关键字时,会发生如下几个步骤

    if(i>5){

创建一个全新的对象。

        foo(i)

这个新对象会被执行[[Prototype]]连接。

    }

这个新对象会绑定到函数调用的this。

}

如果函数没有返回其他对象,那么new表达式中的函数调用会自动返回这个新对象。

console.log(data.count);  // 4

优先级比较

// 用foo标识符来替代this来引用函数对象,回避了this 的问题,完全依赖于变量foo的词法作用域。

前面已经了解了this绑定的四条规则,但是这几种某次应用了多条该怎么办?所以需要测试一下优先级,也就是谁的权利更大些,就听谁的,否则小弟this将不知所措了。

function foo(num) {

隐式绑定 VS 显式绑定

    console.log("foo:" num);

functionfoo(){

    foo.count ;

    console.log( this.a );

}

}varobj1={

foo.count = 0

    a: 2,

var i;

    foo: foo

for(i=0;i<10;i ){

};varobj2 ={

    if(i>5){

    a: 3,

        foo(i)

    foo: foo

    }

};obj1.foo();// 2obj2.foo();// 3obj1.foo.call( obj2 );// 3obj2.foo.call( obj1 );// 2

}

当我们使用call(obj2)显式绑定时,输出的值为obj2的值(a=3),所以显式绑定的优先级更高。

console.log(foo.count) //4

new绑定 VS 隐式绑定

 

functionfoo(something){this.a = something;}varobj1 = {foo: foo};varobj2 = {};obj1.foo(2);console.log( obj1.a );// 2obj1.foo.call( obj2,3);console.log( obj2.a );// 3varbar =newobj1.foo(4);console.log( obj1.a );// 2console.log( bar.a );// 4

*  *  //强制this 指向foo函数对象

可以看到,new绑定的优先级>隐式绑定

    function foo(num) {

那么new绑定的优先级与显式绑定优先级呢?因为new和apply/call无法一起使用,但硬绑定也是显式绑定的一种,可以替换测试

        console.log("foo:" num);

functionfoo(something){this.a = something;}varobj1 = {};varbar = foo.bind( obj1 );bar(2);console.log( obj1.a );// 2varbaz =newbar(3);console.log( obj1.a );// 2console.log( baz.a );// 3

        this.count

new修改了硬绑定调用bar()中的this,代码感觉无法修改this绑定,但是又的确修改了this绑定,这个很特殊,理论上我们可以认为new绑定优先级>显式绑定

    }

综上,优先级比较如下

    foo.count = 0;

new绑定 > 显式绑定 > 隐式绑定

    var i;

    for(i=0; i< 10; i ){

        if(i>5){

            foo.call(foo,i);

        }

    }

    console.log(foo.count)  //4

this是在运行是 绑定的,并不是在编写时绑定的,它的上下文取决于函数调用时的各种条件,this的绑定和和函数声明的位置没有任何关系,只取决于函数调用的方式。

this全面解析

调用栈与调用位置

function baz(){

//当前调用栈是:baz

// 因此,当前的调用中位置是全局作用域

console.log("baz");

bar(); // <--bar的调用位置

}

function bar(){

//当前的调用栈是: baz-> bar

// 因此,当前调用位置在baz

console.log("bar);

foo(); // <-- foo 的调用位置

}

 

function foo(){

//当前的调用栈是: baz-> bar->foo

// 因此,当前调用位置在bar

console.log("foo");

}

baz(); // <-- baz 的调用位置

 

只有运行在非strict mode 下,默认绑定才能绑定到全局对象。

对象属性引用链中只有最顶层或者说最后一层灰影响调用位置。

function foo() {

console.log(this.a);

}

var obj2 = {

a: 42,

foo:foo

};

var obj1 = {

a:2,

obj2: obj2

};

obj1.obj2.foo(); // 42

硬绑定的典型应用场景就是创建一个包裹函数,传入所有的函数并返回接收到的所有的值。

function foo(something){

console.log(this.a,something);

return this.a something;

};

var obj = {

a:2

};

 

var bar = function() {

return foo.apply(obj,arguments);

};

var b = bar(3) ; // 2 3

console.log(b)  // 5

 

另一种方法是创建一个i可以重复使用的辅助函数

function foo(something){

console.log(this.a, something);

return this.a something;

}

// 简单的辅助绑定函数

function bind(fn,obj){

return function(){

return fn.apply(obj,arguments);

};

}

var obj = {

a:2

}

var bar = bind(foo,obj);

var b = bar(3); // 2 3

console.log(b) // 5

 

 

ES5 中提供了内置的方法 Function.prototype.bind,  bind(..) 会返回一个硬编码的新函数,它会

 

把参数设置为this的上下文并调用原始函数。

function foo(something){

console.log(this.a, something);

return this.a something;

}

var obj = {

a:2

}

var bar = foo.bind(obj);

var b = bar(3); // 3 5

console.log(b) // 5

 

API 调用的 上下文

  function foo(el){

console.log(el,this.id);

}

var obj = {  

id: "awesome'

}

// 调用 foo(..)时把this 绑定到obj

[1,2,3].forEach(foo,obj);

// 1 awesome 2 awesome 3 awesome

new可以影响函数调用时this 绑定行为的方法。

  function foo(a){

this.a = a;

     }

var  bar = new foo(2);

console.log(bar.a); // 2

判断this

1.函数是否在new 中调用(new 绑定)? 如果是的话this 绑定的是新创建的对象。

var bar = new foo();

2.函数是否通过call , apply (显示绑定) 或者硬绑定调用? 如果是的话,this的绑定时指定的对象。

va bar = foo.call(obj2)

3.函数是否在某个上下文对象中调用(隐式绑定) ? 如果是的话,this 的绑定时在那个上下文。

var bar = obj1.foo()

4.如果都不是的话,使用默认绑定。如果在严格模式下,就绑定到undefined,否则绑定到全局对象上。  

var bar = foo();

软绑定

function foo(){

console.log("name:" this.name);

}

var obj = {name: "obj"},

obj2 = {name: "obj2"},

obj3 = {name: "obj3"},

obj3 = {name: "obj3"};

var foo0BJ = foo.softBind(obj);

foo0BJ();  // name:obj

obj2.foo = foo.softBind(obj);

obj2.foo(); // name:obj3 <--看!

setTimeout(obj2.foo,10);

澳门新萄京官方网站,// name:obj <--- 应用了软绑定

 

 

 

 

 

本文由澳门新萄京官方网站发布于澳门新萄京赌场网址,转载请注明出处:周全分析,你不知底的javaScript笔记

关键词: