Anmerkung des Moderators: Bitte widersetzen Sie sich dem Drang, den Code zu bearbeiten oder diesen Hinweis zu entfernen. Das Leerzeichenmuster kann Teil der Frage sein und sollte daher nicht unnötig manipuliert werden. Wenn Sie sich im Lager "Leerzeichen sind unbedeutend" befinden, sollten Sie in der Lage sein, den Code unverändert zu akzeptieren.

Ist es jemals möglich, dass in JavaScript (a== 1 && a ==2 && a==3)ausgewertet werden könnte true?

Dies ist eine Interviewfrage, die von einem großen Technologieunternehmen gestellt wird. Es ist vor zwei Wochen passiert, aber ich versuche immer noch, die Antwort zu finden. Ich weiß, dass wir in unserer täglichen Arbeit niemals solchen Code schreiben, aber ich bin neugierig.

Wenn Sie nutzen , wie ==funktioniert , könnten Sie einfach ein Objekt mit einer benutzerdefinierten erstellen toString(oder valueOf) Funktion , die ändert , was es jedes Mal wieder ist es so verwendet , dass es erfüllt alle drei Bedingungen.

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

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

Der Grund, warum dies funktioniert, liegt in der Verwendung des Operators für lose Gleichheit. Wenn bei Verwendung der losen Gleichheit einer der Operanden von einem anderen Typ als der andere ist, versucht die Engine, einen in den anderen zu konvertieren. Bei einem Objekt auf der linken Seite und einer Nummer auf der rechten Seite wird versucht, das Objekt in eine Nummer umzuwandeln, indem zuerst valueOfaufgerufen wird , wenn es aufrufbar ist. Andernfalls wird es angerufen toString. Ich habe toStringin diesem Fall einfach verwendet, weil es mir in den Sinn kam valueOf, sinnvoller wäre. Wenn ich stattdessen eine Zeichenfolge von zurückgegeben hätte toString, hätte die Engine dann versucht, die Zeichenfolge in eine Zahl umzuwandeln, die das gleiche Endergebnis liefert, allerdings mit einem etwas längeren Pfad.

Ich konnte nicht widerstehen - die anderen Antworten sind zweifellos wahr, aber Sie können den folgenden Code wirklich nicht umgehen:

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

Beachten Sie den seltsamen Abstand in der ifAnweisung (den ich von Ihrer Frage kopiert habe). Es ist das Hangul mit halber Breite (das ist Koreanisch für diejenigen, die nicht vertraut sind), ein Unicode-Leerzeichen, das vom ECMA-Skript nicht als Leerzeichen interpretiert wird. Dies bedeutet, dass es ein gültiges Zeichen für einen Bezeichner ist. Daher gibt es drei völlig unterschiedliche Variablen, eine mit dem Hangul nach dem a, eine mit dem vor und die letzte mit nur einem. Wenn Sie den Speicherplatz _aus Gründen der Lesbarkeit durch ersetzen , sieht derselbe Code folgendermaßen aus:

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

Überprüfen Sie die Validierung auf Mathias 'Variablennamen-Validator . Wenn dieser seltsame Abstand tatsächlich in ihrer Frage enthalten war, bin ich mir sicher, dass dies ein Hinweis für diese Art von Antwort ist.

Tu das nicht. Ernsthaft.

Bearbeiten: Es ist mir aufgefallen, dass (obwohl es nicht erlaubt ist, eine Variable zu starten) die Joiner- Zeichen mit der Breite Null und die Nicht-Joiner- Zeichen mit der Breite Null auch in Variablennamen zulässig sind - siehe Verschleierung von JavaScript mit Zeichen mit der Breite Null - Vor- und Nachteile ? .

Dies würde wie folgt aussehen:

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

ES IST MÖGLICH!

var i = 0;

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

Dies verwendet einen Getter innerhalb einer withAnweisung, um adrei verschiedene Werte auswerten zu lassen .

... das bedeutet immer noch nicht, dass dies in echtem Code verwendet werden sollte ...

Schlimmer noch, dieser Trick funktioniert auch mit der Verwendung von ===.

  var i = 0;

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

