Nota del moderatore: resistere alla tentazione di modificare il codice o rimuovere questo avviso. Lo schema degli spazi bianchi può essere parte della domanda e pertanto non deve essere manomesso inutilmente. Se ti trovi nel campo "spazi bianchi è insignificante", dovresti essere in grado di accettare il codice così com'è.

È mai possibile che si (a== 1 && a ==2 && a==3)possa valutare truein JavaScript?

Questa è una domanda di intervista posta da una grande azienda tecnologica. È successo due settimane fa, ma sto ancora cercando di trovare la risposta. So che non scriviamo mai questo codice nel nostro lavoro quotidiano, ma sono curioso.

Se approfitti di come ==funziona , potresti semplicemente creare un oggetto con una funzione personalizzata toString(o valueOf) che cambia ciò che restituisce ogni volta che viene utilizzato in modo tale da soddisfare tutte e tre le condizioni.

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

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

Il motivo per cui funziona è dovuto all'uso dell'operatore di uguaglianza libera. Quando si utilizza l'uguaglianza libera, se uno degli operandi è di tipo diverso dall'altro, il motore tenterà di convertire l'uno nell'altro. Nel caso di un oggetto a sinistra e un numero a destra, tenterà di convertire l'oggetto in un numero chiamando prima valueOfse è richiamabile e, in caso contrario, chiamerà toString. Ho usato toStringin questo caso semplicemente perché è quello che mi è venuto in mente, valueOfavrebbe più senso. Se invece avessi restituito una stringa da toString, il motore avrebbe quindi tentato di convertire la stringa in un numero dandoci lo stesso risultato finale, sebbene con un percorso leggermente più lungo.

Non ho potuto resistere: le altre risposte sono senza dubbio vere, ma non puoi davvero superare il seguente codice:

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

Nota la strana spaziatura ifnell'affermazione (che ho copiato dalla tua domanda). È l'Hangul a mezza larghezza (che è coreano per coloro che non hanno familiarità) che è un carattere spaziale Unicode che non è interpretato dallo script ECMA come un carattere spaziale - ciò significa che è un carattere valido per un identificatore. Pertanto ci sono tre variabili completamente diverse, una con l'Hangul dopo la a, una con essa prima e l'ultima con solo a. Sostituendo lo spazio con _per leggibilità, lo stesso codice sarebbe simile al seguente:

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

Controlla la convalida sul validatore del nome variabile di Mathias . Se quella strana spaziatura fosse effettivamente inclusa nella loro domanda, sono sicuro che sia un suggerimento per questo tipo di risposta.

Non farlo Sul serio.

Modifica: Mi è venuto in mente che (sebbene non sia consentito avviare una variabile) i caratteri joiner a larghezza zero e caratteri non-joiner a larghezza zero sono consentiti anche nei nomi delle variabili - vedi Offuscamento JavaScript con caratteri a larghezza zero - pro e contro ?.

Questo sarebbe simile al seguente:

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

È POSSIBILE!

var i = 0;

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

Questo utilizza un getter all'interno di withun'istruzione per lasciarea valutare tre diversi valori.

... questo non significa ancora che dovrebbe essere usato nel codice reale ...

Ancora peggio, questo trucco funzionerà anche con l'uso di ===.

  var i = 0;

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

Esempio senza getter o valueOf:

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

Questo funziona perché ==invoca toStringquali chiamate.join array.

Un'altra soluzione, Symbol.toPrimitiveche utilizza un equivalente ES6 di toString/valueOf:

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

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

Se viene chiesto se è possibile (non DEVE), può chiedere a "a" di restituire un numero casuale. Sarebbe vero se genera 1, 2 e 3 in sequenza.

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

Quando non puoi fare nulla senza le espressioni regolari:

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

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

Funziona a causa del valueOfmetodo personalizzato che viene chiamato quando Object confrontato con la primitiva (come Numero). Il trucco principale è che a.valueOfrestituisce ogni volta un nuovo valore perché chiama execun'espressione regolare con gflag, il che provoca l'aggiornamento lastIndexdi quell'espressione regolare ogni volta che viene trovata una corrispondenza. Quindi prima volta this.r.lastIndex == 0, che corrisponda 1e aggiornamenti lastIndex: this.r.lastIndex == 1, quindi la prossima volta regex corrisponderà 2e così via.

