Establecer el valor predeterminado del parámetro para la función javascript

Me gustaría que la función de JavaScript tenga argumentos opcionales, para los cuales establezco un valor predeterminado, que se usa si el valor no está definido. En Ruby, puedes hacer esto de la siguiente manera:

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

¿Funciona en javascript?

 function read_file(file, delete_after = false) { // Code } 
2148
21 мая '09 в 23:07 2009-05-21 23:07 Tilendor se establece el 21 de mayo de 2009 a las 23:07 2009-05-21 23:07
@ 22 respuestas

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

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

solo funciona

Referencia: Configuración predeterminada - MDN

Los parámetros de función predeterminados permiten la inicialización de parámetros formales con valores predeterminados si no se pasa ningún valor o undefined .

También puede simular los parámetros nombrados predeterminados a través de la reestructuració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 transferir cualquier cosa, incluso falsa o nula. ( typeof null == "object" )

 function foo(a, b) { a = typeof a !== 'undefined' ? a : 42; b = typeof b !== 'undefined' ? b : 'default_b'; ... } 
3075
21 мая '09 в 23:10 2009-05-21 23:10 Respondió a Tom Ritter el 21 de mayo de 2009 a las 23:10 2009-05-21 23:10
 function read_file(file, delete_after) { delete_after = delete_after || "my default here"; //rest of code } 

Esto establece delete_after en delete_after si no es un valor falso, de lo contrario asigna la cadena "my default here" . Para obtener más información, lea la descripción general en lenguaje de Doug Crockford y lea la sección de operadores .

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

Cuando se trabaja con varios parámetros de función, a menudo es útil permitir al consumidor pasar argumentos a los parámetros en el objeto, y luego combinar estos valores con el 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" }); 
578
21 мая '09 в 23:09 2009-05-21 23:09 La respuesta está dada por Russ Cam el 21 de mayo de 2009 a las 23:09 2009-05-21 23:09

Encuentro algo tan simple como esto, mucho más conciso y legible en persona.

 function pick(arg, def) { return (typeof arg == 'undefined' ? def : arg); } function myFunc(x) { x = pick(x, 'my default'); } 
143
21 мая '09 в 23:18 2009-05-21 23:18 la respuesta se da tj111 21 de mayo de 2009 a las 23:18 2009-05-21 23:18

En ECMAScript 6, puedes escribir exactamente lo que tienes:

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

Esto establecerá delete_after en false si falta o undefined está undefined . Puede usar las características de ES6 como hoy en día con transpilers como Babel .

Vea el artículo de MDN para más detalles .

58
29 мая '15 в 18:25 2015-05-29 18:25 Felix Kling da la respuesta el 29 de mayo de '15 a las 18:25 2015-05-29 18:25

Valores de parámetros predeterminados

Con ES6, probablemente pueda crear uno de los modismos de JavaScript más comunes asociados con la configuración del valor predeterminado para un parámetro de función. La forma en que hemos estado haciendo esto durante muchos 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 

Esta plantilla es la más utilizada, pero es peligrosa cuando pasamos valores, por ejemplo

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

Por que Porque 0 is falsy , etc. x || 11 results in 11 x || 11 results in 11 , en lugar de pasar directamente a 0. Para corregir este error, algunas personas escribirán un cheque con más detalle en su lugar:

 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 considerar una buena sintaxis útil, agregada como ES6 , para ordenar la asignación predeterminada de los argumentos que faltan:

 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 x !== undefined ? x : 11 , que el lenguaje mucho más común x || 11 x || 11

Expresiones por defecto

Function valores predeterminados de la Function pueden ser más que valores simples, 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 predeterminadas se evalúan perezosamente, lo que significa que se ejecutan solo cuando y cuando se necesitan, es decir, cuando el argumento de los parámetros se omite o no está definido.

Una expresión predeterminada puede ser incluso una llamada a una expresión de función incorporada, generalmente llamada expresión con una función inmediata pronunciada (IIFE) :

 function foo( x = (function(v){ return v + 11; })( 31 ) ) { console.log( x ); } foo(); // 42 
23
15 окт. Respuesta dada Thalaivar 15 de octubre 2016-10-15 20:58 '16 a las 8:58 pm 2016-10-15 20:58

Esta solución me funciona en js:

 function read_file(file, delete_after) { delete_after = delete_after || false; // Code } 
10
16 нояб. La respuesta la da Takács Zsolt 16 nov. 2015-11-16 14:29 '15 a las 2:29 pm 2015-11-16 14:29

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

 function read_file(file, delete_after) { if(delete_after === undefined) { delete_after = false; } } 
9
16 нояб. La respuesta es dada por Martin Wantke el 16 de noviembre. 2015-11-16 10:34 '15 a las 10:34 2015-11-16 10:34

Como actualización ... con ECMAScript 6, puede establecer COMPLETAMENTE los valores predeterminados en las declaraciones de parámetros de función de la siguiente manera:

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

Como se mencionó - http://es6-features.org/#DefaultParameterValues

7
06 окт. respuesta dada por zillaofthegods 06 de octubre 2015-10-06 19:16 '15 a las 19:16 2015-10-06 19:16

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

 // 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 de código anterior ilustra los peligros detrás de los valores de argumento predeterminados para los parámetros no utilizados.

7
16 окт. Respuesta dada por Doug Coburn el 16 de octubre. 2017-10-16 01:36 '17 a la 1:36 2017-10-16 01:36

Habiendo sido un desarrollador de C ++ durante mucho tiempo (Rookie to web development :)), cuando me encontré con esta situación, realicé la asignación de parámetros en la definición de una función, como se indica en la pregunta, de la siguiente manera.

 function myfunc(a,b=10) 

Pero tenga cuidado de que no funcione de manera consistente en los navegadores. Para mí, funcionó en Chrome en mi escritorio, pero no funcionó en Chrome en Android. Una opción más segura, como muchos de los mencionados anteriormente, es

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

La intención de esta respuesta no es repetir las mismas decisiones que se mencionaron anteriormente, sino informar que la asignación de parámetros en la definición de una función puede funcionar en algunos navegadores, pero no confiar en ella.

7
19 мая '16 в 9:40 2016-05-19 09:40 la respuesta es dada vivek 19 de mayo, '16 a las 9:40 2016-05-19 09:40

Para cualquier persona interesada en trabajar con código en Microsoft Edge, no use valores predeterminados en los parámetros de función.

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

En este ejemplo, el Edge generará el error "Pendiente") "

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

6
03 авг. Respuesta dada por Steven Johnston 03 ago. 2016-08-03 17:49 '16 a las 5:49 pm 2016-08-03 17:49

ES6: Como se menciona en la mayoría de las respuestas, en ES6 puede simplemente inicializar el parámetro junto con el valor.


ES5: La mayoría de las respuestas proporcionadas no son suficientes para mí, porque hay ocasiones en las que es posible que deba pasar valores falsos, como 0 , null e undefined para una función. Para determinar si un parámetro no está definido, porque el valor que di en lugar de indefinido debido al hecho de que no estaba definido en absoluto, hago esto:

 function foo (param1, param2) { param1 = arguments.length >= 1 ? param1 : "default1"; param2 = arguments.length >= 2 ? param2 : "default2"; } 
3
12 авг. respuesta dada por Angel Politis 12 de agosto 2018-08-12 08:26 '18 a las 8:26 a.m. 2018-08-12 08:26
 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!!! 
3
08 июня '18 в 11:55 2018-06-08 11:55 TinhNQ da la respuesta el 8 de junio de 18 a las 11:55 2018-06-08 11:55

De acuerdo con la sintaxis.

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

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

3
15 окт. la respuesta se da sachin kumar 15 oct. 2017-10-15 23:40 '17 a las 11:40 2017-10-15 23:40

Este ejemplo fue tomado de aquí. 

2
01 июля '18 в 11:50 2018-07-01 11:50 la respuesta se da dutta 01 julio '18 a las 11:50 2018-07-01 11:50

Si está utilizando ES6+ , puede configurar los parámetros predeterminados 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 

La sintaxis anterior utiliza el operador OR . El operador OR siempre devuelve el primer valor si se puede convertir en true si no devuelve un valor de lado derecho. Cuando se llama a la función sin el argumento correspondiente, la variable de parámetro ( bar en nuestro ejemplo) se establece como undefined el mecanismo JS. undefined Luego se convierte en falso y, por lo tanto, el operador OR devuelve el valor 0.

2
08 авг. La respuesta está dada por Willem van der Veen 08 ago. 2018-08-08 18:48 '18 a las 6:48 pm 2018-08-08 18:48

Use esto si desea usar la última sintaxis de ECMA6 :

default function parameters .  Le permite inicializar parámetros formales con valores predeterminados, a menos que se pase o no se defina un valor.  NOTA .  No funcionará con Internet Explorer o con navegadores más antiguos. 

Para la mejor compatibilidad posible , use esto:

2
05 июля '18 в 14:54 2018-07-05 14:54 La respuesta la da BlackBeard el 5 de julio de 18 a 14:54 2018-07-05 14:54

Si, por algún motivo, no está usando ES6 y está usando lodash , esta es la forma más corta de predeterminar los parámetros de la función a través del método _.defaultTo :

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

Lo que establecerá el valor predeterminado si el valor actual es NaN , nulo o no definido

1
10 окт. La respuesta la da Akrion el 10 de octubre. 2018-10-10 10:04 '18 a las 10:04 am 2018-10-10 10:04

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 de ES5 podías hacerlo fácilmente:

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

Esto significa que si hay un valor, use el valor; de lo contrario, use el segundo valor después de || Una operación que hace lo mismo ...

Nota: también hay una gran diferencia entre estos valores si pasa un valor en ES6 , incluso si es falso, que será reemplazado por un nuevo valor, por ejemplo, null o "" ... pero solo se reemplazará un ES5 , si solo se pasa el valor cierto porque el camino || en el trabajo ...

1
18 янв. Responder Alireza 18 Ene 2019-01-18 10:29 '19 a las 10:29 pm 2019-01-18 10:29

Sí, esto se llama la configuración predeterminada.

Los parámetros de función predeterminados permiten la inicialización de parámetros formales con valores predeterminados si el valor no está definido o no está definido.

Sintaxis:

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

Descripción:

Los parámetros de la función no están definidos por defecto. Sin embargo, en situaciones puede ser útil establecer otro valor predeterminado. Esto puede ayudar a la configuración por defecto.

Anteriormente, la estrategia general para establecer valores predeterminados era verificar los valores de los parámetros en el cuerpo de la función y asignar valores si no están definidos. Si no hay un valor en la llamada, su valor no será determinado. Deberá establecer una verificación condicional para asegurarse de que el parámetro no esté definido.

Con los parámetros predeterminados en ES2015, ya no se requiere la verificación en el cuerpo de la función. Ahora simplemente puede poner el valor predeterminado en el encabezado de la función.

Un 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 

Varios ejemplos de sintaxis:

Rellenando los valores indefinidos de otros valores falsos:

Incluso si el valor se especifica explícitamente cuando se invoca, 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 durante una llamada:

El argumento predeterminado se evalúa durante la llamada, por lo que, a diferencia de otros idiomas, cada vez que se llama a una función, se crea un nuevo objeto.

 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 

Las opciones predeterminadas están disponibles para las siguientes opciones predeterminadas:

Los parámetros que ya se encuentran están disponibles para los valores 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:

Presentado en Gecko 33 (Firefox 33 / Thunderbird 33 / SeaMonkey 2.30). Las funciones declaradas en el cuerpo de la función no pueden pasarse dentro de los parámetros predeterminados y lanzar un ReferenceError (actualmente TypeError en SpiderMonkey, ver Error 1022967). Los parámetros predeterminados siempre se ejecutan primero, después de lo cual se evalúan las declaraciones de funciones dentro del cuerpo de la función.

 // Doesn't work! Throws ReferenceError. function f(a = go()) { function go() { return ':P'; } } 

Parámetros sin defecto después de los parámetros por defecto:

Antes de Gecko 26 (Firefox 26 / Thunderbird 26 / SeaMonkey 2.23 / Firefox OS 1.2), el siguiente código dio como resultado un SyntaxError. Esto se solucionó en el error 777060 y funciona como se esperaba en versiones posteriores. Los parámetros siguen siendo de izquierda a derecha, sobrescribiendo los parámetros predeterminados, incluso si hay parámetros más recientes sin valores predeterminados.

 function f(x = 1, y) { return [x, y]; } f(); // [1, undefined] f(2); // [2, undefined] 

Parámetro no estructurado con asignación de valor por defecto:

Puede utilizar la asignación de valor predeterminada utilizando 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
27 сент. esewalson respuesta 27 sep . 2018-09-27 19:56 '18 a las 7:56 pm 2018-09-27 19:56
 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.

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

 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 
-2
19 июля '16 в 14:59 2016-07-19 14:59 Muhammad Awais dio la respuesta el 19 de julio de 2016 a las 14:59 2016-07-19 14:59