උපපරිපාලක සටහන: කරුණාකර කේතය සංස්කරණය කිරීමට හෝ මෙම දැන්වීම ඉවත් කිරීමට ඇති පෙලඹීමට එරෙහි වන්න. හිස් අවකාශයේ රටාව ප්‍රශ්නයේ කොටසක් විය හැකි අතර එම නිසා අනවශ්‍ය ලෙස එය අවුල් නොකළ යුතුය. ඔබ "සුදු අවකාශය නොවැදගත්" කඳවුරක සිටී නම්, ඔබට කේතය පිළිගැනීමට හැකි විය යුතුය.

ජාවාස්ක්‍රිප්ට් තුළ (a== 1 && a ==2 && a==3)තක්සේරු කළ හැකි කවදා හෝ කළ trueහැකිද?

මෙය ප්‍රධාන තාක්ෂණික සමාගමක් ඇසූ සම්මුඛ පරීක්ෂණ ප්‍රශ්නයකි. එය සිදුවී සති දෙකකට පෙර, නමුත් මම තවමත් පිළිතුර සොයා ගැනීමට උත්සාහ කරමි. අපගේ එදිනෙදා රැකියාවේදී අපි කිසි විටෙකත් එවැනි කේතයක් ලියන්නේ නැති බව මම දනිමි, නමුත් මට කුතුහලයක් ඇත.

ඔබ ප්රයෝජන ගන්න නම් කොහොමද ==වැඩ , ඔබ හුදෙක් චාරිත්රයක් සහිත වස්තුවක්, නිර්මාණය කළ හැක 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, එන්ජිම තරමක් දිගු මාවතක් තිබුණද, අපට එම අවසාන ප්‍රති result ලය ලබා දෙන අංකයක් බවට පරිවර්තනය කිරීමට උත්සාහ කරනු ඇත.

මට විරුද්ධ විය නොහැක - අනෙක් පිළිතුරු නිසැකවම සත්‍ය ය, නමුත් ඔබට ඇත්ත වශයෙන්ම පහත කේතය පසුකර යා නොහැක:

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

ifප්‍රකාශයේ ඇති අමුතු පරතරය සැලකිල්ලට ගන්න (මම ඔබේ ප්‍රශ්නයෙන් පිටපත් කළෙමි). එය අර්ධ පළල හන්ගුල් (එය හුරුපුරුදු නොවන අයට කොරියානු ය) යුනිකෝඩ් අභ්‍යවකාශ අක්ෂරයක් වන අතර එය ECMA ස්ක්‍රිප්ට් මගින් අභ්‍යවකාශ චරිතයක් ලෙස අර්ථ නිරූපණය නොකෙරේ - මෙයින් අදහස් කරන්නේ එය හඳුනාගැනීමක් සඳහා වලංගු චරිතයක් බවයි. එබැවින් සම්පූර්ණයෙන්ම වෙනස් විචල්‍යයන් තුනක් ඇත, එකක් a ට පසු හන්ගුල් සමඟ, එකක් ඊට පෙර සහ අවසාන එක a සමඟ. _කියවීමේ හැකියාව සඳහා අවකාශය ප්‍රතිස්ථාපනය කිරීම , එකම කේතය මේ ආකාරයට පෙනේ:

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

මතියස්ගේ විචල්‍ය නාම වලංගුකරණයේ වලංගුභාවය පරීක්ෂා කරන්න . එම අමුතු පරතරය සැබවින්ම ඔවුන්ගේ ප්‍රශ්නයට ඇතුළත් කර ඇත්නම්, එය මේ ආකාරයේ පිළිතුරක් සඳහා ඉඟියක් බව මට විශ්වාසයි.

මෙය නොකරන්න. බරපතල ලෙස.

සංස්කරණය කරන්න: (විචල්‍යයක් ආරම්භ කිරීමට අවසර නැතත්) ශුන්‍ය-පළල සම්බන්ධකය සහ ශුන්‍ය පළල සම්බන්ධ නොවන අක්ෂර ද විචල්‍ය නම් වලින් අවසර දී ඇති බව මගේ අවධානයට යොමු වී ඇත - ශුන්‍ය පළල අක්ෂර සහිත ජාවාස්ක්‍රිප්ට් අවුල් කිරීම බලන්න - වාසි සහ අවාසි ? .

මෙය පහත පරිදි වේ:

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.toPrimitiveඊඑස් 6 ට සමාන තවත් විසඳුමක් toString/valueOf:

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

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

එය කළ හැකි දැයි විමසන්නේ නම් (MUST නොවේ), එයට අහඹු අංකයක් ආපසු ලබා දීමට "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සමඟ නිත්‍ය ප්‍රකාශනය ඉල්ලා සිටින නිසාය . එබැවින් පළමු වරට එය ගැලපෙන අතර යාවත්කාලීන වේ : එබැවින් ඊළඟ වතාවේ රීජෙක්ස් ගැලපෙනු ඇත .glastIndexthis.r.lastIndex == 01lastIndexthis.r.lastIndex == 12

