Javascript中this的指向

作者: 未路过 | 来源:发表于2022-05-13 19:41 被阅读0次

关于js函数中this的指向的问题
JavaScript中this指向
javascript中的this指向
Javascript 中 this 的指向
JavaScript中的this指向
javascript中this的指向
javascript中的this指向
javaScript中this的指向
javascript中的this指向
Javascript中this的指向

1. this的作用

从某些角度来说, 开发中如果没有this, 很多的问题我们也是有解决方案

但是没有this, 会让我们编写代码变得非常的不方便，就是改一个东西的话，就要很多东西该。

var obj = {
  name: "why",
  eating: function() {
    console.log(this.name + "在吃东西")
  },
  running: function() {
    console.log(this.name + "在跑步")
  },
  studying: function() {
    console.log(this.name + "在学习")
  }
}

obj.eating();
obj.running();
obj.studying();

如果不使用this，可以使用
var obj = {
  name: "why",
  eating: function() {
    console.log(obj.name + "在吃东西")
  },
  running: function() {
    console.log(obj.name + "在跑步")
  },
  studying: function() {
    console.log(obj.name + "在学习")
  }
}
//如果哪一个obj的名字改了，就要改eating,running,studying里面的所有obj。比较麻烦。如果使用this的话，
//就只用该obj就好了
var obj100 = {
  name: "why",
  eating: function() {
    console.log(this.name + "在吃东西")
  },
  running: function() {
    console.log(this.name + "在跑步")
  },
  studying: function() {
    console.log(this.name + "在学习")
  }
}

obj100.eating();
obj100.running();
obj100.studying();

2. this在全局作用域下的指向

在全局作用域下

浏览器下指向: window(globalObject)

Node环境指向: {} （一个空的对象）（node指向js代码的时候，会把js文件当作一个模块，

module-->加载--->编译--->放到一个函数里面--->执行这个函数.apply({})）

console.log(this)
//Window {window: Window, self: Window, document: document, name: '', location: Location, …}
console.log(window)
//Window {window: Window, self: Window, document: document, name: '', location: Location, …}

但是，开发中很少直接在全局作用于下去使用this，通常都是在函数中使用。

所有的函数在被调用时，都会创建一个执行上下文：
这个上下文中记录着函数的调用栈、AO对象等；
this也是其中的一条记录；

在执行代码的时候，比如console.log(this.name),就回去函数执行上下文栈中去看一下这个this到底是谁。那么this到底是谁呢？在这里，this是动态绑定的，就是指函数马上要被执行的时候，才会被绑定上去。不是在代码编译的时候确定的。是在函数马上执行的时候，才确定this是谁。所以有非常多的绑定规则。

37.png

this指向什么, 跟函数所处的位置是没有关系的.跟函数的调用方式以及调用的位置有关系。
注意把this.a 和变量a区分。

3. this绑定规则

绑定一：默认绑定

函数没有被绑定到某个对象上进行调用（独立函数调用）

案例一：普通函数调用

该函数直接被调用，并没有进行任何的对象关联；
这种独立的函数调用会使用默认绑定，通常默认绑定时，函数中的this指向全局对象（window）；

function foo() {
  console.log(this); // window
}

foo();

案例二：函数调用链（一个函数又调用另外一个函数）

所有的函数调用都没有被绑定到某个对象上；

// 2.案例二:
function test1() {
  console.log(this); // window
  test2();
}

function test2() {
  console.log(this); // window
  test3()
}

function test3() {
  console.log(this); // window
}
test1();

案例三：把对象调用的函数赋值给全局作用的变量

 3.案例三:
 var obj = {
   name: "why",
   foo: function() {
     console.log(this)
   }
 }

 var bar = obj.foo
 bar() // window

案例四：将函数作为参数，传入到另一个函数中

function foo(func) {
  func()
}

function bar() {
  console.log(this); // window
}

foo(bar);

我们对案例进行一些修改，考虑一下打印结果是否会发生变化：

这里的结果依然是window，为什么呢？
原因非常简单，在真正函数调用的位置，并没有进行任何的对象绑定，只是一个独立函数的调用；

