モデレーターへのメモ：コードを編集したい、またはこの通知を削除したいという衝動に抵抗してください。空白のパターンは問題の一部である可能性があるため、不必要に改ざんしないでください。「ホワイトスペースは重要ではない」陣営にいる場合は、コードをそのまま受け入れることができるはずです。

JavaScriptで(a== 1 && a ==2 && a==3)評価できる可能性trueはありますか？

大手テック企業からのインタビューです。それは2週間前に起こりましたが、私はまだ答えを見つけようとしています。日々の仕事でそのようなコードを書くことは決してないことは知っていますが、私は興味があります。

あなたはを活用する場合はどのよう==な作品は、単にカスタムオブジェクトと作成することができますtoString（またはvalueOf、それはそれはそれはそれを満たすすべての3つの条件などに使用されるたびに返すどのような変更）機能を。

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

if(a == 1 && a == 2 && a == 3) {
  console.log('Hello World!');
}

これが機能する理由は、緩い等価演算子の使用によるものです。緩やかな等式を使用する場合、オペランドの1つが他と異なるタイプである場合、エンジンは1つをもう1つに変換しようとします。左側のオブジェクトと右側の数値のvalueOf場合、最初に呼び出し可能かどうかを呼び出し、それが失敗するとを呼び出して、オブジェクトを数値に変換しようとしますtoString。私toStringがこの場合に使用したのは、それが頭に浮かんだものだからvalueOfこそ、より理にかなっています。代わりにから文字列を返した場合toString、エンジンは文字列を数値に変換しようとしましたが、パスが少し長くなりますが、同じ最終結果が得られます。

私は抵抗できませんでした-他の答えは間違いなく真実ですが、実際には次のコードを通り過ぎることはできません。

var aﾠ = 1;
var a = 2;
var ﾠa = 3;
if(aﾠ==1 && a== 2 &&ﾠa==3) {
    console.log("Why hello there!")
}

if（私があなたの質問からコピーした）ステートメントの奇妙な間隔に注意してください。これは、ECMAスクリプトによってスペース文字として解釈されないUnicodeの空白文字である半角ハングル（慣れていない人のための韓国語）です。これは、識別子の有効な文字であることを意味します。したがって、3つの完全に異なる変数があります。1つはaの後にハングル、もう1つは前に、最後の1つはaだけです。_読みやすくするためにスペースを置き換えると、同じコードは次のようになります。

var a_ = 1;
var a = 2;
var _a = 3;
if(a_==1 && a== 2 &&_a==3) {
    console.log("Why hello there!")
}

Mathiasの変数名バリデーターの検証を確認してください。その奇妙な間隔が実際に彼らの質問に含まれていたなら、私はそれがこの種の答えのヒントであると確信しています。

これを行わないでください。真剣に。

編集：（変数の開始は許可されていませんが）ゼロ幅のジョイナー文字とゼロ幅の非ジョイナー文字も変数名で許可されていることに注意してください- ゼロ幅文字によるJavaScriptの難読化を参照してください-賛否両論？。

これは次のようになります。

var a= 1;
var a‍= 2; //one zero-width character
var a‍‍= 3; //two zero-width characters (or you can use the other one)
if(a==1&&a‍==2&&a‍‍==3) {
    console.log("Why hello there!")
}

可能です！

var i = 0;

with({
  get a() {
    return ++i;
  }
}) {
  if (a == 1 && a == 2 && a == 3)
    console.log("wohoo");
}

これは、withステートメント内でゲッターを使用して、a3つの異なる値に評価させます。

...これは、これが実際のコードで使用されるべきであるという意味ではありません...

さらに悪いことに、このトリックはの使用でも機能します===。

  var i = 0;

  with({
    get a() {
      return ++i;
    }
  }) {
    if (a !== a)
      console.log("yep, this is printed.");
  }

ゲッターまたはvalueOfなしの例：

a = [1,2,3];
a.join = a.shift;
console.log(a == 1 && a == 2 && a == 3);

