Passer par valeur ou passer par référence, est-ce important ?

Passer par valeur vs passer par référence : une discussion approfondie

Lors de mon premier entretien technique, on m'a posé cette question : Quelle est la différence entre passer par valeur et passer par référence ? Ma réponse est : le passage par valeur transmet une valeur, le passage par référence transmet une référence. Bien que cette réponse soit basique et même superficielle, elle n’est pas entièrement fausse et nécessite simplement des explications supplémentaires.

Passage de valeur : La valeur de la variable est copiée et transmise à la fonction en tant que paramètre. La fonction utilise cette valeur copiée pour effectuer diverses opérations, et la valeur de la variable d'origine reste inchangée . Presque tous les langages de programmation connus, y compris JavaScript et Java, utilisent le passage par valeur.

Passage par référence : Une référence fait référence à une variable qui pointe vers une valeur en mémoire. Considérez-la comme un pointeur. Il est transmis à la fonction en tant que paramètre et un alias (référence d'alias) lui est attribué à l'aide du paramètre. La fonction effectue diverses opérations à l'aide de ce paramètre, qui donne accès à l'emplacement mémoire de la valeur. Par conséquent, toute opération utilisant ce paramètre affectera la valeur de la variable d'origine, et la valeur de la variable d'origine sera modifiée. Seuls quelques langages de programmation utilisent le passage par référence, par exemple C a cette capacité, mais même en C, le mode par défaut est le passage par valeur.

Exemple de transmission de valeur :

L'exemple suivant utilise JavaScript, qui suit strictement le passage de valeurs, qu'il s'agisse d'un type primitif ou d'un type référence (objet). Voici un exemple classique de fonction swap :

const firstPrimitive = 1; //传递给firstArgument的原始值
const secondPrimitive = 2; //传递给secondArgument的原始值

const firstObject = {name: "first", reason: "Test pass-by-value"}; //传递给firstArgument的对象
const secondObject = {name: "second", reason: "Test pass-by-value"}; //传递给secondArgument的对象

function swap(firstArgument, secondArgument){
    const placeholder = secondArgument;
    secondArgument = firstArgument;
    firstArgument = placeholder;

    console.log('当前位于函数内部。');
    console.log('firstArgument = ', firstArgument, ', secondArgument = ', secondArgument, '\n');
}

console.log('函数执行前。');
console.log('firstPrimitive = ', firstPrimitive, ', secondPrimitive =', secondPrimitive);
console.log('firstObject = ', firstObject, ', secondObject =', secondObject, '\n');

swap(firstPrimitive, secondPrimitive);
console.log('当前位于函数外部。');
console.log('firstPrimitive = ', firstPrimitive, ', secondPrimitive =', secondPrimitive, '\n');

swap(firstObject, secondObject)
console.log('当前位于函数外部。');
console.log('firstObject = ', firstObject, ', secondObject =', secondObject, '\n');

Après avoir exécuté ce code, les résultats sont les suivants :

<code>函数执行前。
firstPrimitive =  1 , secondPrimitive = 2
firstObject =  { name: 'first', reason: 'Test pass-by-value' } , secondObject = { name: 'second', reason: 'Test pass-by-value' }

当前位于函数内部。
firstArgument =  2 , secondArgument =  1

当前位于函数外部。
firstPrimitive =  1 , secondPrimitive = 2

当前位于函数内部。
firstArgument =  { name: 'second', reason: 'Test pass-by-value' } , secondArgument =  { name: 'first', reason: 'Test pass-by-value' }

当前位于函数外部。
firstObject =  { name: 'first', reason: 'Test pass-by-value' } , secondObject = { name: 'second', reason: 'Test pass-by-value' }</code>

Notez qu'à l'intérieur de la fonction swap, les deux valeurs sont inversées, cependant, en dehors de la fonction, les valeurs restent les mêmes.

Exemple de passage par référence :

L'exemple suivant utilise du C et peut être implémenté en passant par référence. Ceci peut être réalisé en utilisant l'opérateur d'adresse (&). Encore une fois, il utilise une version de la fonction swap :

#include <stdio.h>

void swap(int &i, int &j) {
  int temp = i;
  i = j;
  j = temp;
}

int main(void) {
  int a = 10;
  int b = 20;

  swap(a, b);
  printf("A is %d and B is %d\n", a, b);
  return 0;
}

Le résultat de sortie est :

<code>A is 20 and B is 10</code>

Ici, les valeurs de a et b sont modifiées car elles sont utilisées comme références.

Résumé : Passer par référence signifie que la fonction reçoit l'adresse mémoire de la variable (par référence), lui permettant de modifier directement la variable d'origine tandis que passer par valeur signifie qu'une copie de la variable ; la valeur est transmise sans modifier la variable d'origine.

Est-ce important ?

La plupart des langages de programmation utilisent le passage par valeur, et nous semblons n'avoir pas le choix. Alors, comment cela s’applique-t-il ? Voici ce que j'ai trouvé :

• Utilisez le passage par valeur lorsque vous "utilisez" simplement un paramètre pour effectuer des calculs sans le modifier pour le programme client.
• Utilisez le passage par référence lorsque vous avez besoin d'une fonction pour modifier la valeur originale d'une variable passée en argument, car elle opère directement sur l'emplacement mémoire de la variable au lieu de créer une copie, ce qui la rend plus efficace, surtout lorsque traiter de grandes structures de données (comme un objet ou un tableau complexe) ; cela évite la surcharge liée à la copie des données et permet de modifier la variable d'origine directement dans la fonction. Le passage par référence peut améliorer les performances.

Commentaires bienvenus. Merci.

Matériels de référence : JavaScript est-il transmis par référence ? Passer par référence (C uniquement)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!