Nota del moderador: resista la tentación de editar el código o eliminar este aviso. El patrón de espacios en blanco puede ser parte de la pregunta y, por lo tanto, no debe manipularse innecesariamente. Si se encuentra en el campo "el espacio en blanco es insignificante", debería poder aceptar el código tal como está.

¿Es posible que se (a== 1 && a ==2 && a==3)pueda evaluar trueen JavaScript?

Esta es una pregunta de la entrevista hecha por una importante empresa de tecnología. Sucedió hace dos semanas, pero todavía estoy tratando de encontrar la respuesta. Sé que nunca escribimos ese código en nuestro trabajo diario, pero tengo curiosidad.

Si aprovecha cómo ==funciona , podría simplemente crear un objeto con una función personalizada toString(o valueOf) que cambie lo que devuelve cada vez que se usa de manera que satisfaga las tres condiciones.

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

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

La razón por la que esto funciona se debe al uso del operador de igualdad flexible. Cuando se usa la igualdad flexible, si uno de los operandos es de un tipo diferente al otro, el motor intentará convertir uno al otro. En el caso de un objeto a la izquierda y un número a la derecha, intentará convertir el objeto en un número llamando primero valueOfsi se puede llamar y, en caso contrario, llamará toString. Usé toStringen este caso simplemente porque es lo que me vino a la mente, valueOftendría más sentido. Si en cambio devolviera una cadena de toString, el motor habría intentado convertir la cadena en un número que nos diera el mismo resultado final, aunque con una ruta un poco más larga.

No pude resistirme, las otras respuestas son indudablemente ciertas, pero realmente no puedes pasar por alto el siguiente código:

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

Tenga en cuenta el espaciado extraño en la ifdeclaración (que copié de su pregunta). Es el Hangul de ancho medio (que es coreano para aquellos que no están familiarizados) que es un carácter de espacio Unicode que no es interpretado por el script ECMA como un carácter de espacio; esto significa que es un carácter válido para un identificador. Por lo tanto, hay tres variables completamente diferentes, una con Hangul después de la a, otra con ella antes y la última con solo a. Reemplazando el espacio _por legibilidad, el mismo código se vería así:

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

Consulte la validación en el validador de nombres de variables de Mathias . Si ese espaciado extraño se incluyó realmente en su pregunta, estoy seguro de que es una pista para este tipo de respuesta.

No hagas esto. Seriamente.

Editar: Me ha llamado la atención que (aunque no se permite iniciar una variable) los caracteres de unión de ancho cero y los caracteres de unión de ancho cero también están permitidos en los nombres de las variables; consulte Ofuscar JavaScript con caracteres de ancho cero: pros y contras ? .

Esto tendría el siguiente aspecto:

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 POSIBLE!

var i = 0;

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

Esto usa un captador dentro de una withdeclaración para permitir aevaluar a tres valores diferentes.

... esto todavía no significa que deba usarse en código real ...

Peor aún, este truco también funcionará con el uso de ===.

  var i = 0;

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

Ejemplo sin getters o valueOf:

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

Esto funciona porque ==invoca lo toStringque llama .joina Arrays.

Otra solución, con la Symbol.toPrimitivecual es un equivalente ES6 de toString/valueOf:

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

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

Si se le pregunta si es posible (no DEBE), puede pedir a "a" que devuelva un número aleatorio. Sería cierto si genera 1, 2 y 3 secuencialmente.

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

Cuando no puede hacer nada sin expresiones regulares:

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

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

Funciona debido a un valueOfmétodo personalizado que se llama cuando Object se compara con primitivo (como Number). El truco principal es que a.valueOfdevuelve un valor nuevo cada vez porque llama execa una expresión regular con gbandera, lo que provoca la actualización lastIndexde esa expresión regular cada vez que se encuentra una coincidencia. Entonces, la primera vez this.r.lastIndex == 0, coincide 1y se actualiza lastIndex:, this.r.lastIndex == 1por lo que la próxima vez, la expresión regular coincidirá, 2etc.

