方法一：使用對象屬性訪問器

可以通過定義一個對象，重寫它的屬性訪問器來實現(xiàn)這個效果。具體實現(xiàn)如下：

let a = {
  i: 1,
  toString() {
    return a.i++;
  }
};

console.log(a == 1 && a == 2 && a == 3); // true

這里利用了對象在進行比較時會調(diào)用其 toString() 方法的特性，我們重寫了 a 對象的 toString() 方法，讓其每次返回一個遞增的值，從而使得 a == 1 && a == 2 && a == 3 的結果為 true。

方法二：使用數(shù)組的 join() 方法

還可以利用數(shù)組的 join() 方法來實現(xiàn)：方法二：使用數(shù)組的 join() 方法

還可以利用數(shù)組的 join() 方法來實現(xiàn)：

let a = [1, 2, 3];
a.join = a.shift;

console.log(a == 1 && a == 2 && a == 3); // true

這里我們將 a 數(shù)組的 join() 方法重寫為 shift() 方法，每次調(diào)用 a == 1 && a == 2 && a == 3 時，其實就是將數(shù)組中的元素一個一個地取出來進行比較，從而實現(xiàn)了這個效果。

方法三：使用 ES6 的 Proxy 對象

ES6 中新增了 Proxy 對象，可以用來攔截對對象的訪問，從而實現(xiàn)這個效果：

let a = new Proxy({}, {
  i: 1,
  get: function(target, prop) {
    if (prop == Symbol.toPrimitive || prop == "valueOf") {
      return () => this.i++;
    }
    return this.i++;
  }
});

console.log(a == 1 && a == 2 && a == 3); // true

這里我們創(chuàng)建了一個空對象 a，并使用 Proxy 對象對其進行包裝，通過攔截 get 方法，每次訪問 a 時，都會返回一個遞增的值，從而實現(xiàn)了這個效果。

方法四：使用 generator 和 Symbol.iterator

let a = {
  [Symbol.iterator]: function*() {
    let i = 1;
    while (true) {
      yield i++;
    }
  }
};

console.log(a.next().value == 1 && a.next().value == 2 && a.next().value == 3); // true

這里通過為對象 a 定義一個 Symbol.iterator 屬性，并將其設為一個 generator 函數(shù)，每次調(diào)用 a.next() 方法時返回一個遞增的值。由于 generator 函數(shù)具有迭代器的特性，因此可以使用 a.next().value 來訪問其返回的值，從而實現(xiàn)這個效果。

方法五：使用 setter

let a = {
  i: 1,
  get value() {
    return this.i++;
  },
  set value(val) {
    this.i = val;
  }
};

console.log(a.value == 1 && a.value == 2 && a.value == 3); // true

這里通過為對象 a 定義一個 getter 和 setter 方法，每次調(diào)用 a.value 時返回一個遞增的值，并且每次調(diào)用 a.value 時都將其值設為當前的遞增值。由于 setter 方法會改變對象的屬性值，因此可以利用這個特性來實現(xiàn)這個效果。

方法六：使用數(shù)組的 reduce() 方法

let a = [1, 2, 3];
a.reduce = ((f) => (a, v) => f.call(a, v))(Array.prototype.reduce);

console.log(a == 1 && a == 2 && a == 3); // true

這里將 a 數(shù)組的 reduce() 方法重寫為一個函數(shù)，該函數(shù)接受兩個參數(shù)：一個函數(shù) f 和初始值 a，并返回一個新的函數(shù)。在調(diào)用這個新的函數(shù)時，實際上是調(diào)用了原來數(shù)組的 reduce() 方法，并將重寫后的函數(shù)作為其參數(shù)。由于 reduce() 方法會將數(shù)組中的所有元素都傳入這個函數(shù)中，因此可以利用這個特性來實現(xiàn)這個效果。

需要注意的是，這里的重寫方法是利用了閉包的特性，將原來數(shù)組的 reduce() 方法保存在一個變量 f 中，并在返回的新函數(shù)中通過調(diào)用 f.call() 來實現(xiàn)原來 reduce() 方法的調(diào)用。

方法七：使用 Object.defineProperty()

let a = {
  i: 1
};

Object.defineProperty(window, 'a', {
  get: function() {
    return this.i++;
  }
});

console.log(a == 1 && a == 2 && a == 3); // true

這里利用了 Object.defineProperty() 方法，將對象 a 定義為 window 對象的一個屬性，并且定義了一個 getter 方法，每次訪問 a 時都會返回一個遞增的值。由于這里的 a 是一個全局變量，因此可以在任何地方訪問到它，從而實現(xiàn)這個效果。

需要注意的是，這里定義的 getter 方法是在 window 對象上定義的，因此可能會影響到其他部分的代碼。因此不建議在實際開發(fā)中使用這種方法。

方法八：使用 Function.prototype.toString()

let a = {
  toString: function() {
    return this.i++;
  },
  i: 1
};

console.log(a == 1 && a == 2 && a == 3); // true

這里利用了 JavaScript 中函數(shù)的 toString() 方法，將對象 a 的 toString() 方法重寫為一個方法，每次調(diào)用 a 時都會返回一個遞增的值。由于比較運算符 == 會將對象轉換為字符串，因此可以利用這個特性來實現(xiàn)這個效果。

需要注意的是，這種方法可能會影響到其他部分的代碼，因為它會改變對象 a 的原有 toString() 方法。因此不建議在實際開發(fā)中使用這種方法。

方法九：使用 ES6 模板字符串

let a = {
  i: 1,
  toString() {
    return `${this.i++}`;
  }
};

console.log(a == 1 && a == 2 && a == 3); // true

這里利用了 ES6 中的模板字符串，將對象 a 的 toString() 方法重寫為一個方法，每次調(diào)用 a 時都會返回一個遞增的值。由于比較運算符 == 會將對象轉換為字符串，因此可以利用這個特性來實現(xiàn)這個效果。

這種方法相對于其他方法來說，代碼可讀性較好，而且不會影響到其他部分的代碼。因此建議在實際開發(fā)中使用這種方法。

方法十：使用 Date.prototype.toLocaleString()

let a = {
  toString() {
    return new Date().toLocaleString('en-US', { hour12: false }).replace(/.*(\d{1,2})$/, '$1');
  }
};

console.log(a == 1 && a == 2 && a == 3); // true

這里利用了Date.prototype.toLocaleString() 方法，將對象 a 的 toString() 方法重寫為一個方法，每次調(diào)用 a 時都會返回一個遞增的值。具體實現(xiàn)是獲取當前時間的字符串表示，使用正則表達式從字符串中提取出最后兩位數(shù)字，作為比較的值。

不過這種方法相對于其他方法來說，代碼可讀性較差，而且不如方法九那么直接，因為需要使用到正則表達式。同時這種方法也不如方法九性能好，因為每次調(diào)用 a 都需要重新獲取當前時間的字符串表示。因此不建議在實際開發(fā)中使用這種方法。

綜上所述，方法九是實現(xiàn)這個效果最好的方法，既可讀性好，也不會對其他部分的代碼造成影響。

總結：

以上這些方法都是一些比較巧妙的黑科技，雖然都可以實現(xiàn)這個效果，但在實際開發(fā)中不建議使用，因為它們的代碼可讀性和可維護性較差，容易引起困惑和錯誤。