媒介

不知道用隐式挪用来描述是不是确实,其行动老是隐藏在背地，时不时出来露脸一下，作用貌似不大，然则相识一下照样有用途的，保不准在你的运用下宏图大展。
所谓的隐式挪用简朴来讲就是自动挪用一些要领，而这些要领像钩子一样可以在外部修正，从而转变既定行动。
下面我会枚举一些近来看到的隐式挪用，例子都是点到即止，迎接补充

数据范例转换 toSting 和 valueOf

var obj = {
      a: 1,
      toString: function () {
        console.log('toString')
        return '2'
      },
      valueOf: function () {
        console.log('valueOf')
        return 3
      }
    }
    console.log(obj == '2'); //顺次输出 'valueOf' false
    console.log(String(obj));//顺次输出 'toString' '2'

var obj = {
      a: 1,
      toString: function () {
        console.log('toString')
        return '2'
      },
      valueOf: function () {
        console.log('valueOf')
        return {} //修正为对象
      }
    }
    console.log(obj == '2'); //顺次输出 'valueOf' 'toString' true
    console.log(Number(obj));//顺次输出 'valueOf' 'toString' 2

在相称运算符的操纵中，对象会先挪用 valueOf 假如返回的值是一个对象, 就会挪用 toSting， null除外，然后用返回的值举行比较，第一个例子 相当于 3 == ‘2’ 输出 false， 第二个例子因为实行valueOf 返回的是一个对象， 然后实行 toString， 末了相当于 ‘2’ == ‘2’ 输出true
在 Number 和 String 要领中 Number会先挪用 valueOf, 后挪用 toString， String要领中是相反的。
数据范例的转换除了上面的两个例子外，还存在在种种其他操纵中，如数值运算，当涉及到援用范例时，都邑挪用valueOf 或 toString 要领，只如果对象都邑继续这两个要领,我们可以从新掩盖这两个要领，从而影响数据范例转换的行动

DOM2事宜中的 handleEvent

var eventObj = {
      a: 1,
      handleEvent: function (e) {
        console.log(this, e);//返回 eventObj 和 事宜对象
        alert(this.a)
      }
    }
    document.addEventListener('click', eventObj)

你没有看错，addEventListener 第二个参数除了函数外还可以是一个对象, 事宜触发后会实行对象的handleEvent要领,要领实行时的this指向eventObj, 你可以把想传入的数据绑定在eventObj对象上

JSON对象 toJSON

var Obj = {
      a: 10,
      toJSON: function () {
        return {
          a: 1,
          b: function () {
          },
          c: NaN,
          d: -Infinity,
          e: Infinity,
          f: /\d/,
          g: new Error(),
          h: new Date(),
          i: undefined,
         
        }
      }
    }
    console.log(JSON.stringify(Obj));
    //{"a":1,"c":null,"d":null,"e":null,"f":{},"g":{},"h":"2018-02-09T19:29:13.828Z"}

假如JSON的stringify要领传入的对象有toJSON要领,那末该要领实行的对象会转为toJSON实行后返回的对象,有一点要注意的是，如下面代码

 var Obj1 = {
      a: 10,
      toJSON: function () {
        console.log(this === Obj1);//true
        return this
      }
    }
    console.log(JSON.stringify(Obj1));//{"a":10}

 var Obj2 = {
      a: 10,
      toJSON: function () {
        console.log(this === Obj2);//true
        return {
          a: this
        }
      }
    }
    console.log(JSON.stringify(Obj2));//报错 Maximum call stack size exceeded

假如按上面的说法很明显报错是我们所预期的，然则当直接 return this 基础没有报错，无妨可以斗胆勇敢猜想一下其内部对toJSON返回的对象和原对像举行比较,假如相称就直接运用原对象

promise对象的 then

var obj = {
      then: function (resolve, reject) {
        setTimeout(function () {
          resolve(1000);
        }, 1000)
      }
    }
    Promise.resolve(obj).then(function (data) {
      console.log(data);// 耽误1秒左右输出 1000
    })

当Promise.resolve要领传入对象时,假如存在 then 要领会马上实行then要领,相当于把要领放入new Promise中,除了Promise.resolve有这个行动外,Promise.all也有这个行动

 var timePromise = function (time) {
       return new Promise(function (resolve) {
         setTimeout(function () {
           resolve(time);
         }, time)
       })
     }
     var timePromise1 = timePromise(1000);
     var timePromise2 = timePromise(2000);
     var timePromise3 = timePromise(3000);
     Array.prototype.then = function (resolve) {
         setTimeout(function () {
           resolve(4000);
         }, 4000)
       }
     Promise.all([timePromise1, timePromise2, timePromise3]).then(function (time) {
       console.log(time);// 守候4秒左右输出 4000
     })

对象属性存取器 get 和 set

var obj = {
       _age: 100,
       get age() {
         return this._age < 18 ? this._age : 18;
       },
       set age(value) {
         this._age = value;
         console.log(`岁数设置为${value}岁`);
       }
     }
     obj.age = 1000; //岁数设置为1000岁
     obj.age = 200; //岁数设置为200岁
     console.log(obj.age);// 18
     obj.age = 2; ////岁数设置为2岁
     console.log(obj.age); // 2

可以看到不论把岁数设置为若干,我的岁数都是18岁或以下的,当实行属性存取时实际上是挪用对象属性响应的 get set函数，除了以上写法另有下面的写法

  var input = document.createElement('input');
    var span = document.createElement('span');
    document.body.appendChild(input);
    document.body.appendChild(span);
    var obj = {
      _age:''
    }
    var obj = Object.defineProperty(obj, 'age', {
      get: function () {
        return this._age;
      },
      set: function (value) {
        this._age = value;
        input.value = value;
        span.innerHTML = value;
      }
    });
    input.onkeyup = function (e) {
      if (e.keyCode === 37 || e.keyCode === 39) {
        return;
      }
      obj.age = this.value
    }

如今input的value值和obj.age的属性值span的innerHTML值都绑定在一起了

遍历器接口 Symbol.iterator

 var arr = [ 1, 2 , 3];
    arr[Symbol.iterator] = function () {
      const self = this;
      let index = 0;
      return {
        next () {
          if(index < self.length) {
            return {
              value: self[index] ** self[index++],
              done: false
            }
          } else {
            return {
              value: undefined,
              done: true
            }
          }
        }
      }
    }
    console.log([...arr, 4]);//返回 [1, 4, 27, 4]
    for(let value of arr) {
      console.log(value); //顺次返回 1 4 27
    }

可以看到通常挪用扩大运算符，或许运用 for…of 轮回遍历对象都邑挪用对象的遍历器接口,像Array,String,Map,Set,TypedArray另有一些类数组对象如arguments,NodeList原生具有了遍历器接口，而一般对象没有布置这个接口，假如要让对象可以运用扩大运算符或许for…of轮回可以在对象上增加该要领,也可以在本来具有接口的对象上重写要领,从而转变其行动

末了

临时就想到这么多,迎接人人补充