หมายเหตุผู้ดูแล:โปรดต่อต้านการกระตุ้นให้แก้ไขรหัสหรือลบประกาศนี้ รูปแบบของพื้นที่ว่างอาจเป็นส่วนหนึ่งของคำถามดังนั้นจึงไม่ควรแก้ไขโดยไม่จำเป็น หากคุณอยู่ใน "ช่องว่างที่ไม่มีความหมาย" ค่ายคุณควรจะยอมรับรหัสตามที่เป็นอยู่

เป็นไปได้ไหมที่(a== 1 && a ==2 && a==3)จะประเมินเป็นtrueJavaScript?

นี่คือคำถามสัมภาษณ์ที่ถามโดย บริษัท เทคโนโลยีรายใหญ่ มันเกิดขึ้นเมื่อสองสัปดาห์ก่อน แต่ฉันยังคงพยายามหาคำตอบ ฉันรู้ว่าเราไม่เคยเขียนรหัสดังกล่าวในงานประจำวัน แต่ฉันอยากรู้

หากคุณใช้ประโยชน์จากวิธีการ==ทำงานคุณสามารถสร้างวัตถุที่มีฟังก์ชั่นที่กำหนดเองtoString(หรือvalueOf) ซึ่งจะเปลี่ยนสิ่งที่มันคืนมาในแต่ละครั้งที่มันถูกใช้เพื่อให้เป็นไปตามเงื่อนไขทั้งสามข้อ

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

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

เหตุผลที่งานนี้เกิดจากการใช้ตัวดำเนินการความเท่าเทียมกันแบบหลวม เมื่อใช้ความเท่าเทียมกันแบบหลวมหากตัวถูกดำเนินการตัวใดตัวหนึ่งแตกต่างจากตัวอื่นเครื่องยนต์จะพยายามแปลงค่าหนึ่งเป็นอีกแบบหนึ่ง ในกรณีของวัตถุทางด้านซ้ายและจำนวนที่อยู่ทางขวาหนึ่งก็จะพยายามที่จะแปลงวัตถุไปยังหมายเลขโดยการโทรครั้งแรกvalueOfถ้ามันเป็น callable 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 หนึ่งตัวก่อนและตัวสุดท้ายด้วยตัว แทนที่ช่องว่างด้วย_เพื่อให้สามารถอ่านได้รหัสเดียวกันจะมีลักษณะดังนี้:

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

ตรวจสอบการตรวจสอบในชื่อตัวแปรงัดตรวจสอบ ถ้าระยะห่างแปลก ๆ นั้นรวมอยู่ในคำถามของพวกเขาฉันรู้สึกว่ามันเป็นคำใบ้สำหรับคำตอบแบบนี้

อย่าทำอย่างนี้ อย่างจริงจัง.

แก้ไข: มีความสนใจของฉันที่ (แม้ว่าจะไม่ได้รับอนุญาตให้เริ่มตัวแปร) ตัวเชื่อมตัวZero-widthและZero-width ไม่ใช่ตัวเชื่อมตัวอักษรยังได้รับอนุญาตในชื่อตัวแปร - ดู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วิธีการที่กำหนดเองที่เรียกว่าเมื่อเทียบกับวัตถุดั้งเดิม (เช่นจำนวน) เคล็ดลับหลักคือการa.valueOfส่งคืนค่าใหม่ทุกครั้งเนื่องจากมีการเรียกexecใช้นิพจน์ทั่วไปด้วยgแฟล็กซึ่งทำให้เกิดการอัพเดตlastIndexนิพจน์ทั่วไปนั้นทุกครั้งที่พบการจับคู่ ดังนั้นครั้งแรกthis.r.lastIndex == 0มันจับคู่1และอัปเดตlastIndex: this.r.lastIndex == 1ดังนั้นครั้งต่อไปที่ regex จะจับคู่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,000 ล้านครั้งในครั้งแรก:

ความพยายามครั้งที่สอง:

อย่างที่ฉันบอกว่าโอกาสจะต่ำ แต่ให้เวลามากพอมันจะกระทบกับเงื่อนไข

เคล็ดลับ: หากระบบของคุณใช้เวลานานเกินไป ลองเท่านั้น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
а - ตัวพิมพ์เล็ก Cyrillic A

