Moderatör notu: Lütfen kodu düzenleme veya bu bildirimi kaldırma isteğine karşı koy. Beyaz alanın deseni sorunun bir parçası olabilir ve bu nedenle gereksiz yere kurcalanmamalıdır. Eğer "boşluk önemsiz" kampındaysanız, kodu olduğu gibi kabul edebilmelisiniz.

JavaScript ile (a== 1 && a ==2 && a==3)değerlendirmek mümkün mü true?

Bu, büyük bir teknoloji şirketi tarafından sorulan bir röportaj sorusudur. İki hafta önce oldu, ama hala cevabı bulmaya çalışıyorum. Günlük işimizde böyle bir kod yazmadığımızı biliyorum, ama merak ediyorum.

Nasıl ==çalıştığından faydalanırsanız, her üç koşulu da karşılayacak şekilde her kullanıldığında geri döndüğünü değiştiren özel toString(veya valueOf) işlevli bir nesne oluşturabilirsiniz .

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

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

Bunun nedeni gevşek eşitlik operatörünün kullanılmasıdır. Gevşek eşitlik kullanılırken, işlenenlerden biri diğerinden farklıysa, motor birini diğerine dönüştürmeye çalışır. Solda bir nesne ve sağda bir sayı valueOfolması durumunda, ilk önce çağrılabilir ise çağırarak nesneyi bir sayıya dönüştürmeye çalışır ve başarısız olursa çağrılır toString. toStringBu durumda kullandım çünkü akla gelen şey valueOfdaha mantıklı olurdu. Bunun yerine bir dize döndürdüğümde toString, motor dizeyi bize biraz daha uzun bir yolla olsa da aynı sonuç veren bir sayıya dönüştürmeye çalışırdı.

Karşı koyamadım - diğer cevaplar şüphesiz doğrudur, ancak gerçekten aşağıdaki kodu geçemezsiniz:

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

İfadedeki garip aralığa ifdikkat edin (sorunuzdan kopyaladığım). ECMA betiği tarafından boşluk karakteri olarak yorumlanmayan bir Unicode boşluk karakteri olan yarım genişlikli Hangul'dur (tanıdık olmayanlar için Korece'dir) - bu, tanımlayıcı için geçerli bir karakter olduğu anlamına gelir. Bu nedenle, biri a'dan sonra Hangul, diğerinden önce ve sonuncusu sadece a ile olmak üzere tamamen farklı üç değişken vardır. Alanı _okunabilirlik ile değiştirmek, aynı kod şöyle görünecektir:

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

Mathias değişken adı doğrulayıcısındaki doğrulamayı kontrol edin . Bu garip boşluk aslında sorularına dahil edilmişse, bu tür bir cevap için bir ipucu olduğundan eminim.

Bunu yapma. Ciddi anlamda.

Düzenleme: Değişken adlarında Sıfır genişlikli mafsal ve Sıfır genişlikli marangoz olmayan karakterlere de izin verildiği dikkatimi çekti - bkz. Sıfır genişlikli karakterlerle JavaScript gizleme - artıları ve eksileri ? .

Bu şu şekilde görünecektir:

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

BU MÜMKÜN!

var i = 0;

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

Bu, üç farklı değeri değerlendirmek için withdeyimin içinde bir alıcı kullanır a.

... bu hala bunun gerçek kodda kullanılması gerektiği anlamına gelmez ...

Daha da kötüsü, bu hile de kullanımı ile çalışacaktır ===.

  var i = 0;

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

Alıcı veya değer içermeyen örnek:

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

Bu çalışır çünkü hangi dizileri ==çağırır çağırır .toString.join

Bir Symbol.toPrimitiveES6 eşdeğeri olan başka bir çözüm toString/valueOf:

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

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

Mümkün olup olmadığı sorulursa (ZORUNLU değil), "a" dan rastgele bir sayı döndürmesini isteyebilir. Sırasıyla 1, 2 ve 3 üretmesi doğru olur.

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

Normal ifadeler olmadan hiçbir şey yapamadığınızda:

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

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

valueOfObject, ilkel (Number gibi) ile karşılaştırıldığında çağrılan özel yöntem nedeniyle çalışır . Ana hile, a.valueOfher defasında bayrakla execdüzenli ifadeyi çağırdığı için her seferinde yeni değer döndürür g, bu da lastIndexher eşleşme bulunduğunda düzenli ifadenin güncellenmesine neden olur . İlk kez this.r.lastIndex == 0eşleşir 1ve güncellenir lastIndex:, bir this.r.lastIndex == 1dahaki sefere regex eşleşir 2vb.

