උද්දීපන සලකුණ ශ්‍රිතයට පෙර කරන්නේ කුමක්ද?

!function () {}();

ජාවාස්ක්‍රිප්ට් සින්ටැක්ස් 101. මෙන්න ශ්‍රිත ප්‍රකාශයක් :

function foo() {}

අර්ධ සළකුණක් නොමැති බව සලකන්න: මෙය ශ්‍රිත ප්‍රකාශයක් පමණි . foo()ඇත්ත වශයෙන්ම ශ්‍රිතය ක්‍රියාත්මක කිරීම සඳහා ඔබට ආයාචනයක් අවශ්‍ය වේ.

දැන්, අප පෙනෙන පරිදි අහිංසක විශ්මය ජනක සලකුණක් එකතු කළ විට: !function foo() {}එය ප්‍රකාශනයක් බවට පත් කරයි . එය දැන් ක්‍රියාකාරී ප්‍රකාශනයකි .

මෙම !පමණක් ඇත්තෙන්ම, මෙම උත්සවය පහ වෙන්නේ නැහැ, නමුත් අපි දැන් කළ හැකි ()අවසන් වන විට: !function foo() {}()වඩා ඉහළ තැනක්ද ඇති !හා ක්ෂණිකව කාර්යයෙන් වේ.

එබැවින් කතුවරයා කරන්නේ ශ්‍රිත ප්‍රකාශනයකට බයිට් එකක් ඉතිරි කිරීමයි; වඩාත් කියවිය හැකි ලිවීමේ ක්‍රමයක් මෙය වනු ඇත:

(function(){})();

අවසාන වශයෙන්, !ප්‍රකාශනය නැවත සත්‍ය බවට පත් කරයි. මෙම නිසා පෙරනිමියෙන් සියලු IIFE ආපසු වේ undefinedඅප පිටත් වන, !undefinedවන true. විශේෂයෙන් ප්රයෝජනවත් නොවේ.

කාර්යය:

function () {}

කිසිවක් ආපසු ලබා නොදේ (හෝ නිර්වචනය නොකළ).

සමහර විට අපි ශ්‍රිතයක් නිර්මාණය කරන විට එය කැඳවීමට අවශ්‍යය. මෙය අත්හදා බැලීමට ඔබ පෙළඹෙනු ඇත:

function () {}()

නමුත් එහි ප්‍රති results ලය a SyntaxError.

!ශ්‍රිතයට පෙර ක්‍රියාකරු භාවිතා කිරීමෙන් එය ප්‍රකාශනයක් ලෙස සලකනු ලැබේ, එබැවින් අපට එය හැඳින්විය හැකිය:

!function () {}()

එමෙන්ම මෙම කාර්යය නැවත වටිනාකම වීජ ප්රතිවිරුද්ධ, මේ අවස්ථාවේ දී ආපසු trueනිසා !undefinedය true. ඇමතුමේ ප්‍රති result ලය සත්‍ය ප්‍රතිලාභ අගය වීමට ඔබට අවශ්‍ය නම්, එය මේ ආකාරයෙන් කිරීමට උත්සාහ කරන්න:

(function () {})()

Airbnb JavaScript මාර්ගෝපදේශයේ! සලකුණු කර ඇති ශ්‍රිත ආයාචනය සඳහා භාවිතා කිරීමට හොඳ කරුණක් තිබේ

සාමාන්‍යයෙන් මෙම තාක්ෂණය වෙනම ලිපිගොනු (අකා මොඩියුල) මත භාවිතා කිරීම සඳහා වන අතර පසුව එය සංයුක්ත වේ. මෙහි ඇති අවවාදය නම්, නව ගොනුව නව පේළියට ඇතුළත් කරන මෙවලම් මගින් සංයුක්ත කළ යුතු ලිපිගොනු (මෙය බොහෝ කොන්ක්‍රීට් මෙවලම් සඳහා පොදු හැසිරීමකි). එවැනි අවස්ථාවකදී, භාවිතා කිරීම !කලින් සංක්ෂිප්ත මොඩියුලය පසුපසින් අර්ධ සළකුණ මඟ හැරී ඇත්නම් වැරැද්ද වළක්වා ගැනීමට උපකාරී වන අතර, එමඟින් කිසිදු කරදරයකින් තොරව ඒවා ඕනෑම පිළිවෙලකට තැබීමට නම්යශීලී බවක් ලබා දෙනු ඇත.

