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


2367

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
}

Respuestas:


3298

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';
  ...
}

216
También puede encapsularlo como tal: function defaultFor(arg, val) { return typeof arg !== 'undefined' ? arg : val; }y luego puede llamarlo comoa = defaultFor(a, 42);
Camilo Martin

66
@SiPlus y obtuvo errores de referencia adicionales de forma gratuita al intentar usar undefinedobjetos: p Aunque puede funcionar con algunos navegadores y puede ser más rápido, nullsigue siendo un objeto y undefinedes una referencia al tipo primitivo que intenta decir que hay Nada aquí, ni siquiera null. Vea aquí, ambos casos en pocas palabras: JavaScript / Reference / Global_Objects / undefined .
Sampo Sarrala - codidact.org

99
si verifica la propiedad de un objeto, entonces typeofes redundante. function foo(data) { var bar = data.bar !== undefined ? data.bar : 'default'; }Esto no arrojará errores de referencia y es conciso.
Dziamid

10
Sé que es realmente menor, pero no me gusta cómo está asignando a = ay b = bcuándo esos parámetros no están indefinidos. Además, ese operador ternario con una condición un poco complicada puede ser difícil de leer para futuros mantenedores. Preferiría la siguiente sintaxis: if (typeof a == 'undefined') a = 42- sin asignación innecesaria y un poco más fácil de leer.
Daddy32

12
¿Hay alguna razón para usar typeof? Parecería más simple simplemente hacer a === undefined. Además, de esa manera obtendría un error de referencia si escribe mal undefinedo lo pone en una cadena.
Abe Voelker

599
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" }); 

115
Esto me parece insuficiente, porque es posible que quiera pasar en falso.
Tom Ritter

52
Creo que es adecuado para la mayoría de las situaciones
Russ Cam

50
Debido a que no funciona para los valores de falsey, puede crear una pesadilla de mantenimiento. Un código que siempre ha pasado valores verdaderos antes y de repente falla porque se pasa uno falso probablemente debería evitarse cuando hay un enfoque más robusto disponible.
jinglesthula

1
¿Cómo es que, en este caso, delete_afterno obtiene el resultado booleano de la expresión delete_after || "my default value"?
xbonez

3
o bien, simplemente puede usar un valor predeterminado de falsey, que generalmente es un buen valor predeterminado (por ejemplo, falso para bools, cadena vacía para cadenas, 0 para números, etc.), en cuyo caso realmente no importa cuál era pasó.
Mark Brackett

150

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');
} 

66
Actualización: si ya está usando underscore.js, me parece aún mejor usarlo _.defaults(iceCream, {flavor: "vanilla", sprinkles: "lots"});. El uso del espacio de nombres global como se muestra en esta respuesta es considerado por muchos una mala práctica. También puede considerar rodar su propia utilidad para esta tarea común (p. Ej. util.default(arg, "defaul value")) Si no desea utilizar el guión bajo, pero la mayoría de las veces termino usando el guión bajo cero, tarde o temprano, de ninguna manera tiene sentido reinventar la rueda.
Andersand

2
De hecho, recomiendo este, lo uso y lo llamo "por" que significa "parámetro o"
super

2
No digas typeof arg == 'undefined', en cambio di arg === undefined
OsamaBinLogin

3
@OsamaBinLogin lo que dice es correcto para el JS actual: la prueba anterior persiste porque en algunos navegadores era posible sobrescribir undefinedcon algún otro valor, lo que hace que la prueba falle.
Alnitak

2
@Alnitak: Todavía es posible anular undefined. Por lo tanto, sigue siendo una buena idea usar typeofy 'undefined'.
LS

63

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 .


1
ECMAScript 6, supongo ... (Me habría corregido por mí mismo pero no puedo hacer ediciones <6 caracteres)
Zac

1
Esperando a que el navegador obtenga ECMAScript 6
Adriano Resende

1
¿A qué le transmitiría esto Babel?
harryg


2
Aquí está la tabla de compatibilidad para ES6 kangax.github.io/compat-table/es6/#default_function_parameters Lamentablemente, esta sintaxis aún no es compatible .
freemanoid

