Примечание модератора: Пожалуйста, не поддавайтесь желанию изменить код или удалить это уведомление. Структура пробелов может быть частью вопроса и, следовательно, не должна вмешиваться излишне. Если вы находитесь в лагере «пустое пространство незначительно», вы сможете принять код как есть.

Это когда-либо возможно, что (a== 1 && a ==2 && a==3)может оценитьtrue в JavaScript?

Это вопрос интервью, заданный крупной технологической компанией. Это случилось две недели назад, но я все еще пытаюсь найти ответ. Я знаю, что мы никогда не пишем такой код в нашей повседневной работе, но мне любопытно.

Если вы воспользуетесь том , как ==работы , вы можете просто создать объект с пользовательской toString(или valueOfфункции) , которая изменяет то , что она возвращает каждый раз , когда он используется так , что она удовлетворяет всем трем условиям.

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

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

Причина, по которой это работает, заключается в использовании оператора свободного равенства. При использовании свободного равенства, если один из операндов имеет другой тип, чем другой, механизм будет пытаться преобразовать один в другой. В случае объекта слева и числа справа он будет пытаться преобразовать объект в число, сначала вызвав valueOfего, если он вызывается, и в случае неудачи он вызовет toString. Я использовал toStringв этом случае просто потому, что это то, что пришло на ум, valueOfбудет больше смысла. Если бы я вместо этого возвратил строку из toString, то движок попытался бы преобразовать строку в число, что дало бы тот же конечный результат, хотя и с немного более длинным путем.

Я не мог удержаться - другие ответы, несомненно, верны, но вы действительно не можете пройти мимо следующего кода:

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

Обратите внимание на странный интервал в ifутверждении (которое я скопировал из вашего вопроса). Это хангул половинной ширины (это корейский для тех, кто не знаком), который является символом пробела Unicode, который не интерпретируется сценарием ECMA как символ пробела - это означает, что это допустимый символ для идентификатора. Поэтому есть три совершенно разные переменные, одна с хангул после a, одна с ним до, а последняя с просто a. Заменив пространство _на удобочитаемость, тот же код будет выглядеть так:

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

Проверьте валидацию на валидаторе имени переменной Матиаса . Если этот странный интервал действительно был включен в их вопрос, я уверен, что это подсказка для такого рода ответа.

Не делай этого. Шутки в сторону.

Edit: Он пришел к моему вниманию , что (хотя и не разрешаются начинать переменный) нулевая ширину столяра и нулевой ширина не-столярные символы также разрешены в именах переменных - см запутываний JavaScript с нулевой шириной символами - плюсами и минусами ? ,

Это будет выглядеть следующим образом:

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

ЭТО ВОЗМОЖНО!

var i = 0;

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

При этом используется метод получения внутри withоператора, чтобы позволить aоценить три различных значения.

... это еще не значит, что это должно быть использовано в реальном коде ...

Еще хуже, этот трюк также будет работать с использованием ===.

  var i = 0;

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

Пример без геттеров или значения:

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

Это работает, потому что ==вызывает toStringкакие вызовы.join массивы.

Другое решение, использующее Symbol.toPrimitiveES6-эквивалент toString/valueOf:

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

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

Если его спросить, возможно ли это (не ДОЛЖНО), он может попросить «а» вернуть случайное число. Было бы верно, если бы он генерировал 1, 2 и 3 последовательно.

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

Когда вы ничего не можете сделать без регулярных выражений:

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

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

Это работает из-за пользовательского valueOfметода, который вызывается, когда Object сравнивается с примитивом (таким как Number). Основной трюк заключается в том, что a.valueOfкаждый раз возвращается новое значение, потому что он вызывает execрегулярное выражение с gфлагом, что вызывает обновление lastIndexэтого регулярного выражения каждый раз, когда найдено совпадение. Так что в первый раз this.r.lastIndex == 0, это соответствует 1и обновляет lastIndex:, this.r.lastIndex == 1так что в следующий раз регулярное выражение будет соответствовать2 и так далее.

