这一个使用了带有良好副作用的defineProperty，导致全局变量！

变量_a=1Object.defineProperty（this，“a”{“获取”：（）=>{返回_a++；},可配置：真});控制台日志（a）控制台日志（a）控制台日志（a）

如果没有正则表达式就无法执行任何操作：

变量a={r： /\d/g，valueOf：函数（）{返回此.r.exec（123）[0]}}如果（a==1&&a==2&&a==3）{console.log（“！”）}

它之所以有效，是因为当Object与基元（如Number）进行比较时调用了自定义valueOf方法。主要技巧是，a.valueOf每次都会返回新值，因为它使用g标志对正则表达式调用exec，这会导致每次找到匹配项时更新该正则表达式的lastIndex。所以第一次this.r.lastIndex==0时，它匹配1并更新lastIndex：this.r.lastIndex==1，所以下次regex将匹配2，依此类推。

我认为这是实现它的最小代码：

i=0，a={valueOf:（）=>++i}如果（a==1&&a==2&&a==3）{console.log（'Mind===Blown'）；}

创建具有自定义值Of的虚拟对象，该值在每次调用时递增全局变量i。23个字符！

这是另一种变体，使用数组弹出所需的任何值。

常量a={n： [3,2,1]，toString:函数（）{return a.n.pop（）；}}如果（a==1&&a==2&&a==3）{console.log（“是”）；}

使用代理：

var a = new Proxy({ i: 0 }, {
    get: (target, name) => name === Symbol.toPrimitive ? () => ++target.i : target[name],
});
console.log(a == 1 && a == 2 && a == 3);

代理基本上假装是目标对象（第一个参数），但拦截目标对象上的操作（在本例中是“获取属性”操作），以便有机会执行默认对象行为以外的其他操作。在这种情况下，对when==强制其类型调用“get property”操作，以便将其与每个数字进行比较。发生这种情况：

我们创建一个目标对象｛i:0｝，其中i属性是我们的计数器我们为目标对象创建代理，并将其分配给对于每个a==比较，a的类型都被强制为基元值这种类型强制导致在内部调用[Symbol.toPrimitive]（）Proxy使用“get handler”拦截获取[Symbol.toPrimitive]函数代理的“获取处理程序”检查正在获取的属性是否为Symbol.toPrimitive，在这种情况下，它会递增，然后从目标对象返回计数器：++target.i。如果正在检索不同的属性，我们只需返回默认属性值target[name]

So:

var a = ...; // a.valueOf == target.i == 0
a == 1 && // a == ++target.i == 1
a == 2 && // a == ++target.i == 2
a == 3    // a == ++target.i == 3

与大多数其他答案一样，这只适用于松散的等式检查（==），因为严格的等式检查不执行代理可以拦截的类型强制。

JavaScript

a==a+1

在JavaScript中，没有整数，只有数字，它们被实现为双精度浮点数。

这意味着如果一个数字a足够大，它可以被认为等于四个连续的整数：

a=100000000000000000如果（a==a+1&&a==a+2&&a==a+3）{console.log（“精度损失！”）；}

的确，这并不是面试官所要求的（当a=0时不起作用），但它不涉及隐藏函数或运算符重载的任何技巧。

其他语言

作为参考，Ruby和Python中有a==1&a==2&&a==3个解决方案。稍加修改，在Java中也是可能的。

Ruby

使用自定义==：

class A
  def ==(o)
    true
  end
end

a = A.new

if a == 1 && a == 2 && a == 3
  puts "Don't do this!"
end

或增加一个：

def a
  @a ||= 0
  @a += 1
end

if a == 1 && a == 2 && a == 3
  puts "Don't do this!"
end

蟒蛇

您可以为新类定义==：

class A:
    def __eq__(self, who_cares):
        return True
a = A()

if a == 1 and a == 2 and a == 3:
    print("Don't do that!")

或者，如果你喜欢冒险，重新定义整数的值：

import ctypes

def deref(addr, typ):
    return ctypes.cast(addr, ctypes.POINTER(typ))

deref(id(2), ctypes.c_int)[6] = 1
deref(id(3), ctypes.c_int)[6] = 1
deref(id(4), ctypes.c_int)[6] = 1

print(1 == 2 == 3 == 4)
# True

它可能会出错，这取决于您的系统/解释器。

python控制台与上述代码一起崩溃，因为2或3可能在后台使用。如果您使用不太常见的整数，则可以正常工作：

>>> import ctypes
>>> 
>>> def deref(addr, typ):
...     return ctypes.cast(addr, ctypes.POINTER(typ))
... 
>>> deref(id(12), ctypes.c_int)[6] = 11
>>> deref(id(13), ctypes.c_int)[6] = 11
>>> deref(id(14), ctypes.c_int)[6] = 11
>>> 
>>> print(11 == 12 == 13 == 14)
True

Java

可以修改Java Integer缓存：

package stackoverflow;

import java.lang.reflect.Field;

public class IntegerMess
{
    public static void main(String[] args) throws Exception {
        Field valueField = Integer.class.getDeclaredField("value");
        valueField.setAccessible(true);
        valueField.setInt(1, valueField.getInt(42));
        valueField.setInt(2, valueField.getInt(42));
        valueField.setInt(3, valueField.getInt(42));
        valueField.setAccessible(false);

        Integer a = 42;

        if (a.equals(1) && a.equals(2) && a.equals(3)) {
            System.out.println("Bad idea.");
        }
    }
}