!function abc(){}();
!function bca(){}();

ඒ ආකාරයටම ක්‍රියා කරයි

!function abc(){}();
(function bca(){})();

නමුත් එක් අක්‍ෂරයක් ඉතිරි කරන අතර අත්තනෝමතික පෙනුම වඩා හොඳය.

ඕනෑම යන මාර්ගය +, -, ~, voidක්රියාකරුවන් එම බලපෑම, ශ්රිතය කැඳවමින් අනුව, තහවුරු කිරීම සඳහා ඔබ එම කාර්යය සිට ආපසු යමක් භාවිතා කිරීමට නම් වෙනස් ඔවුන් කටයුතු කරන ඇත.

abcval = !function abc(){return true;}() // abcval equals false
bcaval = +function bca(){return true;}() // bcaval equals 1
zyxval = -function zyx(){return true;}() // zyxval equals -1
xyzval = ~function xyz(){return true;}() // your guess?

නමුත් ඔබ එක් ගොනුවක් සඳහා IIFE රටා එක් මොඩියුලයක් කේත වෙන් කිරීම සහ ප්‍රශස්තිකරණය සඳහා කොන්කට් මෙවලම භාවිතා කරන්නේ නම් (එමඟින් එක් පේළියක් එක් ගොනු කාර්යයක් බවට පත් වේ), එවිට ඉදිකිරීම්

!function abc(/*no returns*/) {}()
+function bca() {/*no returns*/}()

පළමු කේත නියැදියක් සේම ආරක්ෂිත කේත ක්‍රියාත්මක කිරීම සිදු කරයි.

මෙය දෝෂයක් ඇති කරයි ජාවාස්ක්‍රිප්ට් ඒඑස්අයි හට එහි වැඩ කිරීමට නොහැකි වනු ඇත.

!function abc(/*no returns*/) {}()
(function bca() {/*no returns*/})()

ඒකීය ක්‍රියාකරුවන් පිළිබඳ එක් සටහනක්, ඔවුන් සමාන වැඩක් කරනු ඇත, නමුත් ඔවුන් පළමු මොඩියුලයේ භාවිතා නොකළේ නම් පමණි. සංක්ෂිප්ත අනුපිළිවෙල පිළිබඳ පූර්ණ පාලනයක් ඔබට නොමැති නම් ඒවා එතරම් ආරක්ෂිත නොවේ.

මෙය ක්‍රියාත්මක වේ:

!function abc(/*no returns*/) {}()
^function bca() {/*no returns*/}()

මෙය නොවේ:

^function abc(/*no returns*/) {}()
!function bca() {/*no returns*/}()

එම ප්‍රකාශය අසත්‍ය ලෙස තක්සේරු කළ හැකිද යන්න එය නැවත ලබා දෙයි. උදා:

!false      // true
!true       // false
!isValid()  // is not valid

බූලියන් සඳහා අගයක් බල කිරීම සඳහා ඔබට එය දෙවරක් භාවිතා කළ හැකිය:

!!1    // true
!!0    // false

එබැවින්, ඔබේ ප්‍රශ්නයට වඩාත් සෘජුවම පිළිතුරු දීමට:

var myVar = !function(){ return false; }();  // myVar contains true

සංස්කරණය කරන්න: එය ශ්‍රිත ප්‍රකාශනය ශ්‍රිත ප්‍රකාශනයකට වෙනස් කිරීමේ අතුරු ආබාධයක් ඇත. උදා: පහත දැක්වෙන කේතය වලංගු නොවේ, මන්ද එය අවශ්‍ය හඳුනාගැනීමක් (හෝ ශ්‍රිතයේ නම ) නොමැති ක්‍රියාකාරී ප්‍රකාශයක් ලෙස අර්ථකථනය කර ඇත :

function () { return false; }();  // syntax error

අපි ජාවාස්ක්‍රිප්ට් අවම කිරීම සිදු කරන විට දත්ත බයිට් එකක් ඉතිරි කිරීම පමණි.

පහත නිර්නාමික ශ්‍රිතය සලකා බලන්න

function (){}

ඉහත සඳහන් දෑ ස්වයං ආයාචනා කිරීමේ ශ්‍රිතයක් බවට පත් කිරීම සඳහා අපි සාමාන්‍යයෙන් ඉහත කේතය වෙනස් කරන්නෙමු

(function (){}())

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

!function (){}()