Se puede lograr utilizando lo siguiente en el alcance global. Para nodejsusar en globallugar de windowen el código siguiente.

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

Esta respuesta abusa de las variables implícitas proporcionadas por el alcance global en el contexto de ejecución al definir un captador para recuperar la variable.

Esto es posible en caso de que aaccedan a la variable , digamos, 2 trabajadores web a través de SharedArrayBuffer, así como de algún script principal. La posibilidad es baja, pero es posible que cuando el código se compila a código de máquina, los trabajadores Web de actualización de la variable ajusto a tiempo por lo que las condiciones a==1, a==2y a==3están satisfechos.

Este puede ser un ejemplo de condición de carrera en un entorno de subprocesos múltiples proporcionado por los trabajadores web y SharedArrayBuffer en JavaScript.

Aquí está la implementación básica de lo anterior:

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

En mi MacBook Air, sucede después de alrededor de 10 mil millones de iteraciones en el primer intento:

Segundo intento:

Como dije, las posibilidades serán bajas, pero con el tiempo suficiente, se cumplirá la condición.

Consejo: si tarda demasiado en su sistema. Prueba solo a == 1 && a == 2y cambia Math.random()*3a Math.random()*2. Agregar más y más a la lista reduce la posibilidad de acertar.

Esto también es posible utilizando una serie de captadores que se sobrescriben automáticamente:

(Esto es similar a la solución de jontro, pero no requiere una variable de contador).

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

Alternativamente, puede usar una clase para ello y una instancia para el cheque.

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

var a = new A;

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

EDITAR

Usando las clases de ES6, se vería así

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

No veo esta respuesta ya publicada, así que también incluiré esta en la mezcla. Esto es similar a la respuesta de Jeff con el espacio Hangul de ancho medio.

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

Puede notar una ligera discrepancia con el segundo, pero el primero y el tercero son idénticos a simple vista. Los 3 son personajes distintos:

a- A minúscula latina - A minúscula
ａlatina de ancho completo
а- A minúscula cirílica

El término genérico para esto es "homoglyphs": diferentes caracteres Unicode que tienen el mismo aspecto. Normalmente es difícil conseguir tres que sean completamente indistinguibles, pero en algunos casos puedes tener suerte. A, Α, А, y Ꭺ funcionaría mejor (latín-A, alfa griega , cirílico-A , y Cherokee-A , respectivamente; por desgracia, el griego y Cherokee letras minúsculas son demasiado diferentes del latín a: α, ꭺ, y así doesn no ayuda con el fragmento anterior).

Existe toda una clase de ataques de homoglyph, más comúnmente en nombres de dominio falsos (por ejemplo, wikipediа.org(cirílico) frente a wikipedia.org(latino)), pero también puede aparecer en código; típicamente referido como ser deshonesto (como se menciona en un comentario, las preguntas [deshonestas] ahora están fuera de tema en PPCG , pero solían ser un tipo de desafío donde este tipo de cosas aparecían). Usé este sitio web para encontrar los homoglyphs usados ​​para esta respuesta.

¡Sí, es posible! 😎

»JavaScript

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

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

El código anterior es una versión corta (gracias a @Forivin por su nota en los comentarios) y el siguiente código es 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 solo ve la parte superior de mi código y lo ejecuta, dice WOW, ¿cómo?

Entonces creo que basta con decir Sí, es posible a alguien que te dijo: Nada es imposible

Truco: utilicé un carácter oculto después ifpara hacer una función a la que su nombre es similar if. En JavaScript no podemos anular las palabras clave, así que me vi obligado a usar esta forma. Es falso if, ¡pero funciona para ti en este caso!

» C #

También escribí una versión C # ( con técnica de aumento de valor de propiedad ):

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

Demo en vivo

JavaScript

a == a +1

En JavaScript, no hay números enteros, solo Numbers, que se implementan como números de punto flotante de doble precisión.

Significa que si un número aes lo suficientemente grande, se puede considerar igual a tres enteros consecutivos:

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

