javascript中你可能遇到的隱式調用

前言

不知道用隱式調用來形容是否確切,其行爲老是隱藏在背後，時不時出來露臉一下，做用貌似不大，可是瞭解一下仍是有用處的，保不許在你的使用下大有做爲。
所謂的隱式調用簡單來講就是自動調用一些方法，而這些方法像鉤子同樣能夠在外部修改，從而改變既定行爲。
下面我會列舉一些最近看到的隱式調用，例子都是點到即止，歡迎補充

數據類型轉換 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循環能夠在對象上添加該方法,也能夠在原來具有接口的對象上重寫方法,從而改變其行爲

最後

暫時就想到這麼多,歡迎你們補充