Ar yra geresnis būdas atlikti neprivalomus funkcijų parametrus javascript'e?

Aš visada apdorojau neprivalomus parametrus „Javascript“:

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

Ar yra geresnis būdas tai padaryti?

Ar yra atvejų, kai naudojama || atrodo, kad nepavyksta?

724
29 сент. nustatė Mark Biek 29 sep . 2008-09-29 17:27 '08 at 17:27 pm 2008-09-29 17:27
@ 29 atsakymai

Jūsų logika nepavyksta, jei perduodama neprivalomaArg, bet vertinama kaip neteisinga - pabandykite tai kaip alternatyvą

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

Arba alternatyvi idioma:

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

Naudokite bet kurią idiomą, kuri geriausiai susieja jūsų ketinimą!

978
29 сент. atsakymą pateikė Paul Dixon rugsėjo 29 d 2008-09-29 17:30 '08, 17.30 val. 2008-09-29 17:30

Manau, kad tai yra paprasčiausias ir suprantamiausias būdas:

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

Paulius Dicksonas atsako (mano nuolankioje nuomonėje) mažiau suprantamas nei tai, bet jis pasirenka pirmenybę.

border=0

atsakymas į viršų yra daug pažangesnis, bet daug naudingesnis didesnėms funkcijoms!

EDIT 11/17/2013 9:33 pm: sukūriau „Node.js“ paketą, kuris supaprastina funkcijų (metodų), vadinamų parametru, „perkrovą“.

124
15 нояб. atsakymas duotas trusktr 15 nov. 2011-11-15 00:23 '11 prie 0:23 2011-11-15 00:23

„ECMAScript 2015“ (kitaip ES6) galite nurodyti numatytuosius argumentų reikšmes funkcijų deklaracijoje:

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

Daugiau apie juos rasite šiame straipsnyje apie MDN (nepaisant straipsnio pavadinimo, jie vadinami „argumentais“, o ne „parametrais“ „JavaScript“).

Šiuo metu palaikoma tik „Firefox“ , tačiau, kai standartas yra baigtas, tikisi, kad parama bus greitai patobulinta.

107
19 февр. Atsakymą pateikė Lachlan Hunt , vasario 19 d. 2013-02-19 16:13 '13, 16:13, 2013-02-19 16:13

Jei reikia ištraukti pažodinį NULL , gali kilti problemų. Be to, ne, manau, jūs tikriausiai esate teisingame kelyje.

Kitas metodas, kurį kai kurie žmonės pasirenka, yra kintamųjų masyvo perkėlimas, kartojant per argumentų sąrašą. Tai atrodo šiek tiek tvarkinga, bet manau, kad tai šiek tiek daugiau (šiek tiek mažiau) procesas / atmintis.

 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 сент. Atsakymas pateikiamas Oli 29 sep. 2008-09-29 17:34 '08, 17:34 2008-09-29 17:34

Idealiu atveju, jūs turėtumėte pertvarkyti objekto perkėlimą ir sujungti jį su numatytuoju objektu, todėl argumentų priėmimo tvarka nėra svarbi (žr. Antrąjį šio atsakymo skyrių žemiau).

Tačiau, jei norite ką nors greitai, patikimai, lengvai naudoti ir neužkrauti, pabandykite:


Išvalykite greitą pataisą bet kokiam numatytųjų argumentų skaičiui

  • Ji elegantiškai skaito: minimalų papildomą kodą kiekvienai naujai numatytai vertei
  • Galite jį įklijuoti bet kur: tiesiog pakeiskite reikalingų argumentų ir kintamųjų skaičių.
  • Jei norite perduoti undefined argumentą su numatytąją vertę, kintamasis nustatomas kaip undefined . Dauguma kitų šiame puslapyje esančių parinkčių pakeis undefined numatytąją vertę.

Čia pateikiamas trijų pasirinktinių argumentų numatytų verčių pateikimo pavyzdys (su dviem būtinais argumentais)

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

Paprasta demonstracija . Tai panaši į atsakymą į „ roenving“ , tačiau ji lengvai išplėsta į bet kokį skaičių argumentų pagal nutylėjimą, yra lengviau atnaujinama ir naudojama arguments ne „ Function.arguments .


