Note du modérateur: veuillez résister à l'envie de modifier le code ou de supprimer cet avis. Le motif des espaces blancs peut faire partie de la question et ne doit donc pas être altéré inutilement. Si vous êtes dans le camp "les espaces blancs sont insignifiants", vous devriez pouvoir accepter le code tel quel.

Est-il possible que cela (a== 1 && a ==2 && a==3)puisse être évalué trueen JavaScript?

Il s'agit d'une question d'entrevue posée par une grande entreprise de technologie. C'est arrivé il y a deux semaines, mais j'essaie toujours de trouver la réponse. Je sais que nous n'écrivons jamais un tel code dans notre travail quotidien, mais je suis curieux.

Si vous profitez de la façon dont ==fonctionne , vous pouvez simplement créer un objet avec une fonction personnalisée toString(ou valueOf) qui change ce qu'il retourne chaque fois qu'il est utilisé de telle sorte qu'il remplit les trois conditions.

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

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

La raison pour laquelle cela fonctionne est due à l'utilisation de l'opérateur d'égalité lâche. Lors de l'utilisation d'une égalité lâche, si l'un des opérandes est d'un type différent de l'autre, le moteur tentera de convertir l'un en l'autre. Dans le cas d'un objet à gauche et d'un numéro à droite, il tentera de convertir l'objet en un numéro en appelant d'abord valueOfs'il est appelable, et à défaut, il appellera toString. J'ai utilisé toStringdans ce cas simplement parce que c'est ce qui m'est venu à l'esprit, valueOfaurait plus de sens. Si j'avais plutôt renvoyé une chaîne toString, le moteur aurait alors tenté de convertir la chaîne en un nombre nous donnant le même résultat final, mais avec un chemin légèrement plus long.

Je n'ai pas pu résister - les autres réponses sont sans aucun doute vraies, mais vous ne pouvez vraiment pas passer devant le code suivant:

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

Notez l'espacement étrange dans la ifdéclaration (que j'ai copiée de votre question). C'est le Hangul demi-largeur (qui est coréen pour ceux qui ne sont pas familiers) qui est un caractère d'espace Unicode qui n'est pas interprété par le script ECMA comme un caractère d'espace - cela signifie qu'il s'agit d'un caractère valide pour un identifiant. Il y a donc trois variables complètement différentes, une avec le Hangul après le a, une avec lui avant et la dernière avec juste un. En remplaçant l'espace par _lisibilité, le même code ressemblerait à ceci:

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

Découvrez la validation sur le validateur de nom de variable de Mathias . Si cet espacement étrange était réellement inclus dans leur question, je suis sûr que c'est un indice pour ce genre de réponse.

Ne fais pas ça. Sérieusement.

Edit: Il est venu à mon attention que (bien qu'il ne soit pas autorisé à démarrer une variable) le menuisier de largeur nulle et de non-jointure de largeur nulle sont également autorisés dans les noms de variables - voir Obfuscation de JavaScript avec des caractères de largeur nulle - avantages et inconvénients ? .

Cela ressemblerait à ceci:

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

C'EST POSSIBLE!

var i = 0;

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

Cela utilise un getter à l'intérieur d'une withinstruction pour permettre d' aévaluer trois valeurs différentes.

... cela ne signifie toujours pas que cela devrait être utilisé dans du vrai code ...

Pire encore, cette astuce fonctionnera également avec l'utilisation de ===.

  var i = 0;

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

Exemple sans getters ou valueOf:

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

Cela fonctionne car ==invoque toStringqui appelle .joindes tableaux.

Une autre solution, utilisant Symbol.toPrimitivequi est un équivalent ES6 de toString/valueOf:

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

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

Si on lui demande si c'est possible (pas DOIT), il peut demander à "a" de retourner un nombre aléatoire. Ce serait vrai s'il génère 1, 2 et 3 séquentiellement.

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

Lorsque vous ne pouvez rien faire sans expressions régulières:

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

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

Il fonctionne en raison de la valueOfméthode personnalisée qui est appelée lorsque Object est comparé à une primitive (telle que Number). L'astuce principale est de a.valueOfrenvoyer une nouvelle valeur à chaque fois car elle appelle execune expression régulière avec gindicateur, ce qui provoque la mise à jour lastIndexde cette expression régulière à chaque fois qu'une correspondance est trouvée. Donc , première fois this.r.lastIndex == 0, il correspond 1et mises à jour lastIndex: this.r.lastIndex == 1, donc la prochaine fois regex correspondra 2et ainsi de suite.

Cela peut être accompli en utilisant ce qui suit dans la portée globale. À nodejsutiliser globalau lieu de windowdans le code ci-dessous.

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

Cette réponse abuse des variables implicites fournies par la portée globale dans le contexte d'exécution en définissant un getter pour récupérer la variable.

Ceci est possible en cas d' aaccès à une variable par, disons, 2 travailleurs Web via un SharedArrayBuffer ainsi que certains scripts principaux. La possibilité est faible, mais il est possible que lorsque le code est compilé en code machine, les travailleurs Web mettent à jour la variable ajuste à temps pour que les conditions a==1, a==2eta==3 sont satisfaits.

Cela peut être un exemple de condition de concurrence critique dans un environnement multithread fourni par les travailleurs Web et SharedArrayBuffer en JavaScript.

Voici l'implémentation de base de ci-dessus:

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)

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