27

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

13

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

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

44
¿Qué pasa si delete_afteres 0o null? No funcionará correctamente para estos casos.
Dmitri Pavlutin

@StephanBijzitter solo sería cierto en algunos casos. Pero si solo desea que los valores predeterminados desarmen los valores, esto no funcionó, porque 0 o nulo! === falso.
Rutrus

@Rutrus: No entiendo nada de lo que acabas de decir.
Stephan Bijzitter

¿Qué hay de delete_after = delete_after === undefined ? false : delete_after?
aashah7

10

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

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

10

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.


1
Esta "mejor solución" es bastante ilegible. Preferiría verificar el tipo de variable como typeof deleteAfter === 'bool'y lanzar Exception de lo contrario. Además, en caso de utilizar métodos como map / foreach, etc., úselos con precaución y ajuste las llamadas funciones con función anónima. ['1', '2', '3'].map((value) => {read_file(value);})
lugar del

Ese es un buen punto. Estaba tratando de evitar el uso de bibliotecas en mi fragmento de código, pero este idioma es bastante desordenado en javascript puro. Personalmente, usaría el getmétodo de lodash para recuperar deleteAfter. Lanzar una excepción si typeof 'deleteAfter' !== 'bool'también puede ser una buena medida prudente. No me gusta diseñar métodos que requieran que la persona que llama "tenga cuidado". La precaución es responsabilidad de la función, no de la persona que llama. El comportamiento final debe seguir el principio de menor sorpresa.
Doug Coburn el

Estoy de acuerdo, ese método no debe escribirse de la manera, que llamarlo puede romper su comportamiento. Pero tenga en cuenta que la función es como el modelo, y la persona que llama es como el controlador. El modelo debe ocuparse del procesamiento de datos. La función (método) debe esperar que los datos se puedan pasar de manera incorrecta y manejarlos. Es por eso que verificar el tipo de parámetro más lanzar Excepción es la mejor manera. A pesar de que es más complejo. Pero aún así puede salvarte de rascarte la cabeza y seguir preguntando ... ¡¿POR QUÉ NO FUNCIONA ?! y luego ... ¿POR QUÉ ESTÁ FUNCIONANDO?
lugar del

9

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


11
Esta respuesta no es útil porque es un duplicado
usuario

8

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.


3
La asignación dentro de la definición de función tampoco funciona en IE 11, que es la versión más actual de IE para Windows 8.1.
DiMono

1
En caso de que alguien se pregunte, function myfunc(a,b=10)es la sintaxis de ES6, hay enlaces a tablas de compatibilidad en otras respuestas.
gcampbell

7

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


4

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 .


4
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!!!

4

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.


NOTA: como dice @BlackBeard, la función (parámetro = valor) NO funcionará con IE. Utiliza la versión compatible.
MagicLAMP

4

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";
}

3

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í


3

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.


3

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 ...


2

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


1

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
}

El problema es que normalmente nunca quieres hacer eso, ya que esto reasignará opciones que ya están definidas, pero puedes usarlo con otra var que sea legítima.
frank-dspeed

prueba de función (opciones) {/ * Las opciones están definidas, arrojará un error si usa const options = {} now * /}
frank-dspeed

no, no global cuando crea una función y la pasa como opciones de nombre de argumento, entonces dentro de las opciones de la función se define dentro de la función (opt) {} opt se define, no puede usar const opt ​​dentro de esa función, entonces esto es malo porque lo hace reasignación variable si hace eso a menudo y parece que es su patrón general, este es un problema
frank-dspeed

@ google-frank-dspeed ah, ¿quieres decir que no puedes hacer function(opt){ const opt = /*some merging*/; }? Eso seguro no funcionará porque usaría la constvariable antes de que fuera declarada - tendría que ajustar -function test(input_opt){ const opt = { someKey: 'someDefaultValue', ...input_opt} }
jave.web

@ google-frank-dspeed de todos modos, probablemente más personas nuevas se preguntarán acerca de esto, así que agregué el código de
procedimientos

1

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';
    ...
}

0
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 .


0

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

0

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.


-1

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.


Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.