Nota do moderador: resista ao desejo de editar o código ou remover este aviso. O padrão de espaço em branco pode fazer parte da pergunta e, portanto, não deve ser adulterado desnecessariamente. Se você estiver no campo "espaço em branco é insignificante", poderá aceitar o código como está.

É possível (a== 1 && a ==2 && a==3)avaliar trueem JavaScript?

Esta é uma pergunta de entrevista feita por uma grande empresa de tecnologia. Isso aconteceu duas semanas atrás, mas ainda estou tentando encontrar a resposta. Sei que nunca escrevemos esse código em nosso trabalho cotidiano, mas estou curioso.

Se você tirar proveito de como ==funciona , você pode simplesmente criar um objeto com uma função personalizada toString(ou valueOf) que altera o que ele retorna cada vez que é usado, de modo a satisfazer todas as três condições.

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

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

A razão pela qual isso funciona é devido ao uso do operador de igualdade frouxa. Ao usar igualdade solta, se um dos operandos for de um tipo diferente do outro, o mecanismo tentará converter um para o outro. No caso de um objeto à esquerda e um número à direita, ele tentará converter o objeto em um número ligando primeiro, valueOfse for possível chamar , e, na sua falta, ligará toString. Eu usei toStringneste caso simplesmente porque é o que me veio à mente, valueOffaria mais sentido. Se eu retornasse uma string de toString, o mecanismo tentaria converter a string em um número, fornecendo o mesmo resultado final, embora com um caminho um pouco mais longo.

Não pude resistir - as outras respostas são indubitavelmente verdadeiras, mas você realmente não pode passar pelo seguinte código:

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

Observe o espaçamento estranho na ifdeclaração (que copiei da sua pergunta). É o Hangul de meia largura (que é coreano para quem não conhece) que é um caractere de espaço Unicode que não é interpretado pelo script ECMA como um caractere de espaço - isso significa que é um caractere válido para um identificador. Portanto, existem três variáveis ​​completamente diferentes, uma com o Hangul após a, uma com ele antes e a última com apenas a. Substituindo o espaço _por legibilidade, o mesmo código ficaria assim:

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

Confira a validação no validador de nome de variável do Mathias . Se esse espaçamento estranho foi realmente incluído na pergunta, tenho certeza de que é uma dica para esse tipo de resposta.

Não faça isso. A sério.

Edit: Chegou ao meu conhecimento que (embora não seja autorizado a iniciar uma variável), o marceneiro de largura zero e zero-width não marcenaria personagens também são permitidos em nomes de variáveis - ver ofuscando JavaScript com de largura zero personagens - prós e contras ? .

Seria o seguinte:

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

É POSSÍVEL!

var i = 0;

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

Isso usa um getter dentro de uma withinstrução para permitir aavaliar três valores diferentes.

... isso ainda não significa que isso deva ser usado em código real ...

Pior ainda, esse truque também funcionará com o uso de ===.

  var i = 0;

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

Exemplo sem getters ou valueOf:

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

Isso funciona porque ==chama toStringquais chamadas .joinpara matrizes.

Outra solução, usando o Symbol.toPrimitiveque é um equivalente ES6 de toString/valueOf:

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

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

Se for perguntado se é possível (não DEVE), ele pode pedir a "a" para retornar um número aleatório. Seria verdade se gerar 1, 2 e 3 sequencialmente.

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 você não pode fazer nada sem expressões regulares:

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

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

Funciona devido ao valueOfmétodo personalizado chamado quando Object comparado com o primitivo (como Number). O truque principal é que a.valueOfretorna um novo valor toda vez porque está chamando execa expressão regular com gsinalizador, o que causa a atualização lastIndexdessa expressão regular toda vez que a correspondência é encontrada. Então, pela primeira vez this.r.lastIndex == 0, ele corresponde 1e atualizações lastIndex: this.r.lastIndex == 1, tão próxima regex tempo irá corresponder 2e assim por diante.

