怎样明白js中的this和现实运用中须要避开哪些坑

this是什么

this就是函数内部的关键字

看下面例子明白js中的this

    // 例子1
    function fnOne () {
        console.log(this)
    }
    'use strict'
    function fnOne () {
        console.log(this)
    }
    // 例子2
    let a = {
        txt: 'hello world',
        fn: function() {
            console.log(this.txt)
        }
    }
    a.fn()
    window.a.fn()
    // 例子3
    let b = {
        txt: 'hello',
        obj: {
            txt: 'world',
            fn: function(){
                console.log(this.txt)
                console.log(this)
            }
        }
    }
    let c = {
        txt: 'hello',
        obj: {
            // txt: 'world',
            fn: function(){
                console.log(this.txt)
            }
        }
    }
    b.obj.fn()
    c.obj.fn()
    let d = b.obj.fn
    d()
    // 例子4
    function Fn () {
        this.txt = 'hello world'
    }
    let e = new Fn()
    e.txt
    // 例子5
    function Fn () {
        this.txt = 'hello world'
        return {txt:'hello'}
    }
    function Fn () {
        this.txt = 'hello world'
        return [1]
    }
    function Fn () {
        this.txt = 'hello world'
        return 1
    }
    function Fn () {
        this.txt = 'hello world'
        return null
    }
    function Fn () {
        this.txt = 'hello world'
        return undefined
    }
    let e = new Fn()
    e.txt
    // 带有{}或许[]返回值的要领实例化时this指向被转变
    // 例子6
    // 箭头函数与包裹它的代码同享雷同的this对象
    // 假如箭头函数在其他函数的内部
    // 它也将同享该函数的arguments变量
    let bob = {
      _name: "Bob",
      _friends: [],
      printFriends: () => {
        console.log(this._name)
        console.log(this)
      }
    }
    let bob = {
      _name: "Bob",
      _friends: [],
      printFriends() {
        console.log(this._name)
        console.log(this)
      }
    }
    
    let bob = {
      _name: "Bob",
      _friends: [1],
      printFriends() {
        this._friends.forEach((item) => {
            console.log(this._name)
        })
      }
    }
    // arguments 对象
    function square() {
      let example = () => {
        let numbers = [];
        for (let number of arguments) {
          numbers.push(number * number);
        }
    
        return numbers;
      };
    
      return example();
    }
    
    square(2, 4, 7.5, 8, 11.5, 21); // returns: [4, 16, 56.25, 64, 132.25, 441]

this的指向

this永久指向的是末了挪用它的对象(箭头函数除外)

this的运用

怎样转变函数的this指向 apply call bind

三者的区分apply和call转变函数this而且是马上实行。bind(es5新加要领注重兼容性)是复制函数,不会马上实行。依据各自实行机遇的不同来挑选采纳哪一种计划。

function Product(name, price) {
 this.name = name
 this.price = price
}
function Food(name, price) {
 Product.call(this, name, price)
 // Product.apply(this, arguments)
 this.category = 'food'
}
console.log(new Food('cheese', 5).name)

bind用法和能够处理的题目

// 处理,从对象中拿出要领定义给新变量,然则愿望要领的this值坚持稳定这时候能够用bind来绑定this
this.x = 9; 
var module = {
 x: 81,
 getX: function() { return this.x; }
};
module.getX(); // 返回 81
var retrieveX = module.getX;
retrieveX(); // 返回 9, 在这类情况下,"this"指向全局作用域
// 建立一个新函数,将"this"绑定到module对象
// 新手能够会被全局的x变量和module里的属性x所疑惑
var boundGetX = retrieveX.bind(module);
boundGetX(); // 返回 81

// bind合营setTimeout()
function LateBloomer() {
 this.petalCount = Math.ceil(Math.random() * 12) + 1;
}
LateBloomer.prototype.bloom = function() {
 window.setTimeout(this.declare.bind(this), 1000);
}
LateBloomer.prototype.declare = function() {
 console.log('I am a beautiful flower with ' +
   this.petalCount + ' petals!');
}
var flower = new LateBloomer();
flower.bloom();  // 一秒钟后, 挪用'declare'要领
   

箭头函数的this运用注重事项

1、函数体内的this对象,就是定义时地点的对象,而不是运用时地点的对象。

2、不能够看成组织函数,也就是说,不能够运用new敕令,否则会抛出一个毛病。

3、不能够运用arguments对象,该对象在函数体内不存在。假如要用,能够用 rest 参数替代。

4、不能够运用yield敕令,因而箭头函数不能用作 Generator 函数。

5、不能运用apply/call/bind

// 箭头函数能够让setTimeout内里的this,绑定定义时地点的作用域,而不是指向运行时地点的作用域。下面是另一个例子。
function Timer() {
 this.s1 = 0;
 this.s2 = 0;
 // 箭头函数
 setInterval(() => this.s1++, 1000);
 // 一般函数
 setInterval(function () {
   this.s2++;
 }, 1000);
}

var timer = new Timer();

setTimeout(() => console.log('s1: ', timer.s1), 3100);
setTimeout(() => console.log('s2: ', timer.s2), 3100);
// s1: 3
// s2: 0
// 箭头函数能够让this指向牢固化,这类特征很有利于封装回调函数。下面是一个例子,DOM 事宜的回调函数封装在一个对象内里。
var handler = {
  id: '123456',

  init: function() {
    document.addEventListener('click',
      event => this.doSomething(event.type), false);
  },

  doSomething: function(type) {
    console.log('Handling ' + type  + ' for ' + this.id);
  }
};
    原文作者:孙小渃
    原文地址: https://segmentfault.com/a/1190000013686126
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