Es cierto que no es exactamente lo que preguntó el entrevistador (no funciona a=0), pero no implica ningún truco con funciones ocultas o sobrecarga de operadores.

Otros idiomas

Como referencia, existen a==1 && a==2 && a==3soluciones en Ruby y Python. Con una pequeña modificación, también es posible en Java.

Rubí

Con una costumbre ==:

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

Pitón

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 posible modificar la Integercaché de 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.");
        }
    }
}

Esta es una versión invertida de la respuesta de @ Jeff * donde se usa un carácter oculto (U + 115F, U + 1160 o U + 3164) para crear variables que se parecen a 1, 2y 3.

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

* Esa respuesta se puede simplificar utilizando un ensamblador de ancho cero (U + 200C) y un ensamblador de ancho cero (U + 200D). Ambos caracteres están permitidos dentro de los identificadores, pero no al principio:

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

Otros trucos son posibles usando la misma idea, por ejemplo, usando selectores de variación Unicode para crear variables que se vean exactamente iguales ( a︀ = 1; a︁ = 2; a︀ == 1 && a︁ == 2; // true).

Regla número uno de las entrevistas; nunca digas imposible.

No hay necesidad de engaños de personajes ocultos.

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

Honestamente, sin embargo, ya sea que haya una manera de evaluar como verdadero o no (y como otros han demostrado, hay varias formas), la respuesta que estaría buscando, hablando como alguien que ha realizado cientos de entrevistas, sería algo parecido a:

"Bueno, tal vez sí en algunas circunstancias extrañas que no son inmediatamente obvias para mí ... pero si me encontrara con esto en código real, entonces usaría técnicas de depuración comunes para descubrir cómo y por qué estaba haciendo lo que estaba haciendo. y luego refactorizar inmediatamente el código para evitar esa situación ... pero lo más importante: absolutamente NUNCA escribiría ese código en primer lugar porque esa es la definición misma de código intrincado, y me esfuerzo por nunca escribir código intrincado ".

Supongo que a algunos entrevistadores les ofendería que se hiciera lo que obviamente se supone que es una pregunta muy complicada, pero no me importa que los desarrolladores tengan una opinión, especialmente cuando pueden respaldarla con un pensamiento razonado y encajar mi pregunta en una declaración significativa sobre ellos mismos.

Si alguna vez recibe una pregunta de este tipo (o nota algún comportamiento igualmente inesperado en su código), piense qué tipo de cosas podrían causar un comportamiento que parece imposible a primera vista:

1. Codificación : en este caso, la variable que está mirando no es la que cree que es. Esto puede suceder si intencionalmente juega con Unicode usando homoglyphs o espacios para hacer que el nombre de una variable se vea como otra, pero también se pueden introducir problemas de codificación accidentalmente, por ejemplo, al copiar y pegar código de la Web que contiene un código Unicode inesperado puntos (por ejemplo, porque un sistema de gestión de contenido hizo algún "formateo automático", como reemplazar flcon Unicode 'LATIN SMALL LIGATURE FL' (U + FB02)).

2. Condiciones de carrera : puede ocurrir una condición de carrera , es decir, una situación en la que el código no se ejecuta en la secuencia esperada por el desarrollador. Las condiciones de carrera a menudo ocurren en código de múltiples subprocesos, pero varios subprocesos no son un requisito para que las condiciones de carrera sean posibles; la asincronicidad es suficiente (y no se confunda, asíncrono no significa que se usen múltiples subprocesos bajo el capó ).

   Tenga en cuenta que, por lo tanto, JavaScript tampoco está libre de condiciones de carrera solo porque sea de un solo subproceso. Vea aquí un ejemplo simple de un solo subproceso, pero asíncrono. Sin embargo, en el contexto de una sola declaración, la condición de carrera sería bastante difícil de alcanzar en JavaScript.

   JavaScript con los trabajadores web es un poco diferente, ya que puede tener varios hilos. @mehulmpt nos ha mostrado una gran prueba de concepto utilizando trabajadores web .

3. Efectos secundarios : un efecto secundario de la operación de comparación de igualdad (que no tiene que ser tan obvio como en los ejemplos aquí, a menudo los efectos secundarios son muy sutiles).

Este tipo de problemas pueden aparecer en muchos lenguajes de programación, no solo en JavaScript, por lo que no estamos viendo una de las WTF clásicas de JavaScript aquí ¹ .

Por supuesto, la pregunta de la entrevista y las muestras aquí parecen muy elaboradas. Pero son un buen recordatorio de que:

• Los efectos secundarios pueden volverse realmente desagradables y un programa bien diseñado debe estar libre de efectos secundarios no deseados.
• El estado mutable y de subprocesos múltiples puede ser problemático.
• No realizar correctamente la codificación de caracteres y el procesamiento de cadenas puede provocar errores desagradables.

_{¹ Por ejemplo, puede encontrar un ejemplo en un lenguaje de programación totalmente diferente (C #) que exhibe un efecto secundario (uno obvio) aquí .}

Aquí hay otra variación, usando una matriz para extraer los valores que desee.

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

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

Bien, otro truco con generadores:

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

Usando 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);

Los proxies básicamente pretenden ser un objeto de destino (el primer parámetro), pero interceptan operaciones en el objeto de destino (en este caso, la operación "obtener propiedad") para que haya una oportunidad de hacer algo diferente al comportamiento predeterminado del objeto. En este caso, se invoca la acción "obtener propiedad" acuando ==coacciona su tipo para compararlo con cada número. Esto pasa:

1. Creamos un objeto de destino { i: 0 }, donde la ipropiedad es nuestro contador
2. Creamos un Proxy para el objeto de destino y lo asignamos a a
3. Para cada a ==comparación, ael tipo de 'se coacciona a un valor primitivo
4. Este tipo de coerción da como resultado una llamada a[Symbol.toPrimitive]()interna
5. El proxy intercepta la obtención de la a[Symbol.toPrimitive]función mediante el "controlador de obtención"
6. Los cheques de proxy "obtener Handler" que la propiedad que está siendo conseguido es Symbol.toPrimitive, en cuyo caso se incrementa y luego devuelve el contador desde el objeto de destino: ++target.i. Si se recupera una propiedad diferente, simplemente volvemos a devolver el valor de propiedad predeterminado,target[name]

Entonces:

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

Al igual que con la mayoría de las otras respuestas, esto solo funciona con una verificación de igualdad flexible ( ==), porque las verificaciones de igualdad estrictas ( ===) no realizan coerción de tipo que el Proxy pueda interceptar.

En realidad, la respuesta a la primera parte de la pregunta es "Sí" en todos los lenguajes de programación. Por ejemplo, este es el caso 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;
}

Lo mismo, pero diferente, pero igual (se puede "probar" varias veces):

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

Mi idea partió de cómo funciona la ecuación de tipo de objeto numérico.

Una respuesta de ECMAScript 6 que hace uso de símbolos:

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

Debido al ==uso, JavaScript se supone que coaccionan aen algo cerca del segundo operando ( 1, 2, 3en este caso). Pero antes de que JavaScript intente calcular la coerción por sí solo, intenta llamar Symbol.toPrimitive. Si proporciona Symbol.toPrimitiveJavaScript, usaría el valor que devuelve su función. Si no, JavaScript llamaría valueOf.

Creo que este es el código mínimo para implementarlo:

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

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

Creando un objeto ficticio con una costumbre valueOfque incrementa una variable global ien cada llamada. ¡23 personajes!

¡Este usa defineProperty con un buen efecto secundario que causa una variable global!

var _a = 1

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

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

Anulando valueOfuna declaración de clase, se puede hacer:

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

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

const a = new Thing();

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

Lo que pasa es que valueOfse llama en cada operador de comparación. En el primero, aserá igual 1, en el segundo, aserá igual 2, y así sucesivamente, porque cada vez que valueOfse llama, ase incrementa el valor de .

Por lo tanto, console.log se activará y generará (en mi terminal de todos modos) Thing: { value: 4}, lo que indica que el condicional era verdadero.