Isso pode ser realizado usando o seguinte no escopo global. Para nodejsuso em globalvez de windowno código abaixo.

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

Esta resposta abusa das variáveis ​​implícitas fornecidas pelo escopo global no contexto de execução, definindo um getter para recuperar a variável.

Isso é possível no caso de a variável aser acessada por, digamos, 2 trabalhadores da Web por meio de um SharedArrayBuffer, além de algum script principal. A possibilidade é baixa, mas é possível que, quando o código é compilado para código de máquina, os trabalhadores web atualizar a variável aapenas no tempo para que as condições a==1, a==2e a==3estão satisfeitos.

Este pode ser um exemplo de condição de corrida em ambiente multithread fornecido por trabalhadores da Web e SharedArrayBuffer em JavaScript.

Aqui está a implementação básica acima:

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

No meu MacBook Air, isso ocorre após cerca de 10 bilhões de iterações na primeira tentativa:

Segunda tentativa:

Como eu disse, as chances serão baixas, mas, com tempo suficiente, ela atingirá a condição.

Dica: Se demorar muito no seu sistema. Tente apenas a == 1 && a == 2e mude Math.random()*3para Math.random()*2. Adicionar mais e mais à lista diminui a chance de acertar.

Isso também é possível usando uma série de getters de sobregravação automática:

(Isso é semelhante à solução de jontro, mas não requer uma variável 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.");
    }
})();

Como alternativa, você pode usar uma classe para isso e uma instância para a verificação.

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 classes ES6, ficaria assim

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

Eu não vejo essa resposta já postada, então eu vou jogar essa também. Isso é semelhante à resposta de Jeff com o espaço Hangul de meia largura.

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

Você pode notar uma ligeira discrepância com o segundo, mas o primeiro e o terceiro são idênticos a olho nu. Todos os três são caracteres distintos:

a- Letra minúscula latina A
ａ- Letra minúscula latina A completa
а - Letras minúsculas cirílicas A

O termo genérico para isso é "homoglifos": caracteres unicode diferentes que têm a mesma aparência. Normalmente é difícil conseguir três totalmente indistinguíveis, mas em alguns casos você pode ter sorte. A, Α, А, e Ꭺ iria funcionar melhor (Latin-A, alfa grego , cirílico-A , e Cherokee-A , respectivamente; infelizmente, o grego e Cherokee letras minúsculas são muito diferentes do latim a: α,ꭺ e assim doesn ajuda com o trecho acima).

Existe toda uma classe de ataques de homoglyph por aí, mais comumente em nomes de domínio falsos (por exemplo, wikipediа.org(cirílico) vs wikipedia.org(latino)), mas também pode aparecer no código; normalmente referidos como sendo dissimulados (como mencionado em um comentário, perguntas [dissimuladas] agora estão fora de tópico no PPCG , mas costumavam ser um tipo de desafio em que esses tipos de coisas apareciam). Usei este site para encontrar os homoglifos usados ​​para esta resposta.

Sim, é possível! 😎

»JavaScript

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

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

O código acima é uma versão curta (obrigado a @Forivin por sua observação nos comentários) e o código a seguir é 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;}

Se você apenas vê o lado superior do meu código e o executa, diz WOW, como?

Então eu acho que basta dizer Sim, é possível para alguém que te disse: Nada é impossível

Truque: usei um caractere oculto depois ifpara criar uma função cujo nome é semelhante if. No JavaScript, não podemos substituir as palavras-chave, então eu forcei a usar dessa maneira. É uma farsa if, mas funciona para você neste caso!

» C #

Também escrevi uma versão em C # ( com o aumento da propriedade value technic ):

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

Demonstração ao vivo

Javascript

a == a +1

Em JavaScript, não há números inteiros, mas apenasNumber s, que são implementados como números de ponto flutuante de precisão dupla.

Isso significa que, se um número afor grande o suficiente, ele poderá ser considerado igual a três números inteiros consecutivos:

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

