What the f*ck JavaScript?
- Node හි ඇසුරුම් කරන ලද අත්පිටපත
- පරිවර්තන
පටුන
💪 දිරිගැන්වුම
✍🏻 අංකනය
👀 උදාහරණ
📚 වෙනත් සම්පත්
🎓 බලපත්‍රය
What the f*ck JavaScript?
- Node හි ඇසුරුම් කරන ලද අත්පිටපත
- පරිවර්තන
පටුන
💪 දිරිගැන්වුම
✍🏻 අංකනය
👀 උදාහරණ
📚 වෙනත් සම්පත්
🎓 බලපත්‍රය

What the f*ck JavaScript?

හාස්‍යජනක සහ දුරවබෝධ JavaScript උදාහරණ

JavaScript යනු විශිෂ්ට ක්‍රමලේඛන භාෂාවකි.එයට සරල වින්‍යාසයක් සහ පුළුල් පද්ධතියක් ඇති අතර වඩාත්ම වැදගත් කරුණක් ලෙස එය සතුව විශිෂ්ට ප්‍රජාවක් සිටී.කෙසේ නමුත් JavaScript ක්‍රමලේඛන භාෂාවේ වටහා ගැනීමට දුෂ්කර කොටස් ද ඇති බව අපි සියල්ලෝම දනිමු. මෙවැනි සමහරක් කො ටස් අපගේ එදිනෙදා ක්‍රමලේඛන කාර්යයන් ඉක්මනින් මහත් අවුලට පත් කිරීමට සමත් අතර තවත් සමහරක් අපව මහා හඬින් සිනහ නැංවීමට සමත්ය.

WTFJS සඳහා මුල් අදහසේ හිමිකම Brian Leroux සතුය.මෙම ලැයිස්තුව ඔහුගේ 2012 DOTJS හි WTFJS දේශනය විසින් පොළඹවන ලද්දකි.

Node හි ඇසුරුම් කරන ලද අත්පිටපත

ඔබට මෙම අත්පොත npm හරහා ස්ථාපනය කරගත හැකිය.මේ සඳහා පහත විධානය ක්‍රියාත්මක කරන්න.

$ npm install -g wtfjs

දැන් ඔබට විධාන පෙළ හරහා wtfjs ක්‍රියාත්මක කළ හැකි විය යුතුය. මෙය තෝරාගත් $PAGER හි අත්පිටපත විවෘත කරනු ඇත. එසේ නැත්නම් ඔබට මෙහිදී නොනැවතී කියවිය හැකිය.

මූලය මෙහිදී ලබාගත හැක: https://github.com/denysdovhan/wtfjs

පරිවර්තන

දැනට wtfjs හි පහත පරිවර්තන පවතී.

中文版

නව පරිවර්තනයක් ඉල්ලන්න

පටුන

💪 දිරිගැන්වුම
✍🏻 අංකනය
👀 උදාහරණ
වෙනත් සම්පත්
🎓 බලපත්‍රය

💪 දිරිගැන්වුම

හුදෙක් විනෝදය උදෙසා

— “හුදෙක් විනෝදය උදෙසා: අහඹු විප්ලවයක කතාව”, ලීනස් ටොවාල්ඩ්ස්

මෙම ලැයිස්තුවේ මූලික අරමුණ වන්නේ උන්මාදනීය උදාහරණ එක්රැස් කිරීම සහ හැකිනම් ඒවා පැහැදිලි කිරීමයි; මක් නිසාද යත් අප මීට පෙර නොදැන සිටි දෙයක් ඉගෙනීම විනෝදජනක බැවිනි.

ඔබ ආධුනිකයකු නම් , JavaScript හි ගැඹුරට පිවිසෙන්නට මෙම සටහන් උපකාරී වනු ඇත. පිරිවිතර වැඩියෙන් කියවන්නට සහ ඒ සමඟ කල් ගෙවන්නට මෙම සටහන් ඔබට අභිප්‍රේරණයක් වනු ඇතැයි මම බලාපොරොත්තු වෙමි.

ඔබ වෘත්තීමය සංවර්ධකයෙකු නම්, ඔබට මෙම උදාහරණ අපගේ ආදරණීය JavaScript හි අනපේක්ෂිත සහ අසාමාන්‍ය අංශ පිළිබඳ යොමුවක් ලෙස සැලකිය හැක.

කවුරුන් හෝ වේවා, හුදෙක් මෙය කියවන්න. බොහෝ විට ඔබ අලුත් දෙයක් සොයා ගනු ඇත.

✍🏻 අංකනය

// -> භාවිත කෙරෙන්නේ ප්‍රකාශනයක ප්‍රතිඵලය දැක්වීමටයි. උදා:

1 + 1; // -> 2

// > මඟින් අදහස් වන්නේ console . log () හෝ වෙනත් ප්‍රතිදානයක ප්‍රතිඵලයකි. :

console.log("hello, world!"); // > hello, world!

// යනු හුදෙක් විවරණය සඳහා යොදා ගත් ටීකාවකි. උදා:

// foo නියතයට කෘත්‍යයක් පැවරීම
const foo = function() {};

👀 උදාහරණ

`[]` සහ `![]` සමානය

අරාව, නැත අරාව ට සමානය:

[] == ![]; // -> true

💡 විවරණය:

වියුක්ත සමානතා කාරකය, සැසඳීම සඳහා දෙපසම සංඛ්‍යා බවට හරවයි, මෙවිට දෙපසම වෙනස් හේතු නිසා 0 බවට පත් වේ. අරාවන් සත්‍යමය බැවින් මෙහි දකුණු පස අසත්‍ය යන්නට ද අනතුරුව 0 බවට ද පත්වේ. කෙසේ නමුත් වම් පසෙහි හිස් අරාවක් බූලියානු අගයක් බවට පත් නොවී ම සංඛ්‍යාවක් බවට පත් වේ.(සත්‍යමය වීම නොසලකා, හිස් අරාවන් 0 බවට පත් කෙරේ.)

පහත දැක්වෙන්නේ මෙම ප්‍රකාශනය සරල වන ආකාරයයි.:

+[] == +![];
0 == +false;
0 == 0;
true;

[] සත්‍යමය මුත් සත්‍ය නොවේ ද බලන්න.

12.5.9 තාර්කික නිශේධ කාරකය (!)
7.2.13 වියුක්ති සමානතා සංසන්දනය

`true`, `![]`ට සම නොවේ, නමුත් `[]` ට ද සම නොවේ.

අරාව සත්‍ය නොවන මුත් නැත අරාව ද සත්‍ය නොවේ අරාව අසත්‍ය ය, එහෙත් නැත අරාව ද අසත්‍ය ය.

true == []; // -> false
true == ![]; // -> false

false == []; // -> true
false == ![]; // -> true

💡 විවරණය:

true == []; // -> false
true == ![]; // -> false

// පිරිවිතරයට අනුව

true == []; // -> false

toNumber(true); // -> 1
toNumber([]); // -> 0

1 == 0; // -> false

true == ![]; // -> false

![]; // -> false

true == false; // -> false

false == []; // -> true
false == ![]; // -> true

// පිරිවිතරයට අනුව

false == []; // -> true

toNumber(false); // -> 0
toNumber([]); // -> 0

0 == 0; // -> true

false == ![]; // -> false

![]; // -> false

false == false; // -> true

7.2.13 වියුක්ති සමානතා සැසඳීම

සත්‍යය අසත්‍ය ය

!!"false" == !!"true"; // -> true
!!"false" === !!"true"; // -> true

💡 විවරණය:

මෙය පියවරෙන් පියවර සලකන්න:

//
true සත්‍යමය වන අතර අගය 1 මඟින් නිරූපණය වේ. පෙළ මාදිලියේදී 'true' යනු සංඛ්‍යාවක් නොවේ
true == "true"; // -> false
false == "false"; // -> false

//  ‘false’ යනු හිස් පෙළක් නොවේ, එමනිසා එය සත්‍යමය අගයකි
!!"false"; // -> true
!!"true"; // -> true

7.2.13 වියුක්ති සමානතා සැසඳීම

baNaNa

"b" + "a" + +"a" + "a"; // -> 'baNaNa'

මෙය JavaScriptහි පැරණි, එහෙත් වැඩිදියුණු කරන ලද විහිළුවකි.මුල් පිටපත පහත දැක්වේ:

"foo" + +"bar"; // -> 'fooNaN'

💡 විවරණය:

මෙම ප්‍රකාශනය 'foo' + (+'bar') ලෙස නිර්ණය වේ; 'bar', “සංඛ්‍යාවක් නොවේ( NaN )” යන්නට පරිවර්තනය වේ.

12.8.3 ආකලන කාරකය (+)
12.5.6 ඒකක + කාරකය

`NaN` යනු `NaN` නොවේ

NaN === NaN; // -> false

💡 විවරණය:

පිරිවිතරය දැඩි ලෙස ම, මෙම හැසිරීමට හේතුවන තර්කය අර්ථ දක්වයි:

Type(x) සහ Type(y) වෙනස් නම්, false ප්‍රතිදානය කරන්න.

Type(x) සංඛ්‍යාවක් නම්, එවිට,

If x, NaN නම්, false දෙන්න.

If y, NaN නම්, false දෙන්න.

… … …

— 7.2.14 දැඩි සමානතා සැසඳීම

IEEE හි NaN කාරකය පිළිබඳ අර්ථ දැක්වීම අනුගමනය කරමින්:

අන්‍යොන්‍ය වශයෙන් බහිෂ්කාර බන්ධුතා හතරක් වලංගුය: වඩා කුඩා, සමාන, වඩා විශාල, සහ අපිළිවෙළ වශයෙනි. අවම වශයෙන් එක සම්ප්‍රදානයක් හෝ සංඛ්‍යාවක් නොවන විට අවසාන අවස්ථාව උද්ගත වේ. සෑම “සංඛ්‍යාවක් නොවේ” අගයක් ම , තමා ද ඇතුළු ව, සියල්ල සමඟ අපිළිවෙල සසඳයි.

— “IEEE754 සංඛ්‍යාවක් නොවේ අගයන් සැසඳීම් සියල්ල සඳහා අසත්‍ය ප්‍රතිදානය වීමට හේතුව කුමක් ද?” at StackOverflow

එය අසාර්ථකත්වයකි

ඔබ විශ්වාස නොකරනු ඇත, නමුත් …

(![] + [])[+[]] +
  (![] + [])[+!+[]] +
  ([![]] + [][[]])[+!+[] + [+[]]] +
  (![] + [])[!+[] + !+[]];
// -> 'fail'

💡 විවරණය:

ඉහත සංකේත පෙළ කැබලිවලට කඩා ගැනීම මඟින්, පහත රටාව නිතර ඇතිවන බව අප හඳුනා ගනී:

![] + []; // -> 'false'
![]; // -> false

ඉතින් අපි false ට [] එකතු කිරීමට තැත් කරමු. නමුත් අභ්‍යන්තර කෘත්‍ය ඇමතුම් ගණනාවක් නිසා (binary + Operator -> ToPrimitive -> [[DefaultValue]]), එය, දකුණු පස පෙළ ට පරිවර්තනය කිරීමෙන් අවසන් වේ.

![] + [].toString(); // 'false'

පෙළ අරාවක් ලෙස සැලකීමෙන්, [0] මඟින් අපට එහි පළමු අක්ෂරය වෙත ප්‍රවේශ විය හැකිය:

"false"[0]; // -> 'f'

ඉතිරිය ප්‍රත්‍යක්ෂ ය., නමුත් i නොමඟ යවන සුළු ය. “fail” හි i යන්න, ['10'] ස්ථානයේ ඇති අවයවය ග්‍රහණය කිරීමෙන් සහ පෙළ 'falseundefined' උත්පාදනය වීමෙන් ග්‍රහණය කෙරෙනු ලැබේ.

`[]` සත්‍යමය නමුත් `true` නොවේ

අරාවක් යනු සත්‍යමය අගයකි, කෙසේ නමුත් එය true ට සමාන නොවේ.

!![]       // -> true
[] == true // -> false

💡 විවරණය:

ECMA-262 පිරිවිතරයෙහි අදාළ කොටස් වලට සබැඳි පහත දැක්වේ:

12.5.9 තාර්කික NOT කාරකය (!)
7.2.13 වියුක්ත සමානතා සැසඳීම

`null` අසත්‍යමය මුත් `අසත්‍ය` නොවේ

null අසත්‍යමය යන්න නොසලකා, එය false යන්නට සම නොවේ

!!null; // -> false
null == false; // -> false

කෙසේ නමුත්, 0 සහ ”” වැනි අසත්‍යමය අගයන් false ට සම වේ

0 == false; // -> true
"" == false; // -> true

💡 විවරණය:

විවරණය ඉහත උදාහරණය සඳහා පරිදි ම වේ. අදාළ සබැඳිය පහත දැක්වේ:

7.2.13 වියුක්ත සමානතා සැසඳීම

`document.all` යනු වස්තුවකි, නමුත් එය අර්ථ විරහිතය.

⚠️ මෙය පිරික්සුම් යෙදුම් ක්‍රමලේඛ අතුරුමුහුණතේ කොටසක් වන අතර Node.js පරිසරයක ක්‍රියා නොකරනු ඇත ⚠️

document.all යන්න අරාවක් වැනි වස්තුවක් ය යන්න නොසලකා, එය, පිටුවේ DOM අවයව වෙත ප්‍රවේශය සපයයි. එය typeof කෘත්‍යය ට අර්ථ විරහිත ය යන්නෙන් ප්‍රතිචාර දක්වයි.

document.all instanceof Object; // -> true
typeof document.all; // -> 'undefined'

තව ද, document.all, undefined ට සම නොවේ.

document.all === undefined; // -> false
document.all === null; // -> false

නමුත්:

document.all == null; // -> true

💡 විවරණය:

document.all, විශේෂයෙන් IE හි පැරණි මාදිලියන්හිදී, DOM අවයව වෙත ප්‍රවේශ වීමේ මාර්ගයක් ලෙස සැලකුණි. එය කිසි විටෙකත් සම්මතයක් නොවුව ද පැරණි JS කේතයේ එය පුළුල්ව භාවිත විනි. සම්මතය නව අතුරුමුහුණත් සමඟ ප්‍රගමනය වන වූ විට මෙම අතුරුමුහුණත් ඇමතුම යල්පිනූ අතර සම්මත සම්පාදන කොමිසමට එමඟින් කරන්නේ කුමක්ද යන්න තීරණය කිරීමට සිදුව තිබිණි. නමුත් එහි පුළුල් භාවිතය නිසා ඔවුන්, පිරිවිතරයට සචින්ත්‍ය උල්ලංඝනයක් එක් කරමින්, එම අතුරුමුහුණත පවත්වා ගැනීමට තීරණය කරන ලදී. දැඩි සමානතා සැසඳීමේ දී එය false ට undefined ලෙසත්, වියුක්ති සමානතා සැසඳීමේ දී true ලෙසත් ප්‍රතිචාර දැක්වීමට හේතුව පිරිවිතරයේ සචින්ත්ය උල්ලංඝනය කිරීමයි.

— “යල්පිනු විශේෂාංග - document.all” at WhatWG - HTML spec — “පරිච්ජේදය 4 - ToBoolean - අසත්‍යමය අගයන්” at YDKJS - Types & Grammar

අවම අගය, ශුන්‍යය ට වඩා විශාල ය.

Number.MIN_VALUE යනු කුඩා ම සංඛ්‍යාවයි; එය ශුන්‍යය ට වඩා විශාල ය:

Number.MIN_VALUE > 0; // -> true

💡 විවරණය:

Number.MIN_VALUE හි අගය 5e-324 වන අතර එය float හි නිරවද්‍යතාව යටතේ නිරූපණය කළ හැකි කුඩාම ධන සංඛ්‍යාවයි. එය float දත්ත වර්ගයට ලබා දිය හැකි හොඳම විභේදනය අර්ථ දක්වයි.

තදබල ලෙස සැලකීමේදී සත්‍ය වශයෙන් ම සංඛ්‍යාත්මක නොවුවත්,දැන් සමස්ත කුඩාතම අගය Number.NEGATIVE_INFINITY වේ.

— "JavaScript හි දී Number.MIN_VALUE ට වඩා ශුන්‍යය කුඩා වන්නේ මන් ද?" StackOverflow හි

20.1.2.9 Number.MIN_VALUE

කෘත්‍යය, කෘත්‍යයක් නොවේ

⚠️ V8 v5.5 හෝ පහළ (Node.js <=7) පවතින දෝෂයකි ⚠️

ඔබ සැවොම කරදරකාරී undefined is not a function දනී, නමුත් මෙය කුමක් ද?

// null දීර්ඝ කරන පන්තියක් අර්ථ දැක්වීම
class Foo extends null {}
// -> [Function: Foo]

new Foo() instanceof null;
// > TypeError: function is not a function
// >     at … … …

💡 විවරණය:

මෙය පිරිවිතරයෙහි කොටසක් නොවේ. මෙය මේ වන විට නිරාකරණය කර ඇති දෝෂයකි, එමනිසා අනාගතයේදී මෙවැනි ගැටළුවක් පැන නොනඟිනු ඇත.

අරාවන් ආකලනය

ඔබ අරාවන් දෙකක් එකතු කිරීමට තැත් කළහොත් කුමක් සිදුවනු ඇත් ද?

[1, 2, 3] + [4, 5, 6]; // -> '1,2,34,5,6'

💡 විවරණය:

සමෝච්ජය සිදුවේ. මෙය පියවරෙන් පියවර, පහත පරිදි දැක්විය හැක:

[1, 2, 3] +
  [4, 5, 6][
    //toString() කැඳවන්න
    (1, 2, 3)
  ].toString() +
  [4, 5, 6].toString();
// සමෝච්ජය
"1,2,3" + "4,5,6";
// ->
("1,2,34,5,6");

අරාවක පසුයෙදුම් කොමා

ඔබ හිස් අයිතම 4 ක අරාවක් නිර්මාණය කර ඇත. කෙසේ නමුත් පසු යෙදුම් කොමාවන් නිසා, ඔබට අවයව 3කින් සමන්විත අරාවක් ලැබෙනු ඇත:

let a = [, , ,];
a.length; // -> 3
a.toString(); // -> ',,'

💡 විවරණය:

JavaScript කේතයට නව අවයව, පරාමිතීන් හෝ ගුණාංග එක් කිරීමේදී පසුයෙදුම් කොමා ( සමහර විට අවසන් කොමා ලෙස හැඳින්වෙන) ප්‍රයෝජනවත් විය හැක. ඔබට නව ගුණයක් එක් කිරීමට අවශ්‍ය විට, කලින් අවසාන පේලිය දැනටමත් පසුයෙදුම් කොමාවක් භාවිත කරන්නේ නම්, ඔබට සරලවම එම පේලිය විකෘත කිරීමකින් තොරව නව පේළියක් එක් කළ හැක. මෙය පිටපත්-පාලන වෙනස්කම් පිරිසිදුව පවත්වා ගන්නා අතරම කේත සංස්කරණ බාධා අවම කරයි.

— පසුයෙදුම් කොමා at MDN

අරාවන් සැසඳීම යක්ෂයෙකි

ඔබ ට පහත දැකිය හැකි පරිදි, අරාවන් සැසඳීම යක්ෂයෙකි:

[] == ''   // -> true
[] == 0    // -> true
[''] == '' // -> true
[0] == 0   // -> true
[0] == ''  // -> false
[''] == 0  // -> true

[null] == ''      // true
[null] == 0       // true
[undefined] == '' // true
[undefined] == 0  // true

[[]] == 0  // true
[[]] == '' // true

[[[[[[]]]]]] == '' // true
[[[[[[]]]]]] == 0  // true

[[[[[[ null ]]]]]] == 0  // true
[[[[[[ null ]]]]]] == '' // true

[[[[[[ undefined ]]]]]] == 0  // true
[[[[[[ undefined ]]]]]] == '' // true

💡 විවරණය:

ඔබ ඉහත උදාහරණ සඳහා මහත් පරීක්ෂාවෙන් සිටිය යුතුය! මෙම හැසිරීම, පිරිවිතරයේ 7.2.13 වියුක්ත සමානතා සැසඳීම අංශයේ විස්තර කෙරේ.

`undefined` සහ `Number`

අප, Number තනන්නාට කිසිදු පරාමිතියක් යොමු නොකරයි නම්, අපට 0 ලැබේ. සත්‍ය පරාමිතීන් නොමැතිවිට නිල පරාමිතීන්ටඅර්ථ විරහිත අගය පැවරෙයි. මෙනිසා පරාමිති නොමැති Number, අර්ථ විරහිත යන්න එහි පරාමිතියේ අගය ලෙස ගනු ඇතැයි ඔබ බලාපොරොත්තු විය හැකිය. කෙසේ නමුත්, අප අර්ථ විරහිත යොමු කළ විට අපට සංඛ්‍යාවක් නොවේ යන්න ලැබේ

Number(); // -> 0
Number(undefined); // -> NaN

💡 විවරණය:

පිරිවිතරයට අනුව:

මෙම කෘත්‍යයේ ඇමතීමට කිසිදු පරාමිතියක් ලබා දී නැත්නම්, n = +0`.ලෙස ගනිමු.
නැතිනම්. n = ToNumber(value). ලෙස ගනිමු
අර්ථ විරහිත වීමක දී, ToNumber(undefined) විසින් NaN ප්‍රතිදානය කළ යුතුය.

අනුකූල අංශය පහත පරිදි වේ:

20.1.1 සංඛ්‍යා තනන්නා
7.1.3 ToNumber(argument)

`parseInt` නරක මිනිසෙකි

parseInt, එහි චරිත ලක්ෂණ නිසා ප්‍රසිද්ධය:

parseInt("f*ck"); // -> NaN
parseInt("f*ck", 16); // -> 15

💡 විවරණය: මෙය සිදුවන්නේ කුමක් නිසා ද යත්, parseInt විසින් එය නොදන්නා අක්ෂරයක් හමු වනතුරු අකුරෙන් අකුර අඛණ්ඩව විග්‍රහ කරන බැවිනි. 'f*ck' හි f යනු අගය 15 වන සොළොස්වන පාදයේ සංඛ්‍යාවයි.

අනන්තය, පූර්ණ සංඛ්‍යාවක් බවට විග්‍රහ කිරීම තරමක් වැදගත්ය

//
parseInt("Infinity", 10); // -> NaN
// ...
parseInt("Infinity", 18); // -> NaN...
parseInt("Infinity", 19); // -> 18
// ...
parseInt("Infinity", 23); // -> 18...
parseInt("Infinity", 24); // -> 151176378
// ...
parseInt("Infinity", 29); // -> 385849803
parseInt("Infinity", 30); // -> 13693557269
// ...
parseInt("Infinity", 34); // -> 28872273981
parseInt("Infinity", 35); // -> 1201203301724
parseInt("Infinity", 36); // -> 1461559270678...
parseInt("Infinity", 37); // -> NaN

null විග්‍රහ කිරීමේදී ද ප්‍රවේශම් වන්න.:

parseInt(null, 24); // -> 23

💡 විවරණය:

එය අභිශුන්‍යය, පෙළ null බවට පරිවර්තනය කිරීමට උත්සාහ කරයි. පාදම 0 සිට 23 දක්වා එයට පරිවර්තනය කළ හැකි සංඛ්‍යාවක් නොමැති නිසා එය සංඛ්‍යාවක් නොවේ යන්න ප්‍රතිදානය කරයි. 24 හිදී, 14 වනඅක්ෂරය වන n , සංඛ්‍යා පද්ධතියට එක් වේ. 31 හි දී, 21 වන අක්ෂරය වන “u ” එක් කෙරෙන අතර සම්පූර්ණ පෙළ විකේතනය කළ හැකි වේ. 37 හිදී, තවදුරටත්, ජනිත කළ හැකි වලංගු සංඛ්‍යාත්මක කුලකයක් නොමැති බැවින් සංඛ්‍යාවක් නොවේ යන්න ප්‍රතිදානය වේ.

— “parseInt(null, 24) === 23… මොකක්?” StackOverflow හි

අෂ්ටක අමතක නොකරන්න:

parseInt("06"); // 6
parseInt("08"); // 8 if support ECMAScript 5
parseInt("08"); // 0 if not support ECMAScript 5

💡 විවරණය: ප්‍රතිදාන පෙළ “0” න් ආරම්භ වේ නම් , පාදය අට (8) හෝ දහය (10) වේ. නිශ්චිතවම කුමන පාදය තොරාගැනේද යන්න ක්‍රියාකාරීත්වය මත රඳා පවතී. 10 භාවිත වන බව ECMAScript 5 මඟින් නිශ්චය කෙරෙන මුත් සියලු වෙබ් පිරික්සුම් තවම මෙයට සහය නොදක්වයි. මේ හේතුව නිසා parseInt භාවිතයේ දී සෑම විටම පාදය සඳහන් කරන්න.

parseInt සැමවිටම ප්‍රදානය පෙළ බවට හරවයි:

parseInt({ toString: () => 2, valueOf: () => 1 }); // -> 2
Number({ toString: () => 2, valueOf: () => 1 }); // -> 1

Be careful while parsing floating point values

parseInt(0.000001); // -> 0
parseInt(0.0000001); // -> 1
parseInt(1 / 1999999); // -> 5

💡 විවරණය: ParseInt විසින් පෙළ පරාමිතියක් ගෙන සඳහන් කරන ලද පාදයේ නිඛිලයක් ප්‍රතිදානය කරයි.තව ද එමඟින්, යොමු කළ පෙළ පරාමිතියේ, පළමු අංකයක් නොවන අක්ෂරය සහ ඊට පසු සියල්ල ඉවත් කරනු ලැබේ. 0.000001, "0.000001" නම් පෙළ බවට පරිවර්තනය වන අතර parseInt විසින් 0 ප්‍රතිදානය කෙරෙයි. 0.000001 පෙළ බවට හැරවූ විට එය "1e-7" ලෙස සැලකෙන අතර එහෙයින් parseInt විසින් 1 ප්‍රතිදානය කෙරෙයි. 1/1999999, 5.00000250000125e-7 ලෙස නිරූපණය කෙරෙන අතර parseInt විසින් 5 ප්‍රතිදානය කෙරේ.

Math with `true` and `false`

අපි ගණනය කිරීමක යෙදෙමු:

true +
  true(
    // -> 2
    true + true
  ) *
    (true + true) -
  true; // -> 3

හ්ම්… 🤔

💡 විවරණය:

Number තනන්නා මඟින් අපට අගයන් සංඛ්‍යා බවට පත් කළ හැකිය. true, 1 බවට හැරවෙන බව ඉතා ප්‍රත්‍යක්ෂය.:

Number(true); // -> 1

ඒකක ආකලන කාරකය, එහි අගය සංඛ්‍යාවක් බවට පත්කිරීමට උත්සාහ කරයි. එයට, නිඛිල සහ දශම සංඛ්‍යා වල පෙළ නිරූපණයන් මෙන්ම පෙළ අගයන් නොවන true, false සහ null ද පරිවර්තනය කළ හැකිය. එයට කිසියම් අගයක් පරිවර්තනය කළ නොහැකි නම්, එය Nan ලෙස නිර්ණය වේ. මෙයින් අදහස්වන්නේ අපට ඉතා පහසුවෙන් true යන්න 1 බවට හැරවිය හැකි බවයි:

+true; // -> 1

ඔබ එකතු කිරීම හෝ ගුණ කිරීම කරන විට, ToNumber විධිය ව්‍යකෘත වේ. පිරිවිතරය ට අනුව මෙම විධියෙන් ලබා දෙන්නේ:

පරාමිතිය සත්‍ය නම්, 1 ප්‍රතිදානය කරන්න. අසත්‍ය නම් +0 ප්‍රතිදානය කරන්න.

අපට සාමාන්‍ය සංඛ්‍යා පරිදි බූලියානු අගයන් ආකලනය කර නිවැරදි පිළිතුරු ලබා ගත හැක්කේ මේ නිසා ය..

අනුකූල අංශ:

12.5.6 ඒකක + කාරකය
12.8.3 ආකලන කාරකය (+)
7.1.3 ToNumber(argument)

JavaScript හි HTML ටීකාවන් වලංගු ය.

ඔබ පුදුම වනු ඇත, නමුත් <!--(HTML ටීකා ලෙස හැඳින්වෙන) යනු JavaScript හි වලංගු ටීකාවකි.

// valid comment
<!-- valid comment too

💡 විවරණය:

HTML ආකාර ටීකාවන්හි අරමුණ වූයේ <script /> ඇමුණුමට සහය නොදක්වන වෙබ් පිරික්සුම් වලට සහය වීමයි. මෙම පිරික්සුම් (උදා: Netscape 1.x ආදී) තව දුරටත් ජනප්‍රිය නොවේ. එමනිසා ඔබේ <script /> ඇමිණුම් වටා HTML ටීකාවන් යෙදීමට කිසිදු සාධාරණ හේතුවක් නැත.

V8 engine මත Node.js පදනම් වී ඇති බැවින්, Node . js විසින් ද HTML-ආකාරයේ ටීකා සඳහා සහය දක්වයි. තව ද, එය පිරිවිතරයෙහි කොටසකි:

B.1.3 HTML-ආකාරයේ ටීකාවන්

`NaN` is not a number

NaN හි වර්ගය සංඛ්‍යා වේ.:

typeof NaN; // -> 'number'

💡 විවරණය:

typeof සහ instanceof ක්‍රියා කරන ආකාරය පිළිබඳ විවරණයන්:

12.5.5 typeof කාරකය
12.10.4 Runtime Semantics: InstanceofOperator(O,C)

`[]` සහ `null` වස්තූන් ය.

typeof []; // -> 'object'
typeof null; // -> 'object'

// however
null instanceof Object; // false

💡 විවරණය:

typeof කාරකයේ හැසිරීම, පිරිවිතරයේ මෙම කොටසේ අර්ථ දැක්වේ:

12.5.5 typeof කාරකය

පිරිවිතරයට අනුව, වගුව 35: typeof කාරකයේ ප්‍රතිඵල . ට අනුකූලව typeof කාරකය විසින් පෙළ ප්‍රතිදානය කරයි. [[Call]] ක්‍රියාත්මක නොකරන අභිශුන්‍යය , සාමාන්‍ය, සම්මත විදේශීය සහ අසම්මත විදේශීය වස්තුන් සඳහා, එය “object ” පෙළ ප්‍රතිදානය කරයි.

කෙසේ නමුත්, toString විධිය භාවිතයෙන් ඔබට වස්තුවක වර්ගය පරීක්ෂා කළ හැකිය.

Object.prototype.toString.call([]);
// -> '[object Array]'

Object.prototype.toString.call(new Date());
// -> '[object Date]'

Object.prototype.toString.call(null);
// -> '[object Null]'

ඉන්ද්‍රජාලිකව වැඩිවන සංඛ්‍යා

999999999999999; // -> 999999999999999
9999999999999999; // -> 10000000000000000

10000000000000000; // -> 10000000000000000
10000000000000000 + 1; // -> 10000000000000000
10000000000000000 + 1.1; // -> 10000000000000002

💡 විවරණය:

මෙයට හේතු වන්නේ ද්විමය දශම අංක ගණිතය සඳහා වන IEEE 754-2008 සම්මතයයි. මෙම පරිමාණයේ දී, එය ළඟම ඉරට්ටේ සංඛ්‍යාවට වටයයි. වැඩිදුර කියවන්න:

Wikipedia හි 6.1.6 සංඛ්‍යා වර්ගය
IEEE 754

`0.1 + 0.2` හි නිරවද්‍යතාව

හොඳින් දන්නා විහිළුවකි. An addition of 0.1 and 0.2 is deadly precise:

0.1 +
  0.2(
    // -> 0.30000000000000004
    0.1 + 0.2
  ) ===
  0.3; // -> false

💡 විවරණය:

StackOverflow හි ”දශම සංඛ්‍යා අංක ගණිතය බිඳවැටී ද?” ප්‍රශ්නයට පිළිතුර:

ඔබේ ක්‍රමලේඛයේ 0.2 සහ 0.3, ඒවායේ සත්‍ය අගයන්ට නිමානය කිරීම් වේ. 0.2 ට සමීපම දශම සංඛ්‍යාව 0.2 ට වඩා විශාල වන අතර 0.3 ට සමීපම දශම සංඛ්‍යාව, 0.3 ට සම වේ.0.1 සහ 0.2 හි එකතුව 0.3 තාත්වික සංඛ්‍යාවට වඩා විශාල වී එය ඔබේ කේතයේ නියතයට අසමාන වේ.

මෙම ප්‍රශ්නය කෙතරම් ප්‍රසිද්ධ ද යත් 0.30000000000000004.com නමින් වෙබ් අඩවියක් පවා ඇත.එය JavaScript හි පමණක් නොව දශම සංඛ්‍යා ගණිතය භාවිත කරන සෑම භාෂාවකම ඇත

සංඛ්‍යා පූරණය

ඔබට, Number සහ String වැනි දැවටුම් වස්තූන් වලට ඔබේම විධීන් එක් කළ හැකිය.

Number.prototype.isOne = function() {
  return Number(this) === 1;
};

(1.0).isOne(); // -> true
(1).isOne(); // -> true
(2.0)
  .isOne()(
    // -> false
    7
  )
  .isOne(); // -> false

💡 විවරණය:

ප්‍රත්‍යක්ෂව ම, JavaScript හි වෙනත් ඕනෑම වස්තුවක් මෙන් ඔබට Number වස්තුව දීර්ඝ කළ හැකිය. කෙසේ නමුත්, අර්ථ දක්වන ලද විධිය, පිරිවිතරයේ කොටසක් නොවේ නම්, එය නිර්දේශ කරනු නොලැබේ.
Number' හි ගුණාංග ලැයිස්තුවක් පහත දැක්වේ.

20.1 සංඛ්‍යා වස්තූන්

සංඛ්‍යා තුනක් සැසඳීම

1 < 2 < 3; // -> true
3 > 2 > 1; // -> false

💡 විවරණය:

මෙය ඒ අයුරින් ක්‍රියා කරන්නේ මන්ද? ප්‍රශ්නය ඇත්තේ ප්‍රකාශනයක පළමු කොටසේ ය.මෙය ක්‍රියා කරන්නේ මෙසේය.

1 < 2 < 3; // 1 < 2 -> true
true < 3; // true -> 1
1 < 3; // -> true

3 > 2 > 1; // 3 > 2 -> true
true > 1; // true -> 1
1 > 1; // -> false

Greater than or equal operator (>=) මඟින් අපට මෙය සැකසිය හැකිය:

3 > 2 >= 1; // true

බන්ධුතා කාරක පිළිබඳ පිරිවිතරයෙහි වැඩිදුර කියවන්න:

12.10 බන්ධුතා කාරක

හාස්‍යජනක ගණිතය

බොහෝ විට JavaScript හි අංක ගණිතය කර්ම වල ප්‍රතිඵල අනපේක්ෂිත විය හැකිය. පහත උදාහරණ සලකන්න:

 3  - 1  // -> 2
 3  + 1  // -> 4
'3' - 1  // -> 2
'3' + 1  // -> '31'

'' + '' // -> ''
[] + [] // -> ''
{} + [] // -> 0
[] + {} // -> '[object Object]'
{} + {} // -> '[object Object][object Object]'

'222' - -'111' // -> 333

[4] * [4]       // -> 16
[] * []         // -> 0
[4, 4] * [4, 4] // NaN

💡 විවරණය:

පළමු උදාහරණ හතරෙහි සිදුවන්නේ කුමක් ද? JavaScript හි ආකලනය වටහා ගැනීම සඳහා කුඩා වගුවක් පහත දැක්වේ.:

Number  + Number  -> addition
Boolean + Number  -> addition
Boolean + Boolean -> addition
Number  + String  -> concatenation
String  + Boolean -> concatenation
String  + String  -> concatenation

අනෙකුත් උදාහරණ පිළිබඳ කවරේ ද? [] සහ {} සඳහා, ආකලනයට පෙර, ToPrimitive සහ ToString විධීන් සම්පුර්ණයෙන් අමතනු ලැබේ. පිරිවිතරයේ ඇගයීම් ක්‍රියාවලිය පිළිබඳව වැඩිදුර කියවන්න.

12.8.3 ආකලන කාරකය (+)
7.1.1 ToPrimitive(input [,PreferredType])
7.1.12 ToString(argument)

සෙවුම් ප්‍රකාශන ආකලනය

ඔබට මේ අයුරින් සං ඛ්‍යා එකතු කළ හැකි බව ඔබ දැන සිටියා ද?

// Patch a toString method
RegExp.prototype.toString =
  function() {
    return this.source;
  } /
  7 /
  -/5/; // -> 2

💡 විවරණය:

21.2.5.10 get RegExp.prototype.source

පෙළ `String` හි නිදර්ශකයක් නොවේ

"str"; // -> 'str'
typeof "str"; // -> 'string'
"str" instanceof String; // -> false

💡 විවරණය:

String තනන්නා පෙළ ප්‍රතිදානය කරයි:

typeof String("str"); // -> 'string'
String("str"); // -> 'str'
String("str") == "str"; // -> true

අපි new සමඟ උත්සාහ කරමු:

new String("str") == "str"; // -> true
typeof new String("str"); // -> 'object'

වස්තුවක්? එය කුමක් ද?

new String("str"); // -> [String: 'str']

පෙළ තනන්නා පිළිබඳ වැඩිදුර තොරතුරු පිරිවිතරයෙන්:

21.1.1 පෙළ තනන්නා

පසුලකුණු සමඟ කෘත්‍යයන් ඇමතීම

අපි, කොන්සෝලයට සියලු පරාමිතීන් සටහන් කරන කෘත්‍යයක් ප්‍රකාශ කරමු:

function f(...args) {
  return args;
}

මෙම කෘත්‍යය පහත පරිදි ඇමතිය හැකි බව ඔබ දන්නවාට සැක නැත:

f(1, 2, 3); // -> [ 1, 2, 3 ]

නමුත්, ඔබට ඕනෑම කෘත්‍යයක් පසුලකුණු සමඟ ඇමතිය හැකි බව ඔබ දැන සිටියාද?

f`true is ${true}, false is ${false}, array is ${[1, 2, 3]}`;
// -> [ [ 'true is ', ', false is ', ', array is ', '' ],
// ->   true,
// ->   false,
// ->   [ 1, 2, 3 ] ]

💡 විවරණය:

ඔබ Tagged template literals පිළිබඳ දන්නේ නම් මෙය කිසිසේත් ම ඉන්ද්‍රජාලයක් නොවේ. ඉහත උදාහරණයේ, f කෘත්‍යය , ආකෘති වචනාර්ථයක ඇමිණුමකි . ආකෘති වචනාර්ථයට පෙර ඇමිණුම්, කෘත්‍යයක් ඇසුරෙන් ආකෘති වචනාර්ථ බිඳීමට ඔබට ඉඩ දෙයි. ඇමිණුම් කෘත්‍යයක පළමු පරාමිතියේ පෙළ අගයන් සහිත අරාවක් අඩංගුය. ඉතිරි පරාමිතීන් ප්‍රකාශනවලට සම්බන්ධ වේ. උදාහරණය:

function template(strings, ...keys) {
  // do something with strings and keys…
}

React ප්‍රජාවේ ජනප්‍රිය, පිටුපස ක්‍රියාත්මක ඉන්ද්‍රජාලය famous library called 💅 styled-components, මෙයයි.

පිරිවිතරයට සබැඳිය:

12.3.7 ඇමිණු ආකෘති

අමතන්න අමතන්න අමතන්න

[@cramforce] විසින් සොයා ගන්නා ලදී(http://twitter.com/cramforce)

console.log.call.call.call.call.call.apply(a => a, [1, 2]);

💡 විවරණය:

අවධානයට, එය ඔබේ මනස බිඳිය හැකියි. මෙම කේතය ඔබේ මනසේ නැවත උත්පාදනයට උත්සාහ කරන්න: අපි apply විධිය භාවිතයෙන් call විධිය යොදමු. වැඩිදුර කියවන්න.

19.2.3.3 Function.prototype.call(thisArg, ...args)
19.2.3.1 Function.prototype.apply(thisArg, argArray)

තැනුම් ගුණාංගයක්

const c = "constructor";
c[c][c]('console.log("WTF?")')(); // > WTF?

💡 විවරණය:

අපි පියවරෙන් පියවර මෙම උදාහරණය සලකා බලමු:

// අගය පෙළ “constructor” වන ලෙස නව නියතයක් අර්ථ දැක්වීම
const c = "constructor";

// c යනු වාක්‍යයකි( පෙළ )
c; // -> 'constructor'

// Getting a constructor of string
c[c]; // -> [Function: String]

// Getting a constructor of constructor
c[c][c]; // -> [Function: Function]

// Call the Function constructor and pass
// the body of new function as an argument
c[c][c]('console.log("WTF?")'); // -> [Function: anonymous]

// And then call this anonymous function
// The result is console-logging a string 'WTF?'
c[c][c]('console.log("WTF?")')(); // > WTF?

Object.prototype.constructor විසින් නිදර්ශක වස්තුව තැනු Object තැනුම් කෘත්‍යයට යොමුවක් ප්‍රතිදානය කරයි. එය පෙළ විෂයෙහි String , සංඛ්‍යා විෂයෙහි Number ආදී වශයෙන් වේ.

Object.prototype.constructor at MDN
19.1.3.1 Object.prototype.constructor

වස්තුවක්, වස්තුවක ගුණයක යතුර ලෙස

{ [{}]: {} } // -> { '[object Object]': {} }

💡 විවරණය:

මෙය මෙලෙසින් ක්‍රියා කරන්නේ මන් ද? මෙහි අප භාවිත කරන්නේ Computed property name කි. මෙම වරහන් තුළ ඔබ වස්තුවක් යොමු කළ විට, එය එම වස්තුව පෙළ බවට හරවයි. එමනිසා අපට '[object Object]' සහ {} අගය ලැබේ.

අපට වරහන් ජාලාව මෙලෙස තැනිය හැක:

({ [{}]: { [{}]: {} } }[{}][{}]); // -> {}

// structure:
// {
//   '[object Object]': {
//     '[object Object]': {}
//   }
// }

වස්තු වචනාර්ථ පිළිබඳ මෙහි දී වැඩිදුර කියවන්න:

වස්තු අරඹන්නා at MDN
12.2.6 වස්තු අරඹන්නා

`proto` සමඟ මූලාකෘති වෙත ප්‍රවේශ වීම

අප දන්නා පරිදි, ප්‍රාථමික දත්ත වර්ග වලට මුලාකෘති නොමැත. කෙසේ වෙතත්, ප්‍රාථමික දත්ත වර්ග සඳහා __proto__ හි අගය ගැනීමට උත්සාහ කළහොත්, අපට මෙය ලැබෙනු ඇත:

(1).__proto__.__proto__.__proto__; // -> null

💡 විවරණය:

මෙසේ වීමට හේතුව නම් යමකට මූලාකෘතියක් නොමැති විට, එය ToObject මඟින් දැවටී දැවටුම් වස්තුවක් බවට පත් වීමයි. එමනිසා, පියවරෙන් පියවර:

(1)
  .__proto__(
    // -> [Number: 0]
    1
  )
  .__proto__.__proto__(
    // -> {}
    1
  ).__proto__.__proto__.__proto__; // -> null

__proto__ පිළිබඳ වැඩිදුර තොරතුරු මෙතැනින්:

B.2.2.1 Object.prototype.proto
7.1.13 ToObject(argument)

`${{Object}}`

පහත ප්‍රකාශනයේ ප්‍රතිඵලය කුමක් ද?

`${{ Object }}`;

පිළිතුර නම්:

// -> '[object Object]'

💡 විවරණය:

අපි කෙටිඅත් ගුණාංග අංකනය භාවිතයෙන් Object ගුණාංගය සහිත වස්තුවක් අර්ථ දැක්වූයෙමු:

{
  Object: Object;
}

ඉනික්බිති අපි මෙම වස්තුව ආකෘති වචනාර්ථයට යොමු කර තිබේ. එබැවින් එම වස්තුව උදෙසා toString විධිය ආමන්ත්‍රණය කෙරේ. අපට '[object Object]' පෙළ ලැබෙන්නේ මේ නිසා ය.

12.2.9 ආකෘති වචනාර්ථ
වස්තු ආරම්භ කරන්නා at MDN

පෙරනිමි අගයන් සමඟ බිඳීම

මෙම උදාහරණය සලකන්න:

let x,
  { x: y = 1 } = { x };
y;

සම්මුඛ පරීක්ෂණයක් සඳහා ඉහත උදාහරණය කදිමය. y හි අගය කුමක් ද? පිළිතුර නම්:

// -> 1

💡 විවරණය:

let x,
  { x: y = 1 } = { x };
y;
//  ↑       ↑           ↑    ↑
//  1       3           2    4

ඉහත උදාහරණයේ,

අපි අගයක් රහිතව x ප්‍රකාශ කරමු. එබැවින් එය අර්ථ විරහිතය.
ඉනික්බිති අපි x හි අගය , x වස්තු ගුණාංගය වෙත ඇසුරුම් කරමු.
ඉන්පසු, අපි විඛණ්ඩනය භාවිතයෙන් x හි අගය ලබා ගෙන y ට පැවරිය යුතු වෙමු. අගය අර්ථ දක්වා නැත්නම්, 1 පෙරනිමි අගය ලෙස භාවිත කරමු.
y හි අගය ප්‍රතිදානය කරමු.

වස්තු ආරම්භ කරන්නා at MDN

තිත් සහ ව්‍යාප්ත කිරීම

අරාවන් ව්‍යාප්තිය සමඟින් සිත් ඇදගන්නා සුළු උදාහරණ පබැඳිය හැකි ය. මෙය සලකන්න:

[...[..."..."]].length; // -> 3

💡 විවරණය:

3 ලැබෙන්නේ මන් ද? අප ව්‍යාප්ති කාරකය භාවිත කරන විට, @@iterator විධිය ආමන්ත්‍රණය කෙරෙන අතර ප්‍රතිදානය වන පුනරාවර්තනය, පුනරාවර්තනය වීමට නියමිත අගය ලබා ගැනීමට භාවිත වේ. පෙළ සඳහා පෙරනිමි පුනරාවර්තකය, පෙළ, අක්ෂර බවට ව්‍යාප්ත කරයි. ව්‍යාප්ත වීමෙන් පසු, අපි මෙම අක්ෂර අරාවකට ගොනු කර ගනිමු. ඉනික්බිති අපි මෙම අරාව නැවත ව්‍යාප්ත කොට නැවතත් අරාවකට ගොනු කර ගනිමු.

’...’ පෙළ, . අක්ෂර 3 කින් සමන්විත වේ. එමනිසා ප්‍රතිඵලය වන අරාවෙහි දිග 3 වේ.

දැන්, පියවරෙන් පියවර:

[...'...']             // -> [ '.', '.', '.' ]
[...[...'...']]        // -> [ '.', '.', '.' ]
[...[...'...']].length // -> 3

ප්‍රත්යක්ෂවම, ඕනෑම අවස්ථා ගණනකදී, අපට අරාවක අවයවයන් ව්‍යාප්ත කර දැවටිය හැකි ය:

[...'...']                 // -> [ '.', '.', '.' ]
[...[...'...']]            // -> [ '.', '.', '.' ]
[...[...[...'...']]]       // -> [ '.', '.', '.' ]
[...[...[...[...'...']]]]  // -> [ '.', '.', '.' ]
// and so on …

නම් පත්

ක්‍රමලේඛකයන් වැඩි දෙනෙක් JavaScript හි නම් පත් පිළිබඳ නොදනී. ඒවා ඉතා සිත් ගන්නා සුළු ය:

foo: {
  console.log("first");
  break foo;
  console.log("second");
}

// > first
// -> undefined

💡 විවරණය:

නම් කළ ප්‍රකාශනය break හෝ continue ප්‍රකාශ සමඟ භාවිත වේ. ඔබට චක්‍රීය දාමයක් හඳුනා ගැනීම සඳහා නම්පතක් භාවිත කළ හැක, ඉනික්බිති ව, වැඩසටහන විසින් දාමයට බාධා කළ යුතු ද, නැතහොත් දිගටම පවත්වා ගත යුතු ද යන්න, break හෝ continue ප්‍රකාශනයක් මඟින් දැක්විය හැකිය.

ඉහත උදාහරණයේ, අපි foo නමැති නම්පත හඳුනාගනිමු. එයට පසු console.log('first'); ක්‍රියාත්මක වන අතර ඉනික්බිති අප ක්‍රියාකාරීත්වයට බාධා කරමු.

JavaScriptහි නම්පත් පිළිබඳ වැඩිදුර කියවන්න:

13.13 නම්කරන ලද ප්‍රකාශ
නම්කරන ලද ප්‍රකාශන at MDN

කූඩු කළ නම්පත්

a: b: c: d: e: f: g: 1, 2, 3, 4, 5; // -> 5

💡 විවරණය:

පෙර උදාහරණ මෙන් ම, පහත සබැඳි අනුගමනය කරන්න:

12.16 කොමාව කාරකය (,)
13.13 Labelled Statements
Labeled statements at MDN

ද්‍රෝහී `try..catch`

මෙම ප්‍රකාශනය කුමක් ප්‍රතිදානය කරනු ඇත් ද? 2 හෝ 3?

(() => {
  try {
    return 2;
  } finally {
    return 3;
  }
})();

පිළිතුර 3. පුදුම වුණා ද?

💡 විවරණය:

13.15 try ප්‍රකාශය

මෙය බහු උරුමය ද?

පහත උදාහරණය බලන්න:

new class F extends (String, Array) {}(); // -> F []

ෙය බහු උරුමය ද? නැත.

💡 විවරණය:

සිත් ඇදගන්නා සුළු කොටස නම් extends වාක්‍යංශයේ ((String, Array)) කොටසයි කණ්ඩායම් කාරකය සැමවිටම එහි අවසන් පරාමිතික අගය ප්‍රතිදානය කරයි. එමනිසා, (String, Array) යනු සත්‍ය වශයෙන් ම Array වේ. එයින් අදහස් වන්නේ අප අරාව දීර්ඝ කෙරෙන පන්තියක් නිර්මාණය කර ඇති බවයි.

14.5 පන්ති අර්ථ දැක්වීම්
12.16 කොමාව කාරකය (,)

තමා විසින්ම නිපදවා ගන්නා උත්පාදකයෙක්

ස්වයං උත්පාදනයේ යෙදෙන උත්පාදකය පිළිබඳ පහත උදාහරණය සලකන්න:

(function* f() {
  yield f;
})().next();
// -> { value: [GeneratorFunction: f], done: false }

ඔබට දැකිය හැකි පරිදි, ප්‍රතිදාන අගය, එහි අගය, f ට සමාන වූ වස්තුවකි.මෙම අවස්ථාවේ දී අපට මෙවැන්නක් කළ හැකි ය:

(function* f() {
  yield f;
})()
  .next()
  .value()
  .next()(
    // -> { value: [GeneratorFunction: f], done: false }

    // සහ නැවත
    function* f() {
      yield f;
    }
  )()
  .next()
  .value()
  .next()
  .value()
  .next()(
    // -> { value: [GeneratorFunction: f], done: false }

    // සහ නැවත
    function* f() {
      yield f;
    }
  )()
  .next()
  .value()
  .next()
  .value()
  .next()
  .value()
  .next();
// -> { value: [GeneratorFunction: f], done: false }

// and so on
// …

💡 විවරණය:

මෙය මේ අයුරින් ක්‍රියා කරන්නේ මන්දැයි වටහා ගැනීම සඳහා පිරිවිතරයේ පහත අංශ කියවන්න:

25 වියුක්ති වස්තුන් පාලනය කරන්න
25.3 උත්පාදක වස්තු

පන්තියක පන්තියක්

පහත අපැහැදිලි ක්‍රමලේඛ ව්‍යාකරණය සලකන්න:

typeof new class {
  class() {}
}(); // -> 'object'

පන්තියක් තුළ පන්තියක් අර්ථ දැක්වෙන සෙයක් පෙනේ. වැරැද්දක් විය යුතු මුත් පෙළ 'object' ලැබේ.

💡 විවරණය:

ECMAScript 5 යුගයේ පටන්, keywords , property names ලෙස යෙදීමට අවසර ඇත. එබැවින්, මෙම සරල වස්තු උදාහරණය සහ :

const foo = {
  class: function() {}
};

ES6 සම්මත විධි අර්ථ දැක්වීම් ලෙසින් මෙය ගැන සිතන්න . එමෙන් ම, පන්ති අඥාත විය හැකිය. එමනිසා, : function කොටස අතහැරිය හොත් අපට මෙය ලැබේ:

class {
  class() {}
}

සාමාන්‍ය පන්තියක ප්‍රතිඵලය සැමවිටම සරල වස්තුවකි. සහ එහි typeof විසින් 'object' ප්‍රතිදානය කළ යුතුය.

මෙහි දී වැඩිදුර කියවන්න:

14.3 විධි අර්ථ දැක්වීම්
14.5 පන්ති අර්ථ දැක්වීම්

ආයාස නොකළ හැකි වස්තූන්

හොඳින් දන්නා සංකේත සමඟ, වර්ග පරිවර්තනයෙන් මිදීම සඳහා ක්‍රමයක් ඇත. මෙය බලන්න:

function nonCoercible(val) {
  if (val == null) {
    throw TypeError("nonCoercible should not be called with null or undefined");
  }

  const res = Object(val);

  res[Symbol.toPrimitive] = () => {
    throw TypeError("Trying to coerce non-coercible object");
  };

  return res;
}

දැන් අපට මෙය, මෙලෙස භාවිත කළ හැක:

// වස්තූන්
const foo = nonCoercible({ foo: "foo" });

foo * 10; // -> TypeError: Trying to coerce non-coercible object
foo + "evil"; // -> TypeError: Trying to coerce non-coercible object

// පෙළ
const bar = nonCoercible("bar");

bar + "1"; // -> TypeError: Trying to coerce non-coercible object
bar.toString() + 1; // -> bar1
bar === "bar"; // -> false
bar.toString() === "bar"; // -> true
bar == "bar"; // -> TypeError: Trying to coerce non-coercible object

// සංඛ්‍යා
const baz = nonCoercible(1);

baz == 1; // -> TypeError: Trying to coerce non-coercible object
baz === 1; // -> false
baz.valueOf() === 1; // -> true

💡 විවරණය:

A gist by Sergey Rubanov
6.1.5.1 Well-Known Symbols

උපක්‍රමශීලී ඊතල කෘත්‍යයන්

පහත උදාහරණය සලකන්න:

let f = () => 10;
f(); // -> 10

හොඳයි. නමුත් මෙය පිළිබඳව කෙසේ ද:

let f = () => {};
f(); // -> undefined

💡 විවරණය:

ඔබ undefined වෙනුවට {} බලාපොරොත්තු වූවා විය හැකි ය. මෙයට හේතුව නම්, සඟල වරහන් යනු ඊතල කෘත්‍යයන් හි ව්‍යාකරණයේ කොටසක් වීමයි. එමනිසා, f අර්ථ විරහිත යන්න ප්‍රතිදානය කරනු ඇත.කෙසේ නමුත්, ප්‍රතිදාන අගය වරහන් මඟින් වට කිරීම මඟින්, ඊතල කෘත්‍යයකින් ඍජුවම {} ප්‍රතිදානය කළ හැකිය.

let f = () => ({});
f(); // -> {}

ඊතල කෘත්‍යයන්ට තනන්නෙකු විය නොහැක

පහත උදාහරණය සලකන්න:

let f = function() {
  this.a = 1;
};
new f(); // -> { 'a': 1 }

දැන්, ඊතල කෘත්‍යයන් සමඟ එයම සිදු කිරීමට උත්සාහ කරන්න:

let f = () => {
  this.a = 1;
};
new f(); // -> TypeError: f is not a constructor

💡 විවරණය:

තැනුම් ව්‍යුහයන් ලෙස ඊතල කෘත්‍යයන් භාවිත කළ නොහැකි අතර,new සමඟ භාවිත කළ විට දෝෂයක් දක්වනු ඇත. මක් නිසා ද යත්, එය සතුව වචනාර්ථ this ඇති අතර මූලාකෘති ගුණය නොමැත. එමනිසා එය එතරම් අර්ථාන්විත නොවේ.

`arguments` සහ ඊතල කෘත්‍යයන්

පහත උදාහරණය සලකන්න:

let f = function() {
  return arguments;
};
f("a"); // -> { '0': 'a' }

දැන්, ඊතල කෘත්‍යයන් සමඟ එයම සිදු කිරීමට උත්සාහ කරන්න:

let f = () => arguments;
f("a"); // -> Uncaught ReferenceError: arguments is not defined

💡 විවරණය:

ඊතල කෘත්‍යයන් යනු ලුහුඬු බව සහ this මත අවධානය යොමු කරන, සාමාන්‍ය කෘත්‍යයන් හි සැහැල්ලු මාදිලියකි. තව ද, ඊතල කෘත්‍යයන් arguments වස්තුව සඳහා බැඳීම් නොසපයයි. වලංගු විකල්පයක් වශයෙන් එකම ප්‍රතිඵලය සඳහා rest පරාමිතිය භාවිත කරන්න.

let f = (...args) => args;
f("a");

ඊතල කෘත්‍යයන් at MDN.

උපක්‍රමශීලී ප්‍රතිදානය

ප්‍රතිදාන ප්‍රකාශය ද උපක්‍රමශීලීය. මෙය සලකන්න:

(function() {
  return
  {
    b: 10;
  }
})(); // -> undefined

💡 විවරණය:

return සහ ප්‍රතිදාන ප්‍රකාශය එකම පේළියේ තිබිය යුතුය:

(function() {
  return {
    b: 10
  };
})(); // -> { b: 10 }

මෙයට හේතුව ස්වයංක්‍රීය අර්ධ සලකුණු ඇතුළු කිරීම හෙවත් අලුත් පේළියකින් පසු ස්වයංක්‍රීය ව අර්ධ සලකුණු ඇතුලත් කිරීමයි. පළමු උදාහරණයේ ප්‍රතිදාන ප්‍රකාශය සහ වස්තු වචනාර්ථය අතරට අර්ධ සලකුණක් ඇතුළත් ව ඇත. එමනිසා කෘත්‍යය අර්ථ විරහිත ය යන්න ප්‍රතිදානය කරන අතර වස්තු වචනාර්ථය කිසි ලෙසකින් වත් නිර්ණය නොවේ.

11.9.1 ස්වයංක්‍රීය අර්ධ සලකුණු ඇතුළු කිරීම පිළිබඳ නීති
13.10 ප්‍රතිදාන ප්‍රකාශය

වස්තුවක් මත පැවරුම් බැඳීම

var foo = {n: 1};
var bar = foo;

foo.x = foo = {n: 2};

foo.x // -> undefined
foo   // -> {n: 2}
bar   // -> {n: 1, x: {n: 2}}

දකුණේ සිට වමට , foo ට {n: 2} පැවරෙන අතර, මෙම පැවරුමේ අගය වන {n: 2}, foo.x ට පැවරේ. bar , foo ට යොමු කරන නිසා, bar හි අගය {n: 1, x: {n: 2}} වේ. නමුත් foo.x අර්ථ විරහිත වෙමින් bar.x එසේ නොවන්නේ මන්ද?

💡 පවිවරණය:

Foo සහ bar, {n: 1} නම් එකම වස්තුව පරිශීලනය කරන අතර පැවරුම් වලට පෙර වම් පස අගයන් විසඳේ.foo = {n: 2} නව වස්තුවක් නිර්මාණය කරන බැවින්, එම නව වස්තුව පෙන්නුම් කිරීම සඳහා foo යාවත්කාලීන වේ. මෙහිදී සිදුවන ඉන්ද්‍රජාලය නම් foo.x = ... හි foo, වම් පස අගයක් ලෙස අකල්හි විසඳෙන අතර ම පැරණි foo = {n: 1} පෙන්නුම් කරමින් x අගය එක් කොට එය යාවත්කාලීන කිරීමයි. මෙම පැවරුම් බැඳීම් වලට පසුව, bar තවමත් පැරණි foo වස්තුව පෙන්නුම් කරන මුත්, foo , x අන්තර්ගත නොවන නව {n: 2} වස්තුව පෙන්නුම් කරයි.

එය මෙයට සමාන වේ:

var foo = {n: 1};
var bar = foo;

foo = {n: 2} // -> {n: 2}
bar.x = foo // -> {n: 1, x: {n: 2}}
// bar.x point to the address of the new foo object
// it's not equivalent to: bar.x = {n: 2}

අරාවන් සමඟ වස්තුන්හි ගුණ වෙත ප්‍රවේශ වීම

var obj = { property: 1 };
var array = ["property"];

obj[array]; // -> 1

ව්‍යාජ-බහුමාන අරාවන් පිළිබඳ කෙසේ ද?

var map = {};
var x = 1;
var y = 2;
var z = 3;

map[[x, y, z]] = true;
map[[x + 10, y, z]] = true;

map["1,2,3"]; // -> true
map["11,2,3"]; // -> true

💡 විවරණය:

කොටු වරහන් [] කාරකය, toString භාවිතයෙන්, ොමු කරන ලද ප්‍රකාශනය පරිවර්තනය කරයි. ඒක අවයව අරාවක් පෙළ බවට පරිවර්තනය කිරීම, අන්තර්ගත අවයවය පෙළ බවට පරිවර්තනය කිරීමට සමානය.

["property"].toString(); // -> 'property'

අභිශුන්‍යය සහ බන්ධුතා කාරක

null > 0; // false
null == 0; // false

null >= 0; // true

💡 විවරණය:

සැකෙවින් පවසන්නේ නම්, අභිශුන්‍යය 0 ට වඩා කුඩා බව අසත්‍ය නම්, null >= 0 සත්‍ය විය යුතුයි. මේ සඳහා වන ගැඹුරු විවරණය මෙහිදී කියවන්න.

`Number.toFixed()` වෙනස් අංක පෙන්වයි

Number.toFixed() විවිධ වෙබ් පිරික්සුම් හි දී තරමක් වෙනස් ලෙස හැසිරිය හැක. මෙම උදාහරණය බලන්න:

(0.7875).toFixed(3);
// Firefox: -> 0.787
// Chrome: -> 0.787
// IE11: -> 0.788
(0.7876).toFixed(3);
// Firefox: -> 0.788
// Chrome: -> 0.788
// IE11: -> 0.788

💡 විවරණය:

ඔබේ පළමු අදහස “IE11 නිවැරදි අතර Firefox/Chrome වැරදි ය” යන්න විය හැකි වුවත්, සත්‍යය නම්, Firefox/Chrome, සංඛ්‍යා සඳහා වන සම්මුති වලට (IEEE-754 Floating Point) වඩා ඍජුවම ගරු කරන අතර, වඩා පැහැදිලි ප්‍රතිඵලයක් ලබා දීමට දරන උත්සාහය ක දී IE11 විසින් ඒවා ට ගරු නොකරන බවයි.

මෙය ඇතිවන්නේ කෙසේද යන්න ක්ෂණික පරීක්ෂා කීපයක් මඟින් ඔබට දැකගත හැකිය:

// Confirm the odd result of rounding a 5 down
(0.7875).toFixed(3); // -> 0.787
// It looks like it's just a 5 when you expand to the
// limits of 64-bit (double-precision) float accuracy
(0.7875).toFixed(14); // -> 0.78750000000000
// But what if you go beyond the limit?
(0.7875).toFixed(20); // -> 0.78749999999999997780

දශම සංඛ්‍යා, අභ්‍යන්තරිකව තැන්පත් ව පවතින්නේ දශම සංඛ්‍යා සමූහයක් ලෙස නොව toString සහ සමාන ඇමතුම් වලින් වැටයිය හැකි දෝෂ නිපදවන, නමුත් අභ්‍යන්තරයේ නිවැරදිව ඉදිරිපත් කෙරෙන සංකීර්ණ ක්‍රියාදාමයක් මඟිනි .

මෙම අවස්ථාවේදී , අග ඇති 5, සත්‍ය වශයෙන්ම, සත්‍ය 5 ට වඩා අතිශයින් ම කුඩා භාගයකි. එය සාධාරණ දිගකට වැටයීම මඟින් 5 ලෙස දර්ශනය කෙරේ . නමුත් එය අභ්‍යන්තරිකව සත්‍ය වශයෙන් ම 5 නොවේ.

කෙසේ නමුත් ඒ IE 11, toFixed(20) අවස්ථාවේදී පවා, අවසානයට 0 එක් කරමින් පමණක් අගය වාර්තා කරයි . එය දෘඩාංග මඟින් වන දෝෂ අවම කර ගැනීම සඳහා බලයෙන් අගයන් වැටයීමක් කරන සෙයක් පෙනේ.

NOTE 2 යොමුවේ toFixed සඳහා ECMA-262 අර්ථ දැක්වීම බලන්න.

20.1.3.3 Number.prototype.toFixed (fractionDigits)

`Math.min()`ට වඩා `Math.max()` කුඩා ය

Math.min(1, 4, 7, 2); // -> 1
Math.max(1, 4, 7, 2); // -> 7
Math.min(); // -> Infinity
Math.max(); // -> -Infinity
Math.min() > Math.max(); // -> true

💡 විවරණය:

Math.min()ට වඩා Math.max() කුඩා වන්නේ මන් ද? by Charlie Harvey

`null` සහ `0` සැසඳීම

පහත ප්‍රකාශන පරස්පර විරෝධී බවක් හඳුන්වා දෙන සෙයක් පෙනේ.

null == 0; // -> false
null > 0; // -> false
null >= 0; // -> true

null >= 0, true නම්, null , 0ට සමාන හෝ 0 ට වඩා විශාල හෝ නොවන්නේ කෙසේ ද?(මෙය වඩා කුඩායි සමඟ ද මෙලෙසම ක්‍රියා කරයි)

💡 විවරණය:

මෙම ප්‍රකාශන තුන නිර්ණය වන ආකාරය එකිනෙකට වෙනස් වීම, මෙම අනපේක්ෂිත හැසිරීමට වගකිව යුතුය.

පළමුව, වියුක්ති සමානතා සැසඳීම null == 0. සාමාන්‍ය පරිදි, මෙම කාරකයට එක පසෙක හෝ අගයන් නිසි ලෙස සැසඳිය නොහැකි නම්,එය දෙපසම සංඛ්‍යා බවට හරවා සංඛ්‍යා සසඳයි. ඉනික්බිති, ඔබ පහත බලාපොරොත්තු විය හැකි ය:

// සිදුවන්නේ මෙය නොවේ
(null == 0 + null) == +0;
0 == 0;
true;

කෙසේ නමුත්, null හෝ undefined ඇති පැත්තක මෙම පරිවර්තනය සිදු නොවේ. එමනිසා, ඔබේ සමාන ලකුණෙන් එක පසෙක null ඇත්නම්, ප්‍රකාශනය සත්‍යය ප්‍රතිදානය කිරීම සඳහා, අනෙක් පස null හෝ undefined විය යුතුමය. මෙය මෙහිදී සිදු නොවන නිසා අසත්‍ය ප්‍රතිදානය වේ.

මීළඟට, null > 0 සැසඳීම යි. ඇල්ගොරිතමය, වියුක්ති සමානතා කාරකයේ දී මෙන් නොව, null යන්න සංඛ්‍යාවක් බවට හරවයි. මෙනිසා, අපට මෙම හැසිරීම ලැබේ:

null > 0
+null = +0
0 > 0
false

අවසානයේ, null >= 0 සැසඳීම යි. මෙම ප්‍රකාශනය null > 0 || null == 0 හි ප්‍රතිඵලය විය යුතු බවට ඔබට තර්ක කළ හැකිය; මෙය සත්‍ය නම්, ඉහත ප්‍රතිපල වලින් ගම්‍ය වන්නේ මෙය අසත්‍ය ද විය හැකි බවයි. කෙසේ නමුත්, ඇත්ත වශයෙන් ම >= කාරකය ක්‍රියා කරන්නේ ඉතා වෙනස් ආකාරයකිනි;කෙසේද යත් මූලිකවම < හි විරුද්ධාර්ථය ගැනීමෙනි. වඩා විශාල කාරකය යොදාගත් ඉහත උදාහරණය, වඩා කුඩා කාරකයට ද වලංගු නිසා, මෙයින් අදහස් වන්නේ මෙම ප්‍රකාශනය සත්‍ය වශයෙන් ම පහත පරිදි නිර්ණය වන බවයි:

null >= 0;
!(null < 0);
!(+null < +0);
!(0 < 0);
!false;
true;

7.2.12 වියුක්ති බන්ධුතා සැසඳීම
7.2.13 වියුක්ති සමානතා සැසඳීම

එකම විචල්‍යය ප්‍රති ප්‍රකාශ කිරීම

JS, විචල්‍ය ප්‍රති ප්‍රකාශනයට ඉඩ දෙයි:

a;
a;
// මෙයද වලංගුය
a, a;

දැඩි මාදිලියේ දී ද ක්‍රියා කරයි:

var a, a, a;
var a;
var a;

💡 විවරණය:

සියලු අර්ථ දැක්වීම් එක් අර්ථ දැක්වීමකට ඒකාබද්ධ වේ.

13.3.2 විචල්‍ය ප්‍රකාශය

සාමාන්‍ය හැසිරීම Array.prototype.sort()

ඔබට සංඛ්‍යා අරාවක් පිළිවෙළ කිරීමට අවශ්‍ය යයි සිතමු.

[ 10, 1, 3 ].sort() // -> [ 1, 10, 3 ]

💡 විවරණය:

සාමාන්‍ය පිළියෙළ කිරීම් අනුපිළිවෙල, අවයව පෙළ බවට පරිවර්තනය කොට, එම UTF-16 කේත ඒකක සැසඳීම මත තැනී ඇත.

22.1.3.25 Array.prototype.sort ( comparefn )

ඉඟිය

පෙළ හැර වෙන යමක් පිළියෙළ කිරීමේදී comparefn යොමු කරන්න.

[ 10, 1, 3 ].sort((a, b) => a - b) // -> [ 1, 3, 10 ]

📚 වෙනත් සම්පත්

wtfjs.com — ජාලයේ භාෂාව සඳහා වන, අති විශේෂ අසාමාන්‍යතාවන් , නොගැළපීම්, සහ සරලව ම වේදනාකාරී දුරවබෝධ අවස්ථා වල එකතුවකි.
Wat — CodeMash 2012 හි දී Gary Bernhardt සිදු කළ පෙරළිකාර දේශනයක්
What the... JavaScript? — JavaScriptහි වික්ෂිප්ත භාවය ඉවත් කිරීම සඳහා වන උත්සාහයන් දෙකක් ඇතුලත් Kyle Simpsons ගේ දේශනය යි. වඩා පිරිසිදු, වඩා අලංකාර, වඩාත් කියවීමට පහසු කේත ජනනයට ඔබට සහය වීමට සහ ඉනික්බිති විවෘත කේත ප්‍රජාවට දායක වීමට මිනිසුන් දිරි ගැන්වීමට ඔහුට අවශ්‍ය ය.

🎓 බලපත්‍රය

What the f*ck JavaScript?

හාස්‍යජනක සහ දුරවබෝධ JavaScript උදාහරණ

JavaScript යනු විශිෂ්ට ක්‍රමලේඛන භාෂාවකි.එයට සරල වින්‍යාසයක් සහ පුළුල් පද්ධතියක් ඇති අතර වඩාත්ම වැදගත් කරුණක් ලෙස එය සතුව විශිෂ්ට ප්‍රජාවක් සිටී.කෙසේ නමුත් JavaScript ක්‍රමලේඛන භාෂාවේ වටහා ගැනීමට දුෂ්කර කොටස් ද ඇති බව අපි සියල්ලෝම දනිමු. මෙවැනි සමහරක් කො ටස් අපගේ එදිනෙදා ක්‍රමලේඛන කාර්යයන් ඉක්මනින් මහත් අවුලට පත් කිරීමට සමත් අතර තවත් සමහරක් අපව මහා හඬින් සිනහ නැංවීමට සමත්ය.

WTFJS සඳහා මුල් අදහසේ හිමිකම Brian Leroux සතුය.මෙම ලැයිස්තුව ඔහුගේ 2012 DOTJS හි WTFJS දේශනය විසින් පොළඹවන ලද්දකි.

Node හි ඇසුරුම් කරන ලද අත්පිටපත

ඔබට මෙම අත්පොත npm හරහා ස්ථාපනය කරගත හැකිය.මේ සඳහා පහත විධානය ක්‍රියාත්මක කරන්න.

$ npm install -g wtfjs

දැන් ඔබට විධාන පෙළ හරහා wtfjs ක්‍රියාත්මක කළ හැකි විය යුතුය. මෙය තෝරාගත් $PAGER හි අත්පිටපත විවෘත කරනු ඇත. එසේ නැත්නම් ඔබට මෙහිදී නොනැවතී කියවිය හැකිය.

මූලය මෙහිදී ලබාගත හැක: https://github.com/denysdovhan/wtfjs

පරිවර්තන

දැනට wtfjs හි පහත පරිවර්තන පවතී.

中文版

නව පරිවර්තනයක් ඉල්ලන්න

පටුන

💪 දිරිගැන්වුම
✍🏻 අංකනය
👀 උදාහරණ
වෙනත් සම්පත්
🎓 බලපත්‍රය

💪 දිරිගැන්වුම

හුදෙක් විනෝදය උදෙසා

— “හුදෙක් විනෝදය උදෙසා: අහඹු විප්ලවයක කතාව”, ලීනස් ටොවාල්ඩ්ස්

මෙම ලැයිස්තුවේ මූලික අරමුණ වන්නේ උන්මාදනීය උදාහරණ එක්රැස් කිරීම සහ හැකිනම් ඒවා පැහැදිලි කිරීමයි; මක් නිසාද යත් අප මීට පෙර නොදැන සිටි දෙයක් ඉගෙනීම විනෝදජනක බැවිනි.

ඔබ ආධුනිකයකු නම් , JavaScript හි ගැඹුරට පිවිසෙන්නට මෙම සටහන් උපකාරී වනු ඇත. පිරිවිතර වැඩියෙන් කියවන්නට සහ ඒ සමඟ කල් ගෙවන්නට මෙම සටහන් ඔබට අභිප්‍රේරණයක් වනු ඇතැයි මම බලාපොරොත්තු වෙමි.

ඔබ වෘත්තීමය සංවර්ධකයෙකු නම්, ඔබට මෙම උදාහරණ අපගේ ආදරණීය JavaScript හි අනපේක්ෂිත සහ අසාමාන්‍ය අංශ පිළිබඳ යොමුවක් ලෙස සැලකිය හැක.

කවුරුන් හෝ වේවා, හුදෙක් මෙය කියවන්න. බොහෝ විට ඔබ අලුත් දෙයක් සොයා ගනු ඇත.

✍🏻 අංකනය

// -> භාවිත කෙරෙන්නේ ප්‍රකාශනයක ප්‍රතිඵලය දැක්වීමටයි. උදා:

1 + 1; // -> 2

// > මඟින් අදහස් වන්නේ console . log () හෝ වෙනත් ප්‍රතිදානයක ප්‍රතිඵලයකි. :

console.log("hello, world!"); // > hello, world!

// යනු හුදෙක් විවරණය සඳහා යොදා ගත් ටීකාවකි. උදා:

// foo නියතයට කෘත්‍යයක් පැවරීම
const foo = function() {};

👀 උදාහරණ

`[]` සහ `![]` සමානය

අරාව, නැත අරාව ට සමානය:

[] == ![]; // -> true

💡 විවරණය:

වියුක්ත සමානතා කාරකය, සැසඳීම සඳහා දෙපසම සංඛ්‍යා බවට හරවයි, මෙවිට දෙපසම වෙනස් හේතු නිසා 0 බවට පත් වේ. අරාවන් සත්‍යමය බැවින් මෙහි දකුණු පස අසත්‍ය යන්නට ද අනතුරුව 0 බවට ද පත්වේ. කෙසේ නමුත් වම් පසෙහි හිස් අරාවක් බූලියානු අගයක් බවට පත් නොවී ම සංඛ්‍යාවක් බවට පත් වේ.(සත්‍යමය වීම නොසලකා, හිස් අරාවන් 0 බවට පත් කෙරේ.)

පහත දැක්වෙන්නේ මෙම ප්‍රකාශනය සරල වන ආකාරයයි.:

+[] == +![];
0 == +false;
0 == 0;
true;

[] සත්‍යමය මුත් සත්‍ය නොවේ ද බලන්න.

12.5.9 තාර්කික නිශේධ කාරකය (!)
7.2.13 වියුක්ති සමානතා සංසන්දනය

`true`, `![]`ට සම නොවේ, නමුත් `[]` ට ද සම නොවේ.

අරාව සත්‍ය නොවන මුත් නැත අරාව ද සත්‍ය නොවේ අරාව අසත්‍ය ය, එහෙත් නැත අරාව ද අසත්‍ය ය.

true == []; // -> false
true == ![]; // -> false

false == []; // -> true
false == ![]; // -> true

💡 විවරණය:

true == []; // -> false
true == ![]; // -> false

// පිරිවිතරයට අනුව

true == []; // -> false

toNumber(true); // -> 1
toNumber([]); // -> 0

1 == 0; // -> false

true == ![]; // -> false

![]; // -> false

true == false; // -> false

false == []; // -> true
false == ![]; // -> true

// පිරිවිතරයට අනුව

false == []; // -> true

toNumber(false); // -> 0
toNumber([]); // -> 0

0 == 0; // -> true

false == ![]; // -> false

![]; // -> false

false == false; // -> true

7.2.13 වියුක්ති සමානතා සැසඳීම

සත්‍යය අසත්‍ය ය

!!"false" == !!"true"; // -> true
!!"false" === !!"true"; // -> true

💡 විවරණය:

මෙය පියවරෙන් පියවර සලකන්න:

//
true සත්‍යමය වන අතර අගය 1 මඟින් නිරූපණය වේ. පෙළ මාදිලියේදී 'true' යනු සංඛ්‍යාවක් නොවේ
true == "true"; // -> false
false == "false"; // -> false

//  ‘false’ යනු හිස් පෙළක් නොවේ, එමනිසා එය සත්‍යමය අගයකි
!!"false"; // -> true
!!"true"; // -> true

7.2.13 වියුක්ති සමානතා සැසඳීම

baNaNa

"b" + "a" + +"a" + "a"; // -> 'baNaNa'

මෙය JavaScriptහි පැරණි, එහෙත් වැඩිදියුණු කරන ලද විහිළුවකි.මුල් පිටපත පහත දැක්වේ:

"foo" + +"bar"; // -> 'fooNaN'

💡 විවරණය:

මෙම ප්‍රකාශනය 'foo' + (+'bar') ලෙස නිර්ණය වේ; 'bar', “සංඛ්‍යාවක් නොවේ( NaN )” යන්නට පරිවර්තනය වේ.

12.8.3 ආකලන කාරකය (+)
12.5.6 ඒකක + කාරකය

`NaN` යනු `NaN` නොවේ

NaN === NaN; // -> false

💡 විවරණය:

පිරිවිතරය දැඩි ලෙස ම, මෙම හැසිරීමට හේතුවන තර්කය අර්ථ දක්වයි:

Type(x) සහ Type(y) වෙනස් නම්, false ප්‍රතිදානය කරන්න.

Type(x) සංඛ්‍යාවක් නම්, එවිට,

If x, NaN නම්, false දෙන්න.

If y, NaN නම්, false දෙන්න.

… … …

— 7.2.14 දැඩි සමානතා සැසඳීම

IEEE හි NaN කාරකය පිළිබඳ අර්ථ දැක්වීම අනුගමනය කරමින්:

අන්‍යොන්‍ය වශයෙන් බහිෂ්කාර බන්ධුතා හතරක් වලංගුය: වඩා කුඩා, සමාන, වඩා විශාල, සහ අපිළිවෙළ වශයෙනි. අවම වශයෙන් එක සම්ප්‍රදානයක් හෝ සංඛ්‍යාවක් නොවන විට අවසාන අවස්ථාව උද්ගත වේ. සෑම “සංඛ්‍යාවක් නොවේ” අගයක් ම , තමා ද ඇතුළු ව, සියල්ල සමඟ අපිළිවෙල සසඳයි.

— “IEEE754 සංඛ්‍යාවක් නොවේ අගයන් සැසඳීම් සියල්ල සඳහා අසත්‍ය ප්‍රතිදානය වීමට හේතුව කුමක් ද?” at StackOverflow

එය අසාර්ථකත්වයකි

ඔබ විශ්වාස නොකරනු ඇත, නමුත් …

(![] + [])[+[]] +
  (![] + [])[+!+[]] +
  ([![]] + [][[]])[+!+[] + [+[]]] +
  (![] + [])[!+[] + !+[]];
// -> 'fail'

💡 විවරණය:

ඉහත සංකේත පෙළ කැබලිවලට කඩා ගැනීම මඟින්, පහත රටාව නිතර ඇතිවන බව අප හඳුනා ගනී:

![] + []; // -> 'false'
![]; // -> false

ඉතින් අපි false ට [] එකතු කිරීමට තැත් කරමු. නමුත් අභ්‍යන්තර කෘත්‍ය ඇමතුම් ගණනාවක් නිසා (binary + Operator -> ToPrimitive -> [[DefaultValue]]), එය, දකුණු පස පෙළ ට පරිවර්තනය කිරීමෙන් අවසන් වේ.

![] + [].toString(); // 'false'

පෙළ අරාවක් ලෙස සැලකීමෙන්, [0] මඟින් අපට එහි පළමු අක්ෂරය වෙත ප්‍රවේශ විය හැකිය:

"false"[0]; // -> 'f'

ඉතිරිය ප්‍රත්‍යක්ෂ ය., නමුත් i නොමඟ යවන සුළු ය. “fail” හි i යන්න, ['10'] ස්ථානයේ ඇති අවයවය ග්‍රහණය කිරීමෙන් සහ පෙළ 'falseundefined' උත්පාදනය වීමෙන් ග්‍රහණය කෙරෙනු ලැබේ.

`[]` සත්‍යමය නමුත් `true` නොවේ

අරාවක් යනු සත්‍යමය අගයකි, කෙසේ නමුත් එය true ට සමාන නොවේ.

!![]       // -> true
[] == true // -> false

💡 විවරණය:

ECMA-262 පිරිවිතරයෙහි අදාළ කොටස් වලට සබැඳි පහත දැක්වේ:

12.5.9 තාර්කික NOT කාරකය (!)
7.2.13 වියුක්ත සමානතා සැසඳීම

`null` අසත්‍යමය මුත් `අසත්‍ය` නොවේ

null අසත්‍යමය යන්න නොසලකා, එය false යන්නට සම නොවේ

!!null; // -> false
null == false; // -> false

කෙසේ නමුත්, 0 සහ ”” වැනි අසත්‍යමය අගයන් false ට සම වේ

0 == false; // -> true
"" == false; // -> true

💡 විවරණය:

විවරණය ඉහත උදාහරණය සඳහා පරිදි ම වේ. අදාළ සබැඳිය පහත දැක්වේ:

7.2.13 වියුක්ත සමානතා සැසඳීම

`document.all` යනු වස්තුවකි, නමුත් එය අර්ථ විරහිතය.

⚠️ මෙය පිරික්සුම් යෙදුම් ක්‍රමලේඛ අතුරුමුහුණතේ කොටසක් වන අතර Node.js පරිසරයක ක්‍රියා නොකරනු ඇත ⚠️

document.all යන්න අරාවක් වැනි වස්තුවක් ය යන්න නොසලකා, එය, පිටුවේ DOM අවයව වෙත ප්‍රවේශය සපයයි. එය typeof කෘත්‍යය ට අර්ථ විරහිත ය යන්නෙන් ප්‍රතිචාර දක්වයි.

document.all instanceof Object; // -> true
typeof document.all; // -> 'undefined'

තව ද, document.all, undefined ට සම නොවේ.

document.all === undefined; // -> false
document.all === null; // -> false

නමුත්:

document.all == null; // -> true

💡 විවරණය:

document.all, විශේෂයෙන් IE හි පැරණි මාදිලියන්හිදී, DOM අවයව වෙත ප්‍රවේශ වීමේ මාර්ගයක් ලෙස සැලකුණි. එය කිසි විටෙකත් සම්මතයක් නොවුව ද පැරණි JS කේතයේ එය පුළුල්ව භාවිත විනි. සම්මතය නව අතුරුමුහුණත් සමඟ ප්‍රගමනය වන වූ විට මෙම අතුරුමුහුණත් ඇමතුම යල්පිනූ අතර සම්මත සම්පාදන කොමිසමට එමඟින් කරන්නේ කුමක්ද යන්න තීරණය කිරීමට සිදුව තිබිණි. නමුත් එහි පුළුල් භාවිතය නිසා ඔවුන්, පිරිවිතරයට සචින්ත්‍ය උල්ලංඝනයක් එක් කරමින්, එම අතුරුමුහුණත පවත්වා ගැනීමට තීරණය කරන ලදී. දැඩි සමානතා සැසඳීමේ දී එය false ට undefined ලෙසත්, වියුක්ති සමානතා සැසඳීමේ දී true ලෙසත් ප්‍රතිචාර දැක්වීමට හේතුව පිරිවිතරයේ සචින්ත්ය උල්ලංඝනය කිරීමයි.

— “යල්පිනු විශේෂාංග - document.all” at WhatWG - HTML spec — “පරිච්ජේදය 4 - ToBoolean - අසත්‍යමය අගයන්” at YDKJS - Types & Grammar

අවම අගය, ශුන්‍යය ට වඩා විශාල ය.

Number.MIN_VALUE යනු කුඩා ම සංඛ්‍යාවයි; එය ශුන්‍යය ට වඩා විශාල ය:

Number.MIN_VALUE > 0; // -> true

💡 විවරණය:

Number.MIN_VALUE හි අගය 5e-324 වන අතර එය float හි නිරවද්‍යතාව යටතේ නිරූපණය කළ හැකි කුඩාම ධන සංඛ්‍යාවයි. එය float දත්ත වර්ගයට ලබා දිය හැකි හොඳම විභේදනය අර්ථ දක්වයි.

තදබල ලෙස සැලකීමේදී සත්‍ය වශයෙන් ම සංඛ්‍යාත්මක නොවුවත්,දැන් සමස්ත කුඩාතම අගය Number.NEGATIVE_INFINITY වේ.

— "JavaScript හි දී Number.MIN_VALUE ට වඩා ශුන්‍යය කුඩා වන්නේ මන් ද?" StackOverflow හි

20.1.2.9 Number.MIN_VALUE

කෘත්‍යය, කෘත්‍යයක් නොවේ

⚠️ V8 v5.5 හෝ පහළ (Node.js <=7) පවතින දෝෂයකි ⚠️

ඔබ සැවොම කරදරකාරී undefined is not a function දනී, නමුත් මෙය කුමක් ද?

// null දීර්ඝ කරන පන්තියක් අර්ථ දැක්වීම
class Foo extends null {}
// -> [Function: Foo]

new Foo() instanceof null;
// > TypeError: function is not a function
// >     at … … …

💡 විවරණය:

මෙය පිරිවිතරයෙහි කොටසක් නොවේ. මෙය මේ වන විට නිරාකරණය කර ඇති දෝෂයකි, එමනිසා අනාගතයේදී මෙවැනි ගැටළුවක් පැන නොනඟිනු ඇත.

අරාවන් ආකලනය

ඔබ අරාවන් දෙකක් එකතු කිරීමට තැත් කළහොත් කුමක් සිදුවනු ඇත් ද?

[1, 2, 3] + [4, 5, 6]; // -> '1,2,34,5,6'

💡 විවරණය:

සමෝච්ජය සිදුවේ. මෙය පියවරෙන් පියවර, පහත පරිදි දැක්විය හැක:

[1, 2, 3] +
  [4, 5, 6][
    //toString() කැඳවන්න
    (1, 2, 3)
  ].toString() +
  [4, 5, 6].toString();
// සමෝච්ජය
"1,2,3" + "4,5,6";
// ->
("1,2,34,5,6");

අරාවක පසුයෙදුම් කොමා

ඔබ හිස් අයිතම 4 ක අරාවක් නිර්මාණය කර ඇත. කෙසේ නමුත් පසු යෙදුම් කොමාවන් නිසා, ඔබට අවයව 3කින් සමන්විත අරාවක් ලැබෙනු ඇත:

let a = [, , ,];
a.length; // -> 3
a.toString(); // -> ',,'

💡 විවරණය:

JavaScript කේතයට නව අවයව, පරාමිතීන් හෝ ගුණාංග එක් කිරීමේදී පසුයෙදුම් කොමා ( සමහර විට අවසන් කොමා ලෙස හැඳින්වෙන) ප්‍රයෝජනවත් විය හැක. ඔබට නව ගුණයක් එක් කිරීමට අවශ්‍ය විට, කලින් අවසාන පේලිය දැනටමත් පසුයෙදුම් කොමාවක් භාවිත කරන්නේ නම්, ඔබට සරලවම එම පේලිය විකෘත කිරීමකින් තොරව නව පේළියක් එක් කළ හැක. මෙය පිටපත්-පාලන වෙනස්කම් පිරිසිදුව පවත්වා ගන්නා අතරම කේත සංස්කරණ බාධා අවම කරයි.

— පසුයෙදුම් කොමා at MDN

අරාවන් සැසඳීම යක්ෂයෙකි

ඔබ ට පහත දැකිය හැකි පරිදි, අරාවන් සැසඳීම යක්ෂයෙකි:

[] == ''   // -> true
[] == 0    // -> true
[''] == '' // -> true
[0] == 0   // -> true
[0] == ''  // -> false
[''] == 0  // -> true

[null] == ''      // true
[null] == 0       // true
[undefined] == '' // true
[undefined] == 0  // true

[[]] == 0  // true
[[]] == '' // true

[[[[[[]]]]]] == '' // true
[[[[[[]]]]]] == 0  // true

[[[[[[ null ]]]]]] == 0  // true
[[[[[[ null ]]]]]] == '' // true

[[[[[[ undefined ]]]]]] == 0  // true
[[[[[[ undefined ]]]]]] == '' // true

💡 විවරණය:

ඔබ ඉහත උදාහරණ සඳහා මහත් පරීක්ෂාවෙන් සිටිය යුතුය! මෙම හැසිරීම, පිරිවිතරයේ 7.2.13 වියුක්ත සමානතා සැසඳීම අංශයේ විස්තර කෙරේ.

`undefined` සහ `Number`

අප, Number තනන්නාට කිසිදු පරාමිතියක් යොමු නොකරයි නම්, අපට 0 ලැබේ. සත්‍ය පරාමිතීන් නොමැතිවිට නිල පරාමිතීන්ටඅර්ථ විරහිත අගය පැවරෙයි. මෙනිසා පරාමිති නොමැති Number, අර්ථ විරහිත යන්න එහි පරාමිතියේ අගය ලෙස ගනු ඇතැයි ඔබ බලාපොරොත්තු විය හැකිය. කෙසේ නමුත්, අප අර්ථ විරහිත යොමු කළ විට අපට සංඛ්‍යාවක් නොවේ යන්න ලැබේ

Number(); // -> 0
Number(undefined); // -> NaN

💡 විවරණය:

පිරිවිතරයට අනුව:

මෙම කෘත්‍යයේ ඇමතීමට කිසිදු පරාමිතියක් ලබා දී නැත්නම්, n = +0`.ලෙස ගනිමු.
නැතිනම්. n = ToNumber(value). ලෙස ගනිමු
අර්ථ විරහිත වීමක දී, ToNumber(undefined) විසින් NaN ප්‍රතිදානය කළ යුතුය.

