Javascript （a==1&；a==2&；a==3）是否可以计算为真？

主持人注意：请不要急于编辑代码或删除此通知。空白的模式可能是问题的一部分，因此不应不必要地加以篡改。如果您属于“空白无关紧要”阵营，那么您应该能够接受代码的原样

在JavaScript中，

（a==1&&a==2&&a==3）

是否可能计算为

true

这是一家大型科技公司提出的面试问题。事情发生在两周前，但我仍在努力寻找答案。我知道我们在日常工作中从来没有写过这样的代码，但我很好奇。

这是可能的

var i=0；
与({
得到一个（）{
return++i；
}
}) {
如果（a==1&&a==2&&a==3）
控制台日志（“wohoo”）；
}

如果利用，只需使用自定义的

toString

（或

valueOf

）函数创建一个对象，该函数会更改每次使用时返回的内容，以使其满足所有三个条件

const a={
一:1,，
toString:函数（）{
返回a.i++；
}
}
如果（a==1&&a==2&&a==3）{
log（'helloworld！'）；
}

可以在全局范围内使用以下方法完成。对于

nodejs

使用

global

而不是下面代码中的

window

var-val=0；
Object.defineProperty（窗口'a'{
get:function（）{
return++val；
}
});
如果（a==1&&a==2&&a==3）{
console.log（'yay'）；
}

我无法抗拒——其他答案无疑是正确的，但你真的无法通过以下代码：

var aﾠ = 1.
var a=2；
变量ﾠa=3；
如果（a）ﾠ==1&&a==2&&ﾠa==3）{
log（“为什么在那里打招呼！”）
}

如果询问是否可能（而不是必须），它可以要求“a”返回一个随机数。如果它按顺序生成1、2和3，则为真

与({
得到一个（）{
返回Math.floor（Math.random（）*4）；
}
}){
对于（var i=0；i，也可以使用一系列自覆盖getter：

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


（（）=>{
“严格使用”；
Object.defineProperty（这是“a”{
“获取”：（）=>{
Object.defineProperty（这是“a”{
“获取”：（）=>{
Object.defineProperty（这是“a”{
“获取”：（）=>{
返回3；
}
});
返回2；
},
可配置：true
});
返回1；
},
可配置：true
});
如果（a==1&&a==2&&a==3）{
document.body.append（“是的，这是可能的。”）；
}
})（）；
或者，您可以为它使用一个类，并为检查使用一个实例


函数A（）{
var值=0；
this.valueOf=函数（）{return++value；}；
}
var a=新的a；
如果（a==1&&a==2&&a==3）{
console.log（'bingo！'）；
}
面试的第一条规则；永远不要说不可能

不需要隐藏的角色欺骗


window.\uuuuuu定义设置（'a'，函数（）{
如果（i的类型！=='number'）{
//在全局命名空间中定义i，以便在该函数运行后不会丢失它
i=0；
}
return++i；
});
如果（a==1&&a==2&&a==3）{
日志（‘哦，天哪，我们做了什么？’）；
}
我看不到这个答案已经发布了，所以我也会把这个加入到混合中。这类似于半宽的韩文空间


var a=1；
变量ａ = 2.
varа=3；
如果（a==1&&ａ == 2 && а == 3) {
log（“为什么在那里打招呼！”）
}
这一个使用了defineProperty，它有一个很好的副作用，导致全局变量


var\u a=1
Object.defineProperty（这是“a”{
“获取”：（）=>{
返回a++；
},
可配置：true
});
控制台日志（a）
控制台日志（a）
console.log（a）
如果没有正则表达式就无法执行任何操作：


var a={
r://\d/g，
valueOf:function（）{
返回此.r.exec（123）[0]
}
}
如果（a==1&&a==2&&a==3）{
控制台日志（“！”）
}
实际上，在每种编程语言中，问题第一部分的答案都是“是”。例如，在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（b++）
int b=1；
如果（a==1&&a==2&&a==3）{
std：：cout这里是另一个变体，使用数组弹出您想要的任何值


const a={
n:[3,2,1]，
toString:函数（）{
返回a.n.pop（）；
}
}
如果（a==1&&a==2&&a==3）{
console.log（'Yes'）；
}
好的，另一个发电机黑客：


const value=函数*（）{
设i=0；
而（真）收益率+i；
}();
Object.defineProperty（这是“a”{
得到（）{
返回值.next（）.value；
}
});
如果（a==1&&a==2&&a==3）{
console.log（'yo！'）；
}
老实说，不管有没有一种方法可以评估它的真实性（正如其他人所展示的，有多种方法），作为一个进行过数百次采访的人，我想要的答案大致如下：

"好吧，也许在一些对我来说并不明显的奇怪的情况下是的……但是如果我在真实的代码中遇到了这种情况，那么我会使用常见的调试技术来找出它是如何做的以及为什么要做它正在做的事情，然后立即重构代码以避免这种情况……但更重要的是：我绝对不会首先写那个代码，因为这正是卷积代码的定义，我努力不写卷积代码”

我想有些面试官会对提出一个显然是非常棘手的问题感到生气，但我不介意有意见的开发人员，尤其是当他们可以的时候
// 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)

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')
})

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

const a = {value: 1};
a[Symbol.toPrimitive] = function() { return this.value++ };
console.log((a == 1 && a == 2 && a == 3));

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

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