É verdade que não é exatamente o que o entrevistador pediu (não funciona com a=0 ), mas não envolve nenhum truque com funções ocultas ou sobrecarga do operador.

Outras línguas

Para referência, existem a==1 && a==2 && a==3soluções em Ruby e Python. Com uma pequena modificação, também é possível em Java.

Rubi

Com um costume ==:

class A
  def ==(o)
    true
  end
end

a = A.new

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

Ou um aumento a:

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

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

Pitão

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

É possível modificar o 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.");
        }
    }
}

Esta é uma versão invertida do @ de Jeff resposta * onde um personagem oculto (U + 115F, U + 1160 ou U + 3164) é usado para criar variáveis que olhar como 1, 2e 3.

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

* Essa resposta pode ser simplificada usando o marceneiro de largura zero (U + 200C) e o marceneiro de largura zero (U + 200D). Ambos os caracteres são permitidos dentro de identificadores, mas não no começo:

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

Outros truques são possíveis usando a mesma idéia, por exemplo, usando seletores de variação Unicode para criar variáveis ​​que se parecem exatamente ( a︀ = 1; a︁ = 2; a︀ == 1 && a︁ == 2; // true).

Regra número um das entrevistas; nunca diga impossível.

Não há necessidade de truques de caracteres 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, se existe uma maneira de avaliar se é verdade ou não (e, como outros demonstraram, existem várias maneiras), a resposta que eu procuraria, falando como alguém que conduziu centenas de entrevistas, seria algo ao longo das linhas de:

"Bem, talvez sim, em um conjunto estranho de circunstâncias que não são imediatamente óbvias para mim ... mas se eu encontrasse isso em código real, usaria técnicas comuns de depuração para descobrir como e por que estava fazendo o que estava fazendo e refatorar imediatamente o código para evitar essa situação ... mas mais importante: eu NUNCA escreveria absolutamente esse código em primeiro lugar, porque essa é a própria definição de código complicado, e me esforço para nunca escrever código complicado ".

Eu acho que alguns entrevistadores se ofenderiam com o fato de ser obviamente uma pergunta muito complicada, mas eu não me importo com desenvolvedores que tenham uma opinião, especialmente quando eles podem apoiá-la com um pensamento fundamentado e podem encaixar minha pergunta em uma declaração significativa sobre si mesmos.

Se você receber uma pergunta dessa entrevista (ou perceber algum comportamento igualmente inesperado em seu código), pense sobre que tipo de coisas poderia causar um comportamento que parece impossível à primeira vista:

1. Codificação : neste caso, a variável que você está vendo não é a que você pensa que é. Isso pode acontecer se você intencionalmente mexer com Unicode usando homóglifos ou caracteres de espaço para fazer o nome de uma variável parecer com outra, mas problemas de codificação também podem ser introduzidos acidentalmente, por exemplo, ao copiar e colar código da Web que contém código Unicode inesperado pontos (por exemplo, porque um sistema de gerenciamento de conteúdo fez algumas "formatações automáticas", como substituir flpor Unicode 'LATIN SMALL LIGATURE FL' (U + FB02)).

2. Condições de corrida : Pode ocorrer uma condição de corrida , ou seja, uma situação em que o código não está sendo executado na sequência esperada pelo desenvolvedor. As condições de corrida geralmente acontecem no código com vários threads, mas vários threads não são um requisito para que as condições de corrida sejam possíveis - a assincronicidade é suficiente (e não se confunda, a assíncrona não significa que vários threads sejam usados ​​sob o capô ).

   Observe que, portanto, o JavaScript também não está livre de condições de corrida apenas porque é de thread único. Veja aqui um exemplo simples de thread único - mas assíncrono -. No contexto de uma única declaração, a condição de corrida, no entanto, seria bastante difícil de encontrar em JavaScript.

   O JavaScript com trabalhadores da Web é um pouco diferente, pois você pode ter vários threads. O @mehulmpt nos mostrou uma ótima prova de conceito usando trabalhadores da web .

3. Efeitos colaterais : um efeito colateral da operação de comparação de igualdade (que não precisa ser tão óbvia como nos exemplos aqui, geralmente os efeitos colaterais são muito sutis).

Esse tipo de problema pode aparecer em muitas linguagens de programação, não apenas no JavaScript, por isso não estamos vendo um dos WTFs clássicos do JavaScript aqui ¹ .

Obviamente, a pergunta da entrevista e as amostras aqui parecem muito bem-sucedidas. Mas eles são um bom lembrete de que:

• Os efeitos colaterais podem ficar realmente desagradáveis ​​e que um programa bem projetado deve estar livre de efeitos colaterais indesejados.
• O estado multithreading e mutável pode ser problemático.
• Não executar corretamente a codificação de caracteres e o processamento de strings pode levar a erros desagradáveis.

_{¹ Por exemplo, você pode encontrar um exemplo em uma linguagem de programação totalmente diferente (C #) exibindo um efeito colateral (óbvio) aqui .}

Aqui está outra variação, usando uma matriz para exibir os valores desejados.

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

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

Ok, outro hack com geradores:

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

Os proxies basicamente fingem ser um objeto de destino (o primeiro parâmetro), mas interceptam operações no objeto de destino (neste caso, a operação "get property") para que haja uma oportunidade de fazer algo diferente do comportamento padrão do objeto. Nesse caso, a ação "obter propriedade" é chamada aquando ==coagida seu tipo para compará-lo a cada número. Isto acontece:

1. Criamos um objeto de destino { i: 0 }, onde a ipropriedade é nosso contador
2. Criamos um proxy para o objeto de destino e o atribuímos a a
3. Para cada a ==comparação, ao tipo de é coagido a um valor primitivo
4. Esse tipo de coerção resulta em chamar a[Symbol.toPrimitive]()internamente
5. O Proxy intercepta a obtenção da a[Symbol.toPrimitive]função usando o "get handler"
6. Os controlos do proxy "obter manipulador" que a propriedade que está sendo obtido é Symbol.toPrimitive, caso em que ele é incrementado e, em seguida, retorna o contador do objeto de destino: ++target.i. Se uma propriedade diferente estiver sendo recuperada, voltaremos a retornar o valor padrão da propriedade,target[name]

Assim:

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

Como na maioria das outras respostas, isso funciona apenas com uma verificação de igualdade flexível ( ==), porque verificações estritas de igualdade ( ===) não fazem coerção de tipo que o Proxy possa interceptar.

Na verdade, a resposta para a primeira parte da pergunta é "Sim" em todas as linguagens de programação. Por exemplo, isso é no 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;
}

O mesmo, mas diferente, mas ainda o mesmo (pode ser "testado" várias vezes):

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

Minha ideia partiu de como a equação do tipo de objeto Number funciona.

Uma resposta do ECMAScript 6 que utiliza símbolos:

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

Devido ao ==uso, JavaScript é suposto coerce aem algo perto do segundo operando ( 1, 2, 3neste caso). Porém, antes que o JavaScript tente descobrir por si só, ele tenta chamar Symbol.toPrimitive. Se você fornecer Symbol.toPrimitiveJavaScript, usará o valor que sua função retornará. Caso contrário, o JavaScript chamaria valueOf.

Eu acho que este é o código mínimo para implementá-lo:

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

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

Criando um objeto fictício com um costume valueOfque incrementa uma variável global iem cada chamada. 23 caracteres!

Este usa o defineProperty com um bom efeito colateral causando variável global!

var _a = 1

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

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

Substituindo valueOfem uma declaração de classe, isso pode ser feito:

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

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

const a = new Thing();

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

O que acontece é que valueOfé chamado em cada operador de comparação. No primeiro, aserá igual 1, no segundo, aserá igual 2, e assim por diante, porque cada vez que valueOfé chamado, o valor de aé incrementado.

Portanto, o console.log será acionado e emitido (no meu terminal de qualquer maneira) Thing: { value: 4}, indicando que o condicional era verdadeiro.