Beispiel ohne Getter oder valueOf:

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

Dies funktioniert , weil ==aufruft , toStringdie Anrufe .joinfür Arrays.

Eine andere Lösung, bei Symbol.toPrimitiveder es sich um ein ES6-Äquivalent handelt von toString/valueOf:

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

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

Wenn gefragt wird, ob dies möglich ist (nicht MUSS), kann "a" aufgefordert werden, eine Zufallszahl zurückzugeben. Es wäre wahr, wenn es nacheinander 1, 2 und 3 erzeugen würde.

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;
    }
  }
}

Wenn Sie ohne reguläre Ausdrücke nichts tun können:

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

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

Dies funktioniert aufgrund einer benutzerdefinierten valueOfMethode, die aufgerufen wird, wenn Object mit primitiv verglichen wird (z. B. Number). Der Haupttrick besteht darin, dass a.valueOfjedes Mal ein neuer Wert zurückgegeben wird, da ein execregulärer Ausdruck mit gFlag aufgerufen wird, wodurch lastIndexdieser reguläre Ausdruck jedes Mal aktualisiert wird , wenn eine Übereinstimmung gefunden wird. Beim ersten Mal this.r.lastIndex == 0stimmt es überein 1und wird aktualisiert lastIndex: Beim this.r.lastIndex == 1nächsten Mal stimmt der reguläre Ausdruck überein 2und so weiter.

Dies kann im globalen Bereich wie folgt erreicht werden. Zur nodejsVerwendung globalanstelle des folgenden windowCodes.

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

Diese Antwort missbraucht die impliziten Variablen, die vom globalen Bereich im Ausführungskontext bereitgestellt werden, indem ein Getter zum Abrufen der Variablen definiert wird.

Dies ist möglich, wenn auf Variablen avon beispielsweise 2 Web-Workern über einen SharedArrayBuffer sowie ein Hauptskript zugegriffen wird. Die Möglichkeit ist gering, aber es ist möglich , dass , wenn der Code in Maschinencode kompiliert wird, die Web - Arbeiter die Variable aktualisieren , aso dass die Bedingungen gerade rechtzeitig a==1, a==2und a==3sind zufrieden.

Dies kann ein Beispiel für die Race-Bedingung in einer Multithread-Umgebung sein, die von Web-Workern und SharedArrayBuffer in JavaScript bereitgestellt wird.

Hier ist die grundlegende Implementierung von oben:

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

Auf meinem MacBook Air geschieht dies nach ungefähr 10 Milliarden Iterationen beim ersten Versuch:

Zweiter Versuch:

Wie gesagt, die Chancen werden gering sein, aber wenn genügend Zeit zur Verfügung steht, wird es die Bedingung treffen.

Tipp: Wenn es auf Ihrem System zu lange dauert. Versuchen Sie es nur a == 1 && a == 2und wechseln Sie Math.random()*3zu Math.random()*2. Wenn Sie mehr und mehr zur Liste hinzufügen, verringert sich die Trefferchance.

Dies ist auch mit einer Reihe von selbst überschreibenden Gettern möglich:

(Dies ähnelt der Lösung von jontro, erfordert jedoch keine Zählervariable.)

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

Alternativ können Sie eine Klasse dafür und eine Instanz für die Prüfung verwenden.

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

var a = new A;

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

BEARBEITEN

Mit ES6-Klassen würde es so aussehen

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

Ich sehe diese Antwort nicht bereits gepostet, also werde ich diese auch in die Mischung werfen. Dies ähnelt Jeffs Antwort mit dem Hangul-Raum halber Breite.

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

Möglicherweise stellen Sie eine leichte Abweichung von der zweiten fest, aber die erste und dritte sind mit dem bloßen Auge identisch. Alle 3 sind unterschiedliche Zeichen:

a- Lateinische Kleinbuchstaben A
ａ- Volle Breite Lateinische Kleinbuchstaben A
а- Kyrillische Kleinbuchstaben A.