අනුකූල අංශය පහත පරිදි වේ:

20.1.1 සංඛ්‍යා තනන්නා
7.1.3 ToNumber(argument)

`parseInt` නරක මිනිසෙකි

parseInt, එහි චරිත ලක්ෂණ නිසා ප්‍රසිද්ධය:

parseInt("f*ck"); // -> NaN
parseInt("f*ck", 16); // -> 15

💡 විවරණය: මෙය සිදුවන්නේ කුමක් නිසා ද යත්, parseInt විසින් එය නොදන්නා අක්ෂරයක් හමු වනතුරු අකුරෙන් අකුර අඛණ්ඩව විග්‍රහ කරන බැවිනි. 'f*ck' හි f යනු අගය 15 වන සොළොස්වන පාදයේ සංඛ්‍යාවයි.

අනන්තය, පූර්ණ සංඛ්‍යාවක් බවට විග්‍රහ කිරීම තරමක් වැදගත්ය

//
parseInt("Infinity", 10); // -> NaN
// ...
parseInt("Infinity", 18); // -> NaN...
parseInt("Infinity", 19); // -> 18
// ...
parseInt("Infinity", 23); // -> 18...
parseInt("Infinity", 24); // -> 151176378
// ...
parseInt("Infinity", 29); // -> 385849803
parseInt("Infinity", 30); // -> 13693557269
// ...
parseInt("Infinity", 34); // -> 28872273981
parseInt("Infinity", 35); // -> 1201203301724
parseInt("Infinity", 36); // -> 1461559270678...
parseInt("Infinity", 37); // -> NaN

