JavaScript හි ෆන්ක්ෂනල් ප්‍රකාශන වල සියුම් කරුණු
Function Expression යන නම අහඹුවෙන් ලබා දී නැත. එය සැබවින්ම එය අදහස් කරයි - එවැනි ශ්‍රිත යම් ප්‍රකාශනයක කොටසක් වන බව.
උදාහරණයක් ලෙස, අපට යම් වචන පේලියක් එකතු කළ හැකිය සහ නමක් නොමැති ශ්‍රිතයක්:
javascriptlet str = 'str' + function() {return 3;};
console.log(str); // 'strfunction() {return 3;}' ප්‍රතිදානය කරයි
ඇයි අපි එවැනි අමුතු ප්‍රතිඵලයක් දකින්නේ,
සහ අංකය 3 නොවේ? මක්නිසාද යත් දෙවන එකතු කරන ලද දේ
- මෙය ශ්‍රිතය ක්‍රියාත්මක කිරීමේ ප්‍රතිඵලය නොවේ, එහි මූලාශ්‍රයයි
කේතය (සැබවින්ම අපි එම ශ්‍රිතය ක්‍රියාත්මක කර නැත, ඒ වෙනුවට
එය ලිව්වා).
එනම් ෆන්ක්ෂනල් ප්‍රකාශනය යන නම එවැනි ශ්‍රිතයක් යම් ප්‍රකාශනයක කොටසක් වන බව පෙන්වයි.
විචල්‍යයකට ආදේශ කිරීම ද ප්‍රකාශනයකි:
javascriptlet func = function() {
console.log('!');
};
උදාහරණයක් ලෙස, ශ්‍රිතය ප්‍රවේශ වශයෙන් යොමු කළ හැකිය
console.log වෙත පරාමිතියක් ලෙස සහ එය ප්‍රතිදානය කරයි
එහි මූලාශ්‍ර කේතය කොන්සෝලයේ - මෙය ද වේ
ප්‍රකාශනයක් ලෙස සැලකේ:
javascriptconsole.log(function() {return 3;});
මෙය වැදගත් වන්නේ ඇයි: මක්නිසාද Function Declaration සහ Function Expression අතර වෙනස එය නොවේ, පළමු ශ්‍රිතය නමක් සමඟ සාදා ඇති අතර, දෙවැන්නට මුලින් නමක් නොමැත. එය එසේ නොවේ.
උදාහරණය. මෙන්න අපට නමක් නොමැති ශ්‍රිතයක්, නමුත් මේ සමඟ ඕනෑම ප්‍රකාශනයක කොටසක් නොවේ (එනම් එය සමඟ කිසිදු ක්‍රියාවක් සිදු නොවේ, සරලව කියනවා නම්):
javascript/*
මෙම ශ්‍රිතය Function Declaration වේ,
නමුත් වාග් විද්‍යා දෝෂයක් සමඟ:
*/
function() {
console.log('!');
}
එවැනි කේතයක් සම්පූර්ණයෙන්ම දෝෂයක් ලබා දෙයි! ඇයි: එසේ ශ්‍රිතය කිසිදු ප්‍රකාශනයක කොටසක් නොවන බැවින්, බ්‍රවුසරය එය Function Declaration ලෙස සලකයි, නමුත් එහි නම සොයාගත නොහැකි වන අතර දෝෂයක් ලබා දෙයි.
දෝෂය අතුරුදහන් වීම සඳහා, ශ්‍රිතය ක්‍රියාත්මක කිරීම අවශ්‍යයි
යම් ප්‍රකාශනයක කොටසක් වන්න. උදාහරණයක් ලෙස,
එයට පෙර + මෙහෙයුම ලියන්න:
javascript+function() { // එවැනි කේතය නිවැරදියි
console.log('!');
};
මෙය ක්‍රියා කරන්නේ කෙසේද: + මෙහෙයුමම
කිසිවක් නොකරයි, මෙය ලිවීමට සමානය
අංකය 3 වෙනුවට අංකය +3 - අවසර ඇත,
නමුත් කිසිවක් නොවෙනස්ව පවතී.
නමුත් ශ්‍රිතය සමඟ - වෙනස් කරයි. දැන් අපගේ ශ්‍රිතය දැනටමත් සරලව ලියා නැත, එහි කොටසක් වේ ප්‍රකාශනයක. එබැවින් දෝෂය දැන් ඇති නොවේ. ශ්‍රිතය ක්‍රියාත්මක කිරීමේ ප්‍රතිඵලය ද නොමැත, සැබවින්ම අපි එය සරලව ලිව්වා, නමුත් ක්‍රියාත්මක කර නැත.
+ වෙනුවට ඕනෑම දෙයක් ලිවිය හැකිය.
උදාහරණයක් ලෙස:
javascript-function() { // එවැනි කේතය නිවැරදියි
console.log('!');
};
!function() { // එවැනි කේතය නිවැරදියි
console.log('!');
};
අපගේ ශ්‍රිතය වටකුරු වරහන් වලට ද ගත හැකිය, මෙම අවස්ථාවේ දී එය ද ෆන්ක්ෂනල් ප්‍රකාශනයක් බවට පත්වේ:
javascript(function() { // එවැනි කේතය නිවැරදියි
console.log('!');
});
දක්වා ඇති ශ්‍රිතය තීරණය කරන්න Function Declaration හෝ Function Expression ද:
javascriptfunction func() {
console.log('!');
}
දක්වා ඇති ශ්‍රිතය තීරණය කරන්න Function Declaration හෝ Function Expression ද:
javascriptlet func = function() {
console.log('!');
}
දක්වා ඇති ශ්‍රිතය තීරණය කරන්න Function Declaration හෝ Function Expression ද:
javascript+function() {
console.log('!');
}
දක්වා ඇති ශ්‍රිතය තීරණය කරන්න Function Declaration හෝ Function Expression ද:
javascript!function func() {
console.log('!');
}
දක්වා ඇති ශ්‍රිතය තීරණය කරන්න Function Declaration හෝ Function Expression ද:
javascript-function func() {
console.log('!');
}
දක්වා ඇති ශ්‍රිතය තීරණය කරන්න Function Declaration හෝ Function Expression ද:
javascript1 + function func() {
console.log('!');
}
දක්වා ඇති ශ්‍රිතය තීරණය කරන්න Function Declaration හෝ Function Expression ද:
javascript(function func() {
console.log('!');
})
දක්වා ඇති ශ්‍රිතය තීරණය කරන්න Function Declaration හෝ Function Expression ද:
javascriptconsole.log(
function() {
console.log('!');
}
);