function foo(func) {
  func()
}

var obj = {
  name: "why",
  bar: function() {
    console.log(this); // window
  }
}

foo(obj.bar);

案例五：注意区分this和变量的区别（this.a 和 a的区别）

// 5.案例五:
  var a = "window a"
    function foo() {
      var a = "foo a"
      function bar() {
        console.log(this)//window
        console.log(this.a);//window a
        console.log(a);//foo a
      }
      return bar
    }

    var fn = foo()
    fn()

绑定二：隐式绑定

另外一种比较常见的调用方式是通过某个对象进行调用的：

也就是它的调用位置中，是通过某个对象发起的函数调用。

案例一：通过对象调用函数

foo的调用位置是obj.foo()方式进行调用的
那么foo调用时this会隐式的被绑定到obj对象上

function foo() {
  console.log(this); // obj对象
}

var obj = {
  name: "why",
  foo: foo
}

obj.foo();

案例二：案例一的变化

我们通过obj2又引用了obj1对象，再通过obj1对象调用foo函数；
那么foo调用的位置上其实还是obj1被绑定了this；

function foo() {
  console.log(this); // obj1对象
}

var obj1 = {
  name: "obj1",
  foo: foo
}

var obj2 = {
  name: "obj2",
  obj1: obj1
}

obj2.obj1.foo();

案例三：隐式丢失

结果最终是window，为什么是window呢？
因为foo最终被调用的位置是bar，而bar在进行调用时没有绑定任何的对象，也就没有形成隐式绑定；
相当于是一种默认绑定；

function foo() {
  console.log(this);
}

var obj1 = {
  name: "obj1",
  foo: foo
}

// 讲obj1的foo赋值给bar
var bar = obj1.foo;
bar();

绑定三：显示绑定

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

必须在调用的对象内部有一个对函数的引用（比如一个属性）；
如果没有这样的引用，在进行调用时，会报找不到该函数的错误；
正是通过这个引用，间接的将this绑定到了这个对象上；

如果我们不希望在 对象内部 包含这个函数的引用，同时又希望在这个对象上进行强制调用，该怎么做呢？

JavaScript所有的函数都可以使用call和apply方法（这个和Prototype有关）。

   它们两个的区别这里不再展开；

    其实非常简单，第一个参数是相同的，后面的参数，apply为数组，call为参数列表；

这两个函数的第一个参数都要求是一个对象，这个对象的作用是什么呢？就是给this准备的。

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

因为上面的过程，我们明确的绑定了this指向的对象，所以称之为 显示绑定。

3.1. call、apply

通过call或者apply绑定this对象

显示绑定后，this就会明确的指向绑定的对象

function foo() {
  console.log(this); //window
}

foo.call(window); // window
foo.call({name: "why"}); // {name: "why"}
foo.call(123); // Number对象,存放时123

 function foo() {
   console.log("函数被调用了", this)
 }

// 1.foo直接调用和call/apply调用的不同在于this绑定的不同
// foo直接调用指向的是全局对象(window)
 foo() //window

 var obj = {
   name: "obj"
 }

// call/apply是可以指定this的绑定对象
 foo.call(obj) //obj
 foo.apply(obj)//obj
 foo.apply("aaaa")//'aaa'


// 2.call和apply有什么区别?
function sum(num1, num2, num3) {
  console.log(num1 + num2 + num3, this)
}

sum.call("call", 20, 30, 40)
sum.apply("apply", [20, 30, 40])

// 3.call和apply在执行函数时,是可以明确的绑定this, 这个绑定规则称之为显示绑定

3.2. bind函数

如果我们希望一个函数总是显示的绑定到一个对象上，可以怎么做呢？

function foo() {
  console.log(this)
}

// foo.call("aaa")
// foo.call("aaa")
// foo.call("aaa")
// foo.call("aaa")
//想foo的this一直绑定到aaa上面的话，每次都要用foo.call("aaa")
//很麻烦，想直接调用foo()就可以绑定aaa



var newFoo = foo.bind("aaa")

//bind会返回一个新的函数，这个函数里面的this就是aaa
// 默认绑定和显示绑定bind冲突: 优先级(显示绑定)

