Parâmetros de Funções

4.1 Parâmetros de Funções

Os parâmetros de funções em JavaScript permitem passar valores para as funções para serem processados. Isso torna as funções mais flexíveis e adaptáveis. Nesta parte, vamos discutir os aspectos principais de como trabalhar com parâmetros de funções em JavaScript, sem incluir parâmetros padrão e rest parameters.

Os parâmetros são especificados entre parênteses após o nome da função. Ao chamar a função, os valores desses parâmetros são passados para as variáveis correspondentes dentro da função.

Exemplo:

Na função greet() são definidos dois parâmetros: name e age. Ao chamar a função, os valores Alice e 30 são passados para esses parâmetros.

    
      function greet(name, age) {
        return `Hello, ${name}! You are ${age} years old.`;
      }
      console.log(greet('Alice', 30)); // "Hello, Alice! You are 30 years old."
    
  

Tratar parâmetros indefinidos

Se um parâmetro não for passado ao chamar a função, seu valor será undefined. Isso pode levar a erros se operações que não suportam undefined forem realizadas com esse parâmetro.

Exemplo:

Na função greet() é verificado se o parâmetro name foi passado. Se não, é usada a string Guest.

    
      function greet(name) {
        if (name === undefined) {
          return 'Hello, Guest!';
        }
        return `Hello, ${name}!`;
      }

      console.log(greet()); // "Hello, Guest!"
      console.log(greet('Bob')); // "Hello, Bob!"
    
  

4.2 Parâmetros Padrão

Parâmetros padrão permitem definir valores que serão utilizados se um argumento não for passado ao chamar a função ou for passado como undefined. Isso é especialmente útil para criar funções com parâmetros opcionais.

Sintaxe:

    
      function name (arg1 = value1, arg2 = value2) {
        // function body
      }
    
  

Exemplo 1: Função simples com parâmetros padrão

Neste exemplo, a função greet() tem o parâmetro name com o valor padrão Guest. Se não for passado argumento, o valor padrão será usado.

    
      function greet(name = 'Guest') {
        return `Hello, ${name}!`;
      }

      console.log(greet('Alice')); // Vai exibir: Hello, Alice!
      console.log(greet());        // Vai exibir: Hello, Guest!
    
  

Exemplo 2: Parâmetros padrão com expressões

Neste exemplo, o parâmetro tax padrão é calculado como 20% de price se outro argumento não for passado.

    
      function calculatePrice(price, tax = price * 0.2) {
        return price + tax;
      }

      console.log(calculatePrice(100));  // Vai exibir: 120
      console.log(calculatePrice(100, 15)); // Vai exibir: 115
    
  

Exemplo 3: Parâmetros padrão dependentes de outros parâmetros

Neste exemplo, os parâmetros padrão permitem criar um usuário com funções e status predefinidos.

    
      function createUser(name, role = 'user', isActive = true) {
        return { name, role, isActive };
      }

      console.log(createUser('Alice')); // Vai exibir: { name: 'Alice', role: 'user', isActive: true }
      console.log(createUser('Bob', 'admin')); // Vai exibir: { name: 'Bob', role: 'admin', isActive: true }
      console.log(createUser('Charlie', 'moderator', false)); // Vai exibir: { name: 'Charlie', role: 'moderator', isActive: false }
    
  

4.3 Rest Parameters

Rest parameters permitem que uma função receba qualquer quantidade de argumentos e os reúna em um array. Isso é útil para criar funções que podem trabalhar com um número arbitrário de argumentos.

Sintaxe:

    
      function name (arg1, arg2, ...argArray) {
        // function body
      }
    
  

Exemplo 1: Somar todos os argumentos passados

Neste exemplo, a função sumAll() usa rest parameters para somar todos os argumentos passados.

    
      function sumAll(...numbers) {
        return numbers.reduce((sum, num) => sum + num, 0);
      }

      console.log(sumAll(1, 2, 3));       // Vai exibir: 6
      console.log(sumAll(4, 5, 6, 7, 8)); // Vai exibir: 30
    
  

Exemplo 2: Função com parâmetros fixos e rest parameters

Neste exemplo, a função showItems() recebe um parâmetro fixo firstItem e uma quantidade indefinida de outros argumentos, reunidos no array otherItems.

    
      function showItems(firstItem, ...otherItems) {
        console.log(`Primeiro item: ${firstItem}`);
        console.log(`Outros itens: ${otherItems.join(', ')}`);
      }

      showItems('apple', 'banana', 'cherry', 'date');

      // Vai exibir:
      // Primeiro item: apple
      // Outros itens: banana, cherry, date
    
  

Exemplo 3: Função com argumentos dinâmicos

Neste exemplo, a função createMessage() recebe o primeiro argumento messageType e reúne todos os outros parâmetros em um array messages para criar uma mensagem.

    
      function createMessage(messageType, ...messages) {
        return `[${messageType.toUpperCase()}]: ${messages.join(' ')}`;
      }

      console.log(createMessage('info', 'This', 'is', 'an', 'informational', 'message'));
      // Vai exibir: [INFO]: This is an informational message

      console.log(createMessage('error', 'An', 'error', 'occurred'));
      // Vai exibir: [ERROR]: An error occurred