Conţinutul principal

Biblioteca de informatică

Curs: Biblioteca de informatică > Unitatea 3

Lecția 10: Funcții

Recapitulare: Funcții

Aceasta este o recapitulare a noțiunilor învățate în tutorialul despre funcții.

Atunci când scriem programe, deseori vrem să putem reexecuta secvențe de cod, fără să fim nevoiți să rescriem întregul bloc de cod. Avem nevoie de o modalitate de a grupa codul şi de a-i da un nume, astfel încât să o putem apela mai târziu folosind acel nume, iar asta numim noi o funcție.

Pentru a crea o funcție, trebuie mai întâi să o declarăm și să îi dăm un nume, la fel cum am crea orice variabilă, apoi urmează definiția funcției:

var saluta = function() {
};

Am putea pune orice cod în interiorul acelei funcții - o singură instrucțiune sau mai multe instrucțiuni - depinde de ceea ce vrem să facem. În această funcție, am putea să afișăm un mesaj într-o locație aleatoare:

var saluta = function() {
   text("Saluuuuuut!", random(200), random(200));
};

Acum, dacă tot ce facem este să declarăm funcţia, nu se va întâmpla nimic. Pentru ca programul să execute codul din interiorul funcției, trebuie să apelăm funcţia, scriindu-i numele urmat de paranteze goale:

saluta();

Şi apoi o puteam apela oricând dorim, de câte ori dorim!

saluta();
saluta();
saluta();

Adesea vrem să putem personaliza funcţiile, pentru a spune programului "bine, executa tot acest cod, dar schimbă câteva lucruri atunci când faci asta." Astfel, avem un cod care este atât reutilizabil cât şi flexibil. Putem realiza acest lucru specificând "argumente" pentru o funcție, folosind aceste argumente pentru a schimba modul în care se execută funcţia, precizându-i când apelăm funcţia.

De exemplu, dacă am dori să putem spune exact unde vrem să fie afișat mesajul, așa cum putem spune exact unde vrem să desenăm rect() şi elipse()? Am putea să o apelăm punând mesajul la două coordonate precizate:

saluta(50, 100);
saluta(150, 200);

Pentru ca să funcționeze, trebuie să schimbăm definiția funcției noastre saluta, astfel încât să știe că va primi 2 argumente, pe care apoi să le utilizeze:

var saluta = function(xPoz, yPoz) {
   text("Saluuuuut!", xPoz, yPoz);
};

Argumentele care sunt transmise la momentul apelării devin variabile în interiorul definiției funcției tale, iar numele lor depind de felul cum le numeşti între paranteze. Le-am putea redenumi cu ceva mai scurt:

var saluta = function(x, y) {
   text("Saluuuuut!", x, y);
};

Funcțiile noastre pot accepta orice număr de argumente - zero, unul, două, sau mai multe. De asemenea, am fi putut decide dacă dorim să modificăm funcţia pentru a accepta numele celui pe care îl salută:

var saluta = function(nume) {
   text("Saluuuut, " + nume, random(200), random(200));
};

Atunci am apela-o astfel:

saluta("Ana");
saluta("Cosmin");

Am putea combina aceste idei și am putea să facem funcția să accepte trei argumente, pentru nume și poziție:

var saluta = function(nume, x, y) {
   text("Saluuuut " + nume, x, y);
};

Și atunci am apela-o astfel:

saluta("Ana", 10, 100);

Depinde cu adevărat de ceea îți dorești să faci cu funcțiile și de cât de mult dorești să le personalizezi. Poți oricând să începi fără argumente, apoi să le adaugi, pe măsură ce îți dați seama că ai nevoie de ele.

De fapt, până acum ai apelat funcţii tot timpul - aşa ai făcut desene şi animaţii - funcții precum rect, ellipse, triangle, etc. Toate aceste funcţii provin din biblioteca ProcessingJS, pe care noi o încărcăm în fiecare program pe care îl creezi aici, astfel încât să le poţi folosi întotdeauna. Am definit funcţiile pentru tine, pentru că am crezut că vor fi utile, iar acum depinde de tine să decizi ce funcții personalizate vrei să folosești în propriile programe. De exemplu, oferim funcţia ellipse, dar nu oferim o funcţie pisică - dacă programul tău conține multe pisici în diferite locaţii, poate ar trebui să-ți creezi propria funcție pisică!

