Passagem de Parâmetros por Valor e por Referência - JavaScript

Passagem de Parâmetros por Valor

Strings, números e valores booleanos são passados para funções por valor. Ou seja, quando um valor é passado para uma função, ela recebe uma cópia desse valor. Vamos ver o que isso significa na prática:

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

let n = 10;
console.log("n antes de change:", n); // n antes de change: 10
change(n);                            // x em change: 20
console.log("n depois de change:", n); // n depois de change: 10

A função change recebe um número e o duplica. Ao chamar a função, o valor n é passado. No entanto, após a chamada, n permanece inalterado, embora dentro da função o valor do parâmetro tenha sido alterado. Isso acontece porque a função recebe uma cópia do valor de n, e quaisquer mudanças feitas nesta cópia não afetam a variável original n.

Passagem por Referência

Objetos e arrays são tipos referenciados. Ou seja, uma variável ou constante que representa um objeto ou array armazena na verdade uma referência ou ponteiro para a memória onde o objeto ou array está localizado. Por exemplo:

let bob = {
    name: "Bob"
};

A variável bob tecnicamente armazena uma referência a um objeto que tem um campo name. E ao passar objetos ou arrays para uma função, ela recebe uma cópia dessa referência, não uma cópia do objeto ou array.

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

console.log("antes de change:", bob.name); // Bob
change(bob);
console.log("depois de change:", bob.name); // Tom

Nesse exemplo, a função change recebe um objeto e altera sua propriedade name. A função recebe uma cópia da referência de bob, que aponta para o mesmo objeto na memória.

Se tentarmos redefinir completamente o objeto ou array, o valor original não será alterado:

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

console.log("antes de change:", bob.name); // Bob
change(bob);
console.log("depois de change:", bob.name); // Bob

Por que os dados não mudam nesse caso? Aqui, a função recebe uma cópia da referência de bob. Ao redefinir o parâmetro user para outro objeto, essa nova referência aponta para um objeto diferente na memória, separando bob e user.

O mesmo vale para arrays:

function change(array) {
    array[0] = 8;
}

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

let numbers = [1, 2, 3];

console.log("antes de change:", numbers);      // [1, 2, 3]
change(numbers);
console.log("depois de change:", numbers);     // [8, 2, 3]
changeFull(numbers);
console.log("depois de changeFull:", numbers); // [8, 2, 3]

Aqui, a função change modifica o primeiro elemento do array, enquanto changeFull redefine o array para uma nova sequência. No entanto, a redefinição não afeta o array original, pois a nova referência aponta para um array diferente na memória.

Essa é uma introdução básica sobre passagem de parâmetros por valor e por referência em JavaScript, útil para entender como os dados são manipulados dentro das funções.