Der Oberbegriff dafür ist "Homoglyphen": verschiedene Unicode-Zeichen, die gleich aussehen. Normalerweise ist es schwierig, drei zu bekommen , die absolut nicht zu unterscheiden sind, aber in einigen Fällen kann man Glück haben. A, Α, А und Ꭺ würde besser funktionieren (Latein-A, griechisches Alpha , Kyrillisch-A und Cherokee-A verbunden sind; leider die griechische und Cherokee Kleinbuchstaben sind zu verschieden von dem lateinischen a: α, ꭺund so doesn Ich helfe nicht mit dem obigen Ausschnitt.

Es gibt eine ganze Klasse von Homoglyphenangriffen, am häufigsten in gefälschten Domainnamen (z. B. wikipediа.org(kyrillisch) vs wikipedia.org(lateinisch)), aber sie können auch im Code angezeigt werden . Wird normalerweise als hinterhältig bezeichnet (wie in einem Kommentar erwähnt, sind [hinterhältige] Fragen bei PPCG nicht mehr aktuell , waren jedoch früher eine Art Herausforderung, bei der sich solche Dinge zeigten). Ich habe diese Website verwendet , um die für diese Antwort verwendeten Homoglyphen zu finden.

Ja, es ist möglich! 😎

»JavaScript

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

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

Der obige Code ist eine Kurzversion (danke an @Forivin für den Hinweis in den Kommentaren) und der folgende Code ist original:

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;}

Wenn Sie nur die Oberseite meines Codes sehen und ihn ausführen, sagen Sie WOW, wie?

Ich denke, es reicht aus, Ja zu sagen , es ist jemandem möglich , der zu Ihnen gesagt hat: Nichts ist unmöglich

Trick: Ich habe danach ein verstecktes Zeichen verwendet if, um eine Funktion zu erstellen, deren Name ähnlich ist if. In JavaScript können wir Schlüsselwörter nicht überschreiben, daher musste ich diese Methode verwenden. Es ist eine Fälschung if, aber es funktioniert in diesem Fall für Sie!

» C #

Außerdem habe ich eine C # -Version geschrieben ( mit Technik zur Erhöhung des Eigenschaftswerts ):

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

Live-Demo

JavaScript

a == a +1

In JavaScript gibt es keine Ganzzahlen, sondern nur Numbers, die als Gleitkommazahlen mit doppelter Genauigkeit implementiert sind.

Dies bedeutet, dass eine Zahl, adie groß genug ist, als gleich drei aufeinanderfolgende Ganzzahlen betrachtet werden kann:

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

Es ist zwar nicht genau das, was der Interviewer gefragt hat (es funktioniert nicht damit a=0), aber es beinhaltet keinen Trick mit versteckten Funktionen oder Überlastung des Bedieners.

Andere Sprachen

Als Referenz gibt es a==1 && a==2 && a==3Lösungen in Ruby und Python. Mit einer geringfügigen Änderung ist dies auch in Java möglich.

Rubin

Mit einem Brauch ==:

class A
  def ==(o)
    true
  end
end

a = A.new

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

Oder eine zunehmende a:

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

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

Python

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

Es ist möglich, den Java- IntegerCache zu ändern :

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

Dies ist eine invertierte Version von @ Jeffs Antwort * wo ein verstecktes Zeichen (U + 115F, U + 1160 oder U + 3164) verwendet wird , Variablen zu erstellen , die aussehen wie 1, 2und 3.

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

* Diese Antwort kann vereinfacht werden, indem ein Nicht-Joiner mit Nullbreite (U + 200C) und ein Joiner mit Nullbreite (U + 200D) verwendet werden. Diese beiden Zeichen sind in Bezeichnern zulässig, jedoch nicht am Anfang:

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);
****/

