Sim, isso é chamado de parâmetro padrão
Os parâmetros de função padrão permitem que parâmetros formais sejam inicializados com valores padrão se nenhum valor ou indefinido for passado.
Sintaxe:
function [name]([param1[ = defaultValue1 ][, ..., paramN[ = defaultValueN ]]]) {
statements
}
Descrição:
Parâmetros de funções padrão para indefinidos No entanto, em situações, pode ser útil definir um valor padrão diferente. É aqui que os parâmetros padrão podem ajudar.
No passado, a estratégia geral para definir padrões era testar valores de parâmetros no corpo da função e atribuir um valor se eles não estiverem definidos. Se nenhum valor for fornecido na chamada, seu valor será indefinido. Você precisaria definir uma verificação condicional para garantir que o parâmetro não seja indefinido
Com os parâmetros padrão no ES2015, a verificação no corpo da função não é mais necessária. Agora você pode simplesmente colocar um valor padrão na cabeça da função.
Exemplo das diferenças:
// OLD METHOD
function multiply(a, b) {
b = (typeof b !== 'undefined') ? b : 1;
return a * b;
}
multiply(5, 2); // 10
multiply(5, 1); // 5
multiply(5); // 5
// NEW METHOD
function multiply(a, b = 1) {
return a * b;
}
multiply(5, 2); // 10
multiply(5, 1); // 5
multiply(5); // 5
Exemplos de sintaxe diferentes:
Preenchimento indefinido vs outros valores falsos:
Mesmo se o valor for definido explicitamente ao chamar, o valor do argumento num será o padrão.
function test(num = 1) {
console.log(typeof num);
}
test(); // 'number' (num is set to 1)
test(undefined); // 'number' (num is set to 1 too)
// test with other falsy values:
test(''); // 'string' (num is set to '')
test(null); // 'object' (num is set to null)
Avaliada no momento da chamada:
O argumento padrão é avaliado no momento da chamada, portanto, diferente de outros idiomas, um novo objeto é criado toda vez que a função é chamada.
function append(value, array = []) {
array.push(value);
return array;
}
append(1); //[1]
append(2); //[2], not [1, 2]
// This even applies to functions and variables
function callSomething(thing = something()) {
return thing;
}
function something() {
return 'sth';
}
callSomething(); //sth
Os parâmetros padrão estão disponíveis para os parâmetros padrão posteriores:
Os parâmetros já encontrados estão disponíveis para parâmetros padrão posteriores
function singularAutoPlural(singular, plural = singular + 's',
rallyingCry = plural + ' ATTACK!!!') {
return [singular, plural, rallyingCry];
}
//["Gecko","Geckos", "Geckos ATTACK!!!"]
singularAutoPlural('Gecko');
//["Fox","Foxes", "Foxes ATTACK!!!"]
singularAutoPlural('Fox', 'Foxes');
//["Deer", "Deer", "Deer ... change."]
singularAutoPlural('Deer', 'Deer', 'Deer peaceably and respectfully \ petition the government for positive change.')
Funções definidas dentro do corpo da função:
Introduzido no Gecko 33 (Firefox 33 / Thunderbird 33 / SeaMonkey 2.30). As funções declaradas no corpo da função não podem ser consultadas dentro dos parâmetros padrão e geram um ReferenceError (atualmente um TypeError no SpiderMonkey, consulte o bug 1022967). Os parâmetros padrão são sempre executados primeiro, as declarações de funções dentro do corpo da função são avaliadas posteriormente.
// Doesn't work! Throws ReferenceError.
function f(a = go()) {
function go() { return ':P'; }
}
Parâmetros sem padrões após os parâmetros padrão:
Antes do Gecko 26 (Firefox 26 / Thunderbird 26 / SeaMonkey 2.23 / Firefox OS 1.2), o código a seguir resultava em um SyntaxError. Isso foi corrigido no bug 777060 e funciona como esperado em versões posteriores. Os parâmetros ainda são definidos da esquerda para a direita, substituindo os parâmetros padrão, mesmo se houver parâmetros posteriores sem padrões.
function f(x = 1, y) {
return [x, y];
}
f(); // [1, undefined]
f(2); // [2, undefined]
Parâmetro destruído com atribuição de valor padrão:
Você pode usar a atribuição de valor padrão com a notação de atribuição de desestruturação
function f([x, y] = [1, 2], {z: z} = {z: 3}) {
return x + y + z;
}
f(); // 6
function defaultFor(arg, val) { return typeof arg !== 'undefined' ? arg : val; }
e então você pode chamá-lo comoa = defaultFor(a, 42);