JS-14 this绑定规则；默认绑定；隐式绑定；显式绑定；new绑定call、apply、bind方法；this绑定规则优先级；箭头函数及编写优化+this规则之外；this面试题；

已于 2023-07-20 19:51:11 修改
阅读量381 收藏 2
点赞数 2
分类专栏： JavaScript 文章标签： javascript 前端 开发语言
于 2023-06-13 23:52:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54075517/article/details/131198448
版权
文章详细阐述了JavaScript中this的四种绑定规则：默认绑定、隐式绑定、显式绑定和new绑定，以及call、apply、bind方法的使用。重点讨论了箭头函数的特性，它不绑定this，而是继承外层作用域的this。此外，文章还提供了面试题以检验读者的理解。
摘要由CSDN通过智能技术生成

目录

1_this绑定规则

定义一个函数，采用三种不同的方式对它进行调用，它产生了三种不同的结果

<script>

    // 定义函数
    function foo(name) {
      console.log("foo函数:", this)  
    }

    // 1.方式一: 直接调用
     foo()	//foo函数: Window

    // 2.方式二: 通过对象调起
    var obj = { name: "hhh" }
    obj.bbb = foo
    
    obj.bbb()   //foo函数: Object

    // 3 方式三：call /apply调用
    foo.apply("abc")   //foo函数: String {'abc'}

  </script>

案例启示

  • 函数在调用时，JavaScript会默认给this绑定一个值；

  • this的绑定和定义的位置（编写的位置）没有关系；

  • this的绑定和调用方式以及调用的位置有关系；

  • this是在运行时被绑定的；

this的绑定规则

  • 绑定一：默认绑定；

  • 绑定二：隐式绑定；

  • 绑定三：显示绑定；

  • 绑定四：new绑定；


1.1_默认绑定

在独立函数调用情况下发生：理解成函数没有被绑定到某个对象上进行调用；

常见情况通过赋值

<script>
    // "use strict"

    // 定义函数
    // 1.普通的函数被独立的调用
    function foo() {
      console.log("foo:", this)   //this指向 windows对象
    }
    foo()

    // 2.函数定义在对象中, 但是独立调用
    var obj = {
      name: "hhh",
      bar: function() {
        console.log("bar:", this) 
      }
    }
    var baz = obj.bar
    baz()    //this指向 windows对象

    // 3.高阶函数
    function test(fn) {
      fn()
    }
    test(obj.bar)    //this指向 windows对象

    // 4.严格模式下, 独立调用的函数中的this指向的是undefined
  </script>

1.2_隐式绑定

隐式绑定有一个前提条件：

  • 必须在调用的对象内部有一个对函数的引用（比如一个属性）；

  • 如果没有这样的引用，在进行调用时，会报找不到该函数的错误；

  • 通过引用，间接的将this绑定到了这个对象上；

较常见的调用方式是通过某个对象进行调用的：也就是它的调用位置中，是通过某个对象发起的函数调用

<script>
    // 隐式绑定
    function foo() {
      console.log("foo函数:", this)
    }

    var obj = {
      bar: foo
    }

    obj.bar()  //foo函数: Object

  </script>

1.3_显式绑定

如果对象内部不包含函数的引用，但要在这个对象上强制调用， JavaScript所有函数都可以使用call和apply方法

  • 第一个参数为绑定对象

    • 要求传入一个对象；这个对象的作用是给this准备的。

    • 在调用这个函数时，会将this绑定到这个传入的对象上。

  • 第二个参数，apply为数组，call为参数列表上面的过程

明确的绑定了this指向的对象，称之为 显式绑定

<script>
    // 显式绑定
    var obj = {
      name: "hhh"
    }

    function foo() {
      console.log("foo函数:", this)
    }

    // 执行函数, 并且强制this就是obj对象
    foo.call(obj)		//foo函数: Object
    foo.apply(obj)           //foo函数: Object
    foo.call(123)		//foo函数: Number
    foo.call("abc")		//foo函数: String

  </script>

1.4_new绑定

1.创建新的空对象
2.将this指向这个空对象
3.执行函数体中的代码
4.没有显示返回非空对象时, 默认返回这个对象

<script>

    function foo() {
      this.name = "hhh"
      console.log("foo函数:", this)
    }

    new foo()    //foo函数: foo      属于object类型

  </script>

