Pregunta Establecer un valor de parámetro predeterminado para una función de JavaScript


Me gustaría que una función de JavaScript tenga argumentos opcionales en los que establezco un valor predeterminado, que se usa si el valor no está definido. En Ruby puedes hacerlo así:

def read_file(file, delete_after = false)
  # code
end

Funciona esto en JavaScript?

function read_file(file, delete_after = false) {
  // Code
}

2017
2018-05-21 20:07


origen


Respuestas:


Desde ES6 / ES2015, los parámetros predeterminados están en la especificación del idioma.

function read_file(file, delete_after = false) {
  // Code
}

solo funciona

Referencia: Parámetros predeterminados - MDN

Los parámetros de función predeterminados permiten inicializar parámetros formales con valores predeterminados si sin valor o indefinido esta pasado.

Tú también puedes simular por defecto llamado parámetros a través de la desestructuración:

// the `= {}` below lets you call the function without any parameters
function myFor({ start = 5, end = 1, step = -1 } = {}) { // (A)
    // Use the variables `start`, `end` and `step` here
    ···
}

Pre ES2015,

Hay muchas maneras, pero este es mi método preferido: le permite pasar todo lo que quiera, incluso falso o nulo. (typeof null == "object")

function foo(a, b) {
  a = typeof a !== 'undefined' ? a : 42;
  b = typeof b !== 'undefined' ? b : 'default_b';
  ...
}

2931
2018-05-21 20:10



function read_file(file, delete_after) {
    delete_after = delete_after || "my default here";
    //rest of code
}

Esto se asigna a delete_after El valor de delete_after si no es un falsey valor de lo contrario, asigna la cadena "my default here". Para más detalles, echa un vistazo Encuesta de Doug Crockford sobre el idioma y echa un vistazo a la sección de Operadores.

Este enfoque no funciona si quieres pasar un falsey valor, es decir false, null, undefined, 0 o "". Si usted requiere falsey valores que se pasarán en usted necesitaría usar el método en La respuesta de Tom Ritter.

Al tratar con una serie de parámetros para una función, a menudo es útil permitir que el consumidor pase los argumentos de los parámetros en un objeto y luego unir estos valores con un objeto que contiene los valores predeterminados para la función

function read_file(values) {
    values = merge({ 
        delete_after : "my default here"
    }, values || {});

    // rest of code
}

// simple implementation based on $.extend() from jQuery
function merge() {
    var obj, name, copy,
        target = arguments[0] || {},
        i = 1,
        length = arguments.length;

    for (; i < length; i++) {
        if ((obj = arguments[i]) != null) {
            for (name in obj) {
                copy = obj[name];

                if (target === copy) {
                    continue;
                }
                else if (copy !== undefined) {
                    target[name] = copy;
                }
            }
        }
    }

    return target;
};

usar

// will use the default delete_after value
read_file({ file: "my file" }); 

// will override default delete_after value
read_file({ file: "my file", delete_after: "my value" }); 

559
2018-05-21 20:09



Encuentro que algo tan simple como este es mucho más conciso y legible personalmente.

function pick(arg, def) {
   return (typeof arg == 'undefined' ? def : arg);
}

function myFunc(x) {
  x = pick(x, 'my default');
} 

137
2018-05-21 20:18



En ECMAScript 6 realmente podrá escribir exactamente lo que tiene:

function read_file(file, delete_after = false) {
  // Code
}

Esto establecerá delete_after a false si no está presente o undefined. Puede utilizar funciones de ES6 como esta hoy con transpilers como Babel.

Vea el artículo de MDN para más información.


54
2018-05-29 15:25



Valores de parámetros predeterminados

Con ES6, puede hacer quizás uno de los modismos más comunes en JavaScript se refiere a establecer un valor predeterminado para un parámetro de función. La forma en que hemos hecho esto durante años debería ser bastante familiar:

