Pokażę, dlaczego folklor, że „obiekty JS są przekazywane przez referencję, prymitywy przez wartość” nie ma nic wspólnego z przekazywaniem, obiektami ani referencjami i jest w rzeczywistości iluzją. „Obiekty są przekazywane przez odniesienie” (OAPBR) to model teoretyczny/mentalny. Podobnie jak większość teorii, należy ją oceniać na podstawie jej wkładu w zrozumienie, przewidywanie, kontrolę oraz jej koszt pod względem złożoności. Mam nadzieję, że wykorzystam ten przykład jako dowód na to, że bardzo niepoprawny model mentalny:

• Utrudnia naukę zaawansowanych funkcji
• Utrudnia naukę innych języków programowania
• I marnuje czas. Na koniec zasugeruję unikanie bardzo niepoprawnych modeli mentalnych.

Aby pokazać, co stara się wyjaśnić teoria „Obiekty są przekazywane przez odniesienie” (OAPBR), najpierw potrzebujemy dwóch definicji:

function plusNum(n1, n2) {
 return n1 + n2;
}

function mutatingAdd(obj1, n) {
 obj1.value = plusNum(obj1.value, n)
}

function takeNum(n /* number */) {
 n = plusNum(n, 1);
 console.log(n); // 2
}

function primitiveExample() {
 let x = 1;
 takeNum(x);
 console.log(x); // 1
}

function mutateObj(obj /* {field: number} */) {
 mutatingAdd(obj, 1);
 console.log(obj.value); // 2
}

function objectExample() {
 let x = {value: 1};
 mutateObj(x);
 console.log(x.value); // 2
}

Jak teoria „Obiekty są przekazywane przez odniesienie” (OAPBR) zawodzi

Teraz pokażę, że poprzednie przykłady nie mają nic wspólnego z przekazywaniem wartości do funkcji, dostosowując przykłady tak, aby nie używały funkcji:

function primitiveExample2() {
 let x = 1;
 let y = x;
 y = y + 1;
 console.log(y); // 2
 console.log(x); // 1
}

function objectExample2() {
 let x = { value: 1 };
 let y = x;
 y.value = y.value + 1;
 console.log(y.value); // 2
 console.log(x.value); // 2
}

function combinedExample1() {
 let x = Object.assign(1, { value: 100 });
 let y = x;
 mutatingAdd(y, 100);
 console.log(y.value); // 200
 console.log(x.value); // 200
 y = plusNum(y, 1);
 console.log(y + 0); // 2
 console.log(x + 0); // 1
}

function nonMutatingPlusObj(obj1, obj2) {
 return { value: obj1.value + obj2.value };
}

function nonMutatingObjectExample() {
 let x = {value: 100};
 let y = x;
 y = nonMutatingPlusObj(y, {value: 100})
 console.log(y.value); // 200
 console.log(x.value); // 100
}

<?php

function add_mut(&$i1, $i2) {
 $i1 += $i2;
}

$x = 1;
add_mut($x, 1);
echo $x; // 2
?>

fn add_mut(i: &mut i32, i2: i32) {
 *i = (*i) + i2;
}

fn main() {
 let i = &mut 1;
 add_mut(i, 1);
 println!("{}", i); // 2
}

function makeRef(thing) {
 return {value: thing};
}

function addMut(iRef, i2) {
 iRef.value = iRef.value + i2;
}

let iRef = makeRef(1);
addMut(iRef, 1);
console.log(iRef.value); // 2

Lepsza teoria

Zamiast „Obiekty są przekazywane przez referencję, prymitywy są przekazywane przez wartość”, sugeruję lepsze rozróżnienie: między mutacją zakresu a mutacją wartości. W JS zakresy to zmienne odwzorowania nazw zmiennych na wartości.

let x = 1; // the scope maps x to 1
x = 2; // the scope maps x to 2
x += 1; // the scope maps x to 3

Złudzenie „przekazania przez referencję” prawdopodobnie pojawia się w kontekście funkcji, ponieważ każda funkcja wprowadza nowy zakres. Więcej o zakresach w MDN .

W poniższym kodzie xwskaż yten sam obiekt, który mutateObjmutuje. mutatingAddnie mutuje zakresu, ponieważ w funkcjach JavaScript nie można mutować zakresu, nie zamykają się:

function objectExample() {
  let x = {value: 1}; 
  let y = x;
  mutatingAdd(y, 1);
  console.log(y.value); // 2
  console.log(x.value); // 2
}

W szczególności dla JS zrozumienie, że zakres jest zmienny, jest niezbędne do zrozumienia const-vs-let, shadowingu, tożsamości obiektów, zamknięć i pisania interfejsów użytkownika. A to taka prosta koncepcja w porównaniu z niepoprawnym rozróżnieniem „według wartości vs. przez referencję”.

Co dalej

Widziałem złe modele mentalne dla języków programowania pochodzące z tych źródeł:

• Nie korzystaj z żadnych zasobów edukacyjnych, ale zamiast tego zanurzaj się i próbuj programować. To może wydawać się szybkie, ale myślę, że na dłuższą metę jest to powolna trasa.
• Uczenie się z postów na blogach lub filmów. (Wiem, że to post na blogu: ufaj MDN bardziej niż czemukolwiek tutaj.)
• Zakładając, że cechy języka programowania są oczywiste. Nic nie jest oczywiste, zwłaszcza zmienne, i istnieją zaskakujące różnice między językami programowania i wewnątrz nich, jeśli chodzi o sposób działania.

Miłego hakowania!