newFoo()
newFoo()
newFoo()
newFoo()
newFoo()
newFoo()

方案一：自己手写一个辅助函数（了解）

我们手动写了一个bind的辅助函数
这个辅助函数的目的是在执行foo时，总是让它的this绑定到obj对象上

function foo() {
  console.log(this);
}

var obj = {
  name: "why"
}

function bind(func, obj) {
  return function() {
    return func.apply(obj, arguments);
  }
}

var bar = bind(foo, obj);

bar(); // obj对象
bar(); // obj对象
bar(); // obj对象

方案二：使用Function.prototype.bind

function foo() {
  console.log(this);
}

var obj = {
  name: "why"
}

var bar = foo.bind(obj);

bar(); // obj对象
bar(); // obj对象
bar(); // obj对象

绑定四：new绑定

JavaScript中的函数可以当做一个类的构造函数来使用，也就是使用new关键字。

使用new关键字来调用函数时，会执行如下的操作：

1.创建一个全新的对象；
2.这个新对象会被执行Prototype连接；
3.这个新对象会绑定到函数调用的this上（this的绑定在这个步骤完成）；
4.如果函数没有返回其他对象，表达式会返回这个新对象；

// 我们通过一个new关键字调用一个函数时(构造器), 这个时候this是在调用这个构造器时创建出来的对象
// this = 创建出来的对象
// 这个绑定过程就是new 绑定

function Person(name, age) {
  this.name = name
  this.age = age
}

var person = new Person("why", 18)
console.log(person.name, person.age)

var p2 = new Person("kobe", 30)
console.log(p2.name, p2.age)

new 一个对象的四个过程
1.创建一个空对象

 var obj = new Object()

2.设置原型链，将obj的proto成员指向了Person函数对象的prototype成员对象

obj.__prototype = Person.prototype

3、让Person中的this指向obj，并执行Person的函数体

var result = Person.call(obj)

4、判断Person的返回值类型，如果是值类型，返回obj。如果是引用类型，就返回这个引用类型的对象。
注意：若构造函数中返回this或返回值是基本类型（number、string、boolean、null、undefined）的值，则返回新实例对象；若返回值是引⽤类型的值，则实际返回值为这个引⽤类型。

if (typeof(result) == "object"){
  person = result;
} else {
  person = obj
}

return person

3.4 一些函数里面this的分析

有些时候，我们会调用一些JavaScript的内置函数，或者一些第三方库中的内置函数。

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

我们自己并不会显示的调用这些函数，而且JavaScript内部或者第三方库内部会帮助我们执行；

这些函数中的this又是如何绑定的呢？

1.setTimeout

// 1.setTimeout


 setTimeout(function() {
   console.log(this) // window
 }, 2000)
//将函数传递给setTimeOut函数，相当于下面的将fn传递给hySetTimeout函数
//setTimeOut里面是具体怎么调用这个fn函数的我们是不知道的
/* 可能是fn(),这个时候是this
可能是fn.call("abc")，这个时候this就是abc*/

/*所以用系统给我们的setTimeout的时候，是直接调用fn()
所以传入普通函数的时候，this指向的都是window */


// function hySetTimeout(fn, duration) {
//   fn.call("abc")
// }

// hySetTimeout(function() {
//   console.log(this) // window
// }, 3000)

为什么这里是window呢？

这个和setTimeout源码的内部调用有关；
setTimeout内部是通过apply进行绑定的this对象，并且绑定的是全局对象(window)；

2.监听点击

// 2.监听点击
 const boxDiv = document.querySelector('.box')
boxDiv.onclick = function() {
  console.log(this)
} 
/*
把函数传递给了boxDiv的onclick这个属性，
函数在点击div的时候执行，执行的时候函数里面的this是什么呢？
其实内部是boxDiv.onclick()这个样子调用
就是隐士绑定，this就是boxDiv
*/

/* boxDiv.addEventListener('click', function() {
  console.log(this)
})
boxDiv.addEventListener('click', function() {
  console.log(this)
})
boxDiv.addEventListener('click', function() {
  console.log(this)
}) */