Andere Tricks sind mit derselben Idee möglich, z. B. mithilfe von Unicode-Variationsselektoren, um Variablen zu erstellen, die genau gleich aussehen ( a︀ = 1; a︁ = 2; a︀ == 1 && a︁ == 2; // true).

Regel Nummer eins der Interviews; Sag niemals unmöglich.

Keine Notwendigkeit für Tricks mit versteckten Charakteren.

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

Ehrlich gesagt, ob es eine Möglichkeit gibt, sie als wahr zu bewerten oder nicht (und wie andere gezeigt haben, gibt es mehrere Möglichkeiten), wäre die Antwort, nach der ich suchen würde, wenn ich als jemand spreche, der Hunderte von Interviews geführt hat etwas in der Art von:

"Nun, vielleicht ja unter einigen seltsamen Umständen, die mir nicht sofort klar sind ... aber wenn ich dies in echtem Code antreffen würde, würde ich gängige Debugging-Techniken verwenden, um herauszufinden, wie und warum es das tat, was es tat und dann den Code sofort umgestalten, um diese Situation zu vermeiden ... aber was noch wichtiger ist: Ich würde diesen Code NIEMALS schreiben, da dies genau die Definition von verschlungenem Code ist und ich mich bemühe, niemals verschlungenen Code zu schreiben. "

Ich denke, einige Interviewer würden es beleidigen, wenn eine offensichtlich sehr knifflige Frage gestellt wird, aber es macht mir nichts aus, wenn Entwickler eine Meinung haben, insbesondere wenn sie diese mit begründeten Gedanken untermauern und meine Frage ineinander greifen können eine aussagekräftige Aussage über sich.

Wenn Sie jemals eine solche Interviewfrage erhalten (oder ein ebenso unerwartetes Verhalten in Ihrem Code bemerken), überlegen Sie, welche Art von Dingen möglicherweise ein Verhalten verursachen können, das auf den ersten Blick unmöglich erscheint:

1. Codierung : In diesem Fall ist die Variable, die Sie betrachten, nicht die, von der Sie glauben, dass sie es ist. Dies kann passieren, wenn Sie absichtlich mit Unicode herumspielen, indem Sie Homoglyphen oder Leerzeichen verwenden , damit der Name einer Variablen wie eine andere aussieht. Codierungsprobleme können jedoch auch versehentlich auftreten, z. B. beim Kopieren und Einfügen von Code aus dem Web, der unerwarteten Unicode-Code enthält Punkte (z. B. weil ein Content-Management-System einige "automatische Formatierungen" vorgenommen hat, z. B. das Ersetzen fldurch Unicode 'LATIN SMALL LIGATURE FL' (U + FB02)).

2. Rennbedingungen : Eine Rennbedingung kann auftreten, dh eine Situation, in der Code nicht in der vom Entwickler erwarteten Reihenfolge ausgeführt wird. Race-Bedingungen treten häufig in Multithread-Code auf, aber mehrere Threads sind keine Voraussetzung dafür, dass Race-Bedingungen möglich sind - Asynchronität ist ausreichend (und nicht zu verwechseln, Async bedeutet nicht, dass mehrere Threads unter der Haube verwendet werden ).

   Beachten Sie, dass JavaScript daher auch nicht frei von Rennbedingungen ist, nur weil es Single-Threaded ist. Sehen Sie hier für ein einfaches Single-Threaded - aber Asynchron - Beispiel. Im Kontext einer einzelnen Aussage wäre die Rennbedingung in JavaScript jedoch ziemlich schwer zu treffen.

   JavaScript mit Web-Workern ist etwas anders, da Sie mehrere Threads haben können. @mehulmpt hat uns einen großartigen Proof-of-Concept mit Web- Workern gezeigt .

3. Nebenwirkungen : Eine Nebenwirkung der Gleichheitsvergleichsoperation (die nicht so offensichtlich sein muss wie in den Beispielen hier, häufig sind Nebenwirkungen sehr subtil).

Diese Art von Fragen können in vielen Programmiersprachen erscheinen, nicht nur JavaScript, so dass wir nicht zu den klassischen Sehen Sie JavaScript WTFs hier ¹ .

Natürlich sehen die Interviewfrage und die Beispiele hier alle sehr ausgefeilt aus. Aber sie sind eine gute Erinnerung daran, dass:

• Nebenwirkungen können sehr schlimm werden und ein gut gestaltetes Programm sollte frei von unerwünschten Nebenwirkungen sein.
• Multithreading und veränderlicher Zustand können problematisch sein.
• Wenn die Zeichencodierung und Zeichenfolgenverarbeitung nicht richtig ausgeführt wird, kann dies zu bösen Fehlern führen.

_{¹ Zum Beispiel können Sie ein Beispiel in einer völlig anderen Programmiersprache (C #) aufweist , eine Nebenwirkung (eine der nahe liegenden) finden sich hier .}

Hier ist eine weitere Variante, bei der mithilfe eines Arrays beliebige Werte angezeigt werden.

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

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

Okay, noch ein Hack mit Generatoren:

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

Mit Proxies :

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

Proxies geben im Grunde genommen vor, ein Zielobjekt zu sein (der erste Parameter), fangen jedoch Operationen am Zielobjekt ab (in diesem Fall die Operation "get property"), sodass die Möglichkeit besteht, etwas anderes als das Standardobjektverhalten auszuführen. In diesem Fall wird die Aktion "get property" aufgerufen, awenn ==der Typ erzwungen wird, um ihn mit jeder Zahl zu vergleichen. Das passiert:

1. Wir erstellen ein Zielobjekt, { i: 0 }in dem die iEigenschaft unser Zähler ist
2. Wir erstellen einen Proxy für das Zielobjekt und weisen ihn zu a
3. Für jeden a ==Vergleich wird ader Typ auf einen primitiven Wert gezwungen
4. Diese Art von Zwang führt zu einem a[Symbol.toPrimitive]()internen Anruf
5. Der Proxy fängt ab, die a[Symbol.toPrimitive]Funktion mit dem "get handler" abzurufen.
6. Der "get handler" des Proxys prüft, ob die Eigenschaft abgerufen wird Symbol.toPrimitive. In diesem Fall erhöht er den Zähler und gibt ihn vom Zielobjekt zurück : ++target.i. Wenn eine andere Eigenschaft abgerufen wird, wird einfach auf den Standardeigenschaftswert zurückgegriffen.target[name]

Damit:

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

Wie bei den meisten anderen Antworten funktioniert dies nur mit einer losen Gleichheitsprüfung ( ==), da strenge Gleichheitsprüfungen ( ===) keinen Typzwang ausüben, den der Proxy abfangen kann.

Tatsächlich lautet die Antwort auf den ersten Teil der Frage in jeder Programmiersprache "Ja". Dies ist beispielsweise bei C / C ++ der Fall:

#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;
}

Gleich, aber unterschiedlich, aber immer noch gleich (kann mehrfach "getestet" werden):

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

Meine Idee begann damit, wie die Gleichung des Zahlenobjekttyps funktioniert.

Eine ECMAScript 6-Antwort, die Symbole verwendet:

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

Durch ==Nutzung wird JavaScript soll coerce ain etwas nahe dem zweiten Operanden ( 1, 2, 3in diesem Fall). Bevor JavaScript jedoch versucht, das Erzwingen selbst zu ermitteln, wird versucht, es aufzurufen Symbol.toPrimitive. Wenn Sie Symbol.toPrimitiveJavaScript bereitstellen , wird der Wert verwendet, den Ihre Funktion zurückgibt. Wenn nicht, würde JavaScript aufrufen valueOf.

Ich denke, dies ist der minimale Code, um es zu implementieren:

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

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

Erstellen eines Dummy-Objekts mit einem benutzerdefinierten Objekt, das bei jedem Aufruf valueOfeine globale Variable erhöht i. 23 Zeichen!

Dieser verwendet die defineProperty mit einem netten Nebeneffekt, der eine globale Variable verursacht!

var _a = 1

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

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

Durch Überschreiben valueOfeiner Klassendeklaration kann Folgendes erreicht werden:

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

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

const a = new Thing();

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

Was passiert, ist, dass valueOfin jedem Vergleichsoperator aufgerufen wird. Auf dem ersten awird gleich sein 1, auf dem zweiten awird gleich sein 2, und so weiter und so fort, weil jedes Mal valueOf, wenn aufgerufen wird, der Wert von aerhöht wird.

Daher wird die console.log ausgelöst und ausgegeben (jedenfalls in meinem Terminal) Thing: { value: 4}, was darauf hinweist , dass die Bedingung wahr ist.