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

javascriptfunction func() {
  console.log('!');
}

javascriptlet func = function() {
  console.log('!');
}

javascript+function() {
  console.log('!');
}

javascript!function func() {
  console.log('!');
}

javascript-function func() {
  console.log('!');
}

javascript1 + function func() {
  console.log('!');
}

javascript(function func() {
  console.log('!');
})

javascriptconsole.log(
  function() {
    console.log('!');
  }
);