/* 
拿到所有的函数，然后
fn.call(boxDiv)进行调用

*/

获取元素节点，并且监听点击：

在点击事件的回调中，this指向谁呢？box对象；
这是因为在发生点击时，执行传入的回调函数被调用时，会将box对象绑定到该函数中；

3.数组.forEach/map/filter/find


// 3.数组.forEach/map/filter/find
/* 

高阶函数在用的时候，参数传入的函数是怎么被回调的？


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

/* 

abc Window {window: Window, self: Window, document: document, name: '', location: Location, …}
test.html:112 cba Window {window: Window, self: Window, document: document, name: '', location: Location, …}
test.html:112 nba Window {window: Window, self: Window, document: document, name: '', location: Location, …}
*/

/* 
什么都不传的话，这里默认this是window
forEach中传入的第二个参数就是this的绑定

*/

var obj = {
  name:'why',
  age:18
}

names.forEach(function(item) {
  console.log(item, this)
}, obj)

/* 
abc {name: 'why', age: 18}
test.html:127 cba {name: 'why', age: 18}
test.html:127 nba {name: 'why', age: 18}
*/


names.map(function(item) {
  console.log(item, this)
})

/* 
abc Window {window: Window, self: Window, document: document, name: '', location: Location, …}
test.html:145 cba Window {window: Window, self: Window, document: document, name: '', location: Location, …}
test.html:145 nba Window {window: Window, self: Window, document: document, name: '', location: Location, …}
*/

names.map(function(item) {
  console.log(item, this)
}, obj)

/* 
abc {name: 'why', age: 18}
test.html:151 cba {name: 'why', age: 18}
test.html:151 nba {name: 'why', age: 18}
*/

function foo(){
  console.log(this );
}

var obj3 = { 
  name:'obj3'
}

foo.call()//window
foo.call(obj3)//obj3

在forEach中传入的函数打印的也是Window对象；
这是因为默认情况下传入的函数是自动调用函数（默认绑定）；

3.5 规则优先级

1.默认规则的优先级最低

毫无疑问，默认规则的优先级是最低的，因为存在其他规则时，就会通过其他规则的方式来绑定this

2.显示绑定优先级高于隐式绑定

/ 1.call/apply的显示绑定高于隐式绑定
// obj.foo.apply('abc')
// obj.foo.call('abc')

// 2.bind的优先级高于隐式绑定
// var bar = obj.foo.bind("cba")
// bar()


// 3.更明显的比较
function foo() {
  console.log(this)
}

var obj = {
  name: "obj",
  foo: foo.bind("aaa")
}

obj.foo()//'aaa'

3. new绑定优先级高于隐式绑定

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

// new的优先级高于隐式绑定

/* 函数是可以通过new关键字来使用的 
如果里面的this指向obj，则隐式绑定优先级大，
如果this指向foo创建出来的函数对象，则new的绑定优先级大
*/

//obj.foo('123')//{name: 'obj', foo: ƒ}
 var test = new obj.foo('123');
 console.log(test.name);//'123'

4.new绑定优先级高于bind

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

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

// 结论: new关键字不能和apply/call一起来使用

// new的优先级高于bind
function foo() {
  console.log(this)
}

// var bar = foo.bind("aaa")

// var obj = new bar()//// 打印foo, 说明使用的是new绑定


// new绑定 > 显示绑定(apply/call/bind) > 隐式绑定(obj.foo()) > 默认绑定(独立函数调用)

优先级总结：

new绑定 > 显示绑定（bind）> 隐式绑定 > 默认绑定

3.6 this规则之外 – 忽略显示绑定

如果在显示绑定中，我们传入一个null或者undefined，那么这个显示绑定会被忽略，使用默认规则

function foo() {
  console.log(this)
}

foo.apply("abc")//String {'abc'}
foo.apply({})//{}

// apply/call/bind: 当传入null/undefined时, 自动将this绑定成全局对象

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

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

var bar = foo.bind(null)
bar()//Window {window: Window, self: Window, document: document, name: '', location: Location, …}

3.7 this规则之外 - 间接函数引用