これは、配列を==呼び出すtoStringを呼び出すため機能します.join。

Symbol.toPrimitiveES6と同等の使用する別のソリューションtoString/valueOf：

let i = 0;
let a = { [Symbol.toPrimitive]: () => ++i };

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

可能かどうかを尋ねられた場合（必須ではない）、乱数を返すように「a」に要求できます。1、2、3を順番に生成する場合はtrueです。

with({
  get a() {
    return Math.floor(Math.random()*4);
  }
}){
  for(var i=0;i<1000;i++){
    if (a == 1 && a == 2 && a == 3){
      console.log("after " + (i+1) + " trials, it becomes true finally!!!");
      break;
    }
  }
}

正規表現なしでは何もできない場合：

var a = {
  r: /\d/g, 
  valueOf: function(){
    return this.r.exec(123)[0]
  }
}

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

valueOfObjectがプリミティブ（Numberなど）と比較されるときに呼び出されるカスタムメソッドのために機能します。主なトリックは、フラグ付きの正規表現をa.valueOf呼び出すため、毎回新しい値を返すことです。これにより、一致が見つかるたびにその正規表現が更新されます。したがって、最初は一致して更新されます。なので、次回は正規表現が一致します。execglastIndexthis.r.lastIndex == 01lastIndexthis.r.lastIndex == 12

これは、グローバルスコープで次を使用して実現できます。以下のためのnodejs使用globalの代わりに、window以下のコードインチ

var val = 0;
Object.defineProperty(window, 'a', {
  get: function() {
    return ++val;
  }
});
if (a == 1 && a == 2 && a == 3) {
  console.log('yay');
}

この回答は、変数を取得するゲッターを定義することにより、実行コンテキストのグローバルスコープによって提供される暗黙的な変数を悪用します。

これはa、SharedArrayBufferといくつかのメインスクリプトを介して、たとえば2つのWebワーカーが変数にアクセスする場合に可能です。可能性は低いですが、コードはマシンコードにコンパイルされたときに、ウェブの労働者が変数を更新することも可能であるa条件ので、時間だけでa==1、a==2そしてa==3満足しています。

これは、WebワーカーとJavaScriptのSharedArrayBufferによって提供されるマルチスレッド環境での競合状態の例になります。

上記の基本的な実装は次のとおりです。

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)

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

modifier.js

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

私のMacBook Airでは、それは最初の試みでおよそ100億回の繰り返しの後に起こります：

2回目の試み：

言ったように、可能性は低くなりますが、十分な時間が与えられれば、それは条件にヒットします。

ヒント：システムで時間がかかりすぎる場合。のみa == 1 && a == 2を試してに変更Math.random()*3してくださいMath.random()*2。リストにどんどん追加すると、ヒットする可能性が低くなります。

これは、一連の自己上書きゲッターを使用して行うこともできます。

（これはjontroのソリューションに似ていますが、カウンター変数を必要としません。）

(() => {
    "use strict";
    Object.defineProperty(this, "a", {
        "get": () => {
            Object.defineProperty(this, "a", {
                "get": () => {
                    Object.defineProperty(this, "a", {
                        "get": () => {
                            return 3;
                        }
                    });
                    return 2;
                },
                configurable: true
            });
            return 1;
        },
        configurable: true
    });
    if (a == 1 && a == 2 && a == 3) {
        document.body.append("Yes, it’s possible.");
    }
})();

または、クラスとチェックのインスタンスを使用することもできます。

function A() {
    var value = 0;
    this.valueOf = function () { return ++value; };
}

var a = new A;

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

編集する

ES6クラスを使用すると、次のようになります。

class A {
  constructor() {
    this.value = 0;
    this.valueOf();
  }
  valueOf() {
    return this.value++;
  };
}

let a = new A;

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

この回答はすでに投稿されていないので、これもミックスに投入します。これは、半角のハングルスペースに関するジェフの回答に似ています。

