Transmiterea parametrilor prin valoare și prin referință

Transmiterea parametrilor prin valoare

Șirurile, numerele, valorile logice sunt transmise către funcție prin valoare. Cu alte cuvinte, la transmiterea unei valori către o funcție, acea funcție primește o copie a acelei valori. Să vedem ce înseamnă asta în practică:

function change(x){
   x = 2 * x;
   console.log("x in change:", x);
}

let n = 10;
console.log("n before change:", n); // n before change: 10
change(n);                          // x in change: 20
console.log("n after change:", n);  // n after change: 10

Funcția change primește un număr și îl dublează. La apelul funcției change, acesteia i se transmite un număr n. Cu toate acestea, după apelul funcției, observăm că numărul n nu s-a modificat, deși în interiorul funcției a avut loc dublarea valorii parametrului.

Aceasta se întâmplă deoarece la apelul funcției change, aceasta primește o copie a valorii variabilei n. Orice modificări asupra acelei copii nu afectează în mod direct variabila n în sine. În final, obținem următorul rezultat în consola browserului:

n before change: 10
x in change: 20
n after change: 10

Transmitere prin referință

Obiectele și array-urile sunt tipuri de date referențiale. Cu alte cuvinte, o variabilă sau o constantă care reprezintă un obiect sau un array, stochează efectiv o referință sau, în alte cuvinte, un pointer care indică adresa din memorie unde este stocat obiectul. De exemplu:

let bob ={
   name: "Bob"
};

Variabila bob stochează formal un obiect în care este definit un singur câmp numit name. În realitate, însă, variabila bob stochează o referință către obiectul care este localizat undeva în memorie.

Și tipurile referențiale - obiectele și array-urile - sunt transmise către o funcție prin referință. Cu alte cuvinte, funcția primește o copie a referinței către obiect, nu o copie a obiectului însuși.

function change(user){
   user.name = "Tom";
}

let bob ={
   name: "Bob"
};
console.log("before change:", bob.name);    // Bob
change(bob);
console.log("after change:", bob.name);     // Tom

În acest caz, funcția change primește un anumit obiect și modifică proprietatea name a acestuia. La apelul funcției, acesteia i se transmite valoarea variabilei bob:

change(bob);

Fiindcă variabila bob reprezintă un obiect și stochează o referință către un anumit obiect în memorie, funcția change primește o copie a acelei referințe, care indică către același obiect în memorie ca și variabila bob.

În final, vom observa că, după apelul funcției, obiectul original bob, care a fost transmis funcției, a fost modificat.

before change: Bob after change: Tom

Cu toate acestea, dacă încercăm să reasignăm complet un obiect sau un array, valoarea originală nu va fi modificată.

function change(user){
   //reasignarea completă a obiectului
   user= { name:"Tom" };
}

let bob ={
   name: "Bob"
};
console.log("before change:", bob.name);    // Bob
change(bob);
console.log("after change:", bob.name);     // Bob

De ce datele nu se modifică aici? Deoarece, așa cum s-a menționat mai sus, funcția primește o copie a referinței. Adică, atunci când variabila bob este transmisă ca argument la funcție:

change(bob);

Variabila bob și parametrul user reprezintă două referințe diferite, dar care indică către același obiect.

La asignarea unui alt obiect parametrului în funcție:

user= { name:"Tom" };

Referința user începe să indice către un alt obiect în memorie. Astfel, după aceasta, bob și user devin două referințe diferite, care indică către două obiecte diferite în memorie.

Același lucru se aplică și la array-uri:

function change(array){
   array[0] = 8;
}
function changeFull(array){
   array = [9, 8, 7];
}

let numbers = [1, 2, 3];

console.log("before change:", numbers);     // [1, 2, 3]
change(numbers);
console.log("after change:", numbers);      // [8, 2, 3]
changeFull(numbers);
console.log("after changeFull:", numbers);  // [8, 2, 3]