Sí, esto se conoce como un parámetro predeterminado
Los parámetros de función predeterminados permiten que los parámetros formales se inicialicen con valores predeterminados si no se pasa ningún valor o no se define.
Sintaxis:
function [name]([param1[ = defaultValue1 ][, ..., paramN[ = defaultValueN ]]]) {
statements
}
Descripción:
Parámetros de las funciones predeterminadas a indefinidas Sin embargo, en situaciones puede ser útil establecer un valor predeterminado diferente. Aquí es donde los parámetros predeterminados pueden ayudar.
En el pasado, la estrategia general para establecer valores predeterminados era probar los valores de los parámetros en el cuerpo de la función y asignar un valor si no están definidos. Si no se proporciona ningún valor en la llamada, su valor sería indefinido. Debería establecer una comprobación condicional para asegurarse de que el parámetro no esté indefinido
Con los parámetros predeterminados en ES2015, la verificación en el cuerpo de la función ya no es necesaria. Ahora puede simplemente poner un valor predeterminado en el encabezado de la función.
Ejemplo de las diferencias:
// 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
Diferentes ejemplos de sintaxis:
Relleno indefinido frente a otros valores falsos:
Incluso si el valor se establece explícitamente al llamar, el valor del argumento num es el predeterminado.
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)
Evaluado en el momento de la llamada:
El argumento predeterminado se evalúa en el momento de la llamada, por lo que, a diferencia de otros lenguajes, se crea un nuevo objeto cada vez que se llama a la función.
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
Los parámetros predeterminados están disponibles para los parámetros predeterminados posteriores:
Los parámetros ya encontrados están disponibles para los parámetros predeterminados 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.')
Funciones definidas dentro del cuerpo de la función:
Introducido en Gecko 33 (Firefox 33 / Thunderbird 33 / SeaMonkey 2.30). Las funciones declaradas en el cuerpo de la función no se pueden referir dentro de los parámetros predeterminados y arrojan un Error de referencia (actualmente un Error de tipo en SpiderMonkey, vea el error 1022967). Los parámetros predeterminados siempre se ejecutan primero, las declaraciones de funciones dentro del cuerpo de la función se evalúan después.
// Doesn't work! Throws ReferenceError.
function f(a = go()) {
function go() { return ':P'; }
}
Parámetros sin valores predeterminados después de los parámetros predeterminados:
Antes de Gecko 26 (Firefox 26 / Thunderbird 26 / SeaMonkey 2.23 / Firefox OS 1.2), el siguiente código resultó en un SyntaxError. Esto se ha solucionado en el error 777060 y funciona como se esperaba en versiones posteriores. Los parámetros aún se configuran de izquierda a derecha, sobrescribiendo los parámetros predeterminados incluso si hay parámetros posteriores sin valores predeterminados.
function f(x = 1, y) {
return [x, y];
}
f(); // [1, undefined]
f(2); // [2, undefined]
Parámetro desestructurado con asignación de valor predeterminado:
Puede usar la asignación de valor predeterminada con la notación de asignación de desestructuración
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; }
y luego puede llamarlo comoa = defaultFor(a, 42);