variable - pass array to function javascript




JavaScript è un linguaggio pass-by-reference o pass-by-value? (20)

I tipi primitivi (Number, String, ecc.) Vengono passati per valore, ma gli oggetti sono sconosciuti, perché possono essere sia passati per valore (nel caso in cui consideriamo che una variabile che contiene un oggetto sia in realtà un riferimento all'oggetto ) e pass-by-reference (quando consideriamo che la variabile dell'oggetto mantiene l'oggetto stesso).

Anche se alla fine non importa, voglio sapere qual è il modo corretto per presentare gli argomenti che superano le convenzioni. Esiste un estratto dalla specifica JavaScript, che definisce quale dovrebbe essere la semantica in merito?


condividendo ciò che so di riferimenti in javascript

In Javascript, gli oggetti sono memorizzati come riferimenti:

var a = {
  a: 1,
  b: 2,
  c: 3
};
var b = a;

//b.c is referencing to a.c value
console.log(b.c) //output: 3
//changing value of b.c
b.c = 4
//also changes the value of a.c
console.log(a.c) //output: 4


JavaScript passa i tipi primitivi per valore e tipi di oggetto per riferimento

Ora, alle persone piace litigare all'infinito sul fatto che "passare per riferimento" sia il modo corretto per descrivere cosa sia Java et al. davvero. Il punto è questo:

  1. Passare un oggetto non copia l'oggetto.
  2. Un oggetto passato a una funzione può avere i suoi membri modificati dalla funzione.
  3. Un valore primitivo passato a una funzione non può essere modificato dalla funzione. Una copia è fatta

Nel mio libro si chiama passando per riferimento.

- Brian Bi - Quali sono i linguaggi di programmazione per riferimento?


  1. tipo primitivo variabile come stringa, il numero viene sempre passato come valore per valore.
  2. Array e Object vengono passati come pass per riferimento o come valore in base a queste due condizioni.

    • se stai cambiando il valore di quell'oggetto o matrice con un nuovo oggetto o matrice, allora passa per valore.

      object1 = {item: "car"}; array1=[1,2,3];

    qui si assegna un nuovo oggetto o array a quello vecchio. Non si sta cambiando il valore della proprietà del vecchio oggetto. Quindi è passato per valore.

    • se si modifica un valore di una proprietà di un oggetto o di un array, questo viene passato per riferimento.

      object1.key1= "car"; array1[0]=9;

    qui stai modificando un valore di proprietà del vecchio oggetto. Non stai assegnando un nuovo oggetto o array a quello vecchio. Così è passato per riferimento.

Codice

    function passVar(object1, object2, number1) {

        object1.key1= "laptop";
        object2 = {
            key2: "computer"
        };
        number1 = number1 + 1;
    }

    var object1 = {
        key1: "car"
    };
    var object2 = {
        key2: "bike"
    };
    var number1 = 10;

    passVar(object1, object2, number1);
    console.log(object1.key1);
    console.log(object2.key2);
    console.log(number1);

Output: -
    laptop
    bike
    10

È interessante in Javascript. Considera questo esempio:

function changeStuff(a, b, c)
{
  a = a * 10;
  b.item = "changed";
  c = {item: "changed"};
}

var num = 10;
var obj1 = {item: "unchanged"};
var obj2 = {item: "unchanged"};

changeStuff(num, obj1, obj2);

console.log(num);
console.log(obj1.item);    
console.log(obj2.item);

Questo produce l'output:

10
changed
unchanged
  • Se fosse puro passaggio per valore, la modifica di obj1.item avrebbe alcun effetto obj1 esterno alla funzione.
  • Se fosse puro passaggio per riferimento, allora tutto sarebbe cambiato. num sarebbe 100 , e obj2.item leggerà "changed" .

Invece, la situazione è che l'elemento passato viene passato per valore. Ma l'elemento che viene passato per valore è di per un riferimento. Tecnicamente, questo è chiamato call-by-sharing .

In termini pratici, ciò significa che se si modifica il parametro stesso (come con num e obj2 ), ciò non influirà sull'elemento inserito nel parametro. Ma se cambi gli INTERNI del parametro, questo si propagherà di nuovo (come con obj1 ).


Considera quanto segue:

  1. Le variabili sono puntatori ai valori in memoria.
  2. La riassegnazione di una variabile punta semplicemente il puntatore a un nuovo valore.
  3. La riassegnazione di una variabile non influirà mai su altre variabili che puntano allo stesso oggetto

Quindi, dimentica "passa per riferimento / valore" non rimanere bloccato su "passa per riferimento / valore" perché:

  1. I termini sono usati solo per descrivere il comportamento di una lingua, non necessariamente l'effettiva implementazione sottostante. Come risultato di questa astrazione, i dettagli critici che sono essenziali per una spiegazione decente vengono persi, il che porta inevitabilmente alla situazione attuale in cui un singolo termine non descrive adeguatamente il comportamento effettivo e devono essere fornite informazioni supplementari
  2. Questi concetti non erano originariamente definiti con l'intento di descrivere javascript in particolare e quindi non mi sento in dovere di usarli quando aggiungono solo confusione.

Per rispondere alla tua domanda: i riferimenti sono passati.


// code
var obj = {
    name: 'Fred',
    num: 1
};

// illustration
               'Fred'
              /
             /
(obj) ---- {}
             \
              \
               1


// code
obj.name = 'George';


// illustration
                 'Fred'


(obj) ---- {} ----- 'George'
             \
              \
               1


// code
obj = {};

// illustration
                 'Fred'


(obj)      {} ----- 'George'
  |          \
  |           \
 { }            1


// code
var obj = {
    text: 'Hello world!'
};

/* function parameters get their own pointer to 
 * the arguments that are passed in, just like any other variable */
someFunc(obj);


// illustration
(caller scope)        (someFunc scope)
           \             /
            \           /
             \         /
              \       /
               \     /
                 { }
                  |
                  |
                  |
            'Hello world'

Alcuni commenti finali:

  • È allettante pensare che le primitive siano applicate da regole speciali mentre gli oggetti non lo sono, ma le primitive sono semplicemente la fine della catena di puntatori.
  • Come ultimo esempio, considera perché un tentativo comune di cancellare un array non funziona come previsto.


var a = [1,2];
var b = a;

a = [];
console.log(b); // [1,2]
// doesn't work because `b` is still pointing at the original array

In JavaScript, il tipo di valore controlla esclusivamente se quel valore sarà assegnato dalla copia valore o dalla copia di riferimento .

I valori primitivi vengono sempre assegnati / passati per copia del valore :

  • null
  • undefined
  • stringa
  • numero
  • booleano
  • simbolo in ES6

I valori composti vengono sempre assegnati / passati per copia di riferimento

  • oggetti
  • array
  • funzione

Per esempio

var a = 2;
var b = a; // `b` is always a copy of the value in `a`
b++;
a; // 2
b; // 3

var c = [1,2,3];
var d = c; // `d` is a reference to the shared `[1,2,3]` value
d.push( 4 );
c; // [1,2,3,4]
d; // [1,2,3,4]

Nel frammento sopra, poiché 2 è una primitiva scalare, contiene una copia iniziale di quel valore e a b viene assegnata un'altra copia del valore. Quando si cambia b , non si cambia in alcun modo il valore in a .

Ma sia c che d sono riferimenti separati allo stesso valore condiviso [1,2,3] , che è un valore composto. È importante notare che né cd più "possiedono" il valore [1,2,3] - entrambi sono solo riferimenti peer uguali al valore. Quindi, quando si utilizza uno dei due riferimenti per modificare ( .push(4) ) l'effettivo valore di array condivisa, influisce solo .push(4) valore condiviso, e entrambi i riferimenti faranno riferimento al valore appena modificato [1,2,3,4] .

var a = [1,2,3];
var b = a;
a; // [1,2,3]
b; // [1,2,3]

// later
b = [4,5,6];
a; // [1,2,3]
b; // [4,5,6]

Quando eseguiamo il compito b = [4,5,6] , non facciamo assolutamente nulla per influenzare il punto in cui a fa ancora riferimento ( [1,2,3] ). Per fare ciò, b dovrebbe essere un puntatore a a piuttosto che un riferimento array - ma non esiste tale capacità in JS!

function foo(x) {
    x.push( 4 );
    x; // [1,2,3,4]

    // later
    x = [4,5,6];
    x.push( 7 );
    x; // [4,5,6,7]
}

var a = [1,2,3];

foo( a );

a; // [1,2,3,4]  not  [4,5,6,7]

Quando passiamo nell'argomento a , assegna una copia del riferimento a x . x e a sono riferimenti separati che puntano allo stesso valore [1,2,3] . Ora, all'interno della funzione, possiamo usare quel riferimento per mutare il valore stesso ( push(4) ). Ma quando eseguiamo l'assegnazione x = [4,5,6] , ciò non influisce in alcun modo sul punto in cui il riferimento iniziale a è puntato - punti fermi al valore (ora modificato) [1,2,3,4] .

Per passare in modo efficace un valore composto (come un array ) per copia del valore, è necessario crearne manualmente una copia, in modo che il riferimento passato non punti ancora all'originale. Per esempio:

foo( a.slice() );

Valore composto (oggetto, matrice, ecc.) Che può essere passato per copia di riferimento

function foo(wrapper) {
    wrapper.a = 42;
}

var obj = {
    a: 2
};

foo( obj );

obj.a; // 42

Qui, obj funge da wrapper per la proprietà primitiva scalare a . Quando viene passato a foo(..) , viene passata una copia del riferimento obj e impostata sul parametro wrapper . Ora possiamo usare il riferimento wrapper per accedere all'oggetto condiviso e aggiornare la sua proprietà. Al termine della funzione, obj.a visualizzerà il valore aggiornato 42 .

Source


L'oggetto all'esterno di una funzione viene passato in una funzione dando un riferimento all'oggetto esterno. Quando si usa quel riferimento per manipolare il suo oggetto, l'oggetto all'esterno viene quindi influenzato. Tuttavia, se all'interno della funzione hai deciso di puntare il riferimento a qualcos'altro, non hai affatto influenzato l'oggetto all'esterno, perché tutto ciò che hai fatto è stato reindirizzare il riferimento a qualcos'altro.


La variabile non "trattiene" l'oggetto, contiene un riferimento. È possibile assegnare tale riferimento a un'altra variabile, ora entrambi fanno riferimento allo stesso oggetto. È sempre passato per valore (anche quando quel valore è un riferimento ...).

Non c'è modo di alterare il valore detenuto da una variabile passata come parametro, cosa che sarebbe possibile se JS supportasse il passaggio per riferimento.


Passare argomenti a una funzione in JavaScript è analogo al passaggio dei parametri per il valore del puntatore in C:

/*
The following C program demonstrates how arguments
to JavaScript functions are passed in a way analogous
to pass-by-pointer-value in C. The original JavaScript
test case by @Shog9 follows with the translation of
the code into C. This should make things clear to
those transitioning from C to JavaScript.

function changeStuff(num, obj1, obj2)
{
    num = num * 10;
    obj1.item = "changed";
    obj2 = {item: "changed"};
}

var num = 10;
var obj1 = {item: "unchanged"};
var obj2 = {item: "unchanged"};
changeStuff(num, obj1, obj2);
console.log(num);
console.log(obj1.item);    
console.log(obj2.item);

This produces the output:

10
changed
unchanged
*/

#include <stdio.h>
#include <stdlib.h>

struct obj {
    char *item;
};

void changeStuff(int *num, struct obj *obj1, struct obj *obj2)
{
    // make pointer point to a new memory location
    // holding the new integer value
    int *old_num = num;
    num = malloc(sizeof(int));
    *num = *old_num * 10;
    // make property of structure pointed to by pointer
    // point to the new value
    obj1->item = "changed";
    // make pointer point to a new memory location
    // holding the new structure value
    obj2 = malloc(sizeof(struct obj));
    obj2->item = "changed";
    free(num); // end of scope
    free(obj2); // end of scope
}

int num = 10;
struct obj obj1 = { "unchanged" };
struct obj obj2 = { "unchanged" };

int main()
{
    // pass pointers by value: the pointers
    // will be copied into the argument list
    // of the called function and the copied
    // pointers will point to the same values
    // as the original pointers
    changeStuff(&num, &obj1, &obj2);
    printf("%d\n", num);
    puts(obj1.item);
    puts(obj2.item);
    return 0;
}

Pensalo in questo modo: è sempre un valore. Tuttavia, il valore di un oggetto non è l'oggetto stesso, ma un riferimento a quell'oggetto.

Ecco un esempio, passando un numero (un tipo primitivo)

function changePrimitive(val) {
    // At this point there are two '10's in memory.
    // Changing one won't affect the other
    val = val * 10;
}
var x = 10;
changePrimitive(x);
// x === 10

Ripetendo questo con un oggetto si ottengono risultati diversi:

function changeObject(obj) {
    // At this point there are two references (x and obj) in memory,
    // but these both point to the same object.
    // changing the object will change the underlying object that
    // x and obj both hold a reference to.
    obj.val = obj.val * 10;
}
var x = { val: 10 };
changeObject(x);
// x === { val: 100 }

Un altro esempio:

function changeObject(obj) {
    // Again there are two references (x and obj) in memory,
    // these both point to the same object.
    // now we create a completely new object and assign it.
    // obj's reference now points to the new object.
    // x's reference doesn't change.
    obj = { val: 100 };
}
var x = { val: 10 };
changeObject(x);
// x === { val: 10}

Direi che è pass-by-copy -

Considera che gli argomenti e gli oggetti variabili sono oggetti creati durante il contesto di esecuzione creato all'inizio dell'invocazione della funzione - e il tuo valore effettivo / riferimento passato alla funzione viene semplicemente memorizzato in questi argomenti + oggetti variabili.

Semplicemente parlando, per i tipi primitivi, i valori vengono copiati all'inizio della chiamata di funzione, per il tipo di oggetto, il riferimento viene copiato.


I valori semplici all'interno delle funzioni non cambieranno quei valori al di fuori della funzione (vengono passati per valore), mentre quelli complessi lo saranno (vengono passati per riferimento).

function willNotChange(x) {

x = 1;

}

var x = 1000;

willNotChange(x);

document.write('After function call, x = ' + x + '<br>'); //still 1000

function willChange(y) {

y.num = 2;

}

var y = {num: 2000}; 

willChange(y);
document.write('After function call y.num = ' + y.num + '<br>'); //now 2, not 2000

In un linguaggio di basso livello, se si desidera passare una variabile per riferimento, è necessario utilizzare una sintassi specifica nella creazione della funzione:

int myAge = 14;
increaseAgeByRef(myAge);
function increaseAgeByRef(int &age) {
  *age = *age + 1;
}

Il &ageè un riferimento a myAge, ma se si desidera che il valore è necessario convertire il riferimento, utilizzando *age.

Javascript è un linguaggio di alto livello che fa questa conversione per te. Quindi, sebbene gli oggetti siano passati per riferimento, la lingua converte il parametro di riferimento nel valore. Non è necessario utilizzare &, nella definizione della funzione, passarlo per riferimento, né *, sul corpo della funzione, per convertire il riferimento nel valore, JS lo fa per te.

Ecco perché quando provi a cambiare un oggetto all'interno di una funzione, sostituendo il suo valore (cioè age = {value:5}), la modifica non persiste, ma se modifichi le sue proprietà (cioè age.value = 5), lo fa.

Per saperne di più


C'è qualche discussione sull'uso del termine "passa per riferimento" in JS here , ma per rispondere alla tua domanda:

Un oggetto viene automaticamente passato per riferimento, senza necessità di specificarlo

(Dall'articolo di cui sopra.)


Ho trovato il metodo extend della biblioteca Underscore.js molto utile quando voglio passare un oggetto come un parametro che può essere sia modificato o sostituito interamente.

function replaceOrModify(aObj) {
  if (modify) {

    aObj.setNewValue('foo');

  } else {

   var newObj = new MyObject();
   // _.extend(destination, *sources) 
   _.extend(newObj, aObj);
  }
}

I primitivi vengono passati per valore e gli oggetti vengono passati per riferimento. Questo è abbastanza diverso da altre lingue come C, VB o Delphi. Non posso dire come gestiscono esattamente gli oggetti e le primitive, ma so di VB e Delphi che può (e dovrebbe) essere specificato.

php fa qualcosa di simile dalla versione 5: tutti gli oggetti sono passati per riferimento, ma tutti i primitivi possono essere passati per riferimento, se preceduti da una e commerciale (&). Altrimenti i primitivi vengono passati per valore.

Quindi, in javascript, se passo un oggetto X in una funzione tramite un parametro, sarà comunque X. Se si modificano i dati all'interno della funzione (o qualsiasi altro oggetto, ma ciò non è importante) il nuovo valore è disponibile anche al di fuori del funzione.


La spiegazione più succinta che ho trovato è stata nella guida di stile AirBNB :

  • Primitive : quando accedi a un tipo primitivo, lavori direttamente sul suo valore

    • stringa
    • numero
    • booleano
    • nullo
    • non definito

Per esempio:

var foo = 1,
    bar = foo;

bar = 9;

console.log(foo, bar); // => 1, 9
  • Complesso : quando accedi a un tipo complesso lavori su un riferimento al suo valore

    • oggetto
    • schieramento
    • funzione

Per esempio:

var foo = [1, 2],
    bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

In pratica, i tipi primitivi vengono passati per valore e i tipi complessi vengono passati per riferimento.


Per la programmazione degli avvocati linguistici, ho esaminato le seguenti sezioni di ECMAScript 5.1 (che è più facile da leggere rispetto all'ultima edizione), e andare fino a asking sulla mailing list di ECMAScript.

TL; DR : Tutte le informazioni vengono passate in base al valore, ma le proprietà degli oggetti sono riferimenti e la definizione di Object è spaventosamente assente nello standard.

Costruzione di liste di argomenti

La Sezione 11.2.4 "Elenchi di argomenti" dice quanto segue sulla produzione di un elenco di argomenti costituito da un solo argomento:

L'ArgumentList di produzione: AssignmentExpression viene valutato come segue:

  1. Lasciare che ref sia il risultato della valutazione di AssignmentExpression.
  2. Lascia che sia GetValue (ref).
  3. Restituisce una lista il cui unico oggetto è arg.

La sezione elenca anche i casi in cui l'elenco degli argomenti ha argomenti 0 o> 1.

Quindi, tutto è passato per riferimento.

Accesso alle proprietà dell'oggetto

Sezione 11.2.1 "Accessors di proprietà"

La MemberExpression di produzione: MemberExpression [Expression] viene valutata come segue:

  1. Lasciare che BaseReference sia il risultato della valutazione di MemberExpression.
  2. Lasciare baseValue essere GetValue (baseReference).
  3. Lascia che propertyNameReference sia il risultato della valutazione di Expression.
  4. Lascia che propertyNameValue sia GetValue (propertyNameReference).
  5. Chiama CheckObjectCoercible (baseValue).
  6. Sia PropertyNameString essere ToString (propertyNameValue).
  7. Se la produzione sintattica che viene valutata è contenuta in un codice di modalità rigoroso, è necessario che sia strict true, altrimenti sia strict essere false.
  8. Restituisce un valore di tipo Reference il cui valore di base è baseValue e il cui nome di riferimento è propertyNameString e il cui flag di modalità strict è rigoroso.

Pertanto, le proprietà degli oggetti sono sempre disponibili come riferimento.

In riferimento

È descritto nella sezione 8.7 "Il tipo di specifica di riferimento", che i riferimenti non sono tipi reali nella lingua: vengono utilizzati solo per descrivere il comportamento dell'eliminazione, del tipo di operatore e degli operatori di assegnazione.

Definizione di "Oggetto"

È definito nella versione 5.1 che "Un oggetto è una collezione di proprietà". Quindi, possiamo dedurre che il valore dell'oggetto è la collezione, ma quanto a qual è il valore della collezione è scarsamente definito nelle specifiche e richiede un po 'di effort per capire.


Semantica!! L'impostazione di definizioni concrete renderà necessariamente alcune risposte e commenti incompatibili poiché non stanno descrivendo la stessa cosa anche quando si usano le stesse parole e frasi, ma è fondamentale superare la confusione (specialmente per i nuovi programmatori).

Prima di tutto, ci sono più livelli di astrazione che non tutti sembrano afferrare. I nuovi programmatori che hanno imparato le lingue di quarta o quinta generazione possono avere difficoltà a concentrare la loro mente su concetti familiari ai programmatori di assembly o C non graditi da puntatori a puntatori a puntatori. Pass-by-reference non significa semplicemente la possibilità di cambiare un oggetto referenziato usando una variabile parametro funzione.

Variabile : concetto combinato di un simbolo che fa riferimento a un valore in una posizione particolare nella memoria. Questo termine è solitamente troppo carico per essere utilizzato da solo nella discussione dei dettagli.

Simbolo : stringa di testo usata per riferirsi alla variabile (es. Nome della variabile).

Valore : bit particolari memorizzati in memoria e referenziati utilizzando il simbolo della variabile.

Posizione di memoria : dove è memorizzato il valore di una variabile. (La posizione stessa è rappresentata da un numero separato dal valore memorizzato nella posizione.)

Parametro funzione : variabile dichiarata in una definizione di funzione, utilizzata per referenziare le variabili passate alla funzione.

Argomento della funzione : variabile al di fuori della funzione che viene passata alla funzione dal chiamante.

Variabile oggetto : variabile il cui valore di base di base non è l'oggetto stesso, ma il suo valore è un puntatore (valore di posizione di memoria) in un'altra posizione nella memoria in cui sono archiviati i dati reali dell'oggetto. Nella maggior parte dei linguaggi di più alta generazione, l'aspetto "puntatore" è effettivamente nascosto dalla de-referenziazione automatica in vari contesti.

Variabile primitiva : variabile il cui valore è il valore reale. Anche questo concetto può essere complicato da auto-boxing e contesti object-like di vari linguaggi, ma l'idea generale è che il valore della variabile sia il valore reale rappresentato dal simbolo della variabile piuttosto che un puntatore a un'altra posizione di memoria.

Gli argomenti e i parametri della funzione non sono la stessa cosa. Inoltre, il valore di una variabile non è l'oggetto della variabile (come già sottolineato da varie persone, ma apparentemente ignorato). Queste distinzioni sono fondamentali per una corretta comprensione.

Pass-by-value o Call-by-sharing (per oggetti): Il valore dell'argomento della funzione viene COPIATO in un'altra posizione di memoria a cui fa riferimento il simbolo del parametro della funzione (indipendentemente dal fatto che si trovi nello stack o nell'heap). In altre parole, il parametro function ha ricevuto una copia del valore dell'argomento passato ... E (critico) il valore dell'argomento NON È MAI AGGIORNATO / ALTERATO / MODIFICATO dalla funzione chiamante. Ricorda, il valore di una variabile oggetto NON è l'oggetto stesso, ma è il puntatore all'oggetto, quindi il passaggio di una variabile oggetto per valore copia il puntatore alla variabile parametro della funzione. Il valore del parametro della funzione punta esattamente allo stesso oggetto in memoria. I dati dell'oggetto stesso possono essere modificati direttamente tramite il parametro della funzione, MA il valore dell'argomento della funzione NON È MAI AGGIORNATO, quindi continuerà a puntare allo stessooggetto in tutto e anche dopo la chiamata della funzione (anche se i suoi dati dell'oggetto sono stati modificati o se al parametro funzione è stato assegnato un oggetto completamente diverso). Non è corretto concludere che l'argomento della funzione è stato passato per riferimento solo perché l'oggetto di riferimento è aggiornabile tramite la variabile del parametro della funzione.

Call / Pass-by-reference : il valore dell'argomento della funzione può / viene aggiornato direttamente dal parametro della funzione corrispondente. Se aiuta, il parametro della funzione diventa un "alias" effettivo per l'argomento - si riferiscono effettivamente allo stesso valore nella stessa posizione di memoria. Se un argomento di funzione è una variabile oggetto, la possibilità di modificare i dati dell'oggetto non è diversa dal caso pass-by-value poiché il parametro function continuerà a puntare allo stesso oggetto dell'argomento. Ma nel caso della variabile oggetto, se il parametro della funzione è impostato su un oggetto completamente diverso, anche l'argomento punta anche al diverso oggetto - ciò non accade nel caso del valore pass-by-value.

JavaScript non passa per riferimento. Se leggi attentamente, ti renderai conto che tutte le opinioni contrarie fraintendono cosa si intende per pass-by-value e concludono erroneamente che la possibilità di aggiornare i dati di un oggetto tramite il parametro function è sinonimo di "pass-by-value".

Oggetto clone / copia : viene creato un nuovo oggetto e vengono copiati i dati dell'oggetto originale. Può trattarsi di una copia profonda o di una copia superficiale, ma il punto è che viene creato un nuovo oggetto. La creazione di una copia di un oggetto è un concetto separato dal pass-by-value. Alcune lingue distinguono tra oggetti di classe e strutture (o simili) e possono avere un comportamento diverso per il passaggio di variabili di tipi diversi. Ma JavaScript non fa nulla di simile automaticamente quando passa le variabili oggetto. Ma l'assenza di clonazione automatica degli oggetti non si traduce in pass-by-reference.


Un modo semplice per determinare se qualcosa è "passa per riferimento" è se è possibile scrivere una funzione di "scambio". Ad esempio, in C, puoi fare:

void swap(int *i, int *j)
{
    int t;
    t = *i;
    *i = *j;
    *j = t;
}

Se non puoi fare l'equivalente di quello in Javascript, non è "passa per riferimento".





pass-by-value