var a = 1;
var ａ = 2;
var а = 3;
if(a == 1 && ａ == 2 && а == 3) {
    console.log("Why hello there!")
}

2番目のものとはわずかな違いに気付くかもしれませんが、最初と3番目は肉眼と同じです。3つすべてが異なる文字です。

a-ラテン小文字A-
ａ全角ラテン小文字A-
аキリル文字小文字A

これの総称は「ホモグリフ」です。同じように見える異なるUnicode文字です。通常、まったく区別がつかない3つを取得することは困難ですが、場合によってはラッキーになることもあります。A、Αは、А、およびᎪは良く機能するであろう（ラテン-Aは、ギリシャのアルファ、キリル-A 、およびチェロキー-A ;それぞれ、残念ながらギリシャとチェロキー小文字はラテン語からあまりにも異なっているa：α、ꭺ、およびdoesnのように上記のスニペットでは役に立ちません）。

ホモグリフ攻撃のクラス全体があり、最も一般的には偽のドメイン名（たとえばwikipediа.org（キリル文字）対wikipedia.org（ラテン文字））ですが、コードにも表示される可能性があります。通常、アンダーハンドであると呼ばれます（コメントで述べたように、[アンダーハンド]の質問はPPCGではトピックから外れていますが、以前はこの種の問題が発生するタイプの課題でした）。私が使用し、このウェブサイトを、この答えに使用homoglyphsを見つけること。

はい、可能です！😎

»JavaScript

if‌=()=>!0;
var a = 9;

if‌(a==1 && a== 2 && a==3)
{
    document.write("<h1>Yes, it is possible!😎</h1>")
}

上記のコードは短いバージョンであり（コメントでの注記について@Forivinに感謝）、次のコードはオリジナルです。

var a = 9;

if‌(a==1 && a== 2 && a==3)
{
    //console.log("Yes, it is possible!😎")
    document.write("<h1>Yes, it is possible!😎</h1>")
}

//--------------------------------------------

function if‌(){return true;}

私のコードの上側だけを見てそれを実行するなら、WOWと言いますか？

だから私ははいと言うだけで十分だと思います、あなたに言った誰かにそれは可能です：何も不可能ではありません

トリック：if名前がに似た関数を作成するために、後に隠し文字を使用しましたif。JavaScriptではキーワードを上書きできないため、この方法を使用せざるを得ませんでした。それは偽物ifですが、この場合はうまくいきます！

» C＃

また、C＃バージョンを記述しました（プロパティ値のテクニックを増やします）。

static int _a;
public static int a => ++_a;

public static void Main()
{
    if(a==1 && a==2 && a==3)
    {
        Console.WriteLine("Yes, it is possible!😎");
    }
}

ライブデモ

JavaScript

a == a +1

JavaScriptでは、整数はなくNumber、s のみがあり、倍精度浮動小数点数として実装されます。

つまり、Number aが十分に大きければ、3つの連続した整数に等しいと見なすことができます。

a = 100000000000000000
if (a == a+1 && a == a+2 && a == a+3){
  console.log("Precision loss!");
}

確かに、それはインタビュアーが尋ねたものとは完全には一致しません（それはで動作しませんa=0）が、非表示の関数や演算子のオーバーロードに関するトリックは含まれていません。

他の言語

参考までにa==1 && a==2 && a==3、RubyとPython にはソリューションがあります。わずかな変更で、Javaでも可能です。

ルビー

カスタム付き==：

class A
  def ==(o)
    true
  end
end

a = A.new

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

または増加a：

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!")

ジャワ

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

これは、@ Jeffの回答を逆にしたバージョンです。隠し文字（U + 115F、U + 1160、またはU + 3164）を使用して1、2やのような変数を作成します3。

var  a = 1;
var ﾠ1 = a;
var ﾠ2 = a;
var ﾠ3 = a;
console.log( a ==ﾠ1 && a ==ﾠ2 && a ==ﾠ3 );

