Objeto como Resultado de uma Função - JavaScript

Funções podem retornar objetos. Isso pode ser necessário em diversas tarefas. Por exemplo, vamos delegar a criação de um objeto a uma função separada:

function createUser(pName, pAge) {
    return {
        name: pName,
        age: pAge,
        print: function() {
            console.log(`Nome: ${this.name}  Idade: ${this.age}`);
        }
    };
};
const tom = createUser("Tom", 26);
tom.print();
const alice = createUser("Alice", 24);
alice.print();

Aqui, a função createUser() recebe valores pName e pAge e com eles cria um novo objeto, que é o resultado retornado. Resultado da execução do programa:

Nome: Tom  Idade: 26
Nome: Alice  Idade: 24

A vantagem de delegar a criação de um objeto a uma função é que podemos criar vários objetos semelhantes com valores diferentes, atuando como uma fábrica ou construtora. Além disso, nessa função, podemos verificar a correção dos valores passados e, em caso de incorreção, reagir de alguma maneira:

function createUser(pName, pAge) {
    if(pAge < 1 || pAge > 110){       // se a idade for menor que 1 ou maior que 110
        console.log("Idade inválida")
        pAge = 1;
    }
    return {
        name: pName,
        age: pAge,
        print: function() {
            console.log(`Nome: ${this.name}  Idade: ${this.age}`);
        }
    };
 };
 const tom = createUser("Tom", 26);
 tom.print();
 const alice = createUser("Alice", 12345);
 alice.print();

Aqui, o parâmetro pAge, que representa a idade do usuário, é verificado. Teoricamente, isso pode ser qualquer número que pode exceder limites razoáveis, como ser negativo. Neste caso, verificamos pAge para garantir que esteja dentro desse limite. Se o valor de pAge não estiver dentro do limite, atribuímos a ele um valor padrão, neste caso é 1, e emitimos uma mensagem de diagnóstico. Saída do console do programa:

Nome: Tom  Idade: 26
Idade inválida
Nome: Alice  Idade: 1

Também, retornar um objeto pode ser útil se precisarmos retornar mais de um resultado de uma função - neste caso, podemos combiná-los em um único objeto. Por exemplo, a função recebe um array e encontra os valores mínimo e máximo nele:

function getMinMax(numbers){
    // se o array estiver vazio, os valores mínimo e máximo são indefinidos
   if(numbers.length === 0) return { min: undefined, max: undefined };
  
   let minNumber = numbers[0];
   let maxNumber = numbers[0];
   for(let i=1; i < numbers.length; i++) {
        if(minNumber > numbers[i]) minNumber = numbers[i];
        if(maxNumber < numbers[i]) maxNumber = numbers[i];
   }
   return { min: minNumber, max: maxNumber };
 }
  
 const nums = [1, 2, 3, 4, 5];
 const result = getMinMax(nums);
 console.log("Min:", result.min);    // Min: 1
 console.log("Max:", result.max);    // Max: 5

Aqui, a função getMinMax() recebe um array de números e retorna um objeto com os valores mínimo e máximo. Se o array estiver vazio, a função retorna um objeto com valores indefinidos. Se o array não estiver vazio, a função encontra os valores mínimo e máximo e os retorna em um objeto.

Objeto como Parâmetro

Assim como todos os outros valores, um objeto pode ser passado como parâmetro em uma função:

function printPerson(person) {
    console.log("Nome:", person.name);
    console.log("Idade:", person.age);
 }
  
const tom = { name: "Tom", age: 39 };
const alice = { name: "Alice", age: 35 };

printPerson(tom);
printPerson(alice);

Aqui, a função printPerson recebe um objeto que, presume-se, terá duas propriedades: name e age.

Ao passar um objeto para uma função, a referência ao objeto é passada. Isso significa que a função pode alterar as propriedades do objeto através desta referência:

function setAge(person, pAge) {
    person.age = pAge;
 }
  
 const sam = { name: "Sam", age: 29 };
 console.log("Antes de setAge:", sam.age);
 setAge(sam, 30);
 console.log("Depois de setAge:", sam.age);

Neste caso, a constante sam armazena uma referência para a área de memória onde o objeto está localizado. A função setAge é chamada, recebendo o objeto person e modificando sua propriedade age.

Como os objetos são passados por referência, a função setAge recebe uma cópia da referência armazenada na constante sam. Assim, após a modificação feita dentro da função, a propriedade age do objeto sam também será alterada, porque ambas as referências apontam para o mesmo objeto na memória. O resultado no console será:

Antes de setAge: 29
Depois de setAge: 30

Por outro lado, se um parâmetro dentro da função é atribuído a um novo objeto, a referência original não é afetada:

function setDefault(person) {
person = { name: "Indefinido", age: 0 };
}

let sam = { name: "Sam", age: 29 };
console.log("Antes de setDefault:", sam.name);
setDefault(sam);
console.log("Depois de setDefault:", sam.name);

Quando a variável sam é passada para a função setDefault, o parâmetro person da função e a variável sam inicialmente apontam para o mesmo objeto na memória. No entanto, dentro da função, o valor do parâmetro person é alterado para um novo objeto. Como resultado, a referência armazenada em person agora aponta para um novo objeto, enquanto a variável sam continua apontando para o objeto original. O console mostrará:

Antes de setDefault: Sam
Depois de setDefault: Sam

Portanto, ao passar um objeto para uma função, a função pode alterar as propriedades do objeto, mas não pode alterar a referência do objeto. Se a função atribuir um novo objeto ao parâmetro, a referência original não será afetada.

Esse comportamento demonstra como passar objetos por referência funciona em JavaScript e como as funções podem manipular ou não os objetos originais, dependendo de como os parâmetros são tratados dentro delas. Este conceito é fundamental para entender como gerenciar estados e dados em aplicações JavaScript, permitindo um controle mais eficiente e direcionado dos objetos e suas mutações.