//原来赋值语句是有返回值的，就是等号右边的值

var num1 = 100;
var num2 = 0;
var result = (num2 = num1);
console.log(result); // 100
console.log(num1, num2);//100 100

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

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

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

// 争论: 代码规范 ;

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

var obj2 = {
  name: "obj2"
};

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

(obj2.bar = obj1.foo)()//window  独立函数调用
/* 
会赋值表达式的结果做一个调用
赋值语句(表达式的值)的返回值为赋值结果。
就是foo这个函数
*/

//分号很关键
function foo(el){
  console.log(el, this.id);
}

var obj = {
  id:'awesome'
}

[1,2,3].forEach(foo, obj)
//test.html:58 Uncaught TypeError: Cannot read properties of undefined (reading 'forEach')

/* 

问题是obj后面没有加分号，就变成了这个
var obj = {
  id:'awesome'
}[1,2,3].forEach(foo,obj)

forEach前面就是{id:'awesome'}[1,2,3]
不是一个数组*/

3.8 this规则之外 – ES6箭头函数（arrow function）

在ES6中新增一个非常好用的函数类型：箭头函数，它比函数表达式要更加简洁

1.箭头函数不会绑定this，argument属性；

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

3.箭头函数不使用this的四种标准规则（也就是不绑定this），而是根据外层作用域来决定this。

// 1.编写箭头函数
// 1> (): 参数
// 2> =>: 箭头
// 3> {}: 函数的执行体
var foo = (num1, num2, num3) => {
  console.log(num1, num2, num3)
  var result = num1 + num2 + num3
  console.log(result)
}

function bar(num1, num2, num3) {
}

// 高阶函数在使用时, 也可以传入箭头函数
var nums = [10, 20, 45, 78]
nums.forEach((item, index, arr) => {})

// 箭头函数有一些常见的简写:
// 简写一: 如果参数只有一个, ()可以省略
nums.forEach(item => {
  console.log(item)
})

// 简写二: 如果函数执行体只有一行代码, 那么{}也可以省略
// 强调: 并且它会默认将这行代码的执行结果作为返回值
nums.forEach(item => console.log(item))
//console.log(item)的返回值是undefined
var newNums = nums.filter(item => item % 2 === 0)
console.log(newNums)

// filter/map/reduce
var result = nums.filter(item => item % 2 === 0)
                 .map(item => item * 100)
                 .reduce((preValue, item) => preValue + item)
console.log(result)

// 简写三: 如果一个箭头函数, 只有一行代码, 并且返回一个对象, 这个时候如何编写简写
// var bar = () => {
//   return { name: "why", age: 18 }
// }

var bar = () => ({ name: "why", age: 18 })
//加个小括号，告诉箭头函数这个{ name: "why", age: 18 }是整体

测试箭头函数中this指向

// 1.测试箭头函数中this指向
 var name = "why"

 var foo = () => {
   console.log(this)
 }

 foo()//window
 var obj = {foo: foo}
 obj.foo()//window
 foo.call("abc")//window 根据外层作用域来决定this。

我们来看一个模拟网络请求的案例：

这里我使用setTimeout来模拟网络请求，请求到数据后如何可以存放到data中呢？
我们需要拿到obj对象，设置data；
但是直接拿到的this是window，我们需要在外层定义：var _this = this
在setTimeout的回调函数中使用_this就代表了obj对象


// 2.应用场景
var obj = {
  data: [],
  getData: function() {
    // 发送网络请求, 将结果放到上面data属性中
    // 在箭头函数之前的解决方案
    // var _this = this
    // setTimeout(function() {
    //   var result = ["abc", "cba", "nba"]
    //   _this.data = result
    // }, 2000);
    // 箭头函数之后
    setTimeout(() => {
      var result = ["abc", "cba", "nba"]
      this.data = result
    }, 2000);

    //箭头函数不绑定this，意味着没有this，就要去上层作用域里面去找
    //上层作用域里面的this，也就是getData的this，
    //getData是通过obj来调用的，所以箭头函数里面的this指的就是obj对象
  }
}

obj.getData()

3.9 this面试题