Küresel kapsamda aşağıdakiler kullanılarak gerçekleştirilebilir. İçin nodejskullanım globalyerine windowaşağıdaki kodu.

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

Bu yanıt, değişkeni almak için bir alıcı tanımlayarak yürütme bağlamında genel kapsam tarafından sağlanan örtük değişkenleri kötüye kullanır.

Bu, değişkenin abir SharedArrayBuffer ve bazı ana komut dosyası aracılığıyla erişmesi durumunda mümkündür . Olasılık düşüktür, ancak kod makine koduna derlenmiş zaman, web işçileri değişkeni güncellemek mümkündür asadece şartlarda bu yüzden zamanında a==1, a==2ve a==3koşullar sağlanır.

Bu, web çalışanları ve JavaScript'te SharedArrayBuffer tarafından sağlanan çok iş parçacıklı ortamdaki yarış durumuna bir örnek olabilir.

Yukarıdakilerin temel uygulaması:

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'imde, ilk denemede yaklaşık 10 milyar yinelemeden sonra gerçekleşiyor:

İkinci deneme:

Dediğim gibi, şansı düşük olacak, ancak yeterli zaman verildiğinde, duruma çarpacak.

İpucu: Sisteminizde çok uzun sürerse. Sadece deneyin a == 1 && a == 2ve değiştirmek Math.random()*3için Math.random()*2. Listeye gittikçe daha fazla eklemek, vurma şansını azaltır.

Bu, bir dizi kendi kendine yazma alıcısı kullanılarak da mümkündür:

(Bu jontro'nun çözümüne benzer, ancak karşı değişken gerektirmez.)

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

Alternatif olarak, bunun için bir sınıf ve çek için bir örnek kullanabilirsiniz.

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

var a = new A;

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

DÜZENLE

ES6 sınıflarını kullanmak şöyle görünecektir

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

Bu cevabın daha önce gönderildiğini görmüyorum, bu yüzden bunu da karışıma atacağım. Bu Jeff'in yarı genişlikte Hangul alanıyla verdiği cevaba benzer .

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

İkincisi ile hafif bir tutarsızlık fark edebilirsiniz, ancak birinci ve üçüncü çıplak gözle aynıdır. Her üçü de ayrı karakterdir:

a- Latin küçük harf A
ａ- Tam Genişlik Latin küçük harf A
а- Kiril küçük harf A

Bunun genel terimi "homoglifler" dir: aynı görünen farklı unicode karakterler. Tipik olarak tamamen ayırt edilemeyen üç tane elde etmek zordur , ancak bazı durumlarda şanslı olabilirsiniz. A, Α, А ve Ꭺ daha iyi çalışacak (Latince-A, Yunan Alpha , Kiril-A ve Cherokee-A ; sırasıyla maalesef Rum ve Cherokee küçük harfler Latin çok farklıdır a: α, ꭺve doesn böylece yukarıdaki pasajda yardım etmeyin).

Orada, genellikle sahte etki alanı adlarında (örneğin, wikipediа.org(Kiril) ve wikipedia.org(Latin)) bir Homoglif Saldırısı sınıfı var , ancak kodda da görünebilir; tipik olarak el değmemiş olarak adlandırılır (bir yorumda belirtildiği gibi, [el değmemiş ] sorular artık PPCG'de konu dışıdır , ancak bu tür şeylerin ortaya çıkacağı bir tür zorluk olarak kullanılır). Kullandığım bu web sitesini Bu yanıt için kullanılan homoglyphs bulmak için.

Evet mümkün! 😎

»JavaScript

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

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

Yukarıdaki kod kısa bir sürümdür (yorumlardaki notu için @Forivin sayesinde) ve aşağıdaki kod orijinaldir:

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

Kodumun üst tarafını görüp çalıştırırsanız WOW diyorsunuz, nasıl?

Sanırım Evet demenin yeterli olduğunu size söyleyen biri için mümkün : Hiçbir şey imkansız değil

Hile: ifİsminin benzer olduğu bir işlevi yapmak için daha sonra gizli bir karakter kullandım if. JavaScript'te anahtar kelimeleri geçersiz kılamıyoruz, bu yüzden bu şekilde kullanmak zorunda kaldım. Bu sahte if, ama bu durumda sizin için çalışıyor!

» C #

Ayrıca ( özellik değeri artış tekniği ile ) bir C # sürümü yazdım :

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

Canlı Demo

JavaScript

a == a +1

JavaScript'te, çift ​​duyarlıklı kayan nokta sayısı olarak uygulanan tamsayılar değil, yalnızca s'ler vardır Number.

Bir Sayı ayeterince büyükse, art arda üç tamsayıya eşit sayılabileceği anlamına gelir :

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

Doğru, görüşmecinin tam olarak sorduğu şey değildir (çalışmaz a=0), ancak gizli işlevler veya operatör aşırı yüklemesi ile herhangi bir hile içermez.

Diğer diller

Referans olarak, a==1 && a==2 && a==3Ruby ve Python'da çözümler var . Küçük bir değişiklikle Java'da da mümkündür.

Yakut

Bir özel ile ==:

class A
  def ==(o)
    true
  end
end

a = A.new

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

Veya artan a:

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

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

piton

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

Java Integerönbelleğini değiştirmek mümkündür :

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

Bu bir ters versiyonudur Jeff'in cevabı @ gizli karakteri (U + 115F, U + 1160 veya U + 3164) gibi o bakış değişkenleri oluşturmak için kullanılır * 1, 2ve 3.

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

* Bu cevap sıfır genişlikli mafsalsız (U + 200C) ve sıfır genişlikli mafsal (U + 200D) kullanılarak basitleştirilebilir. Bu karakterlerin her ikisine de tanımlayıcıların içinde izin verilir, ancak başlangıçta izin verilmez:

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

Diğer hileler aynı fikri kullanarak mümkündür, örneğin tam olarak ( a︀ = 1; a︁ = 2; a︀ == 1 && a︁ == 2; // true) benzer görünen değişkenler oluşturmak için Unicode varyasyon seçicileri kullanarak .

Mülakatların birinci kuralı; asla imkansız demeyin.

Gizli karakter numarasına gerek yok.

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

Dürüst olmak gerekirse, doğru olup olmadığını değerlendirmenin bir yolu olup olmadığı (ve diğerlerinin de gösterdiği gibi, birçok yol var), yüzlerce röportaj yapan biri olarak konuşurken, aradığım cevap boyunca bir şey:

"Eh, belki evet hemen benim için açık olmayan bazı garip koşullar altında ... ama bunu gerçek kodla karşılaşırsam o zaman ne yaptığını ve neden yaptığını anlamak için ortak hata ayıklama tekniklerini kullanırdım ve sonra hemen bu durumu önlemek için kodu yeniden düzenleyin ... ama daha da önemlisi: Ben kesinlikle ASLA bu kodu ilk etapta yazmak istiyorum çünkü bu kıvrımlı kod tanımı ve asla kıvrımlı kod yazmak için çalışıyoruz ".

Sanırım bazı görüşmeciler, çok zor bir soru olması gerektiği anlamına gelmekle suçlanırlar, ancak bir fikri olan geliştiricilere, özellikle de akılcı düşünceyle destekleyebilecekleri ve sorumu kendileri hakkında anlamlı bir ifade.

Böyle bir röportaj sorusu alırsanız (veya kodunuzda eşit derecede beklenmedik bir davranış fark ederseniz) ilk bakışta imkansız görünen bir davranışa ne tür şeylerin neden olabileceğini düşünün:

1. Kodlama : Bu durumda, baktığınız değişken düşündüğünüz değişken değildir. Bu, değişkenin adını başka bir değişkene benzetmek için homoglifler veya boşluk karakterleri kullanarak kasıtlı olarak Unicode ile uğraşırsanız , ancak kodlama sorunları yanlışlıkla, örneğin beklenmedik Unicode kodu içeren Web'den kod kopyalayıp yapıştırırken de ortaya çıkabilir. (örneğin, bir içerik yönetim sistemi flUnicode 'LATIN SMALL LIGATURE FL' (U + FB02) ile değiştirmek gibi bazı "otomatik biçimlendirme" yaptığı için ).

2. Yarış koşulları : Bir yarış koşulu meydana gelebilir, yani kodun geliştirici tarafından beklenen sırada yürütülmediği bir durum. Yarış koşulları genellikle çok iş parçacıklı kodda gerçekleşir, ancak yarış koşullarının mümkün olması için birden fazla iş parçacığı şart değildir - eşzamansızlık yeterlidir (ve kafanız karışmaz, eşzamansız kaputun altında birden fazla iş parçacığının kullanıldığı anlamına gelmez ).

   Bu nedenle, JavaScript'in tek iş parçacıklı olduğu için yarış koşullarından da bağımsız olmadığını unutmayın. Basit tek iş parçacıklı - ancak zaman uyumsuz - örnek için buraya bakın . Tek bir açıklama bağlamında, yarış koşulunun JavaScript'te vurulması oldukça zor olacaktır.

   Birden fazla iş parçacığına sahip olabileceğiniz için web çalışanlarıyla JavaScript biraz farklıdır. @mehulmpt bize web çalışanlarını kullanan harika bir kavram kanıtı gösterdi .

3. Yan etkiler : Eşitlik karşılaştırma işleminin bir yan etkisi (buradaki örneklerde olduğu gibi açık olması gerekmez, genellikle yan etkiler çok incedir).

Bu tür sorunlar yalnızca JavaScript değil, birçok programlama dilinde de görünebilir, bu yüzden burada klasik JavaScript WTF'lerinden birini görmüyoruz ¹ .

Tabii ki, görüşme sorusu ve buradaki örneklerin hepsi çok tutarlı görünüyor. Ancak bunlar iyi bir hatırlatmadır:

• Yan etkiler gerçekten kötü olabilir ve iyi tasarlanmış bir programın istenmeyen yan etkilerden arınmış olması gerekir.
• Çok iş parçacıklı ve değişken durum sorunlu olabilir.
• Karakter kodlama ve dize işleme hakkı yapmamak kötü hatalara yol açabilir.

_{¹ Örneğin, burada bir yan etki (belirgin bir) gösteren tamamen farklı bir programlama dilinde (C #) bir örnek bulabilirsiniz .}

İstediğiniz değerleri çıkarmak için bir dizi kullanan başka bir varyasyon.

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

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

Tamam, jeneratörlerle başka bir hack:

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

Proxy Kullanımı :

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

Proxy'ler temel olarak bir hedef nesne (ilk parametre) gibi davranır, ancak hedef nesne üzerinde (bu durumda "get property" işlemi) kesişme işlemleri yapar, böylece varsayılan nesne davranışı dışında bir şey yapma fırsatı olur. Bu durumda, türünü her sayı ile karşılaştırmak için zorladığı azaman "özellik al" eylemi çağrılır ==. Bu olur:

1. Mülkün sayacımız { i: 0 }olduğu bir hedef nesne oluşturuyoruzi
2. Hedef nesne için bir Proxy oluşturup a
3. Her a ==karşılaştırma için, atürü ilkel bir değere zorlanır
4. Bu tip baskılar a[Symbol.toPrimitive]()dahili olarak arama ile sonuçlanır
5. Proxy a[Symbol.toPrimitive], "get handler" kullanarak işlevi almayı durdurur
6. Mülkiyet kazanılmış olan o vekilin "işleyicisi olsun" kontrol eder Symbol.toPrimitive, bu durumda o artırır ve daha sonra hedef nesneden sayacı döndürür: ++target.i. Farklı bir özellik alınıyorsa, varsayılan özellik değerini döndürmeye geri döneriz,target[name]

Yani:

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

Diğer cevapların çoğunda olduğu gibi, bu sadece gevşek bir eşitlik kontrolü ( ==) ile çalışır , çünkü katı eşitlik kontrolleri ( ===) Proxy'nin araya girebileceği tipte baskı yapmaz.

Aslında sorunun ilk kısmına verilen cevap her programlama dilinde "Evet" dir. Örneğin, bu C / C ++ durumunda:

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

Aynı, ancak farklı, ama yine de aynı (birden çok kez "test edilebilir"):

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

Fikrim Number nesne türü denkleminin nasıl çalıştığıyla başladı.

Sembolleri kullanan bir ECMAScript 6 cevabı:

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

Nedeniyle ==kullanımı, JavaScript zorlamak gerekiyordu aikinci işlenen bir şey yakın içine ( 1, 2, 3bu durumda). Ancak JavaScript kendi başına zorlamayı anlamaya çalışmadan önce aramaya çalışır Symbol.toPrimitive. Symbol.toPrimitiveJavaScript sağlarsanız , işlevinizin döndürdüğü değeri kullanır. Değilse, JavaScript arayacaktır valueOf.

Bu uygulamak için en az kod olduğunu düşünüyorum:

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

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

Her çağrıda valueOfgenel bir değişkeni artıran bir özel ile kukla bir nesne oluşturma i. 23 karakter!

Bu, global değişkene neden olan hoş bir yan etkiye sahip defineProperty'yi kullanır!

var _a = 1

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

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

valueOfBir sınıf bildiriminde geçersiz kılınarak yapılabilir:

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

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

const a = new Thing();

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

Olan şey, valueOfher karşılaştırma operatörünün çağrılmasıdır. Birincisinde aeşit olacak 1, ikincisinde aeşit olacak 2vb. Çünkü her zaman valueOfçağrıldığında,a artırılır.

Bu nedenle console.log Thing: { value: 4}, koşulun doğru olduğunu belirterek (yine de terminalimde) ateş ve çıkış yapar .