Sur mon MacBook Air, cela se produit après environ 10 milliards d'itérations lors de la première tentative:

Deuxième essai:

Comme je l'ai dit, les chances seront faibles, mais avec suffisamment de temps, cela atteindra la situation.

Astuce: si cela prend trop de temps sur votre système. Essayez uniquement a == 1 && a == 2et passez Math.random()*3à Math.random()*2. Ajouter de plus en plus à la liste diminue les chances de frapper.

Ceci est également possible en utilisant une série de getters auto-écrasants:

(Ceci est similaire à la solution de jontro, mais ne nécessite pas de variable de compteur.)

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

Alternativement, vous pouvez utiliser une classe pour elle et une instance pour la vérification.

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

var a = new A;

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

ÉDITER

En utilisant les classes ES6, cela ressemblerait à ceci

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

Je ne vois pas cette réponse déjà publiée, donc je vais jeter celle-ci dans le mélange aussi. Ceci est similaire à la réponse de Jeff avec l'espace Hangul demi-largeur.

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

Vous remarquerez peut-être un léger écart avec le second, mais le premier et le troisième sont identiques à l'œil nu. Les 3 sont des caractères distincts:

a- Minuscules latines A
ａ- Minuscules latines pleine largeur A
а - Minuscules cyrilliques A

Le terme générique pour cela est "homoglyphes": différents caractères unicode qui se ressemblent. Il est généralement difficile d'en obtenir trois qui sont totalement indiscernables, mais dans certains cas, vous pouvez avoir de la chance. A, Α, А et Ꭺ fonctionneraient mieux (latin-A, grec alpha , cyrillique-A et Cherokee-A respectivement, malheureusement , le grec et Cherokee lettres minuscules sont trop différents du latin a: α,ꭺ , et ainsi doesn 't aider avec l'extrait ci-dessus).

Il existe toute une classe d'attaques d'homoglyphes, le plus souvent dans de faux noms de domaine (par exemple wikipediа.org(cyrillique) vs wikipedia.org(latin)), mais il peut également apparaître dans le code; généralement dénommé sournois (comme mentionné dans un commentaire, les questions [sournoises] sont désormais hors sujet sur PPCG , mais étaient un type de défi où ce genre de choses apparaissait). j'ai utilisé ce site Web pour trouver les homoglyphes utilisés pour cette réponse.

Oui c'est possible! 😎

»JavaScript

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

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

Le code ci-dessus est une version courte (merci à @Forivin pour sa note dans les commentaires) et le code suivant est 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;}

Si vous voyez juste le côté supérieur de mon code et l'exécutez, vous dites WOW, comment?

Donc je pense qu'il suffit de dire oui, c'est possible à quelqu'un qui vous a dit: rien n'est impossible

Astuce: j'ai utilisé un caractère caché après ifpour créer une fonction à laquelle son nom ressemble if. En JavaScript, nous ne pouvons pas remplacer les mots clés, j'ai donc forcé à utiliser de cette façon. C'est un faux if, mais ça marche pour vous dans ce cas!

» C #

J'ai également écrit une version C # ( avec une technique d'augmentation de la valeur des propriétés ):

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

Démo en direct

Javascript

a == a +1

En JavaScript, il n'y a pas d' entiers mais seulement des Numbers, qui sont implémentés comme des nombres à virgule flottante double précision.