2_call、apply、bind

通过call或者apply绑定this对象： 显示绑定后，this就会明确的指向绑定的对象

 <script>

    // call/apply
    function foo(name, age, height) {
      console.log("foo函数被调用:", this)
      console.log("打印参数:", name, age, height)
    }

    // ()调用
    foo("hhh", 18, 1.88)  //foo函数被调用: Window   打印参数: hhh 18 1.88

    // apply
    // 第一个参数: 绑定this
    // 第二个参数: 传入额外的实参, 以数组的形式
    foo.apply("apply", ["kobe", 30, 1.98])   //foo函数被调用: String {'apply'}   打印参数: kobe 30 1.98

    // call
    // 第一个参数: 绑定this
    // 参数列表: 后续的参数以多参数的形式传递, 会作为实参
    foo.call("call", "james", 25, 2.05) //foo函数被调用: String {'call'}   打印参数: james 25 2.05

  </script>

一个函数显示绑定到一个对象上

  • bind() 方法创建一个新的绑定函数（bound function，BF）；

  • 绑定函数是一个 exotic function object（怪异函数对象，ECMAScript 2015 中的术语）

  • 在 bind() 被调用时，这个新函数的 this 被指定为 bind() 的第一个参数，而其余参数将作为新函数的参数，供调用时使用

function foo() {
      console.log("foo:", this)
    }

    var obj = { name: "hhh" }

    // 需求: 调用foo时, 绑定到obj对象身上(obj对象本身没有函数)
    // 1.bind函数的基本使用
    var bar = foo.bind(obj)  // this绑定 obj  
    bar()     // foo: {name: 'hhh'}


<script>
    function foo(name, age, height, address) {
      console.log("foo:", this)
      console.log("参数:", name, age, height, address)
    }
    var obj = { name: "hhh" }

    // 2.bind函数的其他参数(了解)
    var bar = foo.bind(obj, "kobe", 18, 1.88)
    bar("james")	//foo: {name: 'hhh'}	参数: kobe 18 1.88 james

  </script>

内置函数

有时候，会调用一些JavaScript的内置函数（类似windows对象本身拥有的函数），或者一些第三方库中的内置函数。

  • 这些内置函数会要求传入另外一个函数；

  • JavaScript内部或者第三方库内部会帮助执行；

  • 这些函数中的this又是如何绑定？一般是看相关文档解释，或者根据经验

比如setTimeout、数组的forEach、div的点击

<body>
  
  <button>按钮</button>

  <script>
    // 内置函数(第三方库): 根据一些经验
    // 1.定时器
    // setTimeout(function() {
    //   console.log("定时器函数:", this)
    // }, 1000)

    // 2.按钮的点击监听
    // var btnEl = document.querySelector("button")
    // btnEl.onclick = function() {
    //   console.log("btn的点击:", this)
    // }

    // btnEl.addEventListener("click", function() {
    //   console.log("btn的点击:", this)
    // })

    // // 3.forEach
    var names = ["abc", "cba", "nba"]
    names.forEach(function(item) {
      console.log("forEach:", this)		 //String
    }, "aaaa")

  </script>

</body>

3_this绑定规则优先级

如果一个函数调用位置应用了多条规则，优先级谁最高？

  • 默认规则的优先级最低

  • 显示绑定优先级高于隐式绑定

  • new绑定优先级高于隐式绑定

  • new绑定优先级高于bind

    • new绑定和call、apply是不允许同时使用的，所以不存在谁的优先级更高

    • new绑定可以和bind一起使用，new绑定优先级更高


规则之外的情况

（1）忽略显示绑定

在显示绑定中，参数传入一个null或者undefined，那么显示绑定会被忽略，使用默认规则：

 // 情况一: 显式绑定null/undefined, 那么使用的规则是默认绑定
    function foo() {
      console.log("foo:", this)
    }

    foo.apply("abc")  //foo: String {'abc'}
    foo.apply(null)   //foo: Window {window: Window, self: Window, document: document, name: '', location: Location, …}
    foo.apply(undefined)  //foo: Window {window: Window, self: Window, document: document, name: '', location: Location, …}

（2）间接函数引用