Это может быть достигнуто с помощью следующего в глобальной области видимости. Для nodejsиспользования, globalа не windowв коде ниже.

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

Этот ответ использует неявные переменные, предоставляемые глобальной областью действия в контексте выполнения, определяя метод получения для получения переменной.

Это возможно в случае, когда к переменной aобращаются, скажем, 2 веб-работника через SharedArrayBuffer, а также некоторый основной скрипт. Возможность невелика, но вполне возможно , что , когда код компилируется в машинный код, веб - рабочие обновить переменную aкак раз вовремя , так что условия a==1, a==2иa==3 удовлетворены.

Это может быть примером состояния гонки в многопоточной среде, предоставляемой веб-работниками и SharedArrayBuffer в JavaScript.

Вот основная реализация выше:

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

На моем MacBook Air это происходит после 10 миллиардов итераций с первой попытки:

Вторая попытка:

Как я уже сказал, шансы будут низкими, но если уделить достаточно времени, это приведет к ухудшению состояния.

Совет: если это занимает слишком много времени в вашей системе. Попробуйте только a == 1 && a == 2и измените Math.random()*3на Math.random()*2. Добавление все больше и больше в список снижает вероятность попадания.

Это также возможно с использованием ряда перезаписывающих геттеров:

(Это похоже на решение jontro, но не требует переменной счетчика.)

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

В качестве альтернативы вы можете использовать класс для него и экземпляр для проверки.

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

var a = new A;

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

РЕДАКТИРОВАТЬ

С использованием классов ES6 это будет выглядеть так

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

Я не вижу этот ответ уже опубликованным, поэтому я тоже добавлю этот ответ. Это похоже на ответ Джеффа с полушириной пространства Хангула.

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

Вы можете заметить небольшое расхождение со вторым, но первый и третий идентичны невооруженным глазом. Все 3 разных персонажа:

a- латинская строчная A
ａ- полная латинская строчная A
а- кириллическая строчная A

Общий термин для этого - «гомоглифы»: разные символы юникода, которые выглядят одинаково. Обычно трудно получить три , которые совершенно неразличимы, но в некоторых случаях вам может повезти. A, Α, А и Ꭺ будут работать лучше (латиница-A, греческая альфа , кириллица-A , и Cherokee-A соответственно, к сожалению, греческие и чероки строчные буквы слишком отличаются от латинского a: α, ꭺи так Безразлично помогите с приведенным фрагментом).

Существует целый класс атак на гомоглифы, чаще всего в поддельных доменных именах (например, wikipediа.org(кириллица) против wikipedia.org(латиница)), но он также может отображаться в коде; обычно упоминается как закулисный (как упомянуто в комментарии, [закулисные] вопросы теперь не по теме PPCG , но раньше это был тип проблемы, когда такие вещи появлялись ). я использовал этот сайт, чтобы найти гомоглифы, используемые для этого ответа.

Да, это возможно! 😎

»JavaScript

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

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

Приведенный выше код является короткой версией (спасибо @Forivin за примечание в комментариях), а следующий код является оригинальным:

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

Если вы просто видите верхнюю часть моего кода и запускаете его, вы говорите WOW, как?

Поэтому я думаю, что достаточно сказать Да, это возможно для того, кто сказал вам: нет ничего невозможного

Уловка: я использовал скрытый символ после, ifчтобы сделать функцию, название которой похоже if. В JavaScript мы не можем переопределить ключевые слова, поэтому я вынужден использовать этот способ. Это подделка if, но она работает для вас в этом случае!

» C #

Также я написал C # версию ( с техникой увеличения значения свойства ):

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

В JavaScript нет целых чисел, а толькоNumber s, которые реализованы как числа с плавающей запятой двойной точности.

Это означает, что если число aдостаточно велико, его можно считать равным трем последовательным целым числам:

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