Può essere realizzato utilizzando quanto segue nell'ambito globale. Da nodejsutilizzare globalanziché windownel codice seguente.

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

Questa risposta abusa delle variabili implicite fornite dall'ambito globale nel contesto di esecuzione definendo un getter per recuperare la variabile.

Ciò è possibile in caso di accesso variabile a, ad esempio 2 web worker tramite SharedArrayBuffer e alcuni script principali. La possibilità è bassa, ma è possibile che quando il codice viene compilato in linguaggio macchina, i lavoratori web aggiornare la variabile aappena in tempo così le condizioni a==1, a==2ea==3 sono soddisfatti.

Questo può essere un esempio di race condition in ambiente multi-thread fornito dai web worker e SharedArrayBuffer in JavaScript.

Ecco l'implementazione di base di cui sopra:

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

Sul mio MacBook Air, succede dopo circa 10 miliardi di iterazioni al primo tentativo:

Secondo tentativo:

Come ho detto, le probabilità saranno basse, ma dato il tempo sufficiente, colpirà la condizione.

Suggerimento: se il sistema impiega troppo tempo. Prova solo a == 1 && a == 2e Math.random()*3passa a Math.random()*2. Aggiungendo sempre di più all'elenco si riduce la possibilità di colpire.

Ciò è anche possibile utilizzando una serie di getter con sovrascrittura automatica:

(Questo è simile alla soluzione di jontro, ma non richiede una contro variabile.)

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

In alternativa, è possibile utilizzare una classe per essa e un'istanza per il controllo.

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

var a = new A;

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

MODIFICARE

Usando le classi ES6 sarebbe simile a questo

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

Non vedo questa risposta già pubblicata, quindi inserirò anche questa nel mix. Questo è simile alla risposta di Jeff con lo spazio Hangul a metà larghezza.

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

Potresti notare una leggera discrepanza con la seconda, ma la prima e la terza sono identiche a occhio nudo. Tutti e 3 sono personaggi distinti:

a- Lettere minuscole latine A
ａ- Lettere minuscole latine a larghezza intera A
а - lettere minuscole cirilliche A

Il termine generico per questo è "omogenei": diversi caratteri unicode che sembrano uguali. In genere è difficile ottenerne tre che sono assolutamente indistinguibili, ma in alcuni casi puoi essere fortunato. A, Α, А, e Ꭺ avrebbe funzionato meglio (latino-A, greca Alpha , il cirillico-A , e Cherokee-A , rispettivamente, purtroppo greca e Cherokee minuscole sono troppo diversi dal latino a: α,ꭺ , e così doesn aiutare con lo snippet sopra).

Esiste un'intera classe di attacchi omogenei là fuori, più comunemente in nomi di dominio falsi (ad es. wikipediа.org(Cirillico) vs wikipedia.org(latino)), ma può anche apparire in codice; in genere indicato come subdolo (come menzionato in un commento, le domande [subdole] sono ora fuori tema su PPCG , ma era un tipo di sfida in cui si presentavano questo genere di cose). Ho usato questo sito Web per trovare gli omoglifici usati per questa risposta.

Sì, è possibile! 😎

»JavaScript

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

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

Il codice sopra è una versione breve (grazie a @Forivin per la sua nota nei commenti) e il seguente codice è originale:

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

Se vedi solo il lato superiore del mio codice ed eseguilo dici WOW, come?

Quindi penso che sia sufficiente dire Sì, è possibile per qualcuno che ti ha detto: Niente è impossibile

Trucco: ho usato un personaggio nascosto dopo ifper creare una funzione a cui il suo nome è simile if. In JavaScript non possiamo ignorare le parole chiave, quindi ho costretto a utilizzare in questo modo. È un falso if, ma in questo caso funziona per te!

» C #

Inoltre ho scritto una versione C # ( con tecnica di aumento del valore della proprietà ):

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

Dimostrazione dal vivo

JavaScript

a == a +1

In JavaScript, non ci sono numeri interi ma solo Numbers, che sono implementati come numeri in virgola mobile a precisione doppia.

Significa che se un numero aè abbastanza grande, può essere considerato uguale a tre numeri interi consecutivi:

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

