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 utilizan si el valor no está definido (y se ignoran si se pasa el valor). 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
}

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 que los parámetros formales se inicialicen con valores predeterminados si no se pasa ningún valor o no se define.

También puede simular parámetros con nombre predeterminados mediante 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 formas, pero este es mi método preferido: le permite pasar lo que quiera, incluido falso o nulo. ( typeof null == "object")

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

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

Esto se asigna al delete_aftervalor de delete_aftersi no es un valor falsey , de lo contrario, asigna la cadena "my default here". Para obtener más detalles, consulte la encuesta del lenguaje de Doug Crockford y consulte la sección Operadores .

Este enfoque no funciona si se desea pasar de un Falsey- es decir, valor false, null, undefined, 0o "". Si necesita que se pasen los valores de falsey , deberá usar el método en la respuesta de Tom Ritter .

Cuando se trata 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 combine estos valores con un objeto que contenga 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" }); 

Me parece que algo tan simple como esto 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');
} 

En ECMAScript 6 podrás escribir exactamente lo que tienes:

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

Esto se establecerá delete_afteren falsesi no está presente o undefined. Puede utilizar las funciones de ES6 como esta hoy con transpiladores como Babel .

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

Valores de parámetros predeterminados

Con ES6, puede hacer quizás uno de los modismos más comunes en JavaScriptrelación con el establecimiento de un valor predeterminado para un parámetro de función. La forma en que lo hemos hecho durante años debería parecer 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é? Debido a que 0 is falsy, y por lo tanto x || 11 results in 11, no se pasa directamente en 0. Para solucionar este problema, algunas personas escribirán el cheque de manera más detallada de esta manera:

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 agregada ES6para optimizar la asignación de valores predeterminados a los argumentos faltantes:

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 = 11en una declaración de función es más como x !== undefined ? x : 11el idioma mucho más comúnx || 11

Expresiones de valor predeterminado

Functionlos 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 manera perezosa, lo que significa que solo se ejecutan si es necesario, es decir, cuando el argumento de un parámetro se omite o no está definido.

Una expresión de valor predeterminada puede ser incluso una llamada de expresión de función en línea, comúnmente conocida como expresión de función invocada inmediatamente (IIFE):

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

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

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

Simplemente use una comparación explícita con indefinido.

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

Recomiendo extrema precaución al usar valores de parámetros predeterminados en javascript. A menudo crea errores cuando se utiliza en combinación con funciones de orden superior como forEach, map, y reduce. Por ejemplo, considere esta línea de código:

['1', '2', '3'].map(parseInt); // [1, NaN, NaN]

parseInt tiene una segunda function parseInt(s, [raíz de parámetros opcional =10])pero asigna llamadas parseIntcon tres argumentos: ( elemento , índice y matriz ).

Le sugiero que separe los parámetros requeridos de sus argumentos con valor opcional / predeterminado. Si su función toma 1,2, o 3 parámetros requeridos para los cuales ningún valor predeterminado tiene sentido, conviértalos en parámetros posicionales para la función, cualquier parámetro opcional debe seguir como atributos con nombre de un solo objeto. Si su función toma 4 o más, quizás tenga más sentido proporcionar todos los argumentos a través de los atributos de un único parámetro de objeto.

En su caso, le sugiero que escriba su función deleteFile de esta manera: ( editado por instead los comentarios de ...) ...

// unsafe
function read_file(fileName, deleteAfter=false) {
    if (deleteAfter) {
        console.log(`Reading and then deleting ${fileName}`);
    } else {
        console.log(`Just reading ${fileName}`);
    }
}

// better
function readFile(fileName, options) {
  const deleteAfter = !!(options && options.deleteAfter === true);
  read_file(fileName, deleteAfter);
}

console.log('unsafe...');
['log1.txt', 'log2.txt', 'log3.txt'].map(read_file);

console.log('better...');
['log1.txt', 'log2.txt', 'log3.txt'].map(readFile);

La ejecución del fragmento anterior ilustra los peligros que acechan detrás de los valores de argumento predeterminados para los parámetros no utilizados.

Como actualización ... con ECMAScript 6 FINALMENTE puede establecer valores predeterminados en las declaraciones de parámetros de función de esta manera:

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

f(1) === 50

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

Siendo un desarrollador de C ++ desde hace mucho tiempo (Novato en desarrollo web :)), cuando me encontré con 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 tenga 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 navegadores, pero no confíe en ella.

Para cualquier persona interesada en que el código funcione en Microsoft Edge, no use los valores predeterminados en los parámetros de la función.

function read_file(file, delete_after = false) {
    #code
}

En ese ejemplo, Edge arrojará un error "Esperando ')'"

Para evitar este uso

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

A partir del 8 de agosto de 2016, esto sigue siendo un problema

Según la sintaxis

function [name]([param1[ = defaultValue1 ][, ..., paramN[ = defaultValueN ]]]) {
   statements
}

Puede definir el valor predeterminado de los parámetros formales. y también verifique el valor indefinido usando la función typeof .