Правда, это не совсем то, что спросил интервьюер (это не работает с a=0 ), но это не связано с уловкой со скрытыми функциями или перегрузкой операторов.

Другие языки

Для справки, есть a==1 && a==2 && a==3решения на Ruby и Python. С небольшой модификацией это также возможно в Java.

Рубин

С кастомом ==:

class A
  def ==(o)
    true
  end
end

a = A.new

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

Или увеличение a:

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

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

питон

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

Ява

Можно изменить Integerкэш 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.");
        }
    }
}

Это перевернутая версия ответа @ Jeff *, где скрытый символ (U + 115F, U + 1160 или U + 3164) используется для создания переменных, которые выглядят как 1, 2и 3.

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

* Этот ответ можно упростить, если использовать несоединение с нулевой шириной (U + 200C) и соединение с нулевой шириной (U + 200D). Оба эти символа допускаются внутри идентификаторов, но не в начале:

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

Другие приемы возможны при использовании той же идеи, например, с помощью селекторов вариаций Unicode для создания переменных, которые выглядят одинаково ( a︀ = 1; a︁ = 2; a︀ == 1 && a︁ == 2; // true).

Правило номер один из интервью; никогда не говори невозможно.

Нет необходимости для скрытого обмана персонажа.

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

Хотя, если честно, есть ли у него способ оценить истинность или нет (и, как показали другие, есть несколько способов), ответ, который я искал бы, говоря как человек, который провел сотни интервью, был бы что-то вроде:

«Ну, может быть, да при каких-то странных обстоятельствах, которые не сразу очевидны для меня ... но если бы я столкнулся с этим в реальном коде, то я бы использовал общие методы отладки, чтобы выяснить, как и почему он делал то, что делал и затем немедленно реорганизовать код, чтобы избежать такой ситуации ... но что более важно: я бы НИКОГДА не писал этот код, во-первых, потому что это само определение сложного кода, и я стараюсь никогда не писать сложный код ".

Я полагаю, что некоторые интервьюеры обидятся за то, что этот вопрос, очевидно, должен быть очень сложным, но я не возражаю против разработчиков, у которых есть мнение, особенно когда они могут подкрепить его аргументированной мыслью и могут согласовать мой вопрос с значимое утверждение о себе.

Если у вас когда-нибудь возникнет такой вопрос на собеседовании (или вы заметите какое-то столь же неожиданное поведение в вашем коде), подумайте о том, какие вещи могут вызвать поведение, которое на первый взгляд кажется невозможным:

1. Кодировка : в этом случае переменная, на которую вы смотрите, не та, о которой вы думаете. Это может произойти, если вы намеренно возитесь с Юникодом, используя гомоглифы или пробелы, чтобы имя переменной выглядело как другая, но проблемы с кодированием также могут возникать случайно, например, при копировании и вставке кода из Интернета, который содержит неожиданный код Unicode точки (например, потому что система управления контентом сделала некоторое «автоматическое форматирование», например, заменив flUnicode «LATIN SMALL LIGATURE FL» (U + FB02)).

2. Условия гонки : A гонки состояние может возникнуть, например , ситуация , когда код не выполняется в последовательности ожидаемого разработчиком. Условия гонки часто бывают в многопоточном коде, но наличие нескольких потоков не является обязательным условием, чтобы условия гонки были возможны - асинхронность достаточна (и не путайте, асинхронность не означает, что несколько потоков используются под капотом ).

   Обратите внимание, что поэтому JavaScript также не свободен от условий гонки только потому, что он однопоточный. Смотрите здесь для простого однопоточного - но асинхронного - примера. Однако в контексте одного утверждения условие гонки будет довольно сложно выполнить в JavaScript.

   JavaScript с веб-работниками немного отличается, так как вы можете иметь несколько потоков. @mehulmpt показал нам отличное подтверждение концепции с использованием веб-работников .

3. Побочные эффекты : побочный эффект операции сравнения на равенство (который не должен быть таким очевидным, как в приведенных здесь примерах, часто побочные эффекты очень тонкие).

Такого рода вопросы может появляться во многих языках программирования, а не только JavaScript, поэтому мы не видим один из классического JavaScript WTFs здесь ¹ .

Конечно, вопрос интервью и образцы здесь выглядят очень надуманными. Но они являются хорошим напоминанием о том, что:

• Побочные эффекты могут быть очень неприятными, и что хорошо продуманная программа не должна содержать нежелательных побочных эффектов.
• Многопоточность и изменчивое состояние могут быть проблематичными.
• Неправильное кодирование символов и обработка строк могут привести к неприятным ошибкам.

_{¹ Например, вы можете найти пример в совершенно другом языке программирования (C #) экспонирование побочного эффекта (очевидный) здесь .}

Вот еще один вариант, использующий массив для выталкивания любых значений, которые вы хотите.

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

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

Хорошо, еще один взлом с генераторами:

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

Использование прокси :

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

Прокси в основном претендуют на то, чтобы быть целевым объектом (первый параметр), но перехватывают операции на целевом объекте (в данном случае операция «get property»), так что есть возможность сделать что-то отличное от поведения объекта по умолчанию. В этом случае действие «get property» вызывается aпри приведении ==его типа для сравнения его с каждым числом. Это случилось:

1. Мы создаем целевой объект { i: 0 }, где iсвойство является нашим счетчиком
2. Мы создаем прокси для целевого объекта и назначаем его a
3. Для каждого a ==сравнения aтип приводится к примитивному значению.
4. Приведение типа приводит к a[Symbol.toPrimitive]()внутреннему вызову
5. Прокси перехватывает получение a[Symbol.toPrimitive]функции, используя «обработчик get»
6. Прокси - сервер в «получить обработчик» проверяет , что свойство быть полученных незаконным является Symbol.toPrimitive, в этом случае он увеличивает и возвращает счетчик от целевого объекта: ++target.i. Если извлекается другое свойство, мы просто возвращаемся к возвращению значения свойства по умолчанию,target[name]

Так:

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

Как и с большинством других ответов, это работает только с произвольной проверкой равенства ( ==), потому что строгие проверки равенства ( ===) не приводят к принуждению типов, которое прокси-сервер может перехватить.

На самом деле ответ на первую часть вопроса - «Да» на каждом языке программирования. Например, это в случае 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;
}

То же, но другое, но все же (можно «проверить» несколько раз):

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

Моя идея началась с того, как работает уравнение типа объекта Number.

Ответ ECMAScript 6, в котором используются символы:

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

Благодаря ==использованию, JavaScript должен принуждать aв нечто близкое к второй операнд ( 1, 2, 3в данном случае). Но прежде чем JavaScript попытается определить принуждение самостоятельно, он пытается вызвать Symbol.toPrimitive. Если вы предоставите Symbol.toPrimitiveJavaScript, будет использовать значение, которое возвращает ваша функция. Если нет, JavaScript будет вызывать valueOf.

Я думаю, что это минимальный код для его реализации:

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

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

Создание фиктивного объекта с пользовательским элементом, valueOfкоторый увеличивает глобальную переменную iпри каждом вызове. 23 персонажа!

Этот использует defineProperty с хорошим побочным эффектом, вызывающим глобальную переменную!

var _a = 1

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

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

Переопределив valueOfв объявлении класса, это можно сделать:

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

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

const a = new Thing();

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

Что происходит, это valueOfвызывается в каждом операторе сравнения. На первом aбудет равен 1, на втором aбудет равен 2, и так далее, и так далее, потому что каждый раз, когда valueOfвызывается, значение aувеличивается.

Поэтому console.log будет запускаться и выводиться (в любом случае в моем терминале) Thing: { value: 4}, указывая, что условие было истинным.