*その答えは、ゼロ幅の非結合子（U + 200C）とゼロ幅の結合子（U + 200D）を使用することで簡略化できます。これらの文字はどちらも識別子の内側では使用できますが、先頭では使用できません。

var a = 1;
var a‌ = 2;
var a‍ = 3;
console.log(a == 1 && a‌ == 2 && a‍ == 3);

/****
var a = 1;
var a\u200c = 2;
var a\u200d = 3;
console.log(a == 1 && a\u200c == 2 && a\u200d == 3);
****/

同じ考えを使用して、他のトリックも可能です。たとえば、Unicodeバリエーションセレクターを使用して、まったく同じように見える変数を作成します（a︀ = 1; a︁ = 2; a︀ == 1 && a︁ == 2; // true）。

インタビューのルール1。不可能とは決して言いません。

隠されたキャラクターの策略の必要はありません。

window.__defineGetter__( 'a', function(){
    if( typeof i !== 'number' ){
        // define i in the global namespace so that it's not lost after this function runs
        i = 0;
    }
    return ++i;
});

if( a == 1 && a == 2 && a == 3 ){
    alert( 'Oh dear, what have we done?' );
}

正直なところ、それが真と評価する方法があるかどうか（そして他の人が示しているように、複数の方法がある）かどうか、私が探している答えは、何百ものインタビューを行った人として言えば、何かに沿って：

「まあ、たぶん、すぐにはわからない奇妙な一連の状況下ではそうかもしれません...しかし、実際のコードでこれが発生した場合は、一般的なデバッグ手法を使用して、それがどのようにして何をしていたのかを理解しますその状況を回避するためにすぐにコードをリファクタリングします...しかし、より重要なことは、そもそも複雑なコードのまさにその定義であり、複雑なコードを書かないように努めるからです。

一部の面接担当者は、明らかに非常にトリッキーな質問であることを明らかにすることを怒らせると思いますが、特に論理的な考えでそれをバックアップでき、私の質問に答えることができる場合、私は意見を持っている開発者を気にしません。自分自身についての意味のある発言。

このようなインタビューの質問を受け取った場合（またはコードで同様に予期しない動作に気付いた場合）、一見すると不可能と思われる動作を引き起こす可能性のあるものについて考えてください。

1. エンコーディング：この場合、あなたが見ている変数はあなたが思っているものではありません。これは、意図的にホモグリフまたはスペース文字を使用してUnicodeをいじって、変数の名前を別の名前のように見せる場合に発生する可能性がありますが、予期しないUnicodeコードを含むWebからコードをコピーして貼り付ける場合など、エンコードの問題が誤って発生する可能性もありますポイント（たとえば、コンテンツ管理システムがflUnicode 'LATIN SMALL LIGATURE FL'（U + FB02）で置き換えるなどの「自動フォーマット」を行ったため）。

2. 競合状態：競合状態が発生する可能性があります。つまり、開発者が予期した順序でコードが実行されない状況です。競合状態はマルチスレッドコードで発生することがよくありますが、複数スレッドは競合状態を可能にするための要件ではありません。非同期性で十分です（混乱しないでください。非同期は、複数のスレッドが内部で使用されることを意味しません）。

   したがって、JavaScriptはシングルスレッドであるため、競合状態から解放されるわけではないことに注意してください。シンプルなシングルスレッドの、ただし非同期の例については、こちらをご覧ください。ただし、単一のステートメントのコンテキストでは、JavaScriptで競合状態をヒットするのはかなり困難です。

   複数のスレッドを使用できるため、WebワーカーでのJavaScriptは少し異なります。@mehulmptは、Webワーカーを使用した優れた概念実証を示しています。

3. 副作用：等価比較演算の副作用（この例のように明白である必要はありませんが、多くの場合、副作用は非常に微妙です）。

我々は古典の一つを見ていないので、問題のこれらの種類は、多くのプログラミング言語だけでなく、JavaScriptで表示することができたJavaScript WTFsここ¹。

