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.");
        }
    }
}

这在变量a被访问的情况下是可能的，例如，2个web工作人员通过SharedArray Buffer以及一些主脚本进行访问。可能性很低，但当代码被编译为机器代码时，网络工作人员可能会及时更新变量a，从而满足条件a==1、a==2和a==3。

这可以是web工作者和JavaScript中的SharedArray Buffer提供的多线程环境中的竞争条件的一个示例。

以下是上述的基本实现：

main.js

// Main Thread

const worker = new Worker('worker.js')
const modifiers = [new Worker('modifier.js'), new Worker('modifier.js')] // Let's use 2 workers
const sab = new SharedArrayBuffer(1)

modifiers.forEach(m => m.postMessage(sab))
worker.postMessage(sab)

工人.js

let array

Object.defineProperty(self, 'a', {
  get() {
    return array[0]
  }
});

addEventListener('message', ({data}) => {
    array = new Uint8Array(data)
    let count = 0
    do {
        var res = a == 1 && a == 2 && a == 3
        ++count
    } while(res == false) // just for clarity. !res is fine
    console.log(`It happened after ${count} iterations`)
    console.log('You should\'ve never seen this')
})

修改器.js

addEventListener('message' , ({data}) => {
    setInterval( () => {
        new Uint8Array(data)[0] = Math.floor(Math.random()*3) + 1
    })
})

在我的MacBook Air上，第一次尝试大约100亿次迭代后会发生这种情况：

第二次尝试：

正如我所说，机会很低，但如果有足够的时间，它会达到条件。

提示：如果系统花费的时间太长。只尝试a==1&&a==2，然后将Math.random（）*3更改为Math.random（）*2。在列表中添加越来越多的内容会降低命中率。

它可以在全局范围内使用以下方法完成。对于nodejs，在下面的代码中使用global而不是window。

var值=0；Object.defineProperty（窗口，“a”{获取：函数（）{返回++val；}});如果（a==1&&a==2&&a==3）{console.log（“是”）；}

这个答案通过定义getter来检索变量，从而滥用了全局范围在执行上下文中提供的隐式变量。

这也可以使用一系列自重写getter：

（这类似于jontro的解决方案，但不需要计数器变量。）

(() => {“使用严格”；Object.defineProperty（this，“a”{“获取”：（）=>{Object.defineProperty（this，“a”{“获取”：（）=>{Object.defineProperty（this，“a”{“获取”：（）=>{返回3；}});返回2；},可配置：真});返回1；},可配置：真});如果（a==1&&a==2&&a==3）{document.body.append（“是的，这是可能的。”）；}})();

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

变量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，依此类推。

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

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