function helloWorld(name, symbol = '!!!') {
    name = name || 'worlds';
    console.log('hello ' + name + symbol);
}

helloWorld(); // hello worlds!!!

helloWorld('john'); // hello john!!!

helloWorld('john', '(>.<)'); // hello john(>.<)

helloWorld('john', undefined); // hello john!!!

helloWorld(undefined, undefined); // hello worlds!!!

Use esto si quiere usar la última ECMA6sintaxis:

function myFunction(someValue = "This is DEFAULT!") {
  console.log("someValue --> ", someValue);
}

myFunction("Not A default value") // calling the function without default value
myFunction()  // calling the function with default value

Se llama default function parameters. Permite que los parámetros formales se inicialicen con valores predeterminados si no se pasa ningún valor o no se define. NOTA : No funcionará con Internet Explorer o navegadores anteriores.

Para obtener la máxima compatibilidad posible, use esto:

function myFunction(someValue) {
  someValue = (someValue === undefined) ? "This is DEFAULT!" : someValue;
  console.log("someValue --> ", someValue);
}

myFunction("Not A default value") // calling the function without default value
myFunction()  // calling the function with default value

Ambas funciones tienen exactamente el mismo comportamiento, ya que cada uno de estos ejemplos se basa en el hecho de que la variable de parámetro será undefinedsi no se pasó ningún valor de parámetro al llamar a esa función.

ES6: Como ya se mencionó en la mayoría de las respuestas, en ES6, simplemente puede inicializar un parámetro junto con un valor.

ES5: La mayoría de las respuestas dadas no son lo suficientemente buenas para mí porque hay ocasiones en las que es posible que tenga que pasar valores falsos como 0, nully undefineda una función. Para determinar si un parámetro no está definido porque ese es el valor que pasé en lugar de indefinido porque no se ha definido en absoluto, hago esto:

function foo (param1, param2) {
   param1 = arguments.length >= 1 ? param1 : "default1";
   param2 = arguments.length >= 2 ? param2 : "default2";
}

function throwIfNoValue() {
throw new Error('Missing argument');
}
function foo(argValue = throwIfNoValue()) {
return argValue ;
}

Aquí foo () es una función que tiene un parámetro llamado argValue. Si no pasamos nada en la llamada a la función aquí, se llamará a la función throwIfNoValue () y el resultado devuelto se asignará al único argumento argValue. Así es como se puede usar una llamada de función como parámetro predeterminado. Lo que hace que el código sea más simplificado y legible.

Este ejemplo ha sido tomado de aquí

Si está utilizando ES6+, puede establecer los parámetros predeterminados de la siguiente manera:

function test (foo = 1, bar = 2) {
  console.log(foo, bar);
}

test(5); // foo gets overwritten, bar remains default parameter

Si necesita ES5sintaxis, puede hacerlo de la siguiente manera:

function test(foo, bar) {
  foo = foo || 2;
  bar = bar || 0;
  
  console.log(foo, bar);
}

test(5); // foo gets overwritten, bar remains default parameter

En la sintaxis anterior ORse usa el operador. El ORoperador siempre devuelve el primer valor si se puede convertir truesi no, devuelve el valor del lado derecho. Cuando se llama a la función sin argumento correspondiente, el motor JS barestablece la variable de parámetro ( en nuestro ejemplo) undefined. undefinedLuego se convierte en falso y, por lo tanto, el ORoperador devuelve el valor 0.

Sí, el uso de parámetros predeterminados es totalmente compatible con ES6 :

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

o

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

pero antes en ES5 podías hacer esto fácilmente:

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

Lo que significa que si el valor está allí, use el valor, de lo contrario, use el segundo valor después de la ||operación que hace lo mismo ...

Nota: También hay una gran diferencia entre los que si se pasa un valor de ES6 uno incluso el valor sea Falsy, que será reemplazado con el nuevo valor, algo así como nullo ""... pero ES5 uno sólo va a ser reemplazado si sólo el valor pasado es verdad, eso es porque la forma de ||trabajar ...

Si por alguna razón usted no en la ES6 y se utiliza lodashaquí es una forma concisa a los parámetros por defecto de función a través de _.defaultTométodo:

var fn = function(a, b) {
  a = _.defaultTo(a, 'Hi')
  b = _.defaultTo(b, 'Mom!')

  console.log(a, b)
}

fn()                 // Hi Mom!
fn(undefined, null)  // Hi Mom!
fn(NaN, NaN)         // Hi Mom!
fn(1)                // 1 "Mom!"
fn(null, 2)          // Hi 2
fn(false, false)     // false false
fn(0, 2)             // 0 2

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.min.js"></script>

Que establecerá el valor predeterminado si el valor actual es NaN , nulo o indefinido

Sonidos de futuro

En el futuro, podrá "esparcir" un objeto a otro (¡actualmente a partir de 2019 NO es compatible con Edge !) - Demostración de cómo usar eso para buenas opciones predeterminadas independientemente del orden:

function test(options) {
    var options = {
       // defaults
       url: 'defaultURL',
       some: 'somethingDefault',
       // override with input options
       ...options
    };
    
    var body = document.getElementsByTagName('body')[0];
    body.innerHTML += '<br>' + options.url + ' : ' + options.some;
}
test();
test({});
test({url:'myURL'});
test({some:'somethingOfMine'});
test({url:'overrideURL', some:'andSomething'});
test({url:'overrideURL', some:'andSomething', extra:'noProblem'});

Referencia de MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax

... mientras tanto, Edge sí admite Object.assign () (IE no, pero realmente espero que podamos dejar IE atrás :))

Del mismo modo podrías hacer

    function test(options) {
        var options = Object.assign({
           // defaults
           url: 'defaultURL',
           some: 'somethingDefault',
        }, options); // override with input options
        
        var body = document.getElementsByTagName('body')[0];
        body.innerHTML += '<br>' + options.url + ' : ' + options.some;
    }
    test();
    test({});
    test({url:'myURL'});
    test({some:'somethingOfMine'});
    test({url:'overrideURL', some:'andSomething'});
    test({url:'overrideURL', some:'andSomething', extra:'noProblem'});

EDITAR: debido a los comentarios con respecto a las constopciones: el problema con el uso de opciones constantes en el resto de la función no es que no pueda hacer eso, es simplemente que no puede usar la variable constante en su propia declaración: tendría que para ajustar el nombre de entrada a algo como

function test(input_options){
   const options = {
     // defaults
     someKey:    'someDefaultValue',
     anotherKey: 'anotherDefaultValue',

     // merge-in input options
     ...input_options
   };

   // from now on use options with no problem
}

Solo para mostrar mis habilidades también (risas), la función anterior se puede escribir incluso sin haber nombrado argumentos como a continuación:

ES5 y superior

function foo() {
    a = typeof arguments[0] !== 'undefined' ? a : 42;
    b = typeof arguments[1] !== 'undefined' ? b : 'default_b';
    ...
}

ES6 y superior

function foo(...rest) {
    a = typeof rest[0] !== 'undefined' ? a : 42;
    b = typeof rest[1] !== 'undefined' ? b : 'default_b';
    ...
}

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

El siguiente código puede funcionar en esta situación, incluido ECMAScript 6 (ES6), así como versiones anteriores.

function read_file(file, delete_after) {
    if(delete_after == undefined)
        delete_after = false;//default value

    console.log('delete_after =',delete_after);
}
read_file('text1.txt',true);
read_file('text2.txt');

como valor predeterminado en idiomas funciona cuando el valor del parámetro de la función se omite al llamar, en JavaScript se asigna a indefinido . Este enfoque no parece atractivo mediante programación, pero tiene compatibilidad con versiones anteriores .

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

Un enfoque diferente para establecer parámetros predeterminados es utilizar un mapa de objetos de argumentos, en lugar de argumentos directamente. Por ejemplo,

const defaultConfig = {
 category: 'Animals',
 legs: 4
};

function checkOrganism(props) {
 const category = props.category || defaultConfig.category;
 const legs = props.legs || defaultConfig.legs;
}

De esta manera, es fácil extender los argumentos y no preocuparse por la falta de coincidencia de la longitud del argumento.

La respuesta es sí. De hecho, hay muchos idiomas que admiten parámetros predeterminados. Python es uno de ellos:

def(a, enter="Hello"):
   print(a+enter)

Aunque este es el código Python 3 debido a los paréntesis, los parámetros predeterminados en las funciones también funcionan en JS.

Por ejemplo, y en tu caso:

function read_file(file, deleteAfter=false){
  console.log(deleteAfter);
}

read_file("test.txt");

Pero a veces realmente no necesita parámetros predeterminados.

Simplemente puede definir la variable justo después del inicio de la función, así:

function read_file(file){
  var deleteAfter = false;
  console.log(deleteAfter);
}

read_file("test.txt");

En mis dos ejemplos, devuelve lo mismo. Pero a veces pueden ser útiles, como en proyectos muy avanzados.

Entonces, en conclusión, los valores de parámetros predeterminados se pueden usar en JS. Pero es casi lo mismo que definir una variable justo después del inicio de la función. Sin embargo, a veces siguen siendo muy útiles. Como habrá notado, los valores predeterminados de los parámetros toman 1 línea de código menos que la forma estándar que define el parámetro justo después del inicio de la función.

EDITAR: ¡ Y esto es súper importante! Esto no funcionará en IE. Ver documentación . Entonces, con IE, debe usar el método "definir variable en la parte superior de la función". Los parámetros predeterminados no funcionarán en IE.

Sí, esto funcionará en Javascript. También puedes hacer eso:

function func(a=10,b=20)
{
    alert (a+' and '+b);
}

func(); // Result: 10 and 20

func(12); // Result: 12 and 20

func(22,25); // Result: 22 and 25