创建一个函数的间接引用，这种情况使用默认绑定规则。

  • 赋值(obj2.foo = obj1.foo)的结果是foo函数；

  • foo函数被直接调用，那么是默认绑定；

 var obj1 = {
      name: "obj1",
      foo: function() {
        console.log("foo:", this)
      }
    }
    var obj2 = {
      name: "obj2"
    };

    obj2.foo = obj1.foo
    obj2.foo()		//foo: {name: 'obj2', foo: ƒ}

4_箭头函数【重点】

箭头函数是ES6增加的编写函数的方法，比函数表达式更简洁：

  • 箭头函数不会绑定this、arguments属性；

  • 箭头函数不能作为构造函数来使用（不能和new一起来使用，会抛出错误）；

箭头函数编写

  • (): 函数的参数

  • {}: 函数的执行体

  // function写法
  var foo1 = function(name, age) {
      console.log("函数体代码", this, arguments)
      console.log(name, age)
    }

    // 2.箭头函数完整写法
    var foo2 = (name, age) => {
      console.log("箭头函数的函数体")
      console.log(name, age)
    }

4.1_箭头函数的编写优化

优化一：如果只有一个参数()可以省略

var names = ["abc", "cba", "nba"]
 var nums = [20, 30, 11, 15, 111]

    // 1.优化一: 如果箭头函数只有一个参数, 那么()可以省略
    names.forEach(item => {
      console.log(item)
    })
    var newNums = nums.filter(item => {
      return item % 2 === 0
    })

优化二：函数执行体中只有一行代码, 可以省略大括号{} 和return， 并且这行代码会作为整个函数的返回值

// 2.优化二: 如果函数体中只有一行执行代码, 那么{}可以省略
 names.forEach( item => console.log(item) )
// 只有一行代码，要么同时省略{}和return，要么两个都不省略
var newNums = nums.filter(item => {
      return item % 2 === 0
    })

优化三： 如果函数执行体只返回一个对象, 那么需要给这个对象加上()

var arrFn = () => ["abc", "cba"]
var arrFn = () => {} // 注意: 这里是{}执行体
var arrFn = () => ( { name: "xxx" } )
 console.log(arrFn())	//object

4.2_this规则之外 – ES6箭头函数

箭头函数不使用this的四种标准规则（也就是不绑定this），而是根据外层作用域来决定this。
箭头函数并不绑定this对象，那么this引用就会从上层作用于中找到对应的this

// 1.普通函数中是有this的标识符
    function foo() {
      console.log("foo", this)
    }
    foo()              //foo Window
    foo.apply("aaa")  // foo String {'aaa'}

    // 2.箭头函数中, 压根没有this
    var bar = () => {
      console.log("bar:", this)
    }
    bar()       //bar: Window {window: Window, self: Window, document: document, name: '', location: Location, …}
    // 通过apply调用时, 也是没有this，这里的this指向的是windows中的变量this,而不是绑定某个对象
    bar.apply("aaaa")   //bar: Window {window: Window, self: Window, document: document, name: '', location: Location, …}
    console.log("全局this:", this)  //全局this: Window {window: Window, self: Window, document: document, name: '', location: Location, …}

    // 3.this的查找规则
    var obj = {
      name: "obj",
      foo: () => {
        var bar = () => {
          console.log("bar:", this)
        }
        return bar       
      }
    }
    var fn = obj.foo()
    // 无法绑定。箭头函数内部不会通过this绑定调用的对象，而是当成一个变量，现在本身作用域查找，找不到就去上层作用域查找
    fn.apply("bbb")   //bar: Window {window: Window, self: Window, document: document, name: '', location: Location, …}

模拟网络请求的案例：

// 网络请求的工具函数
    function request(url, callbackFn) {
      var results = ["abc", "cba", "nba"]
      callbackFn(results)
    }

    // 实际操作的位置(业务)
    var obj = {
      names: [],
      network: function() {
        // 1.早期写法
        // var _this = this
        // request("/names", function(res) {
        //   _this.names = [].concat(res)
        // })

        // 2.箭头函数写法。虽然箭头函数中的this不会绑定，但是this先在自身查找，找不到往上层作用域查找，正好上层是function，this在function中可以被用来绑定
        request("/names", (res) => {
          this.names = [].concat(res)
        })
      }
    }

    obj.network()
    console.log(obj)	//Object  names(3) ['abc', 'cba', 'nba']  network:ƒ ()



5_面试题

面试题一

var name = "window";

