Uwaga moderatora: Oprzyj się potrzebie edycji kodu lub usunięcia tego powiadomienia. Wzór białych znaków może być częścią pytania i dlatego nie powinien być zmieniany niepotrzebnie. Jeśli jesteś w obozie „białe znaki są nieistotne”, powinieneś być w stanie zaakceptować kod w obecnej postaci.

Czy to możliwe, że (a== 1 && a ==2 && a==3)można to ocenić truew JavaScript?

To pytanie do wywiadu zadane przez dużą firmę technologiczną. Stało się to dwa tygodnie temu, ale wciąż próbuję znaleźć odpowiedź. Wiem, że nigdy nie piszemy takiego kodu w codziennej pracy, ale jestem ciekawy.

Jeśli skorzystasz z tego== , jak to działa , możesz po prostu utworzyć obiekt z funkcją niestandardową toString(lub valueOf), która zmienia to, co zwraca za każdym razem, gdy jest używany, tak aby spełniał wszystkie trzy warunki.

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

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

Powodem tego jest użycie operatora luźnej równości. W przypadku korzystania z luźnej równości, jeśli jeden z operandów jest innego typu niż drugi, silnik podejmie próbę konwersji jednego na drugi. W przypadku obiektu po lewej stronie i numeru po prawej, spróbuje przekształcić obiekt w numer, najpierw wywołując, valueOfjeśli jest to możliwe, a jeśli nie, wywoła toString. Użyłem toStringw tym przypadku po prostu dlatego, że to, co przyszło mi do głowy, valueOfmiałoby większy sens. Gdybym zamiast tego zwrócił ciąg znaków toString, silnik próbowałby następnie przekonwertować ciąg znaków na liczbę, dając nam ten sam efekt końcowy, choć z nieco dłuższą ścieżką.

Nie mogłem się oprzeć - pozostałe odpowiedzi są niewątpliwie prawdziwe, ale tak naprawdę nie można przejść obok następującego kodu:

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

Zwróć uwagę na dziwne odstępy w ifstwierdzeniu (które skopiowałem z twojego pytania). Jest to Hangul o połowie szerokości (koreański dla tych, którzy nie znają), który jest znakiem spacji Unicode, który nie jest interpretowany przez skrypt ECMA jako znak spacji - oznacza to, że jest to poprawny znak identyfikatora. Dlatego istnieją trzy zupełnie różne zmienne, jedna z Hangulem po a, jedna z nim przed, a druga z tylko a. Ten _sam kod, zastępując spację czytelnością, wyglądałby tak:

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

Sprawdź sprawdzenie poprawności nazwy zmiennej Mathiasa . Jeśli to dziwne odstępy rzeczywiście zostały uwzględnione w ich pytaniu, jestem pewien, że jest to wskazówka dla tego rodzaju odpowiedzi.

Nie rób tego Poważnie.

Edit: Doszło do mojej uwagi, że (choć nie wolno rozpocząć zmiennej) Zero-szerokość stolarskie i Zero-szerokość non-stolarskie znaki są także dozwolone w nazwach zmiennych - patrz kasował JavaScript o zerowej szerokości znaków - plusy i minusy ?.

Wyglądałoby to następująco:

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

TO JEST MOŻLIWE!

var i = 0;

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

Używa gettera wewnątrz withinstrukcji, aby pozwolića ocenę do trzech różnych wartości.

... to nadal nie oznacza, że ​​należy tego używać w prawdziwym kodzie ...

Co gorsza, ta sztuczka będzie również działać przy użyciu ===.

  var i = 0;

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

Przykład bez getterów lub wartości:

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

Działa to, ponieważ ==wywołuje funkcję, toStringktóra wymaga .jointablic.

Inne rozwiązanie, za pomocą Symbol.toPrimitivektórego jest odpowiednikiem ES6 toString/valueOf:

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

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

Jeśli zostaniesz zapytany, czy jest to możliwe (nie MUSI), może poprosić „a” o zwrócenie losowej liczby. Byłoby prawdą, gdyby generował kolejno 1, 2 i 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;
    }
  }
}

Jeśli nie możesz nic zrobić bez wyrażeń regularnych:

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

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

Działa z powodu niestandardowej valueOfmetody, która jest wywoływana, gdy Object jest porównywany z pierwotną (taką jak Number). Główna sztuczka polega na tym, że a.valueOfzwraca nową wartość za każdym razem, ponieważ wywołuje execwyrażenie regularne z gflagą, co powoduje aktualizację lastIndextego wyrażenia regularnego za każdym razem, gdy zostanie znalezione dopasowanie. Tak więc po raz pierwszy this.r.lastIndex == 0, to pasuje 1i aktualizacje lastIndex: this.r.lastIndex == 1, więc następnym razem regex będą pasować 2i tak dalej.