もちろん、インタビューの質問とここにあるサンプルはすべて非常に不自然に見えます。ただし、次の点に注意してください。

• 副作用は非常に厄介なものになる可能性があり、適切に設計されたプログラムには不要な副作用がないはずです。
• マルチスレッド化および変更可能な状態は問題になる可能性があります。
• 文字エンコーディングと文字列処理を正しく行わないと、厄介なバグが発生する可能性があります。

_{¹たとえば、副作用（明白な1）を示す全く異なるプログラミング言語（C＃の）の例を見つけることができるここに。}

次に、別のバリエーションを示します。配列を使用して、必要な値をポップします。

const a = {
  n: [3,2,1],
  toString: function () {
    return a.n.pop();
  }
}

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

さて、ジェネレーターを使った別のハック：

const value = function* () {
  let i = 0;
  while(true) yield ++i;
}();

Object.defineProperty(this, 'a', {
  get() {
    return value.next().value;
  }
});

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

プロキシの使用：

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

プロキシは基本的にターゲットオブジェクト（最初のパラメーター）のふりをしますが、ターゲットオブジェクトの操作（この場合は「プロパティの取得」操作）をインターセプトするため、デフォルトのオブジェクトの動作以外のことを行う機会があります。この場合、「数値を取得」アクションは、各数値と比較するためにそのタイプを強制するaときに呼び出され==ます。これは起こります：

1. ターゲットオブジェクトを作成します。{ i: 0 }ここで、iプロパティはカウンターです
2. ターゲットオブジェクトのプロキシを作成し、それを a
3. a ==比較ごとに、aの型はプリミティブ値に強制されます
4. この型強制はa[Symbol.toPrimitive]()内部での呼び出しを引き起こします
5. プロキシa[Symbol.toPrimitive]は、「取得ハンドラ」を使用して関数を取得します。
6. プロキシの「取得ハンドラ」は、取得されているプロパティがであることを確認します。Symbol.toPrimitiveこの場合、プロパティが増分され、ターゲットオブジェクトからカウンタが返されます++target.i。別のプロパティが取得されている場合、フォールバックしてデフォルトのプロパティ値を返します。target[name]

そう：

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

他のほとんどの回答と==同様に、厳密な等価チェック（===）はプロキシがインターセプトできる型強制を行わないため、これは緩やかな等価チェック（）でのみ機能します。

実際、質問の最初の部分に対する答えは、すべてのプログラミング言語で「はい」です。たとえば、これは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;
}

同じですが、異なりますが、同じです（複数回「テスト」できます）：

const a = { valueOf: () => this.n = (this.n || 0) % 3 + 1}
    
if(a == 1 && a == 2 && a == 3) {
  console.log('Hello World!');
}

if(a == 1 && a == 2 && a == 3) {
  console.log('Hello World!');
}

私のアイデアは、Numberオブジェクトタイプの方程式のしくみから始まりました。

記号を利用するECMAScript 6の回答：

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

以下のため==の使用は、JavaScriptが強制になっているa第二オペランドに何かの近くに（1、2、3この場合）。しかし、JavaScriptはそれ自体で強制を計算しようとする前に、を呼び出そうとしますSymbol.toPrimitive。Symbol.toPrimitiveJavaScript を提供する場合、関数が返す値を使用します。そうでない場合、JavaScriptはを呼び出しますvalueOf。

これはそれを実装するための最小限のコードだと思います：

i=0,a={valueOf:()=>++i}

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

各呼び出しでvalueOfグローバル変数をインクリメントするカスタムでダミーオブジェクトを作成しiます。23キャラクター！

これは、definePropertyを使用して、副作用を引き起こすグローバル変数を提供しています！

var _a = 1

Object.defineProperty(this, "a", {
  "get": () => {
    return _a++;
  },
  configurable: true
});

console.log(a)
console.log(a)
console.log(a)

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}、条件が真であったことが示されます。