ගෝලීය විෂය පථයේ පහත සඳහන් දෑ භාවිතා කර එය ඉටු කළ හැකිය. පහත කේතය වෙනුවට nodejsභාවිතය සඳහා .globalwindow

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 විසින් සපයනු ලබන බහු-නූල් පරිසරයක ධාවන තත්වයට මෙය උදාහරණයක් විය හැකිය.

ඉහත මූලික ක්‍රියාත්මක කිරීම මෙන්න:

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)

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

මගේ මැක්බුක් වාතය තුළ, එය සිදු වන්නේ පළමු උත්සාහයේදී බිලියන 10 ක් පමණ පුනරාවර්තනය කිරීමෙන් පසුව ය:

දෙවන උත්සාහය:

මා කී පරිදි, අවස්ථා අඩු වනු ඇත, නමුත් ප්‍රමාණවත් කාලයක් ලබා දීමෙන් එය තත්වයට පත්වනු ඇත.

ඉඟිය: ඔබේ පද්ධතියට වැඩි කාලයක් ගත වුවහොත්. පමණක් උත්සාහ a == 1 && a == 2කර වෙනස් Math.random()*3කරන්න Math.random()*2. ලැයිස්තුගත කිරීම සඳහා වැඩි වැඩියෙන් එකතු කිරීමෙන් පහර දීමේ අවස්ථාව පහත වැටේ.

ස්වයං-නැවත ලිවීමේ මාලාවක් භාවිතා කරමින් මෙය කළ හැකිය:

(මෙය ජොන්ට්‍රෝගේ විසඳුමට සමානය, නමුත් ප්‍රති විචල්‍යයක් අවශ්‍ය නොවේ.)

(() => {
    "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: α, ꭺ, සහ අයෙක් සොයමින් එසේ ඉහත ස්නිපටයට උදව් නොකරන්න).

සමජාතීය හෝමොග්ලිෆ් ප්‍රහාර මාලාවක් ඇත, බොහෝ විට ව්‍යාජ ඩොමේන් නාම වලින් (උදා: wikipediа.org(සිරිලික්) එදිරිව wikipedia.org(ලතින්)), නමුත් එය කේතයෙන් ද පෙන්විය හැකිය; සාමාන්‍යයෙන් හඳුන්වනු ලබන්නේ යටපත් වී ඇති බවය ( විවරණයක සඳහන් කර ඇති පරිදි, [යටින් පවතින] ප්‍රශ්න දැන් PPCG හි මාතෘකාවෙන් බැහැරව ඇත , නමුත් මෙම ආකාරයේ දේවල් පෙන්වන අභියෝගයක් ලෙස භාවිතා කරයි). මෙම පිළිතුර සඳහා භාවිතා කරන සමජාතීයතා සොයා ගැනීමට මම මෙම වෙබ් අඩවිය භාවිතා කළෙමි .

ඔව්, එය කළ හැකිය! 😎

»ජාවාස්ක්‍රිප්ට්

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

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

ඉහත කේතය කෙටි අනුවාදයකි (අදහස් දැක්වීමේ සටහන සඳහා or ෆොරිවින්ට ස්තූතියි) සහ පහත කේතය මුල් ය:

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

ඔබ මගේ කේතයේ ඉහළ පැත්ත දැක එය ක්‍රියාත්මක කරන්නේ නම් ඔබ කියන්නේ වාව්, කෙසේද?

ඉතින් මම හිතන්නේ ඔව් යැයි පැවසීම ප්‍රමාණවත් යැයි ඔබට පැවසූ කෙනෙකුට එය කළ හැකිය : කිසිවක් කළ නොහැකි ය

උපක්‍රමය: ifඑහි නම සමාන වන ශ්‍රිතයක් සෑදීමට මම සැඟවුණු අක්ෂරයක් භාවිතා කළෙමි if. ජාවාස්ක්‍රිප්ට් හි අපට මූල පද ඉක්මවා යා නොහැක, එබැවින් මට මේ ආකාරයෙන් භාවිතා කිරීමට බල කෙරුනි. එය ව්‍යාජ ය 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!😎");
    }
}

සජීවී නිරූපණය

ජාවාස්ක්‍රිප්ට්

a == a +1

ජාවාස්ක්‍රිප්ට් හි පූර්ණ සංඛ්‍යා නොමැති නමුත් ඒවා පමණක් Numberද්විත්ව නිරවද්‍යතාවයකින් යුත් පාවෙන ලක්ෂ්‍ය සංඛ්‍යා ලෙස ක්‍රියාත්මක වේ.

එයින් අදහස් 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රූබි සහ පයිතන් හි විසඳුම් තිබේ. සුළු වෙනස් කිරීමකින්, එය ජාවාහි ද කළ හැකිය.

රූබි

චාරිත්රයක් සමඟ ==:

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හැඹිලිය වෙනස් කිරීමට හැකිය :

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