Można to osiągnąć za pomocą następujących opcji w zakresie globalnym. Do nodejsużytku globalzamiast windoww poniższym kodzie.

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

Ta odpowiedź narusza niejawne zmienne dostarczone przez zakres globalny w kontekście wykonania, definiując moduł pobierający w celu pobrania zmiennej.

Jest to możliwe w przypadku adostępu do zmiennej , powiedzmy 2 robotów internetowych za pośrednictwem SharedArrayBuffer, a także jakiegoś głównego skryptu. Możliwość jest niska, ale możliwe jest, że gdy kod jest kompilowany do kodu maszynowego, pracownicy internetowych zaktualizować zmienną atylko w czasie, więc warunki a==1, a==2i a==3są zadowoleni.

Może to być przykład stanu wyścigu w środowisku wielowątkowym udostępnianym przez pracowników sieci Web i SharedArrayBuffer w JavaScript.

Oto podstawowa implementacja powyższego:

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

Na moim MacBooku Air dzieje się to po około 10 miliardach iteracji przy pierwszej próbie:

Drugie podejście:

Jak powiedziałem, szanse będą niewielkie, ale biorąc pod uwagę wystarczającą ilość czasu, osiągną warunek.

Wskazówka: jeśli trwa zbyt długo w systemie. Spróbuj tylko a == 1 && a == 2i zmień Math.random()*3na Math.random()*2. Dodanie coraz większej liczby do listy zmniejsza szansę na trafienie.

Jest to również możliwe przy użyciu serii samozapisujących się programów pobierających:

(Jest to podobne do rozwiązania jontro, ale nie wymaga zmiennej licznika).

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

Alternatywnie możesz użyć do tego klasy i instancji do sprawdzenia.

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

var a = new A;

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

EDYTOWAĆ

Przy użyciu klas ES6 wyglądałoby to tak

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

Nie widzę już tej odpowiedzi, więc wrzucę ją również do miksu. Jest to podobne do odpowiedzi Jeffa z polem Hangula o połowie szerokości.

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

Możesz zauważyć niewielką rozbieżność z drugą, ale pierwsza i trzecia są identyczne z gołym okiem. Wszystkie 3 są odrębnymi znakami:

a- Łacińska mała litera A
ａ- Pełna szerokość Łacińska mała litera A
а - Cyrylica mała A

Ogólny termin to „homoglyphs”: różne znaki unicode, które wyglądają tak samo. Zazwyczaj trudno jest zdobyć trzy, które są całkowicie nie do odróżnienia, ale w niektórych przypadkach możesz mieć szczęście. A, Α, А i Ꭺ działałyby lepiej (Latin-A, Greek Alpha , Cyrillic-A i Cherokee-A odpowiednio; niestety greckich i Cherokee małe litery są zbyt różni się od łacińskiego a: α, ꭺi tak nie robi pomoc w powyższym fragmencie).

Istnieje cała klasa ataków homoglyphów, najczęściej w fałszywych nazwach domen (np. wikipediа.org(Cyrylica) vs wikipedia.org(łacina)), ale może również pojawiać się w kodzie; zwykle określane jako podstępne (jak wspomniano w komentarzu, [podstępne] pytania są obecnie nie na temat PPCG , ale kiedyś były rodzajem wyzwania, w którym pojawiałyby się tego rodzaju rzeczy). Skorzystałem z tej witryny, aby znaleźć homoglyfy użyte w tej odpowiedzi.

Tak to mozliwe! 😎

»JavaScript

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

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

Powyższy kod jest krótką wersją (dzięki @Forivin za notatkę w komentarzach), a następujący kod jest oryginalny:

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

Jeśli po prostu widzisz górną część mojego kodu i uruchamiasz go, mówisz WOW, jak?

Myślę więc, że wystarczy powiedzieć Tak, możliwe jest, że ktoś powiedział ci: Nic nie jest niemożliwe

Sztuczka: Użyłem ukrytego znaku po, ifaby stworzyć funkcję, której nazwa jest podobna if. W JavaScript nie możemy przesłonić słów kluczowych, więc zmusiłem się do użycia w ten sposób. To podróbka if, ale w tym przypadku działa dla Ciebie!

» C #

Napisałem również wersję C # ( z techniką zwiększania wartości nieruchomości ):

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 na żywo

JavaScript

a == a +1

W JavaScript nie ma liczb całkowitych, ale tylkoNumber s, które są implementowane jako liczby zmiennoprzecinkowe podwójnej precyzji.

Oznacza to, że jeśli liczba ajest wystarczająco duża, można ją uznać za równą trzem kolejnym liczbom całkowitym:

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