Mai există un alt lucru important pe care îl putem face cu funcţiile. Le putem folosi pentru a prelua anumite valori care să fie procesate și apoi funcția să returneze o nouă valoare. Gândește-te la toate lucrurile pe care le poți face cu un calculator - aduni valori, scazi, calculezi rădăcina pătrată, înmulțești, etc. Toate acestea ar fi realizate cu funcții care primesc valorile ca parametri și returnează valoarea calculată. Funcțiile vor primi valorile ca argumente și apoi întorc rezultatul folosind o instrucțiune return. Uite o funcţie care adună două numere şi returnează rezultatul:

var adunaNumere = function(num1, num2) {
  var rezultat = num1 + num2;
  return rezultat;
};

var suma = adunaNumere(5, 2);
text(suma, 200, 200); // Afișează "7"

Instrucțiunea return face două lucruri: returnează o valoare înapoi celui care a apelat (de aceea am putut-o stoca în variabila sum) şi iese imediat din funcţie. Asta înseamnă că ar fi greșit dacă am avea un cod precum cel de mai jos, pentru că ultima linie nu ar fi executată niciodată:

var adunaNumere = function(num1, num2) {
  var rezultat = num1 + num2;
  return rezultat;
  rezultat = rezultat * 2; // greșit!
};

Funcțiile care returnează valori sunt destul de utile pentru manipularea datelor în programe și ele pot fi combinate și în expresii:

var sumaMare = adunaNumere(2, 5) + adunaNumere(3, 2);

Poți chiar apela funcții în interiorul apelurilor altor funcții, deși acest lucru poate fi greu de citit uneori:

var superSuma = adunaNumere(adunaNumere(5, 2), adunaNumere(3, 7));

Acum că știi cum să creezi funcții care încorporează secvențe de cod, trebuie să vorbim despre un concept important: variabile locale versus variable globale.

Când declarăm o nouă variabilă în interiorul unei funcții, spunem că este locală acestei funcții. Asta pentru că doar acea funcţie poate vedea variabila - restul programului nu poate. Odată ce suntem în afara acestei funcții, este ca și cum nu mai există. În următoarea funcție, rezultatLocal este o variabilă locală:

var adunaNumere = function(num1, num2) {
  var rezultatLocal = num1 + num2;
  println("Rezultatul local este: " + rezultatLocal);
  return rezultatLocal;
};
adunaNumere(5, 7);
println(rezultatLocal); // vai nu!

Când executam acel cod, vom primi o eroare la linia finală: "rezultatLocal nu este definit." Variabila este definită doar în interiorul funcţiei, pentru că acolo am declarat-o cu linia var rezultatLocal = şi nu este definită în afara ei.

Când declarăm o variabilă în afara funcţiilor noastre, spunem că este o variabilă globală. Asta pentru că toate funcțiile o pot accesa acum și pot face orice vor cu ea.

var rezultatGlobal;

var adunaNumere = function(num1, num2) {
  rezultatGlobal = num1 + num2;
  println("Rezultatul global este: " + rezultatGlobal);
};
adunaNumere(5, 7);
println(rezultatGlobal);

Când rulăm codul de mai sus, nu vom primi o eroare, pentru că am declarat rezultatGlobal în afara funcţiei, astfel încât să o putem accesa de oriunde ne dorim.

⚠️ Ai putea fi tentat să folosești variabile globale pentru orice, deoarece nu vei primi niciodată o eroare legată de faptul că nu sunt definite. Dar, de fapt, variabilele globale sunt o sursă de erori greu de identificat. În programe mai mari sau în programele colaborative, este ușor de pierdut locul și modul în care tu (sau alții!) s-au folosit aceste variabile globale. Atunci când este posibil, folosește variabile locale.

Fiecare limbaj de programare este diferit, dar pentru JavaScript este important să ştim că variabilele au "function scope" - o funcţie poate vedea variabilele locale care au fost declarate în interiorul lor şi variabilele globale care au fost declarate în afara ei, dar nu poate vedea variabilele locale din interiorul altor funcţii.

Vrei să te alături conversației?

Conectare

Ordonare după:

Nici o postare încă.

Înțelegi engleza? Dă clic aici pentru a vedea mai multe discuții care au loc pe site-ul în limba engleză al Khan Academy.