面试题一：

var name = "window";

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

function sayName() {
  var sss = person.sayName;
  sss(); // window: 独立函数调用
  person.sayName(); // person: 隐式调用
  (person.sayName)(); // person: 隐式调用
    //在这里，对JS引擎来说 加(person.sayName)这个括号和不加是一样的，直接取person里面sayName，对它进行调用
  (b = person.sayName)(); // window: 赋值表达式(独立函数调用)
}

sayName();

面试题二：

var name = 'window'

var person1 = {
  name: 'person1',
  foo1: function () {
    console.log(this.name)
  },
  foo2: () => console.log(this.name),
  foo3: function () {
    return function () {
      console.log(this.name)
    }
  },
  foo4: function () {
    return () => {
      console.log(this.name)
    }
  }
}

var person2 = { name: 'person2' }

// person1.foo1(); // person1(隐式绑定)
// person1.foo1.call(person2); // person2(显示绑定优先级大于隐式绑定)

// person1.foo2(); // window(不绑定作用域,上层作用域是全局)
// person1.foo2.call(person2); // window

// person1.foo3()(); // window(独立函数调用)
// person1.foo3.call(person2)(); // window(独立函数调用)
// person1.foo3().call(person2); // person2(最终调用返回函数式, 使用的是显示绑定)

// person1.foo4()(); // person1(箭头函数不绑定this, 上层作用域this是person1)
// person1.foo4.call(person2)(); // person2(上层作用域被显示的绑定了一个person2)
// person1.foo4().call(person2); // person1(上层找到person1)

面试题3

var name = 'window'

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)
    }
  }
}

var person1 = new Person('person1')
var person2 = new Person('person2')

person1.foo1() // person1
person1.foo1.call(person2) // person2(显示高于隐式绑定)

person1.foo2() // person1 (上层作用域中的this是person1)
person1.foo2.call(person2) // person1 (上层作用域中的this是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 obj = {
  name: "obj",
  foo: function() {

  }
}

面试题4

var name = 'window'

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()() // window
person1.obj.foo1.call(person2)() // window
person1.obj.foo1().call(person2) // person2

person1.obj.foo2()() // obj
person1.obj.foo2.call(person2)() // person2
person1.obj.foo2().call(person2) // obj


// 

// 上层作用域的理解
// var obj = {
//   name: "obj",
//   foo: function() {
//     // 上层作用域是全局
//   }
// }

// function Student() {
//   this.foo = function() {

//   }
// }

非常感谢王红元老师的(前端基础公开课-学习视频教程-腾讯课堂 (qq.com)
)让我学习到很多前端的知识

关于js函数中this的指向的问题
@(javascript)[JavaScript中this的指向] 关于js函数中this的指向的问题 javas...
JavaScript中this指向
文章较长，希望你耐心阅读并有所收获。 this指向想必各位看客老爷搜索此问题，多多少少还是被this迷惑住了，今...
javascript中的this指向
写在前面本文转自深入浅出 JavaScript 中的 this 在java等面向对象的语言中，this关键字的含...
Javascript 中 this 的指向
大家好，我是IT修真院武汉第10期学员，一枚正直、纯洁、善良的前端程序员。今天给大家分享一下，修真院官网任务...
JavaScript中的this指向
1.概念在JavaScript中，this 是指当前函数中正在执行的上下文环境，因为这门语言拥有四种不同的函数调...
javascript中this的指向
在面向对象的语言中（例如Java,C#等)，this含义是明确且具体的，即指向当前对象。一般在编译期绑定。而在ja...
javascript中的this指向
由于javascript中的this是在运行期绑定的，所以javascript中的this的含义很丰富。它可以是全...
javaScript中this的指向
简单笔记： this永远指向调用它的对象，在严格模式下没有调用对象会指向undefined，非严格模式下指向全局变...
javascript中的this指向
首先必须要说的是，this的指向在函数定义的时候是确定不了的，只有函数执行的时候才能确定this到底指向谁，实际上...
Javascript中this的指向
this的指向分为以下四种1.作为对象的方法调用2.作为普通函数调用3.构造器调用4.Function.proto...