null විග්‍රහ කිරීමේදී ද ප්‍රවේශම් වන්න.:

parseInt(null, 24); // -> 23

💡 විවරණය:

එය අභිශුන්‍යය, පෙළ null බවට පරිවර්තනය කිරීමට උත්සාහ කරයි. පාදම 0 සිට 23 දක්වා එයට පරිවර්තනය කළ හැකි සංඛ්‍යාවක් නොමැති නිසා එය සංඛ්‍යාවක් නොවේ යන්න ප්‍රතිදානය කරයි. 24 හිදී, 14 වනඅක්ෂරය වන n , සංඛ්‍යා පද්ධතියට එක් වේ. 31 හි දී, 21 වන අක්ෂරය වන “u ” එක් කෙරෙන අතර සම්පූර්ණ පෙළ විකේතනය කළ හැකි වේ. 37 හිදී, තවදුරටත්, ජනිත කළ හැකි වලංගු සංඛ්‍යාත්මක කුලකයක් නොමැති බැවින් සංඛ්‍යාවක් නොවේ යන්න ප්‍රතිදානය වේ.

— “parseInt(null, 24) === 23… මොකක්?” StackOverflow හි

අෂ්ටක අමතක නොකරන්න:

parseInt("06"); // 6
parseInt("08"); // 8 if support ECMAScript 5
parseInt("08"); // 0 if not support ECMAScript 5