Perkelkite ir sujunkite objektus, kad galėtumėte daugiau lankstumo

Anksčiau minėtas kodas, kaip ir daugelis būdų, kaip įvykdyti argumentus pagal nutylėjimą, negali perduoti argumentų iš sekos, pavyzdžiui, perduodamas optionalC , bet paliekant optionalB grįžti prie standarto.

Geras pasirinkimas tai yra objektų perdavimas ir sujungimas su numatytuoju objektu. Jis taip pat naudingas palaikymui (tik įsitikinkite, kad jūsų kodas yra įskaitomas, todėl būsimi darbuotojai neturės atspėti apie galimą turimų objektų turinį).

JQuery naudojimo pavyzdys. Jei nenaudojate „jQuery“, galite naudoti „Underscore _.defaults(object, defaults) arba peržiūrėti šiuos parametrus :

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

Čia yra paprastas veiksmų pavyzdys .

32
20 февр. atsakymas, kurį pateikė user568458 20 vas. 2012-02-20 18:36 '12 18:36 2012-02-20 18:36

Tam galite naudoti keletą skirtingų schemų, visada bandau .length argumentus:

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

- tai darydamas jis negali žlugti, bet aš nežinau, ar jūsų kelias turi nesėkmių, o dabar negaliu galvoti apie scenarijų, kur jis tikrai nepavyks ...

Edit: Ir tada Paulius pateikė vieną nesėkmingą scenarijų! -)

15
29 сент. atsakymas duodamas 29 sep . 2008-09-29 17:33 '08, 17:33 2008-09-29 17:33

Kaip ir Oli atsakymas, naudoju objekto ir objekto argumentus, kurie apibrėžia numatytąją vertę. Su cukrumi ...

  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 } 

... tai galima padaryti šiek tiek geriau.

 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) 