වෙනත් උපක්‍රම එකම අදහස භාවිතා කළ හැකිය. උදා: යුනිකෝඩ් විචල්‍යතා තේරීම් භාවිතා කරමින් හරියටම සමානව පෙනෙන විචල්‍යයන් නිර්මාණය කිරීම ( 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. කේතීකරණය : මේ අවස්ථාවේ දී ඔබ බලන විචල්‍යය එය ඔබ සිතන ආකාරයට නොවේ. විචල්‍යයක නම වෙනත් එකක් මෙන් පෙනෙන්නට ඔබ හිතාමතාම සමජාතීය හෝ අභ්‍යවකාශ අක්ෂර භාවිතා කරමින් යුනිකෝඩ් සමඟ පටලවා ගන්නේ නම් මෙය සිදුවිය හැකිය , නමුත් කේතීකරණ ගැටළු අහම්බෙන් ද හඳුන්වා දිය හැකිය, උදා: අනපේක්ෂිත යුනිකෝඩ් කේත අඩංගු වෙබයෙන් කේත පිටපත් කර අලවන විට ලකුණු (උදා: අන්තර්ගත කළමනාකරණ පද්ධතියක් flයුනිකෝඩ් 'ලැටින් ස්මාල් ලිගේචර් එෆ්එල්' (යූ + එෆ්බී 02) වෙනුවට ආදේශ කිරීම වැනි "ස්වයංක්‍රීය හැඩතල ගැන්වීම්" කළ නිසා .

2. ධාවන කොන්දේසි : තරඟ තත්වයක් ඇතිවිය හැකිය, එනම් සංවර්ධකයා අපේක්ෂා කරන අනුපිළිවෙලෙහි කේතය ක්‍රියාත්මක නොවන තත්වයක්. ධාවන තත්වයන් බොහෝ විට බහු-නූල් කේත වලින් සිදු වේ, නමුත් බහු කොන්දේසි නූල් වර්ග තත්වයන් සඳහා අවශ්‍ය නොවේ - අසමමුහුර්තතාවය ප්‍රමාණවත් වේ (සහ ව්‍යාකූල නොවන්න, අසින්ක් යන්නෙන් අදහස් කරන්නේ හුඩ් යටතේ බහු නූල් භාවිතා වන බවයි ).

   එබැවින් ජාවාස්ක්‍රිප්ට් තනි-නූල් නිසා පමණක් ධාවන තත්වයන්ගෙන් නිදහස් නොවන බව සලකන්න. සරල තනි නූල් සහිත නමුත් අසින්ක් - උදාහරණයක් සඳහා මෙහි බලන්න . තනි ප්‍රකාශයක සන්දර්භය තුළ ධාවන තත්වය කෙසේ වෙතත් ජාවාස්ක්‍රිප්ට් හි පහර දීමට අපහසු වනු ඇත.

   ඔබට බහු නූල් තිබිය හැකි බැවින් වෙබ් සේවකයින් සමඟ ජාවාස්ක්‍රිප්ට් ටිකක් වෙනස් ය. වෙබ් සේවකයින් භාවිතා කරමින් සංකල්පයේ සාක්‍ෂි සනාථ කිරීම සඳහා memehulmpt අපට පෙන්වා දී ඇත .

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වර්ගය ප්‍රාථමික අගයකට බල කෙරේ
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!');
}

මගේ අදහස ආරම්භ වූයේ අංක වස්තු වර්ග සමීකරණය ක්‍රියාත්මක වන ආකාරයෙනි.

සංකේත භාවිතා කරන 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මෙම නඩුවේ). නමුත් ජාවාස්ක්‍රිප්ට් බලහත්කාරයෙන් බලහත්කාරයෙන් ගණනය කිරීමට උත්සාහ කිරීමට පෙර එය ඇමතීමට උත්සාහ කරයි Symbol.toPrimitive. ඔබ Symbol.toPrimitiveජාවාස්ක්‍රිප්ට් ලබා දෙන්නේ නම් ඔබේ ශ්‍රිතය ලබා දෙන අගය භාවිතා කරයි. එසේ නොවේ නම්, ජාවාස්ක්‍රිප්ට් අමතනු valueOfඇත.

එය ක්‍රියාත්මක කිරීමට ඇති අවම කේතය මෙය යැයි මම සිතමි:

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

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

සෑම ඇමතුමකම valueOfගෝලීය විචල්‍යතාවයක් වැඩි කරන චාරිත්‍රයක් සහිත ව්‍යාජ වස්තුවක් නිර්මාණය කිරීම i. අක්ෂර 23 ක්!

මෙය ගෝලීය විචල්‍යතාවයට හේතු වන හොඳ අතුරු ආබාධයක් සහිත ඩිෆයින් ප්‍රොපර්ටි භාවිතා කරයි!

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වැඩි වේ.

එම නිසා Thing: { value: 4}කොන්දේසිය සත්‍ය බව අඟවමින් console.log (කෙසේ හෝ මගේ පර්යන්තයේ) වෙඩි තබා ප්‍රතිදානය කරනු ඇත .