È vero, non è esattamente quello che l'intervistatore ha chiesto (non funziona con a=0), ma non comporta alcun trucco con funzioni nascoste o sovraccarico dell'operatore.

Altre lingue

Per riferimento, ci sono a==1 && a==2 && a==3soluzioni in Ruby e Python. Con una leggera modifica, è possibile anche in Java.

Rubino

Con un'abitudine ==:

class A
  def ==(o)
    true
  end
end

a = A.new

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

O un aumento a:

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

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

Pitone

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

Giava

È possibile modificare la Integercache Java :

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

Questa è una versione invertita della risposta di @ Jeff * in cui un carattere nascosto (U + 115F, U + 1160 o U + 3164) viene utilizzato per creare variabili simili a 1, 2e 3.

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

* Questa risposta può essere semplificata utilizzando non-joiner a larghezza zero (U + 200C) e joiner a larghezza zero (U + 200D). Entrambi questi personaggi sono consentiti all'interno di identificatori ma non all'inizio:

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

Altri trucchi sono possibili utilizzando la stessa idea, ad esempio utilizzando i selettori di variazione Unicode per creare variabili che si assomigliano esattamente ( a︀ = 1; a︁ = 2; a︀ == 1 && a︁ == 2; // true).

Regola numero uno delle interviste; mai dire impossibile.

Non c'è bisogno di ingannare i personaggi nascosti.

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

Sinceramente, se c'è un modo per valutarlo come vero o no (e come altri hanno dimostrato, ci sono molti modi), la risposta che cerco, parlando come qualcuno che ha condotto centinaia di interviste, sarebbe qualcosa sulla falsariga di:

"Beh, forse sì in alcune strane circostanze che non sono immediatamente ovvie per me ... ma se lo avessi riscontrato nel codice reale, avrei usato tecniche di debug comuni per capire come e perché stesse facendo quello che stava facendo e quindi riformattare immediatamente il codice per evitare quella situazione ... ma soprattutto: non scriverò MAI assolutamente quel codice in primo luogo perché quella è la definizione stessa di codice contorto, e mi sforzo di non scrivere mai codice contorto ".

Immagino che alcuni intervistatori si offenderebbero per aver chiamato quella che è ovviamente intesa come una domanda molto delicata, ma non mi dispiace che gli sviluppatori abbiano un'opinione, soprattutto quando possono sostenerla con un pensiero ragionato e possono inserire la mia domanda in una dichiarazione significativa su se stessi.

Se ricevi mai una domanda del genere (o noti un comportamento altrettanto imprevisto nel tuo codice), pensa a che tipo di cose potrebbero causare un comportamento che sembra impossibile a prima vista:

1. Codifica : in questo caso la variabile che stai osservando non è quella che pensi sia. Questo può accadere se si scherza intenzionalmente con Unicode usando omogenei o caratteri spaziali per far apparire il nome di una variabile come un altro, ma i problemi di codifica possono anche essere introdotti accidentalmente, ad esempio quando si copia e incolla codice dal Web che contiene codice Unicode imprevisto punti (ad es. perché un sistema di gestione dei contenuti ha effettuato una "formattazione automatica" come la sostituzione flcon Unicode "LATIN SMALL LIGATURE FL" (U + FB02)).

2. Condizioni di gara : potrebbe verificarsi una condizione di gara , ovvero una situazione in cui il codice non viene eseguito nella sequenza prevista dallo sviluppatore. Le condizioni di competizione si verificano spesso nel codice multi-thread, ma più thread non sono un requisito per rendere possibili le condizioni di gara: l'asincronicità è sufficiente (e non confondersi, asincronizzazione non significa che vengano utilizzati thread multipli sotto il cofano ).

   Pertanto, JavaScript non è privo di condizioni di gara solo perché è a thread singolo. Vedere qui per un semplice esempio a thread singolo, ma asincrono. Nel contesto di una singola affermazione, tuttavia, le condizioni di gara sarebbero piuttosto difficili da raggiungere in JavaScript.

   JavaScript con i web worker è un po 'diverso, poiché puoi avere più thread. @mehulmpt ci ha mostrato una grande dimostrazione del concetto usando i web worker .

3. Effetti collaterali : un effetto collaterale dell'operazione di confronto sull'uguaglianza (che non deve essere così ovvio come negli esempi qui, spesso gli effetti collaterali sono molto sottili).

Questo tipo di problemi può apparire in molti linguaggi di programmazione, non solo JavaScript, quindi non stiamo vedendo uno dei WTF JavaScript classici qui ¹ .

Naturalmente, la domanda dell'intervista e i campioni qui sembrano tutti molto elaborati. Ma ricordano che:

• Gli effetti collaterali possono diventare davvero sgradevoli e un programma ben progettato dovrebbe essere privo di effetti collaterali indesiderati.
• Il multithreading e lo stato mutabile possono essere problematici.
• Non eseguire correttamente la codifica dei caratteri e l'elaborazione delle stringhe può portare a cattivi bug.

_{¹ Ad esempio, puoi trovare un esempio in un linguaggio di programmazione (C #) completamente diverso che mostra un effetto collaterale (evidente) qui .}

Ecco un'altra variante, utilizzando un array per estrarre qualsiasi valore tu voglia.

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

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

Va bene, un altro hack con generatori:

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

Utilizzo dei proxy :

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

I proxy sostanzialmente fingono di essere un oggetto target (il primo parametro), ma intercettano le operazioni sull'oggetto target (in questo caso l'operazione "get property") in modo che ci sia un'opportunità di fare qualcosa di diverso dal comportamento dell'oggetto predefinito. In questo caso, l'azione "get property" viene chiamata aquando ==costringe il suo tipo per confrontarlo con ciascun numero. Questo succede:

1. Creiamo un oggetto target { i: 0 }, dove ili proprietà è il nostro contatore
2. Creiamo un proxy per l'oggetto target e lo assegniamo a a
3. Per ogni a ==confronto, ail tipo è costretto a un valore primitivo
4. Questo tipo di coercizione comporta una chiamata a[Symbol.toPrimitive]()interna
5. Il proxy intercetta ottenere la a[Symbol.toPrimitive]funzione usando il "get handler"
6. Del proxy "get handler" controlla che la proprietà di essere ammassato è Symbol.toPrimitive, nel qual caso si incrementa e poi ritorna al banco da l'oggetto di destinazione: ++target.i. Se viene recuperata una proprietà diversa, torniamo semplicemente a restituire il valore predefinito della proprietà,target[name]

Così:

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

Come con la maggior parte delle altre risposte, questo funziona solo con un controllo di uguaglianza libero ( ==), poiché controlli di uguaglianza rigorosi ( ===) non generano coercizione che il proxy può intercettare.

In realtà la risposta alla prima parte della domanda è "Sì" in ogni linguaggio di programmazione. Ad esempio, questo è nel caso di 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;
}

Stesso, ma diverso, ma sempre uguale (può essere "testato" più volte):

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

La mia idea è nata da come funziona l'equazione del tipo di oggetto Numero.

Una risposta ECMAScript 6 che utilizza simboli:

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

A causa di ==utilizzo, si suppone Javascript per costringere ain qualcosa di vicino al secondo operando ( 1, 2, 3in questo caso). Ma prima che JavaScript provi a calcolare il coercing da solo, prova a chiamare Symbol.toPrimitive. Se si fornisce Symbol.toPrimitiveJavaScript, verrà utilizzato il valore restituito dalla funzione. In caso contrario, JavaScript chiamerebbe valueOf.

Penso che questo sia il codice minimo per implementarlo:

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

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

Creazione di un oggetto fittizio con un'abitudine valueOfche incrementa una variabile globale isu ogni chiamata. 23 personaggi!

Questo usa la definizioneProperty con un piacevole effetto collaterale che causa una variabile globale!

var _a = 1

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

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

Sostituendo valueOfuna dichiarazione di classe, si può fare:

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

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

const a = new Thing();

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

Quello che succede è che valueOfviene chiamato in ciascun operatore di confronto. Sul primo asarà uguale 1, sul secondo asarà uguale 2e così via, e così via, perché ogni volta che valueOfviene chiamato, il valore di aviene incrementato.

Pertanto console.log verrà generato ed emesso (comunque nel mio terminale) Thing: { value: 4}, indicando che il condizionale era vero.