实际上，在每种编程语言中，问题第一部分的答案都是“是”。例如，这是在C/C++的情况下：

#define a   (b++)
int b = 1;
if (a ==1 && a== 2 && a==3) {
    std::cout << "Yes, it's possible!" << std::endl;
} else {
    std::cout << "it's impossible!" << std::endl;
}

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

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

令人惊讶的是，是的。JS中的==松散相等运算符调用被比较对象的valueOf（）方法。因此，您可以创建一个类，该类返回一个内部值，然后在每次调用时递增该间隔值。这样地：

A类{构造函数（initalVal）{this.val=初始值；}值Of（）{返回此.val++；}}const a=新AClass（1）；console.log（a==1&&a==2&&a==3）

我知道这个问题还有很多其他答案，但这就是ES6语法的用法。

注意：如果不希望发生这种情况，那么应该使用==运算符来检查strict。这样地：

A类{构造函数（initalVal）{this.val=初始值；}值Of（）{返回此.val++；}}const a=新AClass（1）；console.log（a==1&&a==2&&a==3）

面试规则一；永远不要说不可能。

不需要隐藏角色的诡计。

窗口__定义Getter__（'a'，函数（）{if（类型i！=='number'）{//在全局命名空间中定义i，以便在运行此函数后不会丢失i＝0；}返回++i；});如果（a==1&&a==2&&a==3）{console.log（“哦，亲爱的，我们做了什么？”）；}

通过在类声明中重写valueOf，可以执行以下操作：

class Thing {
    constructor() {
        this.value = 1;
    }

    valueOf() {
        return this.value++;
    }
}

const a = new Thing();

if(a == 1 && a == 2 && a == 3) {
    console.log(a);
}

发生的情况是在每个比较运算符中调用valueOf。第一次，a等于1，第二次，a将等于2，依此类推，因为每次调用valueOf时，a的值都会递增。

因此，console.log将激发并输出（在我的终端中）Thing:{value:4}，表示条件为真。

这是可能的！

变量i=0；具有({获取a（）{返回++i；}}) {如果（a==1&&a==2&&a==3）console.log（“wohoo”）；}

这在with语句中使用getter，让一个求值为三个不同的值。

…这仍然不意味着这应该在实际代码中使用。。。

更糟糕的是，使用==也可以使用此技巧。

变量i=0；具有({获取a（）{返回++i；}}) {如果（a！==a）console.log（“是的，这是打印的。”）；}