¿Hay una mejor manera de hacer parámetros de funciones opcionales en javascript?

Siempre he procesado los parámetros opcionales en Javascript de la siguiente manera:

 function myFunc(requiredArg, optionalArg){ optionalArg = optionalArg || 'defaultValue'; //do stuff } 

¿Hay una mejor manera de hacer esto?

¿Hay casos al usar || parece fallar?

724
29 сент. puesta por Mark Biek 29 sep . 2008-09-29 17:27 '08 a las 5:27 pm 2008-09-29 17:27
@ 29 respuestas

Su lógica falla si se pasa opcionalArg, pero se evalúa como falsa; intente esto como una alternativa

 if (typeof optionalArg === 'undefined') { optionalArg = 'default'; } 

O idioma alternativo:

 optionalArg = (typeof optionalArg === 'undefined') ? 'default' : optionalArg; 

¡Usa cualquier lenguaje que conecte mejor tu intención!

978
29 сент. La respuesta la da Paul Dixon el 29 de septiembre. 2008-09-29 17:30 '08 a las 5:30 pm 2008-09-29 17:30

Creo que esta es la forma más fácil y más comprensible:

 if (typeof myVariable === 'undefined') { myVariable = 'default'; } //use myVariable here 

Paul Dickson responde (en mi humilde opinión) menos legible que esto, pero todo se reduce a preferencias.

¡La respuesta es mucho más avanzada, pero mucho más útil para funciones más grandes!

EDITAR 11/17/2013 9:33 pm: Creé un paquete para Node.js, que simplifica la "sobrecarga" de funciones (métodos) llamadas paramétricas .

124
15 нояб. La respuesta se da trusktr 15 nov. 2011-11-15 00:23 '11 a las 0:23 2011-11-15 00:23

En ECMAScript 2015 (de lo contrario ES6) puede declarar los valores de argumento predeterminados en una declaración de función:

 function myFunc(requiredArg, optionalArg = 'defaultValue') { // do stuff } 

Más sobre ellos en este artículo sobre MDN (a pesar del nombre del artículo, se les llama "argumentos" y no "parámetros" en JavaScript).

Actualmente, solo se admite Firefox , pero a medida que se completa el estándar, espere que el soporte se mejore rápidamente.

107
19 февр. La respuesta es dada por Lachlan Hunt el 19 de febrero. 2013-02-19 16:13 '13 a las 16:13 2013-02-19 16:13

Si necesita sacar un NULL literal, entonces puede tener problemas. Además, no, creo que probablemente estés en el camino correcto.

Otro método que algunas personas eligen es transferir una matriz de variables, iterando a través de una lista de argumentos. Se ve un poco limpio, pero creo que es un poco más (muy poco) un poco más de proceso / memoria.

 function myFunction (argArray) { var defaults = { 'arg1' : "value 1", 'arg2' : "value 2", 'arg3' : "value 3", 'arg4' : "value 4" } for(var i in defaults) if(typeof argArray[i] == "undefined") argArray[i] = defaults[i]; // ... } 
43
29 сент. La respuesta fue dada a Oli el 29 de septiembre. 2008-09-29 17:34 '08 a las 17:34 2008-09-29 17:34

Idealmente, tendría que reorganizar la transferencia de objetos y fusionarla con el objeto predeterminado, por lo que no importa el orden en que se pasan los argumentos (consulte la segunda sección de esta respuesta a continuación).

Sin embargo, si solo desea algo rápido, confiable, fácil de usar y no voluminoso, intente lo siguiente:


Solución rápida limpia para cualquier número de argumentos predeterminados

  • Se escala de forma elegante: el código adicional mínimo para cada nuevo valor predeterminado
  • Puede pegarlo en cualquier lugar: solo cambie el número de argumentos y variables requeridas.
  • Si desea pasar undefined argumento con un valor predeterminado, entonces la variable se establece como undefined . La mayoría de las otras opciones en esta página reemplazarían undefined con el valor predeterminado.

Este es un ejemplo de cómo proporcionar valores predeterminados para tres argumentos opcionales (con dos argumentos necesarios)

 function myFunc( requiredA, requiredB, optionalA, optionalB, optionalC ) { switch (arguments.length - 2) { // 2 is the number of required arguments case 0: optionalA = 'Some default'; case 1: optionalB = 'Another default'; case 2: optionalC = 'Some other default'; // no breaks between cases: each case implies the next cases are also needed } } 

Demo simple . Esto es similar a la respuesta de roenving , pero se expande fácilmente a cualquier número de argumentos predeterminados, es más fácil de actualizar y el uso de arguments no de Function.arguments .


Transfiere y fusiona objetos para una mayor flexibilidad.

El código anterior, al igual que muchas formas de ejecutar argumentos por defecto, no puede pasar argumentos de una secuencia, por ejemplo, pasando la optionalC , pero dejando que la optionalB vuelva a su estándar.

Una buena opción para esto es pasar objetos y fusionarlos con el objeto predeterminado. También es útil para la capacidad de mantenimiento (solo asegúrese de que su código sea legible, para que los futuros empleados no tengan que adivinar los posibles contenidos de los objetos que pasa).

Un ejemplo del uso de jQuery. Si no está usando jQuery, puede usar el _.defaults(object, defaults) lugar, o para ver estos parámetros :

 function myFunc( args ) { var defaults = { optionalA: 'Some default', optionalB: 'Another default', optionalC: 'Some other default' }; args = $.extend({}, defaults, args); } 

Aquí hay un ejemplo simple de esto en acción .

32
20 февр. Respuesta dada por el usuario 568458 20 de febrero. 2012-02-20 18:36 '12 a las 18:36 2012-02-20 18:36

Puedes usar varios esquemas diferentes para esto, siempre he probado los argumentos .length:

 function myFunc(requiredArg, optionalArg){ optionalArg = myFunc.arguments.length<2 ? 'defaultValue' : optionalArg; ... 

- Al hacer esto, no puede fallar, pero no sé si tu camino tiene alguna posibilidad de fracaso, ahora no puedo pensar en un escenario en el que realmente fracasará ...

Edición: ¡Y luego Pablo proporcionó un guión sin éxito! -)

15
29 сент. respuesta dada roenving 29 sep . 2008-09-29 17:33 '08 a las 17:33 2008-09-29 17:33

Al igual que la respuesta de Oli, uso los argumentos Objeto y Objeto, que definen valores predeterminados. Con un poco de azúcar ...

  function extend(dest) { for (var i = 1, l = arguments.length; i < l; i++) { var src = arguments[i] if (!src) { continue } for (var property in src) { if (src.hasOwnProperty(property)) { dest[property] = src[property] } } } return dest }  function inherits(child, parent) { var F = function() {} F.prototype = parent.prototype child.prototype = new F() child.prototype.constructor = child return child } 

... se puede hacer un poco mejor.

 function Field(kwargs) { kwargs = extend({ required: true, widget: null, label: null, initial: null, helpText: null, errorMessages: null }, kwargs) this.required = kwargs.required this.label = kwargs.label this.initial = kwargs.initial // ...and so on... } function CharField(kwargs) { kwargs = extend({ maxLength: null, minLength: null }, kwargs) this.maxLength = kwargs.maxLength this.minLength = kwargs.minLength Field.call(this, kwargs) } inherits(CharField, Field) 

¿Qué tiene de bueno este método?

  • Puede omitir tantos argumentos como desee; si solo desea anular el valor de un argumento, puede proporcionar este argumento en lugar de pasar explícitamente undefined cuando, por ejemplo, hay 5 argumentos, y solo desea configurar este último, ya que Habrá que hacer algunos de los otros métodos propuestos.
  • Cuando trabaje con el constructor de funciones para un objeto que hereda de otro, es fácil tomar cualquier argumento que sea requerido por el constructor del objeto al que hereda, ya que no necesita nombrar estos argumentos en su firma de constructor o incluso proporcionar sus propios valores predeterminados (deje que el padre El constructor de objetos hará esto por usted, como se muestra arriba, cuando CharField llama al constructor de Field .
  • Los objetos secundarios en jerarquías de herencia pueden personalizar los argumentos para su constructor principal a su discreción, aplicando sus propios valores predeterminados o asegurando que siempre se utilizará un valor particular.
13
30 сент. La respuesta es dada por Jonny Buchanan el 30 de septiembre. 2008-09-30 02:16 '08 a las 2:16 am del 2008-09-30 02:16

Verificación de tipo libre

Es fácil de escribir, pero 0 , '' , false , null y undefined se convertirán al valor predeterminado, que puede no esperarse.

 function myFunc(requiredArg, optionalArg) { optionalArg = optionalArg || 'defaultValue'; } 

Verificación estricta

Más largo, pero cubre la mayoría de los casos. El único caso en el que asigna incorrectamente un valor predeterminado es cuando pasamos undefined como parámetro.

 function myFunc(requiredArg, optionalArg) { optionalArg = typeof optionalArg !== 'undefined' ? optionalArg : 'defaultValue'; } 

Comprobando argumentos variables

Captura todos los casos, pero el más inconveniente de escribir.

 function myFunc(requiredArg, optionalArg1, optionalArg2) { optionalArg1 = arguments.length > 1 ? optionalArg1 : 'defaultValue'; optionalArg2 = arguments.length > 2 ? optionalArg2 : 'defaultValue'; } 

ES6

Desafortunadamente, ahora tiene un soporte de navegador muy bajo.

 function myFunc(requiredArg, optionalArg = 'defaultValue') { } 
8
15 мая '15 в 16:46 2015-05-15 16:46 Petr Hurtak da la respuesta el 15 de mayo de '15 a las 4:46 de 2015-05-15 16:46

Si utilizas el valor predeterminado por defecto, parece mucho más legible:

 function usageExemple(a,b,c,d){ //defaults a=defaultValue(a,1); b=defaultValue(b,2); c=defaultValue(c,4); d=defaultValue(d,8); var x = a+b+c+d; return x; } 

Simplemente declare esta característica en la pantalla global.

 function defaultValue(variable,defaultValue){ return(typeof variable!=='undefined')?(variable):(defaultValue); } 

Plantilla de uso de fruit = defaultValue(fruit,'Apple');

* PS Puede cambiar el nombre de la función defaultValue a un nombre corto, simplemente no use esta palabra reservada por default en javascript.

8
16 мая '12 в 0:23 2012-05-16 00:23 La respuesta se da Vitim.us 16 de mayo de '12 a las 0:23 2012-05-16 00:23

En ES2015 / ES6, puede usar Object.assign , que puede reemplazar $.extend() o _.defaults()

 function myFunc(requiredArg, options = {}) { const defaults = { message: 'Hello', color: 'red', importance: 1 }; const settings = Object.assign({}, defaults, options); // do stuff } 

También puede utilizar argumentos predeterminados, como

 function myFunc(requiredArg, { message: 'Hello', color: 'red', importance: 1 } = {}) { // do stuff } 
3
01 февр. Respuesta dada por Yann Bertrand el 01 de febrero. 2016-02-01 14:09 '16 a las 2:09 pm 2016-02-01 14:09

Si usas la biblioteca de guiones bajos (deberías hacer de esta una biblioteca maravillosa):

 _.defaults(optionalArg, 'defaultValue'); 
3
23 сент. la respuesta se da roo2 23 sep . 2014-09-23 02:59 '14 a las 2:59 2014-09-23 02:59

Uso algunas opciones básicas para manejar variables opcionales. A veces las versiones relajantes son útiles.

 function foo(a, b, c) { a = a || "default"; // matches 0, "", null, undefined, NaN, false. a || (a = "default"); // matches 0, "", null, undefined, NaN, false. if (b == null) { b = "default"; } // matches null, undefined. if (typeof c === "undefined") { c = "default"; } // matches undefined. } 

Las falsificaciones utilizadas por defecto con la variable a , por ejemplo, se usan ampliamente en backbone.js.

2
13 марта '14 в 9:27 2014-03-13 09:27 la respuesta la da Matt Montag el 13 de marzo de 2014 a las 9:27 2014-03-13 09:27

La búsqueda de los parámetros predeterminados adquiridos para esta pregunta en EcmaScript 2015 se menciona simplemente ...

Con ES6, podemos realizar ajustes por defecto :

 function doSomething(optionalParam = "defaultValue"){ console.log(optionalParam);//not required to check for falsy values } doSomething(); //"defaultValue" doSomething("myvalue"); //"myvalue" 
2
09 окт. respuesta dada por Kulbhushan 09 de octubre 2015-10-09 17:19 '15 a las 17:19 2015-10-09 17:19

Durante el proyecto, noté que repetía demasiado con parámetros y configuraciones opcionales, así que creé una clase que maneja la verificación de tipos y asigna un valor predeterminado, lo que lleva a códigos ordenados y legibles. Mira un ejemplo y hazme saber si esto funciona para ti.

 var myCar = new Car('VW', {gearbox:'automatic', options:['radio', 'airbags 2x']}); var myOtherCar = new Car('Toyota'); function Car(brand, settings) { this.brand = brand; // readable and adjustable code settings = DefaultValue.object(settings, {}); this.wheels = DefaultValue.number(settings.wheels, 4); this.hasBreaks = DefaultValue.bool(settings.hasBreaks, true); this.gearbox = DefaultValue.string(settings.gearbox, 'manual'); this.options = DefaultValue.array(settings.options, []); // instead of doing this the hard way settings = settings || {}; this.wheels = (!isNaN(settings.wheels)) ? settings.wheels : 4; this.hasBreaks = (typeof settings.hasBreaks !== 'undefined') ? (settings.hasBreaks === true) : true; this.gearbox = (typeof settings.gearbox === 'string') ? settings.gearbox : 'manual'; this.options = (typeof settings.options !== 'undefined'  Array.isArray(settings.options)) ? settings.options : []; } 

Utilizando esta clase:

 (function(ns) { var DefaultValue = { object: function(input, defaultValue) { if (typeof defaultValue !== 'object') throw new Error('invalid defaultValue type'); return (typeof input !== 'undefined') ? input : defaultValue; }, bool: function(input, defaultValue) { if (typeof defaultValue !== 'boolean') throw new Error('invalid defaultValue type'); return (typeof input !== 'undefined') ? (input === true) : defaultValue; }, number: function(input, defaultValue) { if (isNaN(defaultValue)) throw new Error('invalid defaultValue type'); return (typeof input !== 'undefined'  !isNaN(input)) ? parseFloat(input) : defaultValue; }, // wrap the input in an array if it is not undefined and not an array, for your convenience array: function(input, defaultValue) { if (typeof defaultValue === 'undefined') throw new Error('invalid defaultValue type'); return (typeof input !== 'undefined') ? (Array.isArray(input) ? input : [input]) : defaultValue; }, string: function(input, defaultValue) { if (typeof defaultValue !== 'string') throw new Error('invalid defaultValue type'); return (typeof input === 'string') ? input : defaultValue; }, }; ns.DefaultValue = DefaultValue; }(this)); 
1
23 марта '16 в 13:52 2016-03-23 13:52 Bart Wttewaall respondió el 23 de marzo de 2016 a las 13:52 2016-03-23 ​​13:52

La prueba para undefined no es necesaria y no es tan estable como podría ser porque el usuario 568458 indicó que la solución provista no se ejecuta si el valor es nulo o falso. Los usuarios de su API pueden ser falsos o nulos para que este método evite este parámetro.

 function PaulDixonSolution(required, optionalArg){ optionalArg = (typeof optionalArg === "undefined") ? "defaultValue" : optionalArg; console.log(optionalArg); }; PaulDixonSolution("required"); PaulDixonSolution("required", "provided"); PaulDixonSolution("required", null); PaulDixonSolution("required", false); 

Resultado:

 defaultValue provided null false 

Esos dos últimos son potencialmente malos. En su lugar, intente:

 function bulletproof(required, optionalArg){ optionalArg = optionalArg ? optionalArg : "defaultValue";; console.log(optionalArg); }; bulletproof("required"); bulletproof("required", "provided"); bulletproof("required", null); bulletproof("required", false); 

Resultado:

 defaultValue provided defaultValue defaultValue 

El único escenario donde esto no es óptimo es cuando tiene parámetros opcionales que deben ser lógicos o deliberados.

1
27 сент. la respuesta se da slartibartfast 27 sep . 2013-09-27 08:15 '13 a las 8:15 am 2013-09-27 08:15

No sé por qué la respuesta de @Paul está abatida, pero la validación con null es una buena opción. Tal vez un ejemplo más positivo sería mejor:

En JS, el parámetro que falta es similar a la variable declarada, que no está inicializada (solo var a1;). Y el operador de igualdad convierte el valor no definido en nulo, por lo que funciona bien con los valores de tipos y objetos, y así es como CoffeeScript maneja los parámetros opcionales.

 function overLoad(p1){ alert(p1 == null); // caution, don't use the strict comparison: === won't work. alert(typeof p1 === 'undefined'); } overLoad(); // true, true overLoad(undefined); // true, true. Yes, undefined is treated as null for equality operator. overLoad(10); // false, false function overLoad(p1){ if (p1 == null) p1 = 'default value goes here...'; //... } 

Aunque existe la preocupación de que la typeof variable === 'undefined' ligeramente mejor para una mejor semántica. No voy a proteger esto, ya que se trata de la API base, cómo se implementa la función, no debería interesar al usuario de la API.

También debe agregarse que aquí la única forma de asegurarse físicamente de que se omitió cualquier argumento utilizando el operador in , que, desafortunadamente, no funcionará con nombres de parámetros, debe pasar el índice de arguments .

 function foo(a, b) { // Both a and b will evaluate to undefined when used in an expression alert(a); // undefined alert(b); // undefined alert("0" in arguments); // true alert("1" in arguments); // false } foo (undefined); 
1
07 мая '13 в 16:31 2013-05-07 16:31 Arman McHitarian, el 7 de mayo de 2013, dio respuesta a las 4:31 pm 2013-05-07 16:31

Probé varias opciones mencionadas aquí, y el rendimiento las probó. Por el momento, el algoritmo lógico parece ser el más rápido. Aunque esto se debe cambiar con el tiempo (diferentes versiones del motor javascript)

Estos son mis resultados (Microsoft Edge 20.10240.16384.0)

 Function executed Operations/sec Statistics TypeofFunction('test'); 92,169,505 ±1.55% 9% slower SwitchFuntion('test'); 2,904,685 ±2.91% 97% slower ObjectFunction({param1: 'test'}); 924,753 ±1.71% 99% slower LogicalOrFunction('test'); 101,205,173 ±0.92% fastest TypeofFunction2('test'); 35,636,836 ±0.59% 65% slower 

Esta prueba de rendimiento se puede reproducir fácilmente en: http://jsperf.com/optional-parameters-typeof-vs-switch/2

Este es el código de prueba:

 <script src="https://ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js"></script> <script> Benchmark.prototype.setup = function() { function TypeofFunction(param1, optParam1, optParam2, optParam3) { optParam1 = (typeof optParam1 === "undefined") ? "Some default" : optParam1; optParam2 = (typeof optParam2 === "undefined") ? "Another default" : optParam2; optParam3 = (typeof optParam3 === "undefined") ? "Some other default" : optParam3; } function TypeofFunction2(param1, optParam1, optParam2, optParam3) { optParam1 = defaultValue(optParam1, "Some default"); optParam2 = defaultValue(optParam2, "Another default"); optParam3 = defaultValue(optParam3, "Some other default"); } function defaultValue(variable, defaultValue) { return (typeof variable !== 'undefined') ? (variable) : (defaultValue); } function SwitchFuntion(param1, optParam1, optParam2, optParam3) { switch (arguments.length - 1) { // <-- 1 is number of required arguments case 0: optParam1 = 'Some default'; case 1: optParam2 = 'Another default'; case 2: optParam3 = 'Some other default'; } } function ObjectFunction(args) { var defaults = { optParam1: 'Some default', optParam2: 'Another default', optParam3: 'Some other default' } args = $.extend({}, defaults, args); } function LogicalOrFunction(param1, optParam1, optParam2, optParam3) { optParam1 || (optParam1 = 'Some default'); optParam2 || (optParam1 = 'Another default'); optParam3 || (optParam1 = 'Some other default'); } }; </script> 
1
19 июня '14 в 14:25 2014-06-19 14:25 la respuesta se da JDC el 19 de junio de '14 a las 14:25 2014-06-19 14:25

Aquí está mi decisión. Con esto, puedes dejar cualquier parámetro. El orden de los parámetros opcionales no es importante, y puede agregar una comprobación personalizada.

 function YourFunction(optionalArguments) { //var scope = this; //set the defaults var _value1 = 'defaultValue1'; var _value2 = 'defaultValue2'; var _value3 = null; var _value4 = false; //check the optional arguments if they are set to override defaults... if (typeof optionalArguments !== 'undefined') { if (typeof optionalArguments.param1 !== 'undefined') _value1 = optionalArguments.param1; if (typeof optionalArguments.param2 !== 'undefined') _value2 = optionalArguments.param2; if (typeof optionalArguments.param3 !== 'undefined') _value3 = optionalArguments.param3; if (typeof optionalArguments.param4 !== 'undefined') //use custom parameter validation if needed, in this case for javascript boolean _value4 = (optionalArguments.param4 === true || optionalArguments.param4 === 'true'); } console.log('value summary of function call:'); console.log('value1: ' + _value1); console.log('value2: ' + _value2); console.log('value3: ' + _value3); console.log('value4: ' + _value4); console.log(''); } //call your function in any way you want. You can leave parameters. Order is not important. Here some examples: YourFunction({ param1: 'yourGivenValue1', param2: 'yourGivenValue2', param3: 'yourGivenValue3', param4: true, }); //order is not important YourFunction({ param4: false, param1: 'yourGivenValue1', param2: 'yourGivenValue2', }); //uses all default values YourFunction(); //keeps value4 false, because not a valid value is given YourFunction({ param4: 'not a valid bool' }); 
1
11 апр. Respuesta dada por Duco L el 11 de abril. 2016-04-11 16:51 '16 a las 4:51 pm 2016-04-11 16:51

Gente -

Después de ver estas y otras soluciones, probé varias de ellas, usando el fragmento de código, originalmente de W3Schools, como base. Puedes encontrar lo que funciona en lo siguiente. Cada uno de los elementos comentados también funciona, y puede simplemente experimentar eliminando comentarios individuales. Para que quede claro, el parámetro "eyecolor" no está definido.

 function person(firstname, lastname, age, eyecolor) { this.firstname = firstname; this.lastname = lastname; this.age = age; this.eyecolor = eyecolor; // if(null==eyecolor) // this.eyecolor = "unknown1"; //if(typeof(eyecolor)==='undefined') // this.eyecolor = "unknown2"; // if(!eyecolor) // this.eyecolor = "unknown3"; this.eyecolor = this.eyecolor || "unknown4"; } var myFather = new person("John", "Doe", 60); var myMother = new person("Sally", "Rally", 48, "green"); var elem = document.getElementById("demo"); elem.innerHTML = "My father " + myFather.firstname + " " + myFather.lastname + " is " + myFather.age + " with " + myFather.eyecolor + " eyes.<br/>" + "My mother " + myMother.firstname + " " + myMother.lastname + " is " + myMother.age + " with " + myMother.eyecolor + " eyes."; 
1
13 апр. Respuesta dada por Mark Funk el 13 de abril. 2014-04-13 23:53 '14 a las 23:53 2014-04-13 23:53
 function Default(variable, new_value) { if(new_value === undefined) { return (variable === undefined) ? null : variable; } return (variable === undefined) ? new_value : variable; } var a = 2, b = "hello", c = true, d; var test = Default(a, 0), test2 = Default(b, "Hi"), test3 = Default(c, false), test4 = Default(d, "Hello world"); window.alert(test + "\n" + test2 + "\n" + test3 + "\n" + test4); 

http://jsfiddle.net/mq60hqrf/

1
03 окт. Responder Imagine Breaker 3 de octubre 2014-10-03 12:28 '14 a las 12:28 2014-10-03 12:28
  • arg || 'default' arg || 'default' es una gran manera y funciona en el 90% de los casos

  • Falla cuando necesitas pasar valores que pueden ser "falsos"

    • false
    • 0
    • NaN
    • ""

    Para estos casos, necesita ser un poco más detallado y verificar undefined

  • También tenga cuidado, cuando tenga argumentos adicionales, debe conocer los tipos de todos sus argumentos.

1
30 апр. respuesta dada por mcfedr 30 de abril 2016-04-30 22:36 '16 a las 10:36 pm 2016-04-30 22:36

Aquí está lo que terminé:

 function WhoLikesCake(options) { options = options || {}; var defaultOptions = { a : options.a || "Huh?", b : options.b || "I don't like cake." } console.log('a: ' + defaultOptions.b + ' - b: ' + defaultOptions.b); // Do more stuff here ... } 

Llamado de la siguiente manera:

 WhoLikesCake({ b : "I do" }); 
1
30 нояб. La respuesta se da NinjaFart 30 Nov. 2013-11-30 00:04 '13 a las 0:04 2013-11-30 00:04

Estas versiones son más cortas que la versión del operador typeof.

 function foo(a, b) { a !== undefined || (a = 'defaultA'); if(b === undefined) b = 'defaultB'; ... } 
0
07 нояб. La respuesta se da Aurélien Ooms 07 Nov. 2013-11-07 21:05 '13 a las 9:05 pm 2013-11-07 21:05

En todos los casos donde opcionalArg es falso, obtendrá valor predeterminado.

 function myFunc(requiredArg, optionalArg) { optionalArg = optionalArg || 'defaultValue'; console.log(optionalArg); //do stuff } myFunc(requiredArg); myFunc(requiredArg, null); myFunc(requiredArg, undefined); myFunc(requiredArg, ""); myFunc(requiredArg, 0); myFunc(requiredArg, false); 

Todo lo anterior es logvalvalal, ya que los 6 son falsos. En el caso de 4, 5, 6, puede que no esté interesado en establecer un atributo opcional como valor predeterminado, pero se establece como falso.

0
02 сент. La respuesta la da Pavan Varanasi 02 sep. 2016-09-02 07:16 '16 a las 7:16 AM 2016-09-02 07:16