Cela signifie que si un nombre aest suffisamment grand, il peut être considéré comme égal à trois entiers consécutifs:

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

Certes, ce n'est pas exactement ce que l'intervieweur a demandé (cela ne fonctionne pas a=0), mais cela n'implique aucune astuce avec des fonctions cachées ou une surcharge d'opérateur.

Autres langues

Pour référence, il existe des a==1 && a==2 && a==3solutions en Ruby et Python. Avec une légère modification, c'est également possible en Java.

Rubis

Avec une coutume ==:

class A
  def ==(o)
    true
  end
end

a = A.new

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

Ou une augmentation 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

Il est possible de modifier le 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.");
        }
    }
}

Il s'agit d'une version inversée de la réponse de @ Jeff * où un caractère caché (U + 115F, U + 1160 ou U + 3164) est utilisé pour créer des variables qui ressemblent à 1, 2et 3.

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

* Cette réponse peut être simplifiée en utilisant un non-jointeur de largeur nulle (U + 200C) et un jointeur de largeur nulle (U + 200D). Ces deux caractères sont autorisés à l'intérieur des identifiants mais pas au début:

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

D'autres astuces sont possibles en utilisant la même idée, par exemple en utilisant des sélecteurs de variation Unicode pour créer des variables qui se ressemblent exactement ( a︀ = 1; a︁ = 2; a︀ == 1 && a︁ == 2; // true).

Règle numéro un des entretiens; ne dites jamais impossible.

Pas besoin de tromperie de personnage caché.

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

Honnêtement cependant, qu'il existe un moyen d'évaluer cela comme vrai ou non (et comme d'autres l'ont montré, il existe plusieurs façons), la réponse que je chercherais, parlant comme quelqu'un qui a mené des centaines d'interviews, serait quelque chose comme:

"Eh bien, peut-être que oui dans un ensemble de circonstances étranges qui ne sont pas immédiatement évidentes pour moi ... mais si je rencontrais cela dans du vrai code, j'utiliserais des techniques de débogage communes pour comprendre comment et pourquoi il faisait ce qu'il faisait puis refactoriser immédiatement le code pour éviter cette situation ... mais plus important encore: je n'écrirais JAMAIS absolument ce code en premier lieu parce que c'est la définition même du code alambiqué, et je m'efforce de ne jamais écrire du code alambiqué ".

Je suppose que certains intervieweurs seraient offensés de voir ce qui est manifestement censé être une question très délicate, mais cela ne me dérange pas des développeurs qui ont une opinion, surtout quand ils peuvent l'étayer avec une pensée raisonnée et peuvent concilier ma question une déclaration significative sur eux-mêmes.

Si jamais vous obtenez une telle question d'entrevue (ou remarquez un comportement tout aussi inattendu dans votre code) pensez à quel genre de choses pourrait éventuellement provoquer un comportement qui semble impossible à première vue:

1. Encodage : dans ce cas, la variable que vous regardez n'est pas celle que vous pensez qu'elle est. Cela peut se produire si vous vous trompez intentionnellement avec Unicode en utilisant des homoglyphes ou des caractères d'espacement pour faire ressembler le nom d'une variable à une autre, mais des problèmes d'encodage peuvent également être introduits accidentellement, par exemple lors de la copie et du collage de code à partir du Web qui contient du code Unicode inattendu (par exemple parce qu'un système de gestion de contenu a fait un "formatage automatique" tel que le remplacement flpar Unicode 'LATIN SMALL LIGATURE FL' (U + FB02)).

2. Conditions de concurrence : Une condition de concurrence peut se produire, c'est-à-dire une situation où le code ne s'exécute pas dans la séquence attendue par le développeur. Les conditions de concurrence se produisent souvent dans le code multi-thread, mais plusieurs threads ne sont pas nécessaires pour que les conditions de concurrence soient possibles - l'asynchronicité est suffisante (et ne vous trompez pas , async ne signifie pas que plusieurs threads sont utilisés sous le capot ).

   Notez que par conséquent, JavaScript n'est pas non plus exempt de conditions de concurrence simplement parce qu'il est monothread. Voir ici pour un exemple simple à un seul thread - mais asynchrone. Dans le contexte d'une seule déclaration, la condition de concurrence serait cependant assez difficile à atteindre en JavaScript.

   JavaScript avec les travailleurs Web est un peu différent, car vous pouvez avoir plusieurs threads. @mehulmpt nous a montré une excellente preuve de concept en utilisant des travailleurs Web .

