Parâmetros padrão em JavaScript | Explicado com exemplos
Para evitar esse resultado indesejável, usamos parâmetros padrão. Parâmetros padrão são os parâmetros que definiram seus valores padrão, caso estejam ausentes na chamada de função de invocação.
Vamos analisar um exemplo em que obtemos um resultado não satificário devido à falta de argumentos e, em seguida, o consertaremos usando parâmetros tradicionais e padrão. Mas primeiro, vamos aprender um pouco mais sobre os parâmetros padrão.
Quais são os parâmetros padrão
Na versão ES6, o JavaScript introduziu um recurso da configuração de parâmetros padrão. Ao desenvolver um aplicativo de pilha completa, geralmente queremos cobrir todos os nossos fins que podem devolver qualquer erro. A questão da falta de argumentos na chamada de função de invocação é um desses cantos e o parâmetro padrão é o guarda que usamos para nos salvar de resultados indesejados.
Declarar parâmetros padrão é bastante fácil. Ao definir o parâmetro da função, basta colocar o valor padrão após o "=" sinal. A sintaxe é como:
função functionIdentifier (parâmetro = value)// corpo da função
;
Por exemplo:
functionPrintName (FirstName, lastName = 'Doe')console.log (primeiro nome + " + someName);
PrintName ('John');
PrintName ("John", "Who");
A saída de ambos os comandos é como:
Para a primeira chamada de função, ele usou o valor padrão "DOE" para o parâmetro "SungName" e, pelo segundo, usou os dois argumentos.
Como os parâmetros padrão funcionam
Usando a mesma função que criamos no exemplo acima, para o primeiro caso em que ambos os argumentos estão presentes, os valores dentro da chamada de função são usados como assim:
E para o segundo caso, no qual faltava um dos argumentos, a função usou o valor que definimos como o valor padrão no parâmetro como:
Por que usar parâmetros padrão
Normalmente, quando nenhum argumento é passado, o parâmetro é considerado "indefinido" por JavaScript. A abordagem tradicional ou trivial para evitar uma saída indesejada é verificar o parâmetro quanto a um valor indefinido. A abordagem trivial pode ser usada com as seguintes linhas de código para uma função adicionar 2 números:
functionAddnumbers (num1, num2)if (num1 === indefinido)
num1 = 1;
if (num2 === indefinido)
num2 = 1;
retornar num1 + num2;
console.log (addNumbers ());
Mesmo que não estejamos transmitindo nenhum argumento ao chamar a função dentro do console.registro() função, não receberemos nenhum erro.
De fato, a saída é como:
Como você pode ver, podemos lidar com a questão de perder argumentos como este também. No entanto, ser um bom programador é tudo sobre ser eficiente, e essa abordagem trivial não é uma solução eficiente.
Se resolvemos o mesmo problema usando os parâmetros padrão, a solução seria muito mais concisa como:
função addNumbers (num1 = 1, num2 = 1)retornar num1 + num2;
console.log (addNumbers ());
Como você pode ver, em vez de escrever inúmeras linhas, fizemos isso em uma única linha e a saída é exatamente a mesma sem erros e não Nan.
Usando o valor do parâmetro padrão de um parâmetro anterior
No ES6, você pode definir um parâmetro padrão usando o parâmetro antes. Isso ocorre porque os parâmetros são inicializados da esquerda para a direita. Resultando no uso de parâmetros definidos anteriores no valor padrão dos parâmetros posteriores.
Por exemplo, pegue o seguinte snippet:
função getSome (a, b = a * 2)retornar a * b;
console.log (getsome (2));
A função getSome () levará 2 parâmetros, se houver apenas um argumento, atribuirá o segundo parâmetro duas vezes o valor do primeiro argumento.
A saída é como:
Como os parâmetros são inicializados da esquerda para a direita, se usarmos um parâmetro posterior como o valor padrão de um parâmetro anterior, isso resultará em um erro.
Pegue o seguinte código como exemplo:
função errorgen (a = b, b = 2)retornar a + b;
console.log (errorgen ());
O exposto acima sofrerá um erro, pois está tentando acessar o parâmetro "B" mesmo antes de ser inicializado.
A saída é como:
Usando funções como valores nos parâmetros padrão
No ES6, você pode até usar funções como os valores de parâmetros padrão. Experimente as seguintes linhas de código:
função calc (a, b = getValue (a))retornar a + b;
função getValue (num)
retornar num * 2;
console.log (calc (2));
Como você pode ver, estamos dando a função getValue (num) como um parâmetro padrão para b E estamos passando o parâmetro a dentro dele. O getValue (num) Multipular o argumento passou para ele por 2 e retorna o valor. É por isso que, quando passamos 2 para dentro calc () função como um único parâmetro, obtemos o seguinte:
É isso para parâmetros padrão em JavaScript.
Conclusão
No ES6, foi introduzido um novo recurso que foi os parâmetros padrão. Para evitar um erro por causa da falta de argumentos, o JavaScript adicionou este recurso. Os parâmetros padrão são usados para colocar um valor padrão de um argumento no momento da escrita dessa função. Aprendemos sobre parâmetros padrão, como podemos usar parâmetros padrão para evitar resultados desfavoráveis e por que devemos usar os parâmetros padrão como substituto da abordagem tradicional/trivial junto com seus exemplos.