තවමත් දෙකම ස්වයං ආයාචනා කිරීමේ කාර්යයන් වන අතර අපි බයිට් එකක්ද ඉතිරි කරමු. අක්ෂර 2 වෙනුවට (,)අපි භාවිතා කළේ එක් අක්‍ෂරයකි!

විශ්මය දනවන සලකුණ ඕනෑම ශ්‍රිතයක් සෑම විටම බූලියන් ආපසු ලබා දෙයි.
අවසාන අගය නම් ශ්‍රිතය මඟින් ආපසු ලබා දුන් අගය ප්‍රතික්ෂේප කිරීමයි.

!function bool() { return false; }() // true
!function bool() { return true; }() // false

සැර බාල !ඉහත උදාහරණ විය හැකි බවට SyntaxError .

function bool() { return true; }() // SyntaxError

කෙසේ වෙතත්, මෙය සාක්ෂාත් කර ගැනීම සඳහා වඩා හොඳ ක්‍රමයක් වනුයේ:

(function bool() { return true; })() // true

! තාර්කික NOT ක්‍රියාකරු, එය එහි ප්‍රතිවිරුද්ධ දෙසට යමක් හරවන බූලියන් ක්‍රියාකරුවෙකි.

ශ්‍රිතයට පෙර BANG (!) භාවිතා කිරීමෙන් ඔබට ආයාචිත ශ්‍රිතයේ වරහන් මග හැරිය හැකි වුවද , එය තවමත් ආපසු හැරවීම වළක්වනු ඇත, එය ඔබට අවශ්‍ය දේ නොවිය හැකිය. IEFE හි දී මෙන්, එය නිර්වචනය නොකෙරේ, එය ප්‍රතිලෝම වූ විට බූලියන් සත්‍ය වේ.

ඒ වෙනුවට, අවශ්‍ය නම් සංවෘත වරහන් සහ BANG ( ! ) භාවිතා කරන්න.

// I'm going to leave the closing () in all examples as invoking the function with just ! and () takes away from what's happening.

(function(){ return false; }());
=> false

!(function(){ return false; }());
=> true

!!(function(){ return false; }());
=> false

!!!(function(){ return false; }());
=> true

වැඩ කරන වෙනත් ක්‍රියාකරුවන් ...

+(function(){ return false; }());
=> 0

-(function(){ return false; }());
=> -0

~(function(){ return false; }());
=> -1

ඒකාබද්ධ ක්‍රියාකරුවන් ...

+!(function(){ return false; }());
=> 1

-!(function(){ return false; }());
=> -1

!+(function(){ return false; }());
=> true

!-(function(){ return false; }());
=> true

~!(function(){ return false; }());
=> -2

~!!(function(){ return false; }());
=> -1

+~(function(){ return false; }());
+> -1

IIFE ලිවීමේ තවත් ක්‍රමයක් (වහාම ක්‍රියාත්මක වන ප්‍රකාශනය).

එහි වෙනත් ලිවීමේ ක්‍රමය -

(function( args ) {})()

සමාන

!function ( args ) {}();

! ප්‍රති result ලයක් ලෙස ඔබ අපේක්ෂා කරන ඕනෑම දෙයක් (ප්‍රතිවිරුද්ධ) ප්‍රතික්ෂේප කරනු ඇත, එනම් ඔබට තිබේ නම්

var boy = true;
undefined
boy
true
!boy
false

ඔබ ආරාධනා boy, ඔබේ ප්රතිඵලය වනු true, එහෙත් මේ මොහොතේ ඔබ එකතු !කරන විට boy, එනම්, !boyඔබේ ප්රතිඵලය වනු false. වෙනත් වචන වලින් ඔබ අදහස් කරන්නේ නොට්බෝයි , නමුත් මෙවර එය මූලික වශයෙන් බූලියන් ප්‍රති result ලයකි , trueනැතහොත් false.

!function () {}();ප්‍රකාශනයට සිදු වන දෙයමයි , ධාවනය function () {}();කිරීමෙන් ඔබට දෝෂයක් සලකුණු වනු ඇත, නමුත් !ඔබේ function () {}();ප්‍රකාශනය ඉදිරිපිට දකුණට එකතු කිරීමෙන් function () {}();එය ඔබට ආපසු ලබා දිය යුතු ප්‍රතිවිරුද්ධ දෙය කරයි true. උදාහරණය පහත දැක්වේ:

function () {}();
SyntaxError: function statement requires a name
!function () {}();
true