function sayHi() { // (1) create alert( "Hello" );}let func = sayHi; // (2) copyfunc(); // Hello // (3) run the copy (it works)!sayHi(); // Hello // this still works too (why wouldn't it)

Iată ce se întâmplă mai sus în detaliu:

1. Declarația funcției (1) creează funcția și o pune în variabila numită sayHi.
2. Linia (2) o copiază în variabila func. Rețineți din nou: nu există paranteze după sayHi. Dacă ar exista, atunci func = sayHi() ar scrie rezultatul apelului sayHi() în func, nu funcția sayHi în sine.
3. Acum funcția poate fi apelată atât ca sayHi(), cât și ca func().

Rețineți că am fi putut, de asemenea, să folosim o expresie de funcție pentru a declara sayHi, în prima linie:

let sayHi = function() { alert( "Hello" );};let func = sayHi;// ...

Toate lucrurile ar fi funcționat la fel.

function sayHi() { // ...}let sayHi = function() { // ...};

function ask(question, yes, no) { if (confirm(question)) yes() else no();}ask( "Do you agree?", function() { alert("You agreed."); }, function() { alert("You canceled the execution."); });

Aici, funcțiile sunt declarate chiar în interiorul apelului ask(...). Ele nu au nici un nume și, prin urmare, sunt numite anonime. Astfel de funcții nu sunt accesibile în afara lui ask (pentru că nu sunt atribuite variabilelor), dar este exact ceea ce ne dorim aici.

Un astfel de cod apare în scripturile noastre foarte natural, este în spiritul lui JavaScript.

Expresie de funcție vs Declarație de funcție

Să formulăm principalele diferențe dintre declarațiile și expresiile de funcție.

În primul rând, sintaxa: cum să le diferențiem în cod.

• Declarație de funcție: o funcție, declarată ca o instrucțiune separată, în fluxul principal de cod.

  // Function Declarationfunction sum(a, b) { return a + b;}

• Expresie de funcție: o funcție, creată în interiorul unei expresii sau în interiorul unei alte construcții sintactice. Aici, funcția este creată în partea dreaptă a „expresiei de atribuire” =:

  // Function Expressionlet sum = function(a, b) { return a + b;};

  Diferența mai subtilă este atunci când o funcție este creată de motorul JavaScript.

  O expresie de funcție este creată atunci când execuția ajunge la ea și este utilizabilă numai din acel moment.

  După ce fluxul de execuție trece în partea dreaptă a asignării let sum = function… – iată, funcția este creată și poate fi utilizată (asignată, apelată, etc. ) de acum încolo.

  Declarațiile de funcții sunt diferite.

  O Declarație de funcție poate fi apelată mai devreme decât este definită.

  De exemplu, o Declarație de funcție globală este vizibilă în tot scriptul, indiferent unde se află.

  Acest lucru se datorează algoritmilor interni. Când JavaScript se pregătește să ruleze scriptul, el caută mai întâi Declarații de funcții globale în acesta și creează funcțiile. Ne putem gândi la aceasta ca la o „etapă de inițializare”.

  Și după ce toate Declarațiile de funcții sunt procesate, codul este executat. Deci are acces la aceste funcții.

  De exemplu, așa funcționează:

  sayHi("John"); // Hello, Johnfunction sayHi(name) { alert( `Hello, ${name}` );}

  Declarația de funcție sayHi este creată atunci când JavaScript se pregătește să pornească scriptul și este vizibilă peste tot în el.

  …Dacă ar fi o expresie de funcție, atunci nu ar funcționa:

  sayHi("John"); // error!let sayHi = function(name) { // (*) no magic any more alert( `Hello, ${name}` );};

  Expresiile de funcție sunt create atunci când execuția ajunge la ele. Acest lucru s-ar întâmpla doar în linia (*). Prea târziu.

  O altă caracteristică specială a Declarațiilor de funcții este sfera lor de cuprindere în bloc.

  În modul strict, atunci când o Declarație de funcție se află în interiorul unui bloc de cod, ea este vizibilă peste tot în interiorul acelui bloc. Dar nu și în afara acestuia.

  De exemplu, să ne imaginăm că trebuie să declarăm o funcție welcome() în funcție de variabila age pe care o primim în timpul execuției. Și apoi plănuim să o folosim ceva mai târziu.

  Dacă folosim declarația de funcție, aceasta nu va funcționa așa cum este prevăzut:

  let age = prompt("What is your age?", 18);// conditionally declare a functionif (age < 18) { function welcome() { alert("Hello!"); }} else { function welcome() { alert("Greetings!"); }}// ...use it laterwelcome(); // Error: welcome is not defined

  Aceasta pentru că o declarație de funcție este vizibilă doar în interiorul blocului de cod în care se află.

  Iată un alt exemplu:

  let age = 16; // take 16 as an exampleif (age < 18) { welcome(); // \ (runs) // | function welcome() { // | alert("Hello!"); // | Function Declaration is available } // | everywhere in the block where it's declared // | welcome(); // / (runs)} else { function welcome() { alert("Greetings!"); }}// Here we're out of curly braces,// so we can not see Function Declarations made inside of them.welcome(); // Error: welcome is not defined

  Ce putem face pentru ca welcome să fie vizibilă în afara lui if?

  Abordarea corectă ar fi să folosim o expresie de funcție și să atribuim welcome variabilei care este declarată în afara lui if și care are vizibilitatea corespunzătoare.

  Acest cod funcționează conform intenției:

  let age = prompt("What is your age?", 18);let welcome;if (age < 18) { welcome = function() { alert("Hello!"); };} else { welcome = function() { alert("Greetings!"); };}welcome(); // ok now

  Sau am putea să îl simplificăm și mai mult folosind un operator semn de întrebare ?:

  let age = prompt("What is your age?", 18);let welcome = (age < 18) ? function() { alert("Hello!"); } : function() { alert("Greetings!"); };welcome(); // ok now

  Când să alegem declarația de funcție versus expresia de funcție?

  Ca regulă generală, atunci când trebuie să declarăm o funcție, prima care trebuie luată în considerare este sintaxa Function Declaration. Aceasta oferă mai multă libertate în ceea ce privește modul de organizare a codului nostru, deoarece putem apela astfel de funcții înainte de a fi declarate.

  De asemenea, acest lucru este mai bun pentru lizibilitate, deoarece este mai ușor să căutăm function f(…) {…} în cod decât let f = function(…) {…};. Declarațiile de funcții sunt mai „eye-catching”.

  …Dar dacă o declarație de funcții nu ne convine din anumite motive, sau avem nevoie de o declarație condiționată (tocmai am văzut un exemplu), atunci ar trebui folosită expresia de funcții.

  Summary

  • Funcțiile sunt valori. Ele pot fi atribuite, copiate sau declarate în orice loc din cod.
  • Dacă funcția este declarată ca o instrucțiune separată în fluxul principal de cod, aceasta se numește „Declarație de funcție”.
  • Dacă funcția este creată ca parte a unei expresii, aceasta se numește „Expresie de funcție”.
  • Declarațiile de funcție sunt procesate înainte ca blocul de cod să fie executat. Ele sunt vizibile peste tot în bloc.
  • Expresiile de funcție sunt create atunci când fluxul de execuție ajunge la ele.

  În majoritatea cazurilor în care trebuie să declarăm o funcție, este preferabilă o Declarație de funcție, deoarece aceasta este vizibilă înainte de declarația propriu-zisă. Aceasta ne oferă mai multă flexibilitate în organizarea codului și, de obicei, este mai ușor de citit.

  De aceea, ar trebui să folosim o Expresie de funcție numai atunci când o Declarație de funcție nu este potrivită pentru sarcina respectivă. Am văzut câteva exemple în acest capitol și vom mai vedea și altele în viitor.

  .