คำทั่วไปสำหรับสิ่งนี้คือ "homoglyphs": อักขระยูนิโค้ดที่แตกต่างกันซึ่งมีลักษณะเหมือนกัน โดยทั่วไปแล้วยากที่จะได้รับสามที่แยกไม่ออกอย่างเต็มที่ แต่ในบางกรณีคุณสามารถได้รับโชคดี A, Α, АและᎪจะทำงานได้ดีขึ้น (ละติน -A, กรีกอัลฟ่า , Cyrillic-AและCherokee-Aตามลำดับ แต่น่าเสียดายที่อักษรตัวพิมพ์เล็กกรีกและภาษาเชอโรกีแตกต่างจากละตินa: α,ꭺและอื่น ๆ doesn ไม่ช่วยตัวอย่างข้อมูลด้านบน)

มีการโจมตีแบบ Homoglyph ทั้งชั้นโดยทั่วไปมักจะเป็นชื่อโดเมนปลอม (เช่นwikipediа.org(Cyrillic) vs wikipedia.org(ละติน)) แต่สามารถแสดงเป็นรหัสได้เช่นกัน โดยทั่วไปจะเรียกว่าการใช้เล่ห์เหลี่ยม (ดังที่ได้กล่าวไว้ในความคิดเห็นคำถาม[การใช้เล่ห์เหลี่ยม]ตอนนี้เป็นหัวข้อในPPCGแต่เคยเป็นประเภทของความท้าทายที่สิ่งต่างๆเหล่านี้จะปรากฏขึ้น) ฉันใช้เว็บไซต์นี้เพื่อค้นหาคำว่า homoglyph ที่ใช้สำหรับคำตอบนี้

ใช่มันเป็นไปได้! 😎

»จาวาสคริปต์

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

ชวา

เป็นไปได้ที่จะแก้ไข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, และ23

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

แม้ว่าจะมีวิธีที่จะประเมินว่าเป็นจริงหรือไม่ก็ตาม (และอย่างที่คนอื่น ๆ ได้แสดงมีหลายวิธี) คำตอบที่ฉันจะมองหาพูดเป็นคนที่ได้ทำการสัมภาษณ์หลายร้อยคนจะเป็นอย่างไร บางสิ่งบางอย่างตามแนวของ:

"อาจจะใช่ภายใต้สถานการณ์แปลก ๆ บางอย่างที่ไม่ชัดเจนสำหรับฉันทันที ... แต่ถ้าฉันพบสิ่งนี้ในรหัสจริงฉันจะใช้เทคนิคการตรวจแก้จุดบกพร่องทั่วไปเพื่อหาว่าทำไมมันถึงทำในสิ่งที่ทำ และจากนั้น refactor รหัสทันทีเพื่อหลีกเลี่ยงสถานการณ์นั้น ... แต่ที่สำคัญกว่านั้น: ฉันจะไม่เขียนโค้ดนั้นตั้งแต่แรกเพราะนั่นคือคำจำกัดความของรหัสที่ซับซ้อนมากและฉันพยายามไม่เขียนโค้ดที่ซับซ้อน "

ฉันเดาว่าผู้สัมภาษณ์บางคนจะขุ่นเคืองกับการมีสิ่งที่เห็นได้ชัดว่าเป็นคำถามที่ยากมาก แต่ฉันไม่รังเกียจนักพัฒนาที่มีความคิดเห็นโดยเฉพาะเมื่อพวกเขาสามารถสำรองข้อมูลด้วยความคิดที่มีเหตุผลและสามารถทำให้คำถามของฉัน คำพูดที่มีความหมายเกี่ยวกับตัวเอง

หากคุณเคยได้รับคำถามสัมภาษณ์ (หรือสังเกตเห็นพฤติกรรมบางอย่างที่ไม่คาดคิดในรหัสของคุณ) ให้คิดว่าสิ่งใดที่อาจทำให้เกิดพฤติกรรมที่ดูเหมือนเป็นไปไม่ได้ในแวบแรก:

1. การเข้ารหัส : ในกรณีนี้ตัวแปรที่คุณกำลังดูไม่ใช่สิ่งที่คุณคิดว่าเป็น สิ่งนี้อาจเกิดขึ้นได้หากคุณจงใจยุ่งกับ Unicode โดยใช้homoglyphsหรือspace spaceเพื่อทำให้ชื่อของตัวแปรดูคล้ายกับตัวแปรอื่น แต่ปัญหาการเข้ารหัสยังสามารถนำไปใช้โดยไม่ตั้งใจเช่นเมื่อคัดลอกและวางโค้ดจากเว็บที่มีรหัส Unicode ที่ไม่คาดคิด คะแนน (เช่นเนื่องจากระบบการจัดการเนื้อหาทำ "การจัดรูปแบบอัตโนมัติ" บางอย่างเช่นการแทนที่flด้วย Unicode 'LATIN SMALL LIGATURE FL' (U + FB02)

2. สภาพการแข่งขัน : สภาพการแข่งขันอาจเกิดขึ้นเช่นสถานการณ์ที่โค้ดไม่ได้ดำเนินการตามลำดับที่ผู้พัฒนาคาดหวัง เงื่อนไขการแข่งขันมักจะเกิดขึ้นในรหัสแบบมัลติเธรด แต่หลายเธรดไม่จำเป็นสำหรับเงื่อนไขการแข่งขันที่เป็นไปได้ - asynchronicity เพียงพอ (และไม่สับสน, async ไม่ได้หมายความว่ามีการใช้เธรดหลายรายการภายใต้ประทุน )

   โปรดทราบว่า JavaScript จึงไม่ปลอดจากเงื่อนไขการแข่งขันเพียงเพราะเป็นเธรดเดี่ยว ดูที่นี่สำหรับตัวอย่างของเธรดเดี่ยว - แต่ async - ง่ายๆ ในบริบทของคำสั่งเดียวสภาพการแข่งขันจะค่อนข้างยากที่จะตีใน JavaScript

   จาวาสคริปต์กับคนทำงานเว็บนั้นแตกต่างกันเล็กน้อยเนื่องจากคุณสามารถมีหลายเธรด @mehulmpt ได้แสดงให้เราดีหลักฐานของแนวคิดโดยใช้คนงานเว็บ

3. ผลข้างเคียง : ผลข้างเคียงของการดำเนินการเปรียบเทียบความเท่าเทียมกัน (ซึ่งไม่จำเป็นต้องชัดเจนเหมือนในตัวอย่างที่นี่บ่อยครั้งที่ผลข้างเคียงนั้นบอบบางมาก)

ปัญหาประเภทนี้สามารถปรากฏในภาษาการเขียนโปรแกรมมากมายไม่เพียง แต่ JavaScript ดังนั้นเราจึงไม่เห็นJavaScript WTFsแบบคลาสสิกที่นี่¹ 1

แน่นอนว่าคำถามสัมภาษณ์และตัวอย่างที่นี่ล้วนดูเป็นสิ่งที่วางแผนไว้มาก แต่พวกเขาเป็นเครื่องเตือนใจที่ดีว่า:

• ผลข้างเคียงอาจเป็นที่น่ารังเกียจจริงๆและโปรแกรมที่ออกแบบมาอย่างดีควรปราศจากผลข้างเคียงที่ไม่พึงประสงค์
• สถานะที่มีหลายเธรดและไม่แน่นอนอาจเป็นปัญหาได้
• การไม่เข้ารหัสอักขระและการประมวลผลสตริงที่ถูกต้องอาจทำให้เกิดข้อบกพร่องที่น่ารังเกียจ

_{¹ตัวอย่างเช่นคุณสามารถหาตัวอย่างในการเขียนโปรแกรมภาษาที่แตกต่างกันโดยสิ้นเชิง (C #) ความ exhibiting ผลข้างเคียง (เห็นได้ชัดอย่างใดอย่างหนึ่ง) ที่นี่}

นี่คือรูปแบบอื่นโดยใช้อาร์เรย์เพื่อแสดงค่าที่คุณต้องการ

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เมื่อ==coerces ประเภทของมันเพื่อเปรียบเทียบกับแต่ละหมายเลข สิ่งนี้เกิดขึ้น:

1. เราสร้างวัตถุเป้าหมาย{ i: 0 }ที่ที่iคุณสมบัติเป็นตัวนับของเรา
2. เราสร้างพร็อกซีสำหรับวัตถุเป้าหมายและกำหนดให้ a
3. สำหรับแต่ละa ==การเปรียบเทียบaประเภทจะถูกบังคับให้มีค่าดั้งเดิม
4. การข่มขู่ประเภทนี้ส่งผลให้เกิดการโทร a[Symbol.toPrimitive]()ภายใน
5. พร็อกซีสกัดกั้นการรับ a[Symbol.toPrimitive]ฟังก์ชันโดยใช้ "get handler"
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 ที่ใช้ประโยชน์จาก Symbols:

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

เนื่องจาก==การใช้งานจาวาสคริควรจะบีบบังคับให้aเป็นสิ่งที่ใกล้เคียงกับตัวถูกดำเนินการสอง ( 1, 2, 3ในกรณีนี้) แต่ก่อนที่จะพยายามที่จะร่าง coercing ในตัวเอง 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}แสดงว่าเงื่อนไขเป็นจริง