Kas gera apie šį metodą?

  • Jūs galite praleisti tiek daug argumentų, kiek norite - jei norite tik panaikinti vieno argumento vertę, galite paprasčiausiai pateikti šį argumentą, o ne aiškiai perduoti undefined kai, tarkim, yra 5 argumentai, ir tik norite konfigūruoti pastarąjį, nes turės atlikti kai kuriuos kitus siūlomus metodus.
  • Dirbdami su funkcijų konstruktoriumi kitam objektui, kurį paveldi, lengva priimti bet kokius argumentus, kurių reikalauja objekto konstruktorius, kuriam jūs paveldėsite, nes jums nereikia nurodyti šių argumentų savo konstruktoriaus paraše arba net pateikti savo numatytųjų reikšmių (leiskite tėvui Objekto konstruktorius tai padarys jūsų CharField , kaip parodyta aukščiau, kai CharField kviečia Field konstruktorių.
  • Vaiko daiktai paveldėjimo hierarchijose gali savo nuožiūra pritaikyti savo tėvų konstruktoriaus argumentus, taikydami savo numatytas vertes arba užtikrindami, kad visada bus naudojama konkreti vertė.
13
30 сент. Atsakymą pateikė Jonny Buchanan, rugsėjo 30 d. 2008-09-30 02:16 '08, 2:16, 2008-09-30 02:16

Laisvas tipo patikrinimas

Tai lengva rašyti, bet 0 , '' , false , null ir undefined bus konvertuojama į numatytąją vertę, kurios gali nebūti tikėtina.

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

Griežtas tipo patikrinimas

Ilgesnis, bet apima daugelį atvejų. Vienintelis atvejis, kai jis neteisingai priskiria numatytąją vertę, yra tada, kai perduodame undefined parametrą.

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

Kintamų argumentų tikrinimas

Įrašo visus atvejus, bet labiausiai nepatogu rašyti.

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

ES6

Deja, dabar ji turi labai mažą naršyklės palaikymą.

 function myFunc(requiredArg, optionalArg = 'defaultValue') { } 
8
15 мая '15 в 16:46 2015-05-15 16:46 atsakymą pateikė Petr Hurtak gegužės 15 d., 15 val. 4:46 2015-05-15 16:46

Jei naudojate numatytąjį standartą, jis atrodo daug lengviau skaitomas:

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

Tiesiog nurodykite šią funkciją pasauliniame ekrane.

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

fruit = defaultValue(fruit,'Apple'); naudojimas template fruit = defaultValue(fruit,'Apple');

* PS Jūs galite pervadinti funkciją defaultValue į trumpą pavadinimą, tiesiog nenaudokite default šio rezervuoto žodžio javascript.

8
16 мая '12 в 0:23 2012-05-16 00:23 atsakymas pateikiamas Vitim.us gegužės 16 d., 12 val. 0:23 2012-05-16 00:23

ES2015 / ES6 galite naudoti Object.assign , kuris gali pakeisti $.extend() arba _.defaults()

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

Taip pat galite naudoti numatytuosius argumentus, pvz.,

 function myFunc(requiredArg, { message: 'Hello', color: 'red', importance: 1 } = {}) { // do stuff } 
3
01 февр. Yann Bertrand atsakymas, pateiktas vasario 1 d. 2016-02-01 14:09 '16 at 14:09 2016-02-01 14:09

Jei naudojate „ Underscore“ biblioteką (tai turėtumėte padaryti šią nuostabią biblioteką):

 _.defaults(optionalArg, 'defaultValue'); 
3
23 сент. atsakymas pateikiamas roo2 23 sep . 2014-09-23 02:59 '14, 2:59 2014-09-23 02:59

Naudojau keletą pagrindinių parinkčių, kaip valdyti pasirinktinius kintamuosius. Kartais yra naudingos atpalaiduojančios versijos.

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

Pavyzdžiui, falsifikacijos, naudojamos pagal nutylėjimą su kintamuoju a , yra plačiai naudojamos backbone.js.

2
13 марта '14 в 9:27 2014-03-13 09:27 atsakymą pateikė Mattas Montagas kovo 14 d. 14 d. 9:27 val. 2014-03-13 09:27

Todėl numatytasis parametras, gautas šiam klausimui „EcmaScript 2015“, yra paprasčiausiai paminėtas ...

Su ES6 galima nustatyti numatytuosius nustatymus :

 function doSomething(optionalParam = "defaultValue"){ console.log(optionalParam);//not required to check for falsy values } doSomething(); //"defaultValue" doSomething("myvalue"); //"myvalue" 
2
09 окт. atsakymas, kurį pateikė Kulbhushan 09 spalis 2015-10-09 17:19 '15, 17:19, 2015-10-09 17:19

Projekto metu pastebėjau, kad pernelyg pakartojau pasirinktinius parametrus ir parametrus, todėl sukūriau klasę, kuri tvarko tipo tikrinimą ir priskiria numatytąją vertę, kuri veda prie tvarkingų ir skaitomų kodų. Žr. Pavyzdį ir leiskite man žinoti, ar tai jums tinka.

 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 : []; } 

Naudojant šią klasę:

 (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 Atsakymą pateikė Bart Wttewaall kovo 23, 16 d. 13:52 2016-03-23 ​​13:52

Neapibrėžtam bandymui atlikti nereikia ir jis nėra toks pat stabilus, kaip ir todėl, kad vartotojas568458 nurodė, kad pateiktas sprendimas nėra įvykdytas, jei vertė yra nulinė arba klaidinga. Jūsų API naudotojai gali būti klaidingi arba nuliniai, kad šis metodas būtų išvengta šio parametro.

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

Rezultatas:

 defaultValue provided null false 

Šie du paskutiniai yra potencialiai blogi. Vietoj to, pabandykite:

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

Rezultatas:

 defaultValue provided defaultValue defaultValue 

Vienintelis scenarijus, kai tai nėra optimalus, yra pasirinktiniai parametrai, kurie turi būti logiški ar apgalvoti.

1
27 сент. atsakymas duodamas 27 sepibartfast . 2013-09-27 08:15 '13, 08:15 am 2013-09-27 08:15

Nežinau, kodėl @Paul atsakymas yra sumažintas, tačiau patvirtinimas naudojant null yra geras pasirinkimas. Galbūt geresnis pavyzdys būtų geresnis:

JS trūkstamas parametras yra panašus į deklaruojamą kintamąjį, kuris nėra inicijuotas (tik var a1;). Ir lygybės operatorius konvertuoja neapibrėžtą vertę į nulį, todėl jis veikia gerai tiek tipų, tiek objektų vertėmis, ir taip CoffeeScript tvarko pasirinktinius parametrus.

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

Nors yra susirūpinimas, kad typeof variable === 'undefined' geresnis už geresnį semantiką. Neketinu to apsaugoti, nes tai yra pagrindinės API klausimas, kaip ši funkcija įgyvendinama, ji neturėtų dominti API naudotojo.

Taip pat reikėtų pridurti, kad vienintelis būdas fiziškai įsitikinti, kad bet koks argumentas buvo praleistas naudojant operatorių, kuris, deja, neveiks su parametrų pavadinimais, turi išlaikyti arguments indeksą.

 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 atsakymą pateikė Arman McHitarian gegužės 7 d. 13 d. 16:31 2013-05-07 16:31

Aš išbandžiau keletą čia paminėtų variantų, o jų atlikimas buvo išbandytas. Šiuo metu loginis algoritmas atrodo greičiausias. Nors tai pasikeis laikui bėgant (skirtingos javascript variklio versijos)

Tai mano rezultatai („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 

Šis našumo testas gali būti lengvai atkuriamas: http://jsperf.com/optional-parameters-typeof-vs-switch/2

Tai yra bandymo kodas:

 <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 atsakymas duotas JDC birželio 19, 14, 14:25 2014-06-19 14:25

Čia yra mano sprendimas. Tai galite palikti bet kurį parametrą. Pasirinktinių parametrų tvarka nėra svarbi ir galite pridėti pasirinktinį patikrinimą.

 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 апр. Duco L atsakymas balandžio 11 d. 2016-04-11 16:51 '16 at 16:51 pm 2016-04-11 16:51

Žmonės -

Pažvelgus į šiuos ir kitus sprendimus, bandžiau kelis iš jų, naudodamas kodo fragmentą, kuris iš pradžių buvo W3Schools. Čia rasite tai, kas veikia. Kiekvienas iš komentuotų elementų taip pat veikia, ir jūs galite tiesiog eksperimentuoti pašalindami atskirus komentarus. Kad būtų aišku, parametras „eyecolor“ nėra apibrėžtas.

 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 апр. Mark Funk atsakymas balandžio 13 d 2014-04-13 23:53 '14, 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 окт. Atsakyti Imagine Breaker Oct 3 2014-10-03 12:28 '14, 12:28 2014-10-03 12:28
  • arg || 'default' arg || 'default' yra puikus būdas ir veikia 90% atvejų

  • Tai nepavyksta, kai reikia perduoti vertes, kurios gali būti „klaidingos“

    • false
    • 0
    • NaN
    • ""

    Šiais atvejais jums reikia šiek tiek išsamesnės ir patikrinti undefined

  • Taip pat būkite atsargūs, jei turite papildomų argumentų, turite žinoti visų jūsų argumentų tipus.

1
30 апр. atsakymas, kurį pateikė mcfedr Bal 30 2016-04-30 22:36 '16 at 10:36 pm 2016-04-30 22:36

Štai ką baigiau:

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

Tai vadinama:

 WhoLikesCake({ b : "I do" }); 
1
30 нояб. Atsakymas pateikiamas NinjaFart 30 lapkričio. 2013-11-30 00:04 '13, 00:04 2013-11-30 00:04

Šios versijos yra trumpesnės nei operatoriaus versija.

 function foo(a, b) { a !== undefined || (a = 'defaultA'); if(b === undefined) b = 'defaultB'; ... } 
0
07 нояб. Atsakymas pateikiamas Aurélien Ooms 07.11 . 2013-11-07 21:05 '13, 9:05 val. 2013-11-07 21:05

Visais atvejais, kai neprivalomasArg yra klaidingas, gausite defaultValue.

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

Visa tai yra logvalvalal, nes visi 6 yra klaidingi. 4, 5, 6 atveju gali būti nenorite nustatyti neprivalomo atributo kaip defaultValue, tačiau jis nustatomas kaip neteisingas

0
02 сент. atsakymas duotas Pavan Varanasi 02 sep. 2016-09-02 07:16 '16 at 07:16 2016-09-02 07:16