To prawda, że ​​nie jest to dokładnie to, o co pytał ankieter (nie działa a=0 ), ale nie wiąże się z żadną sztuczką z ukrytymi funkcjami lub przeciążeniem operatora.

Inne języki

Dla porównania istnieją a==1 && a==2 && a==3rozwiązania w Ruby i Python. Po niewielkiej modyfikacji jest to również możliwe w Javie.

Rubin

Z niestandardowym ==:

class A
  def ==(o)
    true
  end
end

a = A.new

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

Lub rosnąca a:

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

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

Pyton

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

Jawa

Możliwe jest zmodyfikowanie Integerpamięci podręcznej 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.");
        }
    }
}

Jest to odwrócona wersja @ Jeffa odpowiedzi *, gdzie ukryty charakter (U + 115F, U + U + 1160 lub 3164) jest używany do tworzenia zmiennych, które wyglądają jak 1, 2i 3.

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

* Odpowiedź można uprościć, stosując łącznik zerowy (U + 200C) i łącznik zerowy (U + 200D). Oba te znaki są dozwolone w identyfikatorach, ale nie na początku:

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

Inne sztuczki są możliwe przy użyciu tego samego pomysłu, np. Przy użyciu selektorów wariacji Unicode do tworzenia zmiennych, które wyglądają dokładnie tak samo ( a︀ = 1; a︁ = 2; a︀ == 1 && a︁ == 2; // true).

Zasada numer jeden podczas wywiadów; nigdy nie mów niemożliwe.

Nie potrzeba sztuczek z ukrytymi postaciami.

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

Szczerze mówiąc, bez względu na to, czy istnieje sposób, aby ocenić to jako prawdziwe, czy nie (i jak wykazali inni, istnieje wiele sposobów), odpowiedź, której szukałam, mówiąc jako ktoś, kto przeprowadził setki wywiadów, byłaby coś w stylu:

„Cóż, może tak w dziwnych okolicznościach, które nie są dla mnie od razu oczywiste ... ale jeśli napotkałem to w prawdziwym kodzie, użyłbym typowych technik debugowania, aby dowiedzieć się, jak i dlaczego robi to, co robi a następnie natychmiast ponownie kodujemy, aby uniknąć takiej sytuacji ... ale co ważniejsze: absolutnie NIGDY nie napisałbym tego kodu w pierwszej kolejności, ponieważ jest to definicja zawiłego kodu, i staram się nigdy nie pisać skomplikowanego kodu ".

Wydaje mi się, że niektórzy ankieterzy obrażą się na wywołanie tego, co w oczywisty sposób ma być bardzo trudnym pytaniem, ale nie mam nic przeciwko programistom, którzy mają zdanie, szczególnie gdy mogą poprzeć to uzasadnioną myślą i mogą dopasować moje pytanie do znaczące oświadczenie o sobie.

Jeśli kiedykolwiek dostaniesz takie pytanie podczas rozmowy kwalifikacyjnej (lub zauważysz w swoim kodzie jakieś równie nieoczekiwane zachowanie), zastanów się, jakie rzeczy mogą spowodować zachowanie, które na pierwszy rzut oka wydaje się niemożliwe:

1. Kodowanie : W tym przypadku zmienna, na którą patrzysz, nie jest tą, o której myślisz, że jest. Może się to zdarzyć, jeśli celowo zepsujesz Unicode przy użyciu homoglyfów lub znaków spacji, aby nazwa zmiennej wyglądała jak inna, ale problemy z kodowaniem można również wprowadzić przypadkowo, np. Podczas kopiowania i wklejania kodu z Internetu zawierającego nieoczekiwany kod Unicode punktów (np. ponieważ system zarządzania treścią przeprowadził pewne „automatyczne formatowanie”, takie jak zastąpienie flgo Unicode „LATIN SMALL LIGATURE FL” (U + FB02)).

2. Warunki wyścigu : A race-stan może wystąpić, czyli sytuacji, gdy kod nie jest wykonywany w kolejności oczekiwanej przez dewelopera. Warunki wyścigu często zdarzają się w kodzie wielowątkowym, ale wiele wątków nie jest warunkiem, aby warunki wyścigu były możliwe - asynchroniczność jest wystarczająca (i nie myl się, asynchronizacja nie oznacza, że ​​wiele wątków jest używanych pod maską ).

   Pamiętaj, że JavaScript nie jest wolny od warunków wyścigu tylko dlatego, że jest jednowątkowy. Widzieć tutaj prosty przykład jednowątkowy - ale asynchroniczny - przykład. W kontekście pojedynczego stwierdzenia warunki wyścigu byłyby jednak trudne do osiągnięcia w JavaScript.

   JavaScript z robotami WWW jest nieco inny, ponieważ możesz mieć wiele wątków. @mehulmpt pokazał nam świetną weryfikację koncepcji przy użyciu pracowników sieci .

3. Efekty uboczne : efekt uboczny operacji porównywania równości (która nie musi być tak oczywista jak w przykładach tutaj, często skutki uboczne są bardzo subtelne).

Tego rodzaju problemy mogą pojawić się w wielu językach programowania nie tylko JavaScript, więc nie widzą jedną z klasycznych WTFs JavaScript tutaj ¹ .

Oczywiście pytanie z wywiadu i próbki tutaj wyglądają na bardzo wymyślne. Ale są dobrym przypomnieniem, że:

• Efekty uboczne mogą być naprawdę nieprzyjemne, a dobrze zaprojektowany program powinien być wolny od niepożądanych efektów ubocznych.
• Stan wielowątkowy i zmienny może być problematyczny.
• Niewłaściwe kodowanie znaków i przetwarzanie ciągów może prowadzić do nieprzyjemnych błędów.

_{¹ Na przykład, można znaleźć przykład w zupełnie innym języku programowania (C #) wykazujący efekt uboczny (oczywisty) tutaj .}

Oto kolejna odmiana: użycie tablicy do usunięcia dowolnych wartości.

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

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

OK, kolejny hack z generatorami:

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

Korzystanie z serwerów proxy :

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

Serwery proxy w zasadzie udają obiekt docelowy (pierwszy parametr), ale przechwytują operacje na obiekcie docelowym (w tym przypadku operację „pobierz właściwość”), dzięki czemu istnieje możliwość zrobienia czegoś innego niż domyślne zachowanie obiektu. W tym przypadku akcja „pobierz właściwość” jest wywoływana, agdy ==wymusza jej typ w celu porównania z każdym numerem. To się stało:

1. Tworzymy obiekt docelowy { i: 0 }, w którymi właściwość jest naszym licznikiem
2. Tworzymy serwer proxy dla obiektu docelowego i przypisujemy go do a
3. Dla każdego a ==porównania atyp jest wymuszany na pierwotną wartość
4. Ten rodzaj przymusu powoduje wywoływanie a[Symbol.toPrimitive]()wewnętrzne
5. Serwer proxy przechwytuje pobranie a[Symbol.toPrimitive]funkcji za pomocą „get handler”
6. „Dostać obsługi” kontrole pełnomocnika, że nieruchomość jest zdobyty jest Symbol.toPrimitive, w tym przypadku zwiększa go, a następnie zwraca licznik z obiektu docelowego: ++target.i. Jeśli pobierana jest inna właściwość, po prostu wracamy do zwracania domyślnej wartości właściwości,target[name]

Więc:

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

Podobnie jak w przypadku większości innych odpowiedzi, działa to tylko z luźną kontrolą równości ( ==), ponieważ ścisłe kontrole równości ( ===) nie powodują przymusu typu, który może przechwycić serwer proxy.

W rzeczywistości odpowiedź na pierwszą część pytania brzmi „Tak” w każdym języku programowania. Na przykład dzieje się tak w przypadku 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;
}

To samo, ale inne, ale wciąż takie samo (może być „przetestowane” wiele razy):

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

Mój pomysł zaczął się od tego, jak działa równanie typu obiektu Number.

Odpowiedź ECMAScript 6, która korzysta z symboli:

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

Ze względu na ==użycie, JavaScript ma zmusić ado czegoś blisko drugiego argumentu ( 1, 2, 3w tym przypadku). Ale zanim JavaScript spróbuje samodzielnie wymusić wymuszenie, próbuje zadzwonić Symbol.toPrimitive. Jeśli podasz Symbol.toPrimitiveJavaScript, użyje wartości, którą zwróci twoja funkcja. Jeśli nie, JavaScript zadzwoni valueOf.

Myślę, że to minimalny kod do jego wdrożenia:

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

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

Tworzenie obojętnego obiektu za pomocą niestandardowego parametru, valueOfktóry zwiększa globalną zmienną iprzy każdym wywołaniu. 23 znaki!

Ten wykorzystuje definProperty z przyjemnym efektem ubocznym powodującym zmienną globalną!

var _a = 1

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

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

Przesłaniając valueOfdeklarację klasy, można to zrobić:

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

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

const a = new Thing();

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

To, co się dzieje, valueOfjest wywoływane w każdym operatorze porównania. W pierwszym abędzie równy 1, w drugim abędzie równy 2, i tak dalej, i tak dalej, ponieważ za każdym razem valueOfjest wywoływana, wartość ajest zwiększana.

Dlatego konsola.log uruchomi się i wyśle ​​(i tak w moim terminalu) Thing: { value: 4}, wskazując, że warunek był prawdziwy.