💡 විවරණය: ප්‍රතිදාන පෙළ “0” න් ආරම්භ වේ නම් , පාදය අට (8) හෝ දහය (10) වේ. නිශ්චිතවම කුමන පාදය තොරාගැනේද යන්න ක්‍රියාකාරීත්වය මත රඳා පවතී. 10 භාවිත වන බව ECMAScript 5 මඟින් නිශ්චය කෙරෙන මුත් සියලු වෙබ් පිරික්සුම් තවම මෙයට සහය නොදක්වයි. මේ හේතුව නිසා parseInt භාවිතයේ දී සෑම විටම පාදය සඳහන් කරන්න.

parseInt සැමවිටම ප්‍රදානය පෙළ බවට හරවයි:

parseInt({ toString: () => 2, valueOf: () => 1 }); // -> 2
Number({ toString: () => 2, valueOf: () => 1 }); // -> 1

Be careful while parsing floating point values

parseInt(0.000001); // -> 0
parseInt(0.0000001); // -> 1
parseInt(1 / 1999999); // -> 5

💡 විවරණය: ParseInt විසින් පෙළ පරාමිතියක් ගෙන සඳහන් කරන ලද පාදයේ නිඛිලයක් ප්‍රතිදානය කරයි.තව ද එමඟින්, යොමු කළ පෙළ පරාමිතියේ, පළමු අංකයක් නොවන අක්ෂරය සහ ඊට පසු සියල්ල ඉවත් කරනු ලැබේ. 0.000001, "0.000001" නම් පෙළ බවට පරිවර්තනය වන අතර parseInt විසින් 0 ප්‍රතිදානය කෙරෙයි. 0.000001 පෙළ බවට හැරවූ විට එය "1e-7" ලෙස සැලකෙන අතර එහෙයින් parseInt විසින් 1 ප්‍රතිදානය කෙරෙයි. 1/1999999, 5.00000250000125e-7 ලෙස නිරූපණය කෙරෙන අතර parseInt විසින් 5 ප්‍රතිදානය කෙරේ.

Math with `true` and `false`

අපි ගණනය කිරීමක යෙදෙමු:

true +
  true(
    // -> 2
    true + true
  ) *
    (true + true) -
  true; // -> 3

හ්ම්… 🤔

💡 විවරණය:

Number තනන්නා මඟින් අපට අගයන් සංඛ්‍යා බවට පත් කළ හැකිය. true, 1 බවට හැරවෙන බව ඉතා ප්‍රත්‍යක්ෂය.:

Number(true); // -> 1

ඒකක ආකලන කාරකය, එහි අගය සංඛ්‍යාවක් බවට පත්කිරීමට උත්සාහ කරයි. එයට, නිඛිල සහ දශම සංඛ්‍යා වල පෙළ නිරූපණයන් මෙන්ම පෙළ අගයන් නොවන true, false සහ null ද පරිවර්තනය කළ හැකිය. එයට කිසියම් අගයක් පරිවර්තනය කළ නොහැකි නම්, එය Nan ලෙස නිර්ණය වේ. මෙයින් අදහස්වන්නේ අපට ඉතා පහසුවෙන් true යන්න 1 බවට හැරවිය හැකි බවයි:

+true; // -> 1

ඔබ එකතු කිරීම හෝ ගුණ කිරීම කරන විට, ToNumber විධිය ව්‍යකෘත වේ. පිරිවිතරය ට අනුව මෙම විධියෙන් ලබා දෙන්නේ:

පරාමිතිය සත්‍ය නම්, 1 ප්‍රතිදානය කරන්න. අසත්‍ය නම් +0 ප්‍රතිදානය කරන්න.

අපට සාමාන්‍ය සංඛ්‍යා පරිදි බූලියානු අගයන් ආකලනය කර නිවැරදි පිළිතුරු ලබා ගත හැක්කේ මේ නිසා ය..

අනුකූල අංශ:

12.5.6 ඒකක + කාරකය
12.8.3 ආකලන කාරකය (+)
7.1.3 ToNumber(argument)

JavaScript හි HTML ටීකාවන් වලංගු ය.

ඔබ පුදුම වනු ඇත, නමුත් <!--(HTML ටීකා ලෙස හැඳින්වෙන) යනු JavaScript හි වලංගු ටීකාවකි.

// valid comment
<!-- valid comment too

💡 විවරණය:

HTML ආකාර ටීකාවන්හි අරමුණ වූයේ <script /> ඇමුණුමට සහය නොදක්වන වෙබ් පිරික්සුම් වලට සහය වීමයි. මෙම පිරික්සුම් (උදා: Netscape 1.x ආදී) තව දුරටත් ජනප්‍රිය නොවේ. එමනිසා ඔබේ <script /> ඇමිණුම් වටා HTML ටීකාවන් යෙදීමට කිසිදු සාධාරණ හේතුවක් නැත.

V8 engine මත Node.js පදනම් වී ඇති බැවින්, Node . js විසින් ද HTML-ආකාරයේ ටීකා සඳහා සහය දක්වයි. තව ද, එය පිරිවිතරයෙහි කොටසකි:

B.1.3 HTML-ආකාරයේ ටීකාවන්

`NaN` is not a number

NaN හි වර්ගය සංඛ්‍යා වේ.:

typeof NaN; // -> 'number'

💡 විවරණය:

typeof සහ instanceof ක්‍රියා කරන ආකාරය පිළිබඳ විවරණයන්:

12.5.5 typeof කාරකය
12.10.4 Runtime Semantics: InstanceofOperator(O,C)

`[]` සහ `null` වස්තූන් ය.

typeof []; // -> 'object'
typeof null; // -> 'object'

// however
null instanceof Object; // false

💡 විවරණය:

typeof කාරකයේ හැසිරීම, පිරිවිතරයේ මෙම කොටසේ අර්ථ දැක්වේ:

12.5.5 typeof කාරකය

පිරිවිතරයට අනුව, වගුව 35: typeof කාරකයේ ප්‍රතිඵල . ට අනුකූලව typeof කාරකය විසින් පෙළ ප්‍රතිදානය කරයි. [[Call]] ක්‍රියාත්මක නොකරන අභිශුන්‍යය , සාමාන්‍ය, සම්මත විදේශීය සහ අසම්මත විදේශීය වස්තුන් සඳහා, එය “object ” පෙළ ප්‍රතිදානය කරයි.

කෙසේ නමුත්, toString විධිය භාවිතයෙන් ඔබට වස්තුවක වර්ගය පරීක්ෂා කළ හැකිය.

Object.prototype.toString.call([]);
// -> '[object Array]'

Object.prototype.toString.call(new Date());
// -> '[object Date]'

Object.prototype.toString.call(null);
// -> '[object Null]'

ඉන්ද්‍රජාලිකව වැඩිවන සංඛ්‍යා

999999999999999; // -> 999999999999999
9999999999999999; // -> 10000000000000000

10000000000000000; // -> 10000000000000000
10000000000000000 + 1; // -> 10000000000000000
10000000000000000 + 1.1; // -> 10000000000000002

💡 විවරණය:

මෙයට හේතු වන්නේ ද්විමය දශම අංක ගණිතය සඳහා වන IEEE 754-2008 සම්මතයයි. මෙම පරිමාණයේ දී, එය ළඟම ඉරට්ටේ සංඛ්‍යාවට වටයයි. වැඩිදුර කියවන්න:

Wikipedia හි 6.1.6 සංඛ්‍යා වර්ගය
IEEE 754

`0.1 + 0.2` හි නිරවද්‍යතාව

හොඳින් දන්නා විහිළුවකි. An addition of 0.1 and 0.2 is deadly precise:

0.1 +
  0.2(
    // -> 0.30000000000000004
    0.1 + 0.2
  ) ===
  0.3; // -> false

💡 විවරණය:

StackOverflow හි ”දශම සංඛ්‍යා අංක ගණිතය බිඳවැටී ද?” ප්‍රශ්නයට පිළිතුර:

ඔබේ ක්‍රමලේඛයේ 0.2 සහ 0.3, ඒවායේ සත්‍ය අගයන්ට නිමානය කිරීම් වේ. 0.2 ට සමීපම දශම සංඛ්‍යාව 0.2 ට වඩා විශාල වන අතර 0.3 ට සමීපම දශම සංඛ්‍යාව, 0.3 ට සම වේ.0.1 සහ 0.2 හි එකතුව 0.3 තාත්වික සංඛ්‍යාවට වඩා විශාල වී එය ඔබේ කේතයේ නියතයට අසමාන වේ.

මෙම ප්‍රශ්නය කෙතරම් ප්‍රසිද්ධ ද යත් 0.30000000000000004.com නමින් වෙබ් අඩවියක් පවා ඇත.එය JavaScript හි පමණක් නොව දශම සංඛ්‍යා ගණිතය භාවිත කරන සෑම භාෂාවකම ඇත

සංඛ්‍යා පූරණය

ඔබට, Number සහ String වැනි දැවටුම් වස්තූන් වලට ඔබේම විධීන් එක් කළ හැකිය.

Number.prototype.isOne = function() {
  return Number(this) === 1;
};

(1.0).isOne(); // -> true
(1).isOne(); // -> true
(2.0)
  .isOne()(
    // -> false
    7
  )
  .isOne(); // -> false

💡 විවරණය:

ප්‍රත්‍යක්ෂව ම, JavaScript හි වෙනත් ඕනෑම වස්තුවක් මෙන් ඔබට Number වස්තුව දීර්ඝ කළ හැකිය. කෙසේ නමුත්, අර්ථ දක්වන ලද විධිය, පිරිවිතරයේ කොටසක් නොවේ නම්, එය නිර්දේශ කරනු නොලැබේ.
Number' හි ගුණාංග ලැයිස්තුවක් පහත දැක්වේ.

20.1 සංඛ්‍යා වස්තූන්

සංඛ්‍යා තුනක් සැසඳීම

1 < 2 < 3; // -> true
3 > 2 > 1; // -> false

💡 විවරණය:

මෙය ඒ අයුරින් ක්‍රියා කරන්නේ මන්ද? ප්‍රශ්නය ඇත්තේ ප්‍රකාශනයක පළමු කොටසේ ය.මෙය ක්‍රියා කරන්නේ මෙසේය.

1 < 2 < 3; // 1 < 2 -> true
true < 3; // true -> 1
1 < 3; // -> true

3 > 2 > 1; // 3 > 2 -> true
true > 1; // true -> 1
1 > 1; // -> false

Greater than or equal operator (>=) මඟින් අපට මෙය සැකසිය හැකිය:

3 > 2 >= 1; // true

බන්ධුතා කාරක පිළිබඳ පිරිවිතරයෙහි වැඩිදුර කියවන්න:

12.10 බන්ධුතා කාරක

හාස්‍යජනක ගණිතය

බොහෝ විට JavaScript හි අංක ගණිතය කර්ම වල ප්‍රතිඵල අනපේක්ෂිත විය හැකිය. පහත උදාහරණ සලකන්න:

 3  - 1  // -> 2
 3  + 1  // -> 4
'3' - 1  // -> 2
'3' + 1  // -> '31'

'' + '' // -> ''
[] + [] // -> ''
{} + [] // -> 0
[] + {} // -> '[object Object]'
{} + {} // -> '[object Object][object Object]'

'222' - -'111' // -> 333

[4] * [4]       // -> 16
[] * []         // -> 0
[4, 4] * [4, 4] // NaN

💡 විවරණය:

පළමු උදාහරණ හතරෙහි සිදුවන්නේ කුමක් ද? JavaScript හි ආකලනය වටහා ගැනීම සඳහා කුඩා වගුවක් පහත දැක්වේ.:

Number  + Number  -> addition
Boolean + Number  -> addition
Boolean + Boolean -> addition
Number  + String  -> concatenation
String  + Boolean -> concatenation
String  + String  -> concatenation

අනෙකුත් උදාහරණ පිළිබඳ කවරේ ද? [] සහ {} සඳහා, ආකලනයට පෙර, ToPrimitive සහ ToString විධීන් සම්පුර්ණයෙන් අමතනු ලැබේ. පිරිවිතරයේ ඇගයීම් ක්‍රියාවලිය පිළිබඳව වැඩිදුර කියවන්න.

12.8.3 ආකලන කාරකය (+)
7.1.1 ToPrimitive(input [,PreferredType])
7.1.12 ToString(argument)

සෙවුම් ප්‍රකාශන ආකලනය

ඔබට මේ අයුරින් සං ඛ්‍යා එකතු කළ හැකි බව ඔබ දැන සිටියා ද?

// Patch a toString method
RegExp.prototype.toString =
  function() {
    return this.source;
  } /
  7 /
  -/5/; // -> 2

💡 විවරණය:

21.2.5.10 get RegExp.prototype.source

පෙළ `String` හි නිදර්ශකයක් නොවේ

"str"; // -> 'str'
typeof "str"; // -> 'string'
"str" instanceof String; // -> false

💡 විවරණය:

String තනන්නා පෙළ ප්‍රතිදානය කරයි:

typeof String("str"); // -> 'string'
String("str"); // -> 'str'
String("str") == "str"; // -> true

අපි new සමඟ උත්සාහ කරමු:

new String("str") == "str"; // -> true
typeof new String("str"); // -> 'object'

වස්තුවක්? එය කුමක් ද?

new String("str"); // -> [String: 'str']

පෙළ තනන්නා පිළිබඳ වැඩිදුර තොරතුරු පිරිවිතරයෙන්:

21.1.1 පෙළ තනන්නා

පසුලකුණු සමඟ කෘත්‍යයන් ඇමතීම

අපි, කොන්සෝලයට සියලු පරාමිතීන් සටහන් කරන කෘත්‍යයක් ප්‍රකාශ කරමු:

function f(...args) {
  return args;
}

මෙම කෘත්‍යය පහත පරිදි ඇමතිය හැකි බව ඔබ දන්නවාට සැක නැත:

f(1, 2, 3); // -> [ 1, 2, 3 ]

නමුත්, ඔබට ඕනෑම කෘත්‍යයක් පසුලකුණු සමඟ ඇමතිය හැකි බව ඔබ දැන සිටියාද?

f`true is ${true}, false is ${false}, array is ${[1, 2, 3]}`;
// -> [ [ 'true is ', ', false is ', ', array is ', '' ],
// ->   true,
// ->   false,
// ->   [ 1, 2, 3 ] ]

💡 විවරණය:

ඔබ Tagged template literals පිළිබඳ දන්නේ නම් මෙය කිසිසේත් ම ඉන්ද්‍රජාලයක් නොවේ. ඉහත උදාහරණයේ, f කෘත්‍යය , ආකෘති වචනාර්ථයක ඇමිණුමකි . ආකෘති වචනාර්ථයට පෙර ඇමිණුම්, කෘත්‍යයක් ඇසුරෙන් ආකෘති වචනාර්ථ බිඳීමට ඔබට ඉඩ දෙයි. ඇමිණුම් කෘත්‍යයක පළමු පරාමිතියේ පෙළ අගයන් සහිත අරාවක් අඩංගුය. ඉතිරි පරාමිතීන් ප්‍රකාශනවලට සම්බන්ධ වේ. උදාහරණය:

function template(strings, ...keys) {
  // do something with strings and keys…
}

React ප්‍රජාවේ ජනප්‍රිය, පිටුපස ක්‍රියාත්මක ඉන්ද්‍රජාලය famous library called 💅 styled-components, මෙයයි.

පිරිවිතරයට සබැඳිය:

12.3.7 ඇමිණු ආකෘති

අමතන්න අමතන්න අමතන්න

[@cramforce] විසින් සොයා ගන්නා ලදී(http://twitter.com/cramforce)

console.log.call.call.call.call.call.apply(a => a, [1, 2]);

💡 විවරණය:

අවධානයට, එය ඔබේ මනස බිඳිය හැකියි. මෙම කේතය ඔබේ මනසේ නැවත උත්පාදනයට උත්සාහ කරන්න: අපි apply විධිය භාවිතයෙන් call විධිය යොදමු. වැඩිදුර කියවන්න.

19.2.3.3 Function.prototype.call(thisArg, ...args)
19.2.3.1 Function.prototype.apply(thisArg, argArray)

තැනුම් ගුණාංගයක්

const c = "constructor";
c[c][c]('console.log("WTF?")')(); // > WTF?

💡 විවරණය:

අපි පියවරෙන් පියවර මෙම උදාහරණය සලකා බලමු:

// අගය පෙළ “constructor” වන ලෙස නව නියතයක් අර්ථ දැක්වීම
const c = "constructor";

// c යනු වාක්‍යයකි( පෙළ )
c; // -> 'constructor'

// Getting a constructor of string
c[c]; // -> [Function: String]

// Getting a constructor of constructor
c[c][c]; // -> [Function: Function]

// Call the Function constructor and pass
// the body of new function as an argument
c[c][c]('console.log("WTF?")'); // -> [Function: anonymous]

// And then call this anonymous function
// The result is console-logging a string 'WTF?'
c[c][c]('console.log("WTF?")')(); // > WTF?

Object.prototype.constructor විසින් නිදර්ශක වස්තුව තැනු Object තැනුම් කෘත්‍යයට යොමුවක් ප්‍රතිදානය කරයි. එය පෙළ විෂයෙහි String , සංඛ්‍යා විෂයෙහි Number ආදී වශයෙන් වේ.

Object.prototype.constructor at MDN
19.1.3.1 Object.prototype.constructor

වස්තුවක්, වස්තුවක ගුණයක යතුර ලෙස

{ [{}]: {} } // -> { '[object Object]': {} }

💡 විවරණය:

මෙය මෙලෙසින් ක්‍රියා කරන්නේ මන් ද? මෙහි අප භාවිත කරන්නේ Computed property name කි. මෙම වරහන් තුළ ඔබ වස්තුවක් යොමු කළ විට, එය එම වස්තුව පෙළ බවට හරවයි. එමනිසා අපට '[object Object]' සහ {} අගය ලැබේ.

අපට වරහන් ජාලාව මෙලෙස තැනිය හැක:

({ [{}]: { [{}]: {} } }[{}][{}]); // -> {}

// structure:
// {
//   '[object Object]': {
//     '[object Object]': {}
//   }
// }

වස්තු වචනාර්ථ පිළිබඳ මෙහි දී වැඩිදුර කියවන්න:

වස්තු අරඹන්නා at MDN
12.2.6 වස්තු අරඹන්නා

`proto` සමඟ මූලාකෘති වෙත ප්‍රවේශ වීම

අප දන්නා පරිදි, ප්‍රාථමික දත්ත වර්ග වලට මුලාකෘති නොමැත. කෙසේ වෙතත්, ප්‍රාථමික දත්ත වර්ග සඳහා __proto__ හි අගය ගැනීමට උත්සාහ කළහොත්, අපට මෙය ලැබෙනු ඇත:

(1).__proto__.__proto__.__proto__; // -> null

💡 විවරණය:

මෙසේ වීමට හේතුව නම් යමකට මූලාකෘතියක් නොමැති විට, එය ToObject මඟින් දැවටී දැවටුම් වස්තුවක් බවට පත් වීමයි. එමනිසා, පියවරෙන් පියවර:

(1)
  .__proto__(
    // -> [Number: 0]
    1
  )
  .__proto__.__proto__(
    // -> {}
    1
  ).__proto__.__proto__.__proto__; // -> null

__proto__ පිළිබඳ වැඩිදුර තොරතුරු මෙතැනින්:

B.2.2.1 Object.prototype.proto
7.1.13 ToObject(argument)

`${{Object}}`

පහත ප්‍රකාශනයේ ප්‍රතිඵලය කුමක් ද?

`${{ Object }}`;

පිළිතුර නම්:

// -> '[object Object]'

💡 විවරණය:

අපි කෙටිඅත් ගුණාංග අංකනය භාවිතයෙන් Object ගුණාංගය සහිත වස්තුවක් අර්ථ දැක්වූයෙමු:

{
  Object: Object;
}

ඉනික්බිති අපි මෙම වස්තුව ආකෘති වචනාර්ථයට යොමු කර තිබේ. එබැවින් එම වස්තුව උදෙසා toString විධිය ආමන්ත්‍රණය කෙරේ. අපට '[object Object]' පෙළ ලැබෙන්නේ මේ නිසා ය.

12.2.9 ආකෘති වචනාර්ථ
වස්තු ආරම්භ කරන්නා at MDN

පෙරනිමි අගයන් සමඟ බිඳීම

මෙම උදාහරණය සලකන්න:

let x,
  { x: y = 1 } = { x };
y;

සම්මුඛ පරීක්ෂණයක් සඳහා ඉහත උදාහරණය කදිමය. y හි අගය කුමක් ද? පිළිතුර නම්:

// -> 1

💡 විවරණය:

let x,
  { x: y = 1 } = { x };
y;
//  ↑       ↑           ↑    ↑
//  1       3           2    4

ඉහත උදාහරණයේ,

අපි අගයක් රහිතව x ප්‍රකාශ කරමු. එබැවින් එය අර්ථ විරහිතය.
ඉනික්බිති අපි x හි අගය , x වස්තු ගුණාංගය වෙත ඇසුරුම් කරමු.
ඉන්පසු, අපි විඛණ්ඩනය භාවිතයෙන් x හි අගය ලබා ගෙන y ට පැවරිය යුතු වෙමු. අගය අර්ථ දක්වා නැත්නම්, 1 පෙරනිමි අගය ලෙස භාවිත කරමු.
y හි අගය ප්‍රතිදානය කරමු.

වස්තු ආරම්භ කරන්නා at MDN

තිත් සහ ව්‍යාප්ත කිරීම

අරාවන් ව්‍යාප්තිය සමඟින් සිත් ඇදගන්නා සුළු උදාහරණ පබැඳිය හැකි ය. මෙය සලකන්න:

[...[..."..."]].length; // -> 3

💡 විවරණය:

3 ලැබෙන්නේ මන් ද? අප ව්‍යාප්ති කාරකය භාවිත කරන විට, @@iterator විධිය ආමන්ත්‍රණය කෙරෙන අතර ප්‍රතිදානය වන පුනරාවර්තනය, පුනරාවර්තනය වීමට නියමිත අගය ලබා ගැනීමට භාවිත වේ. පෙළ සඳහා පෙරනිමි පුනරාවර්තකය, පෙළ, අක්ෂර බවට ව්‍යාප්ත කරයි. ව්‍යාප්ත වීමෙන් පසු, අපි මෙම අක්ෂර අරාවකට ගොනු කර ගනිමු. ඉනික්බිති අපි මෙම අරාව නැවත ව්‍යාප්ත කොට නැවතත් අරාවකට ගොනු කර ගනිමු.

’...’ පෙළ, . අක්ෂර 3 කින් සමන්විත වේ. එමනිසා ප්‍රතිඵලය වන අරාවෙහි දිග 3 වේ.

දැන්, පියවරෙන් පියවර:

[...'...']             // -> [ '.', '.', '.' ]
[...[...'...']]        // -> [ '.', '.', '.' ]
[...[...'...']].length // -> 3

ප්‍රත්යක්ෂවම, ඕනෑම අවස්ථා ගණනකදී, අපට අරාවක අවයවයන් ව්‍යාප්ත කර දැවටිය හැකි ය:

[...'...']                 // -> [ '.', '.', '.' ]
[...[...'...']]            // -> [ '.', '.', '.' ]
[...[...[...'...']]]       // -> [ '.', '.', '.' ]
[...[...[...[...'...']]]]  // -> [ '.', '.', '.' ]
// and so on …

නම් පත්

ක්‍රමලේඛකයන් වැඩි දෙනෙක් JavaScript හි නම් පත් පිළිබඳ නොදනී. ඒවා ඉතා සිත් ගන්නා සුළු ය:

foo: {
  console.log("first");
  break foo;
  console.log("second");
}

// > first
// -> undefined

💡 විවරණය:

නම් කළ ප්‍රකාශනය break හෝ continue ප්‍රකාශ සමඟ භාවිත වේ. ඔබට චක්‍රීය දාමයක් හඳුනා ගැනීම සඳහා නම්පතක් භාවිත කළ හැක, ඉනික්බිති ව, වැඩසටහන විසින් දාමයට බාධා කළ යුතු ද, නැතහොත් දිගටම පවත්වා ගත යුතු ද යන්න, break හෝ continue ප්‍රකාශනයක් මඟින් දැක්විය හැකිය.

ඉහත උදාහරණයේ, අපි foo නමැති නම්පත හඳුනාගනිමු. එයට පසු console.log('first'); ක්‍රියාත්මක වන අතර ඉනික්බිති අප ක්‍රියාකාරීත්වයට බාධා කරමු.

JavaScriptහි නම්පත් පිළිබඳ වැඩිදුර කියවන්න:

13.13 නම්කරන ලද ප්‍රකාශ
නම්කරන ලද ප්‍රකාශන at MDN

කූඩු කළ නම්පත්

a: b: c: d: e: f: g: 1, 2, 3, 4, 5; // -> 5

💡 විවරණය:

පෙර උදාහරණ මෙන් ම, පහත සබැඳි අනුගමනය කරන්න:

12.16 කොමාව කාරකය (,)
13.13 Labelled Statements
Labeled statements at MDN

ද්‍රෝහී `try..catch`

මෙම ප්‍රකාශනය කුමක් ප්‍රතිදානය කරනු ඇත් ද? 2 හෝ 3?

(() => {
  try {
    return 2;
  } finally {
    return 3;
  }
})();

පිළිතුර 3. පුදුම වුණා ද?

💡 විවරණය:

13.15 try ප්‍රකාශය

මෙය බහු උරුමය ද?

පහත උදාහරණය බලන්න:

new class F extends (String, Array) {}(); // -> F []

ෙය බහු උරුමය ද? නැත.

💡 විවරණය:

සිත් ඇදගන්නා සුළු කොටස නම් extends වාක්‍යංශයේ ((String, Array)) කොටසයි කණ්ඩායම් කාරකය සැමවිටම එහි අවසන් පරාමිතික අගය ප්‍රතිදානය කරයි. එමනිසා, (String, Array) යනු සත්‍ය වශයෙන් ම Array වේ. එයින් අදහස් වන්නේ අප අරාව දීර්ඝ කෙරෙන පන්තියක් නිර්මාණය කර ඇති බවයි.

14.5 පන්ති අර්ථ දැක්වීම්
12.16 කොමාව කාරකය (,)

තමා විසින්ම නිපදවා ගන්නා උත්පාදකයෙක්

ස්වයං උත්පාදනයේ යෙදෙන උත්පාදකය පිළිබඳ පහත උදාහරණය සලකන්න:

(function* f() {
  yield f;
})().next();
// -> { value: [GeneratorFunction: f], done: false }

ඔබට දැකිය හැකි පරිදි, ප්‍රතිදාන අගය, එහි අගය, f ට සමාන වූ වස්තුවකි.මෙම අවස්ථාවේ දී අපට මෙවැන්නක් කළ හැකි ය:

(function* f() {
  yield f;
})()
  .next()
  .value()
  .next()(
    // -> { value: [GeneratorFunction: f], done: false }

    // සහ නැවත
    function* f() {
      yield f;
    }
  )()
  .next()
  .value()
  .next()
  .value()
  .next()(
    // -> { value: [GeneratorFunction: f], done: false }

    // සහ නැවත
    function* f() {
      yield f;
    }
  )()
  .next()
  .value()
  .next()
  .value()
  .next()
  .value()
  .next();
// -> { value: [GeneratorFunction: f], done: false }

// and so on
// …

💡 විවරණය:

මෙය මේ අයුරින් ක්‍රියා කරන්නේ මන්දැයි වටහා ගැනීම සඳහා පිරිවිතරයේ පහත අංශ කියවන්න:

25 වියුක්ති වස්තුන් පාලනය කරන්න
25.3 උත්පාදක වස්තු

පන්තියක පන්තියක්

පහත අපැහැදිලි ක්‍රමලේඛ ව්‍යාකරණය සලකන්න:

typeof new class {
  class() {}
}(); // -> 'object'

පන්තියක් තුළ පන්තියක් අර්ථ දැක්වෙන සෙයක් පෙනේ. වැරැද්දක් විය යුතු මුත් පෙළ 'object' ලැබේ.

💡 විවරණය:

ECMAScript 5 යුගයේ පටන්, keywords , property names ලෙස යෙදීමට අවසර ඇත. එබැවින්, මෙම සරල වස්තු උදාහරණය සහ :

const foo = {
  class: function() {}
};

ES6 සම්මත විධි අර්ථ දැක්වීම් ලෙසින් මෙය ගැන සිතන්න . එමෙන් ම, පන්ති අඥාත විය හැකිය. එමනිසා, : function කොටස අතහැරිය හොත් අපට මෙය ලැබේ:

class {
  class() {}
}

සාමාන්‍ය පන්තියක ප්‍රතිඵලය සැමවිටම සරල වස්තුවකි. සහ එහි typeof විසින් 'object' ප්‍රතිදානය කළ යුතුය.

මෙහි දී වැඩිදුර කියවන්න:

14.3 විධි අර්ථ දැක්වීම්
14.5 පන්ති අර්ථ දැක්වීම්

ආයාස නොකළ හැකි වස්තූන්

හොඳින් දන්නා සංකේත සමඟ, වර්ග පරිවර්තනයෙන් මිදීම සඳහා ක්‍රමයක් ඇත. මෙය බලන්න:

function nonCoercible(val) {
  if (val == null) {
    throw TypeError("nonCoercible should not be called with null or undefined");
  }

  const res = Object(val);

  res[Symbol.toPrimitive] = () => {
    throw TypeError("Trying to coerce non-coercible object");
  };

  return res;
}

දැන් අපට මෙය, මෙලෙස භාවිත කළ හැක:

// වස්තූන්
const foo = nonCoercible({ foo: "foo" });

foo * 10; // -> TypeError: Trying to coerce non-coercible object
foo + "evil"; // -> TypeError: Trying to coerce non-coercible object

// පෙළ
const bar = nonCoercible("bar");

bar + "1"; // -> TypeError: Trying to coerce non-coercible object
bar.toString() + 1; // -> bar1
bar === "bar"; // -> false
bar.toString() === "bar"; // -> true
bar == "bar"; // -> TypeError: Trying to coerce non-coercible object

// සංඛ්‍යා
const baz = nonCoercible(1);

baz == 1; // -> TypeError: Trying to coerce non-coercible object
baz === 1; // -> false
baz.valueOf() === 1; // -> true

💡 විවරණය:

A gist by Sergey Rubanov
6.1.5.1 Well-Known Symbols

උපක්‍රමශීලී ඊතල කෘත්‍යයන්

පහත උදාහරණය සලකන්න:

let f = () => 10;
f(); // -> 10

හොඳයි. නමුත් මෙය පිළිබඳව කෙසේ ද:

let f = () => {};
f(); // -> undefined

💡 විවරණය:

ඔබ undefined වෙනුවට {} බලාපොරොත්තු වූවා විය හැකි ය. මෙයට හේතුව නම්, සඟල වරහන් යනු ඊතල කෘත්‍යයන් හි ව්‍යාකරණයේ කොටසක් වීමයි. එමනිසා, f අර්ථ විරහිත යන්න ප්‍රතිදානය කරනු ඇත.කෙසේ නමුත්, ප්‍රතිදාන අගය වරහන් මඟින් වට කිරීම මඟින්, ඊතල කෘත්‍යයකින් ඍජුවම {} ප්‍රතිදානය කළ හැකිය.

let f = () => ({});
f(); // -> {}

ඊතල කෘත්‍යයන්ට තනන්නෙකු විය නොහැක

පහත උදාහරණය සලකන්න:

let f = function() {
  this.a = 1;
};
new f(); // -> { 'a': 1 }

දැන්, ඊතල කෘත්‍යයන් සමඟ එයම සිදු කිරීමට උත්සාහ කරන්න:

let f = () => {
  this.a = 1;
};
new f(); // -> TypeError: f is not a constructor

💡 විවරණය:

තැනුම් ව්‍යුහයන් ලෙස ඊතල කෘත්‍යයන් භාවිත කළ නොහැකි අතර,new සමඟ භාවිත කළ විට දෝෂයක් දක්වනු ඇත. මක් නිසා ද යත්, එය සතුව වචනාර්ථ this ඇති අතර මූලාකෘති ගුණය නොමැත. එමනිසා එය එතරම් අර්ථාන්විත නොවේ.

`arguments` සහ ඊතල කෘත්‍යයන්

පහත උදාහරණය සලකන්න:

let f = function() {
  return arguments;
};
f("a"); // -> { '0': 'a' }

දැන්, ඊතල කෘත්‍යයන් සමඟ එයම සිදු කිරීමට උත්සාහ කරන්න:

let f = () => arguments;
f("a"); // -> Uncaught ReferenceError: arguments is not defined

💡 විවරණය:

ඊතල කෘත්‍යයන් යනු ලුහුඬු බව සහ this මත අවධානය යොමු කරන, සාමාන්‍ය කෘත්‍යයන් හි සැහැල්ලු මාදිලියකි. තව ද, ඊතල කෘත්‍යයන් arguments වස්තුව සඳහා බැඳීම් නොසපයයි. වලංගු විකල්පයක් වශයෙන් එකම ප්‍රතිඵලය සඳහා rest පරාමිතිය භාවිත කරන්න.

let f = (...args) => args;
f("a");

ඊතල කෘත්‍යයන් at MDN.

උපක්‍රමශීලී ප්‍රතිදානය

ප්‍රතිදාන ප්‍රකාශය ද උපක්‍රමශීලීය. මෙය සලකන්න:

(function() {
  return
  {
    b: 10;
  }
})(); // -> undefined

💡 විවරණය:

return සහ ප්‍රතිදාන ප්‍රකාශය එකම පේළියේ තිබිය යුතුය:

(function() {
  return {
    b: 10
  };
})(); // -> { b: 10 }

මෙයට හේතුව ස්වයංක්‍රීය අර්ධ සලකුණු ඇතුළු කිරීම හෙවත් අලුත් පේළියකින් පසු ස්වයංක්‍රීය ව අර්ධ සලකුණු ඇතුලත් කිරීමයි. පළමු උදාහරණයේ ප්‍රතිදාන ප්‍රකාශය සහ වස්තු වචනාර්ථය අතරට අර්ධ සලකුණක් ඇතුළත් ව ඇත. එමනිසා කෘත්‍යය අර්ථ විරහිත ය යන්න ප්‍රතිදානය කරන අතර වස්තු වචනාර්ථය කිසි ලෙසකින් වත් නිර්ණය නොවේ.

11.9.1 ස්වයංක්‍රීය අර්ධ සලකුණු ඇතුළු කිරීම පිළිබඳ නීති
13.10 ප්‍රතිදාන ප්‍රකාශය

වස්තුවක් මත පැවරුම් බැඳීම

var foo = {n: 1};
var bar = foo;

foo.x = foo = {n: 2};

foo.x // -> undefined
foo   // -> {n: 2}
bar   // -> {n: 1, x: {n: 2}}

දකුණේ සිට වමට , foo ට {n: 2} පැවරෙන අතර, මෙම පැවරුමේ අගය වන {n: 2}, foo.x ට පැවරේ. bar , foo ට යොමු කරන නිසා, bar හි අගය {n: 1, x: {n: 2}} වේ. නමුත් foo.x අර්ථ විරහිත වෙමින් bar.x එසේ නොවන්නේ මන්ද?

💡 පවිවරණය:

Foo සහ bar, {n: 1} නම් එකම වස්තුව පරිශීලනය කරන අතර පැවරුම් වලට පෙර වම් පස අගයන් විසඳේ.foo = {n: 2} නව වස්තුවක් නිර්මාණය කරන බැවින්, එම නව වස්තුව පෙන්නුම් කිරීම සඳහා foo යාවත්කාලීන වේ. මෙහිදී සිදුවන ඉන්ද්‍රජාලය නම් foo.x = ... හි foo, වම් පස අගයක් ලෙස අකල්හි විසඳෙන අතර ම පැරණි foo = {n: 1} පෙන්නුම් කරමින් x අගය එක් කොට එය යාවත්කාලීන කිරීමයි. මෙම පැවරුම් බැඳීම් වලට පසුව, bar තවමත් පැරණි foo වස්තුව පෙන්නුම් කරන මුත්, foo , x අන්තර්ගත නොවන නව {n: 2} වස්තුව පෙන්නුම් කරයි.

එය මෙයට සමාන වේ:

var foo = {n: 1};
var bar = foo;

foo = {n: 2} // -> {n: 2}
bar.x = foo // -> {n: 1, x: {n: 2}}
// bar.x point to the address of the new foo object
// it's not equivalent to: bar.x = {n: 2}

අරාවන් සමඟ වස්තුන්හි ගුණ වෙත ප්‍රවේශ වීම

var obj = { property: 1 };
var array = ["property"];

obj[array]; // -> 1

ව්‍යාජ-බහුමාන අරාවන් පිළිබඳ කෙසේ ද?

var map = {};
var x = 1;
var y = 2;
var z = 3;

map[[x, y, z]] = true;
map[[x + 10, y, z]] = true;

map["1,2,3"]; // -> true
map["11,2,3"]; // -> true

💡 විවරණය:

කොටු වරහන් [] කාරකය, toString භාවිතයෙන්, ොමු කරන ලද ප්‍රකාශනය පරිවර්තනය කරයි. ඒක අවයව අරාවක් පෙළ බවට පරිවර්තනය කිරීම, අන්තර්ගත අවයවය පෙළ බවට පරිවර්තනය කිරීමට සමානය.

["property"].toString(); // -> 'property'

අභිශුන්‍යය සහ බන්ධුතා කාරක

null > 0; // false
null == 0; // false

null >= 0; // true

💡 විවරණය:

සැකෙවින් පවසන්නේ නම්, අභිශුන්‍යය 0 ට වඩා කුඩා බව අසත්‍ය නම්, null >= 0 සත්‍ය විය යුතුයි. මේ සඳහා වන ගැඹුරු විවරණය මෙහිදී කියවන්න.

`Number.toFixed()` වෙනස් අංක පෙන්වයි

Number.toFixed() විවිධ වෙබ් පිරික්සුම් හි දී තරමක් වෙනස් ලෙස හැසිරිය හැක. මෙම උදාහරණය බලන්න:

(0.7875).toFixed(3);
// Firefox: -> 0.787
// Chrome: -> 0.787
// IE11: -> 0.788
(0.7876).toFixed(3);
// Firefox: -> 0.788
// Chrome: -> 0.788
// IE11: -> 0.788

💡 විවරණය:

ඔබේ පළමු අදහස “IE11 නිවැරදි අතර Firefox/Chrome වැරදි ය” යන්න විය හැකි වුවත්, සත්‍යය නම්, Firefox/Chrome, සංඛ්‍යා සඳහා වන සම්මුති වලට (IEEE-754 Floating Point) වඩා ඍජුවම ගරු කරන අතර, වඩා පැහැදිලි ප්‍රතිඵලයක් ලබා දීමට දරන උත්සාහය ක දී IE11 විසින් ඒවා ට ගරු නොකරන බවයි.

මෙය ඇතිවන්නේ කෙසේද යන්න ක්ෂණික පරීක්ෂා කීපයක් මඟින් ඔබට දැකගත හැකිය:

// Confirm the odd result of rounding a 5 down
(0.7875).toFixed(3); // -> 0.787
// It looks like it's just a 5 when you expand to the
// limits of 64-bit (double-precision) float accuracy
(0.7875).toFixed(14); // -> 0.78750000000000
// But what if you go beyond the limit?
(0.7875).toFixed(20); // -> 0.78749999999999997780

දශම සංඛ්‍යා, අභ්‍යන්තරිකව තැන්පත් ව පවතින්නේ දශම සංඛ්‍යා සමූහයක් ලෙස නොව toString සහ සමාන ඇමතුම් වලින් වැටයිය හැකි දෝෂ නිපදවන, නමුත් අභ්‍යන්තරයේ නිවැරදිව ඉදිරිපත් කෙරෙන සංකීර්ණ ක්‍රියාදාමයක් මඟිනි .

මෙම අවස්ථාවේදී , අග ඇති 5, සත්‍ය වශයෙන්ම, සත්‍ය 5 ට වඩා අතිශයින් ම කුඩා භාගයකි. එය සාධාරණ දිගකට වැටයීම මඟින් 5 ලෙස දර්ශනය කෙරේ . නමුත් එය අභ්‍යන්තරිකව සත්‍ය වශයෙන් ම 5 නොවේ.

කෙසේ නමුත් ඒ IE 11, toFixed(20) අවස්ථාවේදී පවා, අවසානයට 0 එක් කරමින් පමණක් අගය වාර්තා කරයි . එය දෘඩාංග මඟින් වන දෝෂ අවම කර ගැනීම සඳහා බලයෙන් අගයන් වැටයීමක් කරන සෙයක් පෙනේ.

NOTE 2 යොමුවේ toFixed සඳහා ECMA-262 අර්ථ දැක්වීම බලන්න.

20.1.3.3 Number.prototype.toFixed (fractionDigits)

`Math.min()`ට වඩා `Math.max()` කුඩා ය

Math.min(1, 4, 7, 2); // -> 1
Math.max(1, 4, 7, 2); // -> 7
Math.min(); // -> Infinity
Math.max(); // -> -Infinity
Math.min() > Math.max(); // -> true

💡 විවරණය:

Math.min()ට වඩා Math.max() කුඩා වන්නේ මන් ද? by Charlie Harvey

`null` සහ `0` සැසඳීම

පහත ප්‍රකාශන පරස්පර විරෝධී බවක් හඳුන්වා දෙන සෙයක් පෙනේ.

null == 0; // -> false
null > 0; // -> false
null >= 0; // -> true

null >= 0, true නම්, null , 0ට සමාන හෝ 0 ට වඩා විශාල හෝ නොවන්නේ කෙසේ ද?(මෙය වඩා කුඩායි සමඟ ද මෙලෙසම ක්‍රියා කරයි)

💡 විවරණය:

මෙම ප්‍රකාශන තුන නිර්ණය වන ආකාරය එකිනෙකට වෙනස් වීම, මෙම අනපේක්ෂිත හැසිරීමට වගකිව යුතුය.

පළමුව, වියුක්ති සමානතා සැසඳීම null == 0. සාමාන්‍ය පරිදි, මෙම කාරකයට එක පසෙක හෝ අගයන් නිසි ලෙස සැසඳිය නොහැකි නම්,එය දෙපසම සංඛ්‍යා බවට හරවා සංඛ්‍යා සසඳයි. ඉනික්බිති, ඔබ පහත බලාපොරොත්තු විය හැකි ය:

// සිදුවන්නේ මෙය නොවේ
(null == 0 + null) == +0;
0 == 0;
true;

කෙසේ නමුත්, null හෝ undefined ඇති පැත්තක මෙම පරිවර්තනය සිදු නොවේ. එමනිසා, ඔබේ සමාන ලකුණෙන් එක පසෙක null ඇත්නම්, ප්‍රකාශනය සත්‍යය ප්‍රතිදානය කිරීම සඳහා, අනෙක් පස null හෝ undefined විය යුතුමය. මෙය මෙහිදී සිදු නොවන නිසා අසත්‍ය ප්‍රතිදානය වේ.

මීළඟට, null > 0 සැසඳීම යි. ඇල්ගොරිතමය, වියුක්ති සමානතා කාරකයේ දී මෙන් නොව, null යන්න සංඛ්‍යාවක් බවට හරවයි. මෙනිසා, අපට මෙම හැසිරීම ලැබේ:

null > 0
+null = +0
0 > 0
false

අවසානයේ, null >= 0 සැසඳීම යි. මෙම ප්‍රකාශනය null > 0 || null == 0 හි ප්‍රතිඵලය විය යුතු බවට ඔබට තර්ක කළ හැකිය; මෙය සත්‍ය නම්, ඉහත ප්‍රතිපල වලින් ගම්‍ය වන්නේ මෙය අසත්‍ය ද විය හැකි බවයි. කෙසේ නමුත්, ඇත්ත වශයෙන් ම >= කාරකය ක්‍රියා කරන්නේ ඉතා වෙනස් ආකාරයකිනි;කෙසේද යත් මූලිකවම < හි විරුද්ධාර්ථය ගැනීමෙනි. වඩා විශාල කාරකය යොදාගත් ඉහත උදාහරණය, වඩා කුඩා කාරකයට ද වලංගු නිසා, මෙයින් අදහස් වන්නේ මෙම ප්‍රකාශනය සත්‍ය වශයෙන් ම පහත පරිදි නිර්ණය වන බවයි:

null >= 0;
!(null < 0);
!(+null < +0);
!(0 < 0);
!false;
true;

7.2.12 වියුක්ති බන්ධුතා සැසඳීම
7.2.13 වියුක්ති සමානතා සැසඳීම

එකම විචල්‍යය ප්‍රති ප්‍රකාශ කිරීම

JS, විචල්‍ය ප්‍රති ප්‍රකාශනයට ඉඩ දෙයි:

a;
a;
// මෙයද වලංගුය
a, a;

දැඩි මාදිලියේ දී ද ක්‍රියා කරයි:

var a, a, a;
var a;
var a;

💡 විවරණය:

සියලු අර්ථ දැක්වීම් එක් අර්ථ දැක්වීමකට ඒකාබද්ධ වේ.

13.3.2 විචල්‍ය ප්‍රකාශය

සාමාන්‍ය හැසිරීම Array.prototype.sort()

ඔබට සංඛ්‍යා අරාවක් පිළිවෙළ කිරීමට අවශ්‍ය යයි සිතමු.

[ 10, 1, 3 ].sort() // -> [ 1, 10, 3 ]

💡 විවරණය:

සාමාන්‍ය පිළියෙළ කිරීම් අනුපිළිවෙල, අවයව පෙළ බවට පරිවර්තනය කොට, එම UTF-16 කේත ඒකක සැසඳීම මත තැනී ඇත.

22.1.3.25 Array.prototype.sort ( comparefn )

ඉඟිය

පෙළ හැර වෙන යමක් පිළියෙළ කිරීමේදී comparefn යොමු කරන්න.

[ 10, 1, 3 ].sort((a, b) => a - b) // -> [ 1, 3, 10 ]

📚 වෙනත් සම්පත්

wtfjs.com — ජාලයේ භාෂාව සඳහා වන, අති විශේෂ අසාමාන්‍යතාවන් , නොගැළපීම්, සහ සරලව ම වේදනාකාරී දුරවබෝධ අවස්ථා වල එකතුවකි.
Wat — CodeMash 2012 හි දී Gary Bernhardt සිදු කළ පෙරළිකාර දේශනයක්
What the... JavaScript? — JavaScriptහි වික්ෂිප්ත භාවය ඉවත් කිරීම සඳහා වන උත්සාහයන් දෙකක් ඇතුලත් Kyle Simpsons ගේ දේශනය යි. වඩා පිරිසිදු, වඩා අලංකාර, වඩාත් කියවීමට පහසු කේත ජනනයට ඔබට සහය වීමට සහ ඉනික්බිති විවෘත කේත ප්‍රජාවට දායක වීමට මිනිසුන් දිරි ගැන්වීමට ඔහුට අවශ්‍ය ය.

Files

README-si.md

Latest commit

History

README-si.md

File metadata and controls

Table of Contents

What the f*ck JavaScript?

Node හි ඇසුරුම් කරන ලද අත්පිටපත

පරිවර්තන

පටුන

💪 දිරිගැන්වුම

✍🏻 අංකනය

👀 උදාහරණ

[] සහ ![] සමානය

💡 විවරණය:

true, ![]ට සම නොවේ, නමුත් [] ට ද සම නොවේ.

💡 විවරණය:

සත්‍යය අසත්‍ය ය

💡 විවරණය:

baNaNa

💡 විවරණය:

NaN යනු NaN නොවේ

💡 විවරණය:

එය අසාර්ථකත්වයකි

💡 විවරණය:

[] සත්‍යමය නමුත් true නොවේ

💡 විවරණය:

null අසත්‍යමය මුත් අසත්‍ය නොවේ

💡 විවරණය:

document.all යනු වස්තුවකි, නමුත් එය අර්ථ විරහිතය.

💡 විවරණය:

අවම අගය, ශුන්‍යය ට වඩා විශාල ය.

💡 විවරණය:

කෘත්‍යය, කෘත්‍යයක් නොවේ

💡 විවරණය:

අරාවන් ආකලනය

💡 විවරණය:

අරාවක පසුයෙදුම් කොමා

💡 විවරණය:

අරාවන් සැසඳීම යක්ෂයෙකි

💡 විවරණය:

undefined සහ Number

💡 විවරණය:

parseInt නරක මිනිසෙකි

Math with true and false

💡 විවරණය:

JavaScript හි HTML ටීකාවන් වලංගු ය.

💡 විවරණය:

NaN is not a number

💡 විවරණය:

[] සහ null වස්තූන් ය.

💡 විවරණය:

ඉන්ද්‍රජාලිකව වැඩිවන සංඛ්‍යා

💡 විවරණය:

0.1 + 0.2 හි නිරවද්‍යතාව

💡 විවරණය:

සංඛ්‍යා පූරණය

💡 විවරණය:

සංඛ්‍යා තුනක් සැසඳීම

💡 විවරණය:

හාස්‍යජනක ගණිතය

💡 විවරණය:

සෙවුම් ප්‍රකාශන ආකලනය

💡 විවරණය:

පෙළ String හි නිදර්ශකයක් නොවේ

💡 විවරණය:

පසුලකුණු සමඟ කෘත්‍යයන් ඇමතීම

💡 විවරණය:

අමතන්න අමතන්න අමතන්න

💡 විවරණය:

තැනුම් ගුණාංගයක්

💡 විවරණය:

වස්තුවක්, වස්තුවක ගුණයක යතුර ලෙස

💡 විවරණය:

__proto__ සමඟ මූලාකෘති වෙත ප්‍රවේශ වීම

💡 විවරණය:

`${{Object}}`

💡 විවරණය:

පෙරනිමි අගයන් සමඟ බිඳීම

`[]` සහ `![]` සමානය

`true`, `![]`ට සම නොවේ, නමුත් `[]` ට ද සම නොවේ.

`NaN` යනු `NaN` නොවේ

`[]` සත්‍යමය නමුත් `true` නොවේ

`null` අසත්‍යමය මුත් `අසත්‍ය` නොවේ

`document.all` යනු වස්තුවකි, නමුත් එය අර්ථ විරහිතය.

`undefined` සහ `Number`

`parseInt` නරක මිනිසෙකි

Math with `true` and `false`

`NaN` is not a number

`[]` සහ `null` වස්තූන් ය.

`0.1 + 0.2` හි නිරවද්‍යතාව

පෙළ `String` හි නිදර්ශකයක් නොවේ

`proto` සමඟ මූලාකෘති වෙත ප්‍රවේශ වීම

ද්‍රෝහී `try..catch`

`arguments` සහ ඊතල කෘත්‍යයන්

`Number.toFixed()` වෙනස් අංක පෙන්වයි

`Math.min()`ට වඩා `Math.max()` කුඩා ය

`null` සහ `0` සැසඳීම

`[]` සහ `![]` සමානය

`true`, `![]`ට සම නොවේ, නමුත් `[]` ට ද සම නොවේ.

`NaN` යනු `NaN` නොවේ