3. Effets secondaires : Un effet secondaire de l'opération de comparaison d'égalité (qui ne doit pas être aussi évident que dans les exemples ici, souvent les effets secondaires sont très subtils).

Ce type de problèmes peut apparaître dans de nombreux langages de programmation, pas seulement JavaScript, donc nous ne voyons pas l'un des WTF JavaScript classiques ici ¹ .

Bien sûr, la question d'entrevue et les échantillons ici semblent tous très artificiels. Mais ils rappellent bien que:

• Les effets secondaires peuvent devenir vraiment désagréables et qu'un programme bien conçu devrait être exempt d'effets secondaires indésirables.
• L'état multithread et mutable peut être problématique.
• Ne pas faire correctement l'encodage des caractères et le traitement des chaînes peut conduire à des bugs désagréables.

_{¹ Par exemple, vous pouvez trouver un exemple dans un langage de programmation (C #) totalement différent présentant un effet secondaire (évident) ici .}

Voici une autre variante, en utilisant un tableau pour masquer les valeurs que vous souhaitez.

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

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

D'accord, un autre hack avec des générateurs:

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

Utilisation de procurations :

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

Les proxys prétendent fondamentalement être un objet cible (le premier paramètre), mais interceptent les opérations sur l'objet cible (dans ce cas, l'opération "get property") afin qu'il y ait une possibilité de faire autre chose que le comportement par défaut de l'objet. Dans ce cas, l'action "get property" est appelée alorsque ==contraint son type afin de le comparer à chaque nombre. Ça arrive:

1. Nous créons un objet cible { i: 0 }, où la ipropriété est notre compteur
2. Nous créons un proxy pour l'objet cible et l'affectons à a
3. Pour chaque a ==comparaison, ale type de est contraint à une valeur primitive
4. Ce type de coercition conduit à appeler en a[Symbol.toPrimitive]()interne
5. Le proxy intercepte l'obtention de la a[Symbol.toPrimitive]fonction en utilisant le "get handler"
6. Les chèques « gestionnaire » de proxy obtenir que la propriété se récupérer est Symbol.toPrimitive, dans ce cas , il incrémente puis retourne le compteur de l'objet cible: ++target.i. Si une propriété différente est récupérée, nous revenons simplement au retour de la valeur de propriété par défaut,target[name]

Donc:

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

Comme avec la plupart des autres réponses, cela ne fonctionne qu'avec une vérification d'égalité lâche ( ==), car les vérifications d'égalité strictes ( ===) ne font pas de coercition de type que le proxy peut intercepter.

En fait, la réponse à la première partie de la question est "Oui" dans tous les langages de programmation. Par exemple, c'est dans le cas de 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;
}

Identique, mais différent, mais toujours identique (peut être "testé" plusieurs fois):

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

Mon idée est née du fonctionnement de l'équation du type d'objet Number.

Une réponse ECMAScript 6 qui utilise des symboles:

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

En raison de son ==utilisation, JavaScript est censé contraindre aquelque chose de proche du deuxième opérande ( 1,2 , 3dans ce cas). Mais avant que JavaScript essaie de comprendre la contrainte par lui-même, il essaie d'appeler Symbol.toPrimitive. Si vous fournissez Symbol.toPrimitiveJavaScript, utilisez la valeur renvoyée par votre fonction. Sinon, JavaScript appellerait valueOf.

Je pense que c'est le code minimal pour l'implémenter:

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

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

Création d'un objet factice avec une coutume valueOfqui incrémente une variable globale ià chaque appel. 23 personnages!

Celui-ci utilise le defineProperty avec un bel effet secondaire provoquant une variable globale!

var _a = 1

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

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

En remplaçant valueOfdans une déclaration de classe, cela peut être fait:

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

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

const a = new Thing();

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

Ce qui se passe, c'est que cela valueOfest appelé dans chaque opérateur de comparaison. Sur le premier, asera égal 1, sur le second, asera égal 2, et ainsi de suite et ainsi de suite, car à chaque valueOfappel, la valeur de aest incrémentée.

Par conséquent, le fichier console.log se déclenchera et sortira (dans mon terminal de toute façon) Thing: { value: 4}, indiquant que le conditionnel était vrai.