Discussion :

[free_01_binairy]

Je voudrais savoir s'il est possible de passer par reference un argument en javascript . si oui comment procède t-on? Merci

[kaari kosaku]

Si je ne me trompe pas, les arguments en javascript sont tous passés en référence, hormis les types primitifs.
A confirmer.

[Watilin]

Vrai. Les types primitifs en JS sont les nombres et les booléens. Tout le reste est objet donc passé par référence, ce qui inclut les chaînes, les tableaux, les fonctions, etc.

Exemple avec un objet littéral :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
var obj = {};
 
function ajouterProp(o) {
  o.prop = "bonjour";
}
 
ajouterProp(obj); // obj est automatiquement passé par référence
 
console.log(o.prop); // affiche "bonjour" dans la console

Certains sont tentés de déclarer toutes leurs variables avec new, y compris celles de type primitif, par exemple new Number(42). C'est une mauvaise idée, car en faisant ça on crée en fait un objet et les avantages du type primitif sont perdus.

[lysandro]

Les arguments d'une fonction en Javascript sont tous sans exception, c'est à dire quel que soit leur type objet ou pas, passés par valeur et non par référence.

La spécificité d'un passage par référence est que dans l'appelant, l'argument passé peut revenir modifié. On ne parle pas de son contenu, mais de l'argument lui même.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
// Soit une fonction qui échange ses arguments :
function swap ( a, b ) {
    var t = a;
    a = b;
    b = t;
}
var a = 1, b = "deux";
swap(a,b);
// Si a et b étaient passés par référence, on aurait
// a == "deux" et b == 1
// mais ici, on aura toujours
// a == 1 et b == "deux"

Quels que soient les types et valeurs pour a et b.

[Darkaurora]

Je rejoins kaari & Watilin sur ce point pour ma part tout ce qui est objet sera passé par référence, tout ce qui est primitive sera par valeur.

Ton exemple lysandro, utilise deux primitives. Un Number & un String

[Golgotha]

Exemple avec un Objet :



C'est bien l'adresse de l'objet qui est passée.

[sekaijin]

je ne sais pas quel est le langage de préilection de lysandro
Mais je pense qu'il y a confusion sur le terme référence.

il existe 3 façon de passer une variable à une fonction.
Par valeur
Par référence
Par pointeur

Le passage par valeur est facile à comprendre.
La valeur est donnée à la fonction et celle-ci ne connait pas la variable. elle ne peut donc pas la modifier.

Le passage par référence conciste à donner une référence à la variable en parrametre à la fonction.
La fonction a donc connaissance de la variable et peut en modifier la valeur. mais elle ne peut pas modifier la variable elle même.
par exemple si je passe un objet User dont le nom est toto je peut modifier le non de User mais cela restera User.

Le passage par pointeur conciste à donner une référence sur l'adresse de la variable.
la fonction peut donc accéder à la valeur.
elle a aussi connaissance de la variable et peut modifier sa valeur
mais comme elle a une référence à l'adresse elle peut aussi modifier cette référence.

la chose se résume ainsi
soit deux varaible référençant le même objet

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
    +--------+
a ->|        |
    |  x:15  |
b ->|        |
    +--------+

Appel par valeur f(a); l'objet référencé par a et par b n'a pas changé

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
    +--------+
a ->|        |
    |  x:15  |
b ->|        |
    +--------+

Appel par référence f(a); l'objet référencé par a et par b a pas changé mais a et b référence toujour cet objet

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
    +--------+
a ->|        |
    |  x:32  |
b ->|        |
    +--------+

Appel par pointf(a); l'objet référencé par a n'est plus le même que celui référencé par b.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
    +--------+
a ->|  x:32  |
    +--------+
 
    +--------+
b ->|  x:15  |
    +--------+

En Javascript seuls les passage par valeur pour les type primitifs et par référence pour tout le reste existe.

A+JYT

[SylvainPV]

Vrai. Les types primitifs en JS sont les nombres et les booléens. Tout le reste est objet donc passé par référence, ce qui inclut les chaînes, les tableaux, les fonctions, etc.

Les chaînes de caractères sont des primitives aussi !
http://msdn.microsoft.com/en-us/libr...(v=vs.94).aspx
https://developer.mozilla.org/fr/doc...e_donn%C3%A9es

Si on prend comme définition de primitive tout ce qui n'est pas objet, on a bien "string" instanceof Object === false.