function foo(x,y) {
 x = x || 11;
 y = y || 31;
 console.log( x + y );
}
foo(); // 42
foo( 5, 6 ); // 11
foo( 5 ); // 36
foo( null, 6 ); // 17

Este patrón es el más utilizado, pero es peligroso cuando pasamos valores como

foo(0, 42)
foo( 0, 42 ); // 53 <-- Oops, not 42

¿Por qué? Porque el 0 is falsy, y entonces el x || 11 results in 11, no el aprobado directamente en 0. Para solucionar este problema, algunas personas escribirán el cheque más detalladamente así:

function foo(x,y) {
 x = (x !== undefined) ? x : 11;
 y = (y !== undefined) ? y : 31;
 console.log( x + y );
}
foo( 0, 42 ); // 42
foo( undefined, 6 ); // 17

ahora podemos examinar una buena sintaxis útil añadida a partir de ES6 para agilizar la asignación de valores predeterminados a argumentos perdidos:

function foo(x = 11, y = 31) {
 console.log( x + y );
}

foo(); // 42
foo( 5, 6 ); // 11
foo( 0, 42 ); // 42
foo( 5 ); // 36
foo( 5, undefined ); // 36 <-- `undefined` is missing
foo( 5, null ); // 5 <-- null coerces to `0`
foo( undefined, 6 ); // 17 <-- `undefined` is missing
foo( null, 6 ); // 6 <-- null coerces to `0`

x = 11 en una declaración de función es más como x !== undefined ? x : 11 que el idioma mucho más común x || 11

Expresiones de valor predeterminado

Function los valores predeterminados pueden ser más que simples valores como 31; pueden ser cualquier expresión válida, incluso una function call:

function bar(val) {
 console.log( "bar called!" );
 return y + val;
}
function foo(x = y + 3, z = bar( x )) {
 console.log( x, z );
}
var y = 5;
foo(); // "bar called"
 // 8 13
foo( 10 ); // "bar called"
 // 10 15
y = 6;
foo( undefined, 10 ); // 9 10

Como puede ver, las expresiones de valor predeterminadas se evalúan de forma diferida, lo que significa que solo se ejecutan si se necesitan, es decir, cuando el argumento de un parámetro se omite o no se define.

Una expresión de valor por defecto puede incluso ser una llamada de expresión de función en línea, comúnmente denominada Expresión de Función Invocada Inmediatamente. (IIFE):

function foo( x =
 (function(v){ return v + 11; })( 31 )
) {
 console.log( x );
}
foo(); // 42

18
2017-10-15 17:58



esa solución es trabajo para mí en js:

function read_file(file, delete_after) {
    delete_after = delete_after || false;
    // Code
}

8
2017-11-16 11:29



Solo use una comparación explícita con undefined.

function read_file(file, delete_after)
{
    if(delete_after === undefined) { delete_after = false; }
}

6
2017-11-16 07:34



Al ser un desarrollador de C ++ por mucho tiempo (Rookie to web development :)), cuando me enteré de esta situación, hice la asignación de parámetros en la definición de la función, como se menciona en la pregunta, de la siguiente manera.

function myfunc(a,b=10)

Pero ten en cuenta que no funciona de manera consistente en todos los navegadores. Para mí, funcionó en Chrome en mi escritorio, pero no funcionó en Chrome en Android. Opción más segura, como muchos han mencionado anteriormente es -

    function myfunc(a,b)
    {
    if (typeof(b)==='undefined') b = 10;
......
    }

La intención de esta respuesta no es repetir las mismas soluciones, lo que otros ya han mencionado, sino informar que la asignación de parámetros en la definición de la función puede funcionar en algunos buscadores, pero no confíe en ello.


5
2018-05-19 06:40



Como una actualización ... con ECMAScript 6 puedes FINALMENTE establecer los valores predeterminados en las declaraciones de parámetros de funciones de esta manera:

function f (x, y = 7, z = 42) {
  return x + y + z
}

f(1) === 50

Como se hace referencia por - http://es6-features.org/#DefaultParameterValues


4
2017-10-06 16:16