Примітка модератора: Будь ласка, протистоять бажанню редагувати код або видалити це повідомлення. Шаблон пробілів може бути частиною питання, і тому його не слід підробляти без необхідності. Якщо ви перебуваєте в таборі "пробіл несуттєвий", ви повинні мати можливість прийняти код таким, який є.

Чи можливо коли-небудь, що (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!")
}

Перевірте перевірку валідатора імені змінної Mathias . Якщо цей дивний проміжок був насправді включений у їх запитання, я впевнений, що це підказка для такого виду відповіді.

Не робіть цього. Серйозно.

Редагувати: Мені подобається, що (хоча заборонено запускати змінну) столярний знак не ширини та нульової ширини також дозволений у назвах змінних - див. Очищення 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");
}

Для цього використовується getter всередині withоператора, щоб aоцінити до трьох різних значень.

... це все ще не означає, що це слід використовувати в реальному коді ...

Ще гірше, що цей трюк також буде працювати з використанням ===.

  var i = 0;

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

Приклад без getters або valueOf:

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

Це працює, тому що ==викликає, toStringякий викликає .joinмасиви.

Ще одне рішення, за допомогою Symbol.toPrimitiveякого еквівалент ES6 toString/valueOf:

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

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

Якщо його запитають, чи можливо (ОБОВ'ЯЗКОВО), він може попросити "a" повернути випадкове число. Це було б правдою, якби він генерує 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, скажімо, двома веб-працівниками через 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)

робітник.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!');
}

EDIT

Використовуючи класи 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, Α, А, і Ꭺ буде працювати краще (Latin-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!😎");
    }
}

Демонстраційна демонстрація

JavaScript

a == a +1

У JavaScript немає цілих чисел, а лише Numbers, які реалізовані як подвійні точні числа з плаваючою комою.

Це означає, що якщо число 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!")

Java

Можливо змінити 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.");
        }
    }
}

Це перевернутий варіант @ відповідь Джеффа * , де прихований символ (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, використовуючи гомогліфи чи символи пробілу, щоб зробити ім'я змінної схожим на іншу, але проблеми кодування також можуть бути введені випадково, наприклад, при копіюванні та вставці коду з Інтернету, який містить несподіваний код Unicode бали (наприклад, через те, що система управління вмістом зробила деяке "автоматичне форматування", наприклад, замінивши flUnicode "LATIN SMALL LIGATURE FL" (U + FB02)).

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

   Зауважте, що тому 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);

Проксі-сервери в основному претендують на цільовий об'єкт (перший параметр), але перехоплюють операції над цільовим об'єктом (в даному випадку операція "отримати властивість"), так що є можливість зробити щось інше, ніж поведінка об'єкта за замовчуванням. У цьому випадку дія "отримати властивість" викликається, aколи ==примушує її тип, щоб порівняти її з кожним числом. Це відбувається:

1. Ми створюємо цільовий об'єкт { i: 0 }, деi властивість є нашим лічильником
2. Ми створюємо проксі для цільового об’єкта і присвоюємо йому a
3. Для кожного a ==порівнянняa тип 's примушується до примітивного значення
4. Цей тип примусу призводить до виклику a[Symbol.toPrimitive]() внутрішнього
5. Проксі перехоплює отримання a[Symbol.toPrimitive] функції за допомогою "отримати обробник"
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}, вказуючи на те, що умовне значення було вірно.