var person = {
  name: "person",
  sayName: function () {
    console.log(this.name);
  }
};

function sayName() {
  var sss = person.sayName; //通过赋值，使用函数

  sss(); // 独立函数调用， 默认绑定, window -> window

  person.sayName(); // 调用对象内部的函数: 隐式绑定, person -> person

  (person.sayName)(); // 跟上面一样，加了括号而已: 隐式绑定, person -> person

  (b = person.sayName)(); // 术语: 间接函数引用, window -> window
}

sayName();

面试题二

var name = 'window'   //windows全局对象变量 name
// {} -> 对象
// {} -> 代码块
var person1 = {
  name: 'person1',
  foo1: function () {
    console.log(this.name)  
  },
  foo2: () => console.log(this.name),   //不绑定this，往上层作用域找，这里是windows
  foo3: function () {
    return function () {    //在函数内部，返回一个function函数
      console.log(this.name)
    }
  },
  foo4: function () {  
    return () => {		//在函数内部，返回一个箭头函数  ，不绑定this
      console.log(this.name)
    }
  }
}
var person2 = { name: 'person2' }

//题目:
person1.foo1(); // 进入foo1函数，this绑定自身对象person1
person1.foo1.call(person2); // 进入foo1对象，绑定person2，this指向person2

person1.foo2(); //进入foo2函数，箭头函数不绑定foo2的person1，寻找上层作用域windows
//虽然调用对象内部函数，但这个对象是箭头函数不绑定this。寻找 上层作用域: window
person1.foo2.call(person2);//进入foo2函数,foo2绑定person，箭头函数不绑定foo2的person2，寻找上层作用域windows

person1.foo3()();//进入foo3函数，调用，抛出(返回)的function函数【理解为抛出到windows】
//独立函数调用，在函数内部被返回的函数。默认绑定: window
person1.foo3.call(person2)(); //进入foo3函数，foo3绑定person2，调用，抛出的function函数到windows
person1.foo3().call(person2); //进入foo3函数，foo3绑定person2，抛出的函数未被调用，所以this仍在foo3的作用域，this绑定person2

person1.foo4()();//进入foo4函数，调用，抛出(返回)的箭头函数，不绑定this（理解为this不指向windows），所以this寻找上层作用域，也就是foo4绑定的person1
person1.foo4.call(person2)(); //进入foo4函数，foo4绑定person2,；调用，抛出(返回)的箭头函数，不绑定this（理解为this不指向windows），所以this寻找上层作用域，也就是foo4绑定的person2
person1.foo4().call(person2);  //进入foo4函数，foo4绑定person2，函数内部抛出的箭头函数未被调用，所以在foo4的作用域运行，但是this不被foo4绑定，寻找上层作用域，也就是person1

面试题三

var name = 'window'   

/*
  1.创建一个空的对象
  2.将这个空的对象赋值给this
  3.执行函数体中代码
  4.将这个新的对象默认返回
*/
function Person(name) {
  this.name = name
  this.foo1 = function () {
    console.log(this.name)
  },
  this.foo2 = () => console.log(this.name),
  this.foo3 = function () {
    return function () {
      console.log(this.name)
    }
  },
  this.foo4 = function () {
    return () => {
      console.log(this.name)
    }
  }
}

// person1/person都是对象(实例instance)
var person1 = new Person('person1')
var person2 = new Person('person2')


// 面试题目:
person1.foo1() // 隐式绑定: person1
person1.foo1.call(person2) // 显式绑定: person2

person1.foo2() // 上层作用域查找: person1
person1.foo2.call(person2) // 上层作用域查找: person1

person1.foo3()() // 默认绑定: window
person1.foo3.call(person2)() // 默认绑定: window
person1.foo3().call(person2) // 显式绑定: person2

person1.foo4()() // 上层作用域查找: person1(隐式绑定)
person1.foo4.call(person2)() //  上层作用域查找: person2(显式绑定)
person1.foo4().call(person2) // 上层作用域查找: person1(隐式绑定)

面试题四

var name = 'window'

/*  构造函数。
  1.创建一个空的对象
  2.将这个空的对象赋值给this
  3.执行函数体中代码
  4.将这个新的对象默认返回
*/
function Person(name) {
  this.name = name
  this.obj = {
    name: 'obj',
    foo1: function () {
      return function () {
        console.log(this.name)
      }
    },
    foo2: function () {
      return () => {
        console.log(this.name)
      }
    }
  }
}
//构造函数被调用，新建实例对象
var person1 = new Person('person1')
var person2 = new Person('person2')

person1.obj.foo1()()   //进入foo1函数，foo1本身绑定person1；调用，抛出的function函数到windows
// 默认绑定: window
person1.obj.foo1.call(person2)() //进入foo1函数，foo1本身绑定person2；调用，抛出的function函数到windows
// 默认绑定: window
person1.obj.foo1().call(person2) //进入foo1函数，foo1本身绑定person2；被抛出的function函数未被调用，所以this不绑定windows，而是在foo1作用域，所以this绑定person2
// 显式绑定: person2

person1.obj.foo2()() //进入foo2函数，foo2本身绑定person1；调用，抛出的箭头函数到windows，但是this不绑定windows，而是寻找上层作用域，也就是foo2，所以This绑定perison1
// 上层作用域查找: obj(隐式绑定)
person1.obj.foo2.call(person2)() //进入foo2函数，foo2本身绑定person2；调用，抛出的箭头函数到windows。但是this不绑定windows，而是寻找上层作用域，也就是foo2，所以This绑定perison2
// 上层作用域查找: person2(显式绑定)
person1.obj.foo2().call(person2) //进入foo2函数，foo2本身绑定person2；抛出的箭头函数到windows，未被调用，所以箭头函数的this作用在foo2，但是不绑定foo2，而是寻找上层作用域person1
// 上层作用域查找: obj(隐式绑定)
龙猫呗
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简单谈谈javascript中this的隐式绑定
10-22
在JavaScript中，this 的概念比较复杂。除了在面向对象编程中，this 还是随处可用的。这篇文章介绍了this的隐式绑定，希望大家能够喜欢。
Js--this的绑定
m0_57909743的博客
09-04 233
this的绑定。
js 中的this，默认绑定、隐式绑定、显式绑定、new绑定、箭头函数绑定详解
FREEDOM
09-17 803
壹 ❀ 引 可以说this与闭包、原型链一样，属于JavaScript开发中老生常谈的问题了，百度一搜，this相关的文章铺天盖地。可开发好几年，被几道this题安排明明白白的人应该不在少数（我就是其一）。我觉得this概念抽象，变化多端总是让人晕头转向，但平心它并不是有多难，今天我们就从this绑定的五种场景（默认绑定、隐式绑定、显式绑定、new绑定、箭头函数绑定）出发，静下心来好好聊聊这个 this，本文开始。 贰 ❀ this默认绑定 this默认绑定我们可以理解为函数调用时无任何调用前缀的情.
JS中this的绑定规则的优先级
qq_44482048的博客
10-19 364
如果一个函数调用位置应用了多条this绑定规则，谁的优先级会更高？new绑定 > 显式绑定（call/apply/bind）> 隐式绑定(obj.foo()) > 默认绑定(独立函数调用)
js中this绑定详解
eyes++的博客
04-29 234
直接上代码，代码中有详细解释以及例子 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0">
JavaScript高级-this绑定规则+箭头函数
10-21
- 当`this`绑定规则冲突时，优先级如下：new绑定 > 隐式绑定 > 默认绑定 > 显式绑定（bind优先级高于apply/call） - 如果在`new`绑定中尝试使用`apply()`或`call()`，`this`仍然会指向新创建的对象，而不是传递的...
JS中this的4种绑定规则详解
10-15
本文将详细讲解JS中`this`的四种绑定规则：默认绑定、隐式绑定、显示绑定和硬绑定。 1. **默认绑定**： 当函数独立调用时（不作为任何对象的方法调用），`this`会默认绑定到全局对象。在浏览器环境中，全局对象...
JavaScript中this的四个绑定规则总结
10-21
显式绑定是通过`call()`、`apply()`或`bind()`方法强制设置`this`的值。这些方法允许我们明确指定`this`的绑定对象。 ```javascript function foo() { console.log(this.a); } var obj = { a: 2 }; foo.call(obj);...
JavaScript this绑定过程深入详解
10-17
显式绑定是通过一些函数方法，如Function.prototype.call()和Function.prototype.apply()，来手动指定函数调用的this值。通过这些方法，即使函数不是被对象所引用，也可以强制改变函数内部的this指向。 4. new绑定 ...
JS基础知识04——this的绑定规则及优先级
weixin_43473114的博客
01-06 351
this在不同应用场景中，如何取值？？？ this的使用场景有： 作为普通函数被调用 使用call，apply，bind被调用 作为对象方法被调用 作为对象方法中的函数被调用 箭头函数中被调用 在class中被作为方法调用 this在各个场景中取什么样的值是在函数执行的时候确认的，不是在函数定义的时候确认的。 1. 作为普通函数被调用 function fn1() { console...
JS中的this绑定
izwell的博客
02-14 371
JS中的this绑定 一共有5种情况，下面一一进行介绍 1、默认绑定 默认绑定中的this指向undefined或者window,根据环境不同，指向不同。在strict模式下，指向undefined 2、隐式绑定 隐式绑定简单来说就是谁调用的绑定谁 3、显示绑定 使用apply、bind、call来进行强制的显示绑定，需要注意bind绑定返回的是一个函数，而apply和call是函数调用，而且ap...
this绑定的优先级
weixin_34347651的博客
09-07 140
我们已经了解了 this绑定 的四条规则，一个位置调用多条规则，需要指定规则的优先级。 显然，默认绑定的优先级是最低的。 function foo() { console.log( this.a ); } var obj1 = { a: 111, foo: foo }; var obj2 = { a: 222, foo: foo }; obj1.foo(...
你不知道的js--this的显示绑定
web分享客的博客
09-03 343
显示绑定：使用call（）、apply（）、bind（）方法进行强制绑定。   1、硬绑定            2、API调用的上下文   
五种绑定彻底弄懂this，默认绑定、隐式绑定、显式绑定、new绑定、箭头函数绑定详解
行星飞行的博客
07-29 651
可以说this与闭包、原型链一样，属于JavaScript开发中老生常谈的问题了，但开发好几年，依然被几道this指向题安排明明白白的人应该不在少数。对于初学者而言，this概念抽象，变化多端总是让人晕头转向，但平心而论它并没有多难，今天我们就从this绑定的五种场景（默认绑定、隐式绑定、显式绑定、new绑定、箭头函数绑定）出发，静下心来好好聊聊这个this，本文开始。...
this绑定规则优先级
qq_42504734的博客
03-10 119
判断this 现在我们可以根据优先级来判断函数在某个调用位置应用的是哪条规则。可以按照下面的 顺序来进行判断： 1. 函数是否在 new 中调用（new 绑定）？如果是的话 this 绑定的是新创建的对象。 var bar = new foo() 2. 函数是否通过 call、apply（显式绑定）或者硬绑定调用？如果是的话，this 绑定的是 指定的对象。 var bar = foo.call(obj2) 3. 函数是否在某个上下文对象中调用（隐式绑定）？如果是的话，this 绑定的是那个上 下文对
this绑定规则的优先级
最新发布
xiaoxiannvh的博客
02-08 388
this绑定规则的优先级
JavaScript this绑定规则
cc_fys的博客
06-20 374
每个函数的this是在调用时被绑定的，完全取决于函数的调用位置。1 默认绑定function foo() { console.log(this); //输出：Window {postMessage: ƒ, blur: ƒ, focus: ƒ, close: ƒ, frames: Window, …} console.log(this.a); //输出：2 } var...
JS：this的绑定规则
elevenhope的博客
02-09 404
一、默认绑定 this默认指向了window全局对象。 1.全局环境下的this指向了window console.log(this); // Window 2.函数独立调用，函数内部的this也指向了window function fn(){ console.log(this); } fn(); // Window 3.被嵌套的函数独立调用时，this默认指向了window var a = 0; var obj = { a: 2, foo: function() {
JavaScript this绑定过程
明月如霜丶
01-08 337
在理解this 的绑定过程之前，首先要理解调用位置：调用位置就是函数在代码中被调用的位置（而不是声明的位置）。只有仔细分析调用位置才能回答这个问题：这个this 到底引用的是什么？通常来说，寻找调用位置就是寻找“函数被调用的位置”，但是做起来并没有这么简单，因为某些编程模式可能会隐藏真正的调用位置。最重要的是要分析调用栈（就是为了到达当前执行位置所调用的所有函数）。我们关心的调用位置就在当前正在执...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值