Objekto nuosavybės nustatymas neapibrėžtas

Koks yra geriausias būdas patikrinti, ar „JavaScript“ objekto nuosavybė yra neapibrėžta?

2533
26 авг. nustatė Matt Sheppard 26 rug. 2008-08-26 10:25 '08, 10:25, 2008-08-26 10:25
@ 43 atsakymai
  • 1
  • 2

Naudoti:

 if (typeof something === "undefined") { alert("something is undefined"); } 

Jei objekto kintamasis turi tam tikrų savybių, galite naudoti tą patį, kaip:

 if (typeof my_obj.someproperties === "undefined"){ console.log('the property is not available...'); // print into console } 
2431
06 янв. atsakymas suteiktas Erwin 06 jan. 2009-01-06 15:27 '09, 15:27, 2009-01-06 15:27

Manau, kad šiuo klausimu yra keletas neteisingų atsakymų. Priešingai nei visuotinis įsitikinimas, „neapibrėžta“ nėra „JavaScript“ raktinis žodis ir gali turėti jam priskirtą vertę.

Teisingas kodas

Tikriausias būdas atlikti šį testą:

 if (typeof myVar === "undefined") 
border=0

Tai visada grąžina teisingą rezultatą ir netgi tvarko situaciją, kai myVar nėra deklaruotas.

Degeneruoti kodą. NENAUDOKITE.

 var undefined = false; // Shockingly, this is completely legal! if (myVar === undefined) { alert("You have been misled. Run away!"); } 

Be to, myVar === undefined sukels klaidą situacijoje, kai myVar nėra deklaruotas.

837
23 авг. Atsakyti MarkPflug 23 rug . 2010-08-23 21:03 '10, 21:03, 2010-08-23 21:03

Nors aš čia labai rekomenduoju daug kitų atsakymų, tai yra blogas pasirinkimas. Jis niekada neturėtų būti naudojamas patikrinti, ar kintamieji turi undefined reikšmę, nes jis veikia kaip undefined vertės kombinuotas testas ir nustato, ar kintamasis egzistuoja. Daugeliu atvejų jūs žinote, kada egzistuoja kintamasis, o tipas tiesiog reiškia tylaus avarijos potencialą, jei sukuriate klaidą kintamojo pavadinime arba eilutės tekste 'undefined' .

 var snapshot = …; if (typeof snaposhot === 'undefined') { // ^ // misspelled¹ – this will never run, but it won't throw an error! } 
 var foo = …; if (typeof foo === 'undefned') { // ^ // misspelled – this will never run, but it won't throw an error! } 

Taigi, jei neaptinkate aptikimo funkcijos2, kai yra neaiškumų, ar nurodytas vardas bus apimtis (pvz., typeof module !== 'undefined' testo tipas typeof module !== 'undefined' kaip bendrosios bendrosios programos specifinio kodo žingsnis), tipas yra žalingas pasirinkimas, kai naudojant kintamąjį ir teisinga parinktis yra tiesioginis vertės palyginimas:

 var foo = …; if (foo === undefined) { ⋮ } 

Kai kurios dažniausios klaidingos nuomonės apie tai:

  • kad skaitant „uninitialized“ kintamąjį ( var foo ) arba parametrą ( function bar(foo) { … } , vadinama bar() ), klaida bus klaidinga. Tai tiesiog nėra tiesa: kintamieji be aiškios iniciacijos ir parametrų, kurie nenurodė vertės, visada tampa undefined ir visada yra apimti.

  • kad undefined gali būti perrašyta. Tai daug daugiau. undefined nėra „JavaScript“ raktinis žodis. Vietoj to, jo nuosavybė pasauliniame objekte, kurio vertė yra neapibrėžta. Tačiau, kadangi ES5, ši savybė buvo tik skaityta ir ji nebuvo konfigūruojama. Jokia moderni naršyklė leis jums pakeisti undefined turtą ir nuo 2017 m. Tai vyksta ilgą laiką. Griežto režimo nebuvimas neturi įtakos undefined s elgsenai - tai tiesiog daro undefined = 5 teiginius undefined = 5 nedaro nieko, o ne mesti. Kadangi tai nėra raktinis žodis, galite deklaruoti undefined kintamuosius ir šiuos kintamuosius galima keisti, todėl šis vienkartinis šablonas:

     (function (undefined) { // … })() 

    pavojingesnis nei naudojant pasaulinį undefined . Jei turite būti suderinami su ES3, pakeiskite undefined typeof void 0 - typeof . (Tuščia visada buvo unarusis operatorius, kuris įvertina neapibrėžtą bet kurio operando vertę.)

Keičiant kintamuosius, atėjo laikas nuspręsti, koks yra klausimas: objekto savybės. Nėra prasmės naudoti objektų savybių typeof . Ankstesnė išimtis dėl funkcijos aptikimo čia netaikoma - typeof būdingas tik ypatingas kintamųjų elgesys, o išraiškos, susijusios su objekto savybėmis, nėra kintamieji.

Tai yra:

 if (typeof foo.bar === 'undefined') { ⋮ } 

visada lygiai taip:

 if (foo.bar === undefined) { ⋮ } 

ir atsižvelgiant į pirmiau nurodytus patarimus, nesupainioti skaitytojų apie tai, kodėl jūs naudojate typeof , nes yra tikslinga naudoti === kad patikrintumėte lygybę, nes ji gali būti reorganizuota, kad vėliau būtų galima patikrinti kintamųjų vertę, ir todėl, kad jis tik atrodo geriau, čia visada turėtumėte naudoti === undefined ³ .

Kažkas, ką reikia apsvarstyti, kai kalbama apie objektų savybes, yra tai, ar jūs tikrai nenorite patikrinti undefined . Šio objekto pavadinime gali būti, kad objekte (skaitant undefined reikšmę) nėra objekto, kurio vertė yra undefined , objektų, kurių vertė yra undefined arba kuri yra bet kurioje iš tų, kurių vertė nėra undefined prototipo. 'key' in obj pasakys, ar raktas yra objektų prototipo grandinėje, ir Object.prototype.hasOwnProperty.call(obj, 'key') pasakys, ar jis yra tiesiogiai ant objekto. Į šį prototipą neatsakysiu ir neatsakysiu į objektus žemėlapių pavidalu su raktais, nes daugiausia siekiama išspręsti visus blogus patarimus kitais atsakymais, neatsižvelgiant į galimus pradinio klausimo aiškinimus. Daugiau skaitykite MDN objektų prototipą !

¹ pvz., Neįprastas kintamojo pavadinimo pasirinkimas? Tai tikras miręs kodas iš „NoScript“ plėtinio „Firefox“.
² nereikia manyti, kad, nežinodamas, kokia yra prasmė, viskas yra tvarkinga. premijos pažeidžiamumas, kurį sukelia piktnaudžiavimas dinamine sritimi: Project Zero 1225
³ vėl priima ES5 + aplinką ir tai, kad undefined nurodo undefined pasaulinio objekto nuosavybę. kitaip pakeiskite void 0 .

161
27 февр. Atsakymas pateikiamas Ry- 27 vasario mėn. 2014-02-27 00:17 '14 ne 0:17 2014-02-27 00:17

„JavaScript“ yra nulinis , ir yra neapibrėžta . Jie turi skirtingas reikšmes.

  • neapibrėžta reiškia, kad kintamojo vertė yra neapibrėžta; nežinoma, kokia yra ši reikšmė.
  • null reiškia, kad kintamojo vertė yra apibrėžta ir nustatyta nuliui (be vertės).

Mariein Haverbecke savo nemokamame „ JavaScript“ ebook (mano dėmesys):

Taip pat yra panaši vertė, nulinė, kurios vertė "ši vertė yra apibrėžta, bet neturi vertės". Neapibrėžtos ir nulinės reikšmės skirtumai daugiausia yra akademiniai, ir paprastai tai nėra labai įdomu. Praktinėse programose dažnai reikia patikrinti, ar kažkas yra svarbi. “Tokiais atvejais gali būti naudojamas terminas„ = = undefined “, nes, nors jos nėra lygiai tokios pačios vertės, null == undefined grįš tiesa.

Taigi, manau, kad geriausias būdas patikrinti, ar kažkas buvo neapibrėžta:

 if (something == undefined) 

Tikiuosi, kad tai padės!

Redaguoti: Atsakydami į redagavimą, objekto ypatybės turėtų veikti taip pat.

 var person = { name: "John", age: 28, sex: "male" }; alert(person.name); // "John" alert(person.fakeVariable); // undefined 
142
26 авг. Atsakymas duotas Pandincus 26 rug . 2008-08-26 10:36 '08 10:36 am. 2008-08-26 10:36

Ką tai reiškia: „neapibrėžta objekto nuosavybė ?

Iš tiesų, tai gali reikšti du visiškai skirtingus dalykus! Pirma, tai gali reikšti, kad objektas niekada nebuvo apibrėžtas, ir, antra, jis gali reikšti neapibrėžtos vertės turtą. Pažvelkite į šį kodą:

 var o = { a: undefined } 

Ar yra neapibrėžta? Taip Jo vertė yra neapibrėžta. Ar yra neapibrėžta? Žinoma! Nėra jokio „b“ turto! Na, pažiūrėkite, kaip skirtingi požiūriai elgiasi abiem atvejais:

 typeof oa == 'undefined' // true typeof ob == 'undefined' // true oa === undefined // true ob === undefined // true 'a' in o // true 'b' in o // false 

Mes galime aiškiai matyti, kad typeof obj.prop == 'undefined' ir obj.prop === undefined lygiavertės, ir jos neišskiria šių skirtingų situacijų. 'prop' in obj gali aptikti situaciją, kai turtas visai nebuvo apibrėžtas ir neatsižvelgia į turto vertę, kuri gali būti neapibrėžta.

Taigi, ką daryti?

1) Norite žinoti, ar neapibrėžta nuosavybė yra pirmoji ar antroji vertė (dažniausia situacija).

 obj.prop === undefined // IMHO, see "final fight" below 

2) Jūs tiesiog norite sužinoti, ar objektas turi nuosavybę ir nerūpi jo vertės.

 'prop' in obj 

Pastabos:

  • Jūs negalite vienu metu patikrinti objekto ir jo nuosavybės. Pavyzdžiui, šis xa === undefined arba šis typeof xa == 'undefined' skambučiai ReferenceError: x is not defined jei x nėra apibrėžtas.
  • undefined kintamasis yra pasaulinis kintamasis (todėl iš tikrųjų jis yra window.undefined naršyklėse). Jis yra palaikomas su ECMAScript 1st Edition, o su ECMAScript 5 tik skaitoma . Todėl šiuolaikinėse naršyklėse ji negali būti iš naujo apibrėžta tiesai, kaip daugelis autorių norėtų mus išgąsdinti, tačiau tai dar tinka ir senesnėms naršyklėms.

Galutinė kova: obj.prop === undefined vs typeof obj.prop == 'undefined'

obj.prop === undefined :

  • Tai šiek tiek trumpesnis ir atrodo šiek tiek gražesnis.
  • „JavaScript“ mechanizmas suteiks jums klaidos pranešimą, jei turite klaidą su undefined

Trūkumai obj.prop === undefined :

  • undefined gali būti panaikinta senesnėse naršyklėse.

Argumentai " typeof obj.prop == 'undefined' :

  • Tai tikrai universalus! Jis veikia naujose ir senose naršyklėse.

typeof obj.prop == 'undefined' trūkumai:

  • 'undefned' (su klaida) yra tik eilutės konstanta, todėl „JavaScript“ mechanizmas negali padėti jums, jei turite klaidą, tarsi tiesiog padariau.

Atnaujinimas (serverio pusės JavaScript):

„Node.js“ palaiko pasaulinį kintamąjį, undefined kaip global.undefined (jis taip pat gali būti naudojamas be „global“ prefikso). Nežinau apie kitus serverio pusės „JavaScript“ diegimus.

109
08 авг. Konstantino Smolyanino atsakymas 08 rug. 2013-08-08 23:28 '13, 23:28, 2013-08-08 23:28

Problema susideda iš trijų atvejų:

  • Objektas turi nuosavybę ir jo vertė nėra undefined .
  • Objektas turi nuosavybę ir jo vertė yra undefined .
  • Objektas neturi nuosavybės.

Tai mums pasakoja kažką svarbaus:

Yra skirtumas tarp neapibrėžto nario ir konkretaus nario, kurio vertė yra neapibrėžta.

Tačiau, deja, typeof obj.foo nesako mums, kuris iš šių trijų atvejų. Vis dėlto mes galime sujungti šį "foo" in obj su "foo" in obj kad būtų atskirti atvejai.

  | typeof obj.x === 'undefined' | !("x" in obj) 1. { x:1 } | false | false 2. { x : (function(){})() } | true | false 3. {} | true | true 

Pažymėtina, kad šie testai yra vienodi null įrašams.

  | typeof obj.x === 'undefined' | !("x" in obj) { x:null } | false | false 

Sakyčiau, kad kai kuriais atvejais yra tikslinga (ir aiškiau) patikrinti, ar ši nuosavybė yra, nei patikrinti, ar ji nėra apibrėžta, ir vienintelis atvejis, kai šis patikrinimas bus kitoks, yra 2 atvejis, retas faktinis įrašas Objektas su neapibrėžta verte.

Pavyzdžiui: aš ką tik perdirbiau kodo krūva, kuri patikrino, ar objektas turi tam tikrą turtą.

 if( typeof blob.x != 'undefined' ) { fn(blob.x); } 

Kuris buvo aiškesnis rašant, nenustatant neapibrėžto.

 if( "x" in blob ) { fn(blob.x); } 

Tačiau, kaip jau minėta, tai ne visai vienoda (bet daugiau nei mano poreikiams).

62
08 июня '11 в 7:04 2011-06-08 07:04 Atsakymą davė Michaelas Andersonas birželio 8 d. 11 d. 7:04 val. 2011-06-08 07:04
 if ( typeof( something ) == "undefined") 

Jis dirbo man, kiti ne.

40
27 июля '10 в 19:03 2010-07-27 19:03 atsakė Kevinui liepos 27 d. 10 d. 19:03 2010-07-27 19:03

Nežinau, iš kur atsirado === su typeof , ir kaip konvenciją, kurią matau, jis naudojamas daugelyje bibliotekų, tačiau operatorius grąžina eilutę, o mes žinome, kas yra priešais jį, kodėl taip pat norite įvesti ir patikrinkite?

 typeof x; // some string literal "string", "object", "undefined" if (typeof x === "string") { // === is redundant because we already know typeof returns a string literal if (typeof x == "string") { // sufficient 
35
22 сент. Atsakymą Eric pateikė rugsėjo 22 d. 2010-09-22 17:20 '10, 17:20, 2010-09-22 17:20

Kryžminis atsakymas į mano atsakymą į susijusį klausimą Kaip patikrinti „undefined“ „JavaScript“?

Konkretus šiam klausimui, žr. someObject.<whatever> pavyzdžiai su tam someObject.<whatever> .


Kai kurie scenarijai, iliustruojantys įvairių atsakymų rezultatus: http://jsfiddle.net/drzaus/UVjM4/

(Atkreipkite dėmesį, kad naudojant var for testuose yra svarbu, kai naudojate apvalkalą su tam tikra apimtimi

Nuorodos kodas:

 (function(undefined) { var definedButNotInitialized; definedAndInitialized = 3; someObject = { firstProp: "1" , secondProp: false // , undefinedProp not defined } // var notDefined; var tests = [ 'definedButNotInitialized in window', 'definedAndInitialized in window', 'someObject.firstProp in window', 'someObject.secondProp in window', 'someObject.undefinedProp in window', 'notDefined in window', '"definedButNotInitialized" in window', '"definedAndInitialized" in window', '"someObject.firstProp" in window', '"someObject.secondProp" in window', '"someObject.undefinedProp" in window', '"notDefined" in window', 'typeof definedButNotInitialized == "undefined"', 'typeof definedButNotInitialized === typeof undefined', 'definedButNotInitialized === undefined', '! definedButNotInitialized', '!! definedButNotInitialized', 'typeof definedAndInitialized == "undefined"', 'typeof definedAndInitialized === typeof undefined', 'definedAndInitialized === undefined', '! definedAndInitialized', '!! definedAndInitialized', 'typeof someObject.firstProp == "undefined"', 'typeof someObject.firstProp === typeof undefined', 'someObject.firstProp === undefined', '! someObject.firstProp', '!! someObject.firstProp', 'typeof someObject.secondProp == "undefined"', 'typeof someObject.secondProp === typeof undefined', 'someObject.secondProp === undefined', '! someObject.secondProp', '!! someObject.secondProp', 'typeof someObject.undefinedProp == "undefined"', 'typeof someObject.undefinedProp === typeof undefined', 'someObject.undefinedProp === undefined', '! someObject.undefinedProp', '!! someObject.undefinedProp', 'typeof notDefined == "undefined"', 'typeof notDefined === typeof undefined', 'notDefined === undefined', '! notDefined', '!! notDefined' ]; var output = document.getElementById('results'); var result = ''; for(var t in tests) { if( !tests.hasOwnProperty(t) ) continue; // bleh try { result = eval(tests[t]); } catch(ex) { result = 'Exception--' + ex; } console.log(tests[t], result); output.innerHTML += "\n" + tests[t] + ": " + result; } })(); 

Ir rezultatai:

 definedButNotInitialized in window: true definedAndInitialized in window: false someObject.firstProp in window: false someObject.secondProp in window: false someObject.undefinedProp in window: true notDefined in window: Exception--ReferenceError: notDefined is not defined "definedButNotInitialized" in window: false "definedAndInitialized" in window: true "someObject.firstProp" in window: false "someObject.secondProp" in window: false "someObject.undefinedProp" in window: false "notDefined" in window: false typeof definedButNotInitialized == "undefined": true typeof definedButNotInitialized === typeof undefined: true definedButNotInitialized === undefined: true ! definedButNotInitialized: true !! definedButNotInitialized: false typeof definedAndInitialized == "undefined": false typeof definedAndInitialized === typeof undefined: false definedAndInitialized === undefined: false ! definedAndInitialized: false !! definedAndInitialized: true typeof someObject.firstProp == "undefined": false typeof someObject.firstProp === typeof undefined: false someObject.firstProp === undefined: false ! someObject.firstProp: false !! someObject.firstProp: true typeof someObject.secondProp == "undefined": false typeof someObject.secondProp === typeof undefined: false someObject.secondProp === undefined: false ! someObject.secondProp: true !! someObject.secondProp: false typeof someObject.undefinedProp == "undefined": true typeof someObject.undefinedProp === typeof undefined: true someObject.undefinedProp === undefined: true ! someObject.undefinedProp: true !! someObject.undefinedProp: false typeof notDefined == "undefined": true typeof notDefined === typeof undefined: true notDefined === undefined: Exception--ReferenceError: notDefined is not defined ! notDefined: Exception--ReferenceError: notDefined is not defined !! notDefined: Exception--ReferenceError: notDefined is not defined 
21
13 янв. Atsakymas pateikiamas drzaus sausio 13 d 2013-01-13 20:43 '13, 08:43 pm 2013-01-13 20:43

Jei tai padarysite

 if (myvar == undefined ) { alert('var does not exists or is not initialized'); } 

jis neveiks, jei „ myvar kintamasis neegzistuoja, nes „myvar“ nėra apibrėžtas, todėl scenarijus yra sugadintas ir testas neturi jokio poveikio.

Kadangi >

Pavyzdžiui:

 var myvar = 'test'; 

„Myvar“ pasaulinis kintamasis yra toks pat kaip >

Jei norite išvengti klaidų tikrinant, kai egzistuoja pasaulinis kintamasis, geriau naudoti:

 if(window.myvar == undefined ) { alert('var does not exists or is not initialized'); } 

Klausimas, ar kintamasis iš tikrųjų egzistuoja, nesvarbu, jo vertė neteisinga. Priešingu atveju, kvaila inicijuoti kintamuosius su neapibrėžtais, o inicijuoti geriau naudoti false. Kai žinote, kad visi jūsų deklaruojami kintamieji yra inicijuoti false, galite tiesiog patikrinti jo tipą arba pasikliauti „ !window.myvar kad patikrintumėte, ar ji turi teisingą / teisingą vertę. Taigi, net jei kintamasis nėra apibrėžtas, tada „ !window.myvar toks pat myvar = undefined arba myvar = false arba myvar = 0 .

Kai tikitės tam tikro tipo, patikrinkite kintamojo tipą. Kad pagreitintumėte valstybės bandymus, geriau:

 if( !window.myvar || typeof window.myvar != 'string' ) { alert('var does not exists or is not type of string'); } 

Kai pirmoji ir paprasta sąlyga yra teisinga, vertėjas praleidžia šiuos testus.

Visada geriau naudoti egzemplioriaus / objekto kintamąjį, kad patikrintumėte, ar ji turi galiojančią vertę. Jis yra stabilesnis ir yra geriausias būdas programuoti.

(y)

16
12 авг. Atsakymą pateikia Codebeat 12 rug . 2011-08-12 17:40 '11, 17:40 2011-08-12 17:40

Aš nematau (tikiuosi, kad to nepamiršau), kažkas patikrino objektą priešais turtą. Taigi tai yra trumpiausias ir efektyviausias (nors nebūtinai aiškiausias):

 if (obj  obj.prop) { // Do something; } 

Jei obj arba obj.prop yra neapibrėžtas, nulinis arba „falsy“, jei pareiškimas neveiks kodo bloko. Dažniausiai tai yra pageidaujamas elgesys daugelyje kodų operatorių (javascript).

15
25 сент. Joe Johnson atsakymas į 25 sep. 2012-09-25 21:41 '12, 9:41 val. 2012-09-25 21:41

Straipsnyje „ Naršyti„ Null “ir„ Neapibrėžta “„ JavaScript “, aš perskaičiau, kad tokios sistemos kaip„ Underscore.js “ naudoja šią funkciją:

 function isUndefined(obj){ return obj === void 0; } 
12
19 дек. atsakymą pateikė Marthijn gruodžio 19 d 2013-12-19 13:44 '13, 13:44 2013-12-19 13:44

„jei (window.x) {}“ yra saugus su klaida

Labiausiai tikėtina, jei norite if (window.x) . Šis patikrinimas yra saugus, net jei x nebuvo deklaruotas ( var x; ) - naršyklė nepateikia klaidos.

Pavyzdys: noriu sužinoti, ar mano naršyklė palaiko istorijos API.

 if (window.history) { history.call_some_function(); } 

Kaip tai veikia:

> yra objektas, kuriame yra visi visuotiniai kintamieji kaip jo nariai, ir teisėta bandyti gauti prieigą prie neegzistuojančio elemento. Jei x nebuvo deklaruota arba nebuvo nustatyta, tada window.x grąžina neapibrėžtą . neapibrėžtos priežastys suklydo , jei () įvertina.

10
10 февр. Atsakyti DenisS 10 Vas 2014-02-10 19:26 '14, 19:26, 2014-02-10 19:26
 "propertyName" in obj //-> true | false 
9
05 мая '14 в 3:13 2014-05-05 03:13 atsakymas duotas sam 05 gegužės 14 d. 3:13 2014-05-05 03:13

Perskaičius šį klausimą, esu nustebęs, kad to nematau. Radau kelis algoritmus, kurie tai veiks.

Niekada nenustatyta

Jei objekto vertė niekada nebuvo apibrėžta, tai neleis grąžinti true reikšmės, jei ji bus apibrėžta kaip null arba undefined . Tai naudinga, jei norite grąžinti tikrą reikšmę, nustatytą undefined

 if(obj.prop === void 0) console.log("The value has never been defined"); 

Apibrėžta kaip neapibrėžta arba niekada neapibrėžta

Jei norite, kad rezultatas būtų true vertėms, apibrėžtoms undefined verte arba niekada nenustatyta, galite tiesiog naudoti === undefined

 if(obj.prop === undefined) console.log("The value is defined as undefined, or never defined"); 

Apibrėžta kaip apgaulė, neapibrėžta, nulinė arba niekada neapibrėžta.

Paprastai žmonės paprašė man sukurti algoritmą, jei vertė yra klaidinga, undefined arba null . Toliau pateiktas darbas.

 if(obj.prop == false || obj.prop === null || obj.prop === undefined) { console.log("The value is falsy, null, or undefined"); } 
9
15 февр. Travis atsakymą pateikė vasario 15 d. 2015-02-15 06:10 '15 at 6:10 2015-02-15 06:10

Visą neapibrėžtą masyvą galite gauti naudodami kelią naudojant šį kodą.

  function getAllUndefined(object) { function convertPath(arr, key) { var path = ""; for (var i = 1; i < arr.length; i++) { path += arr[i] + "->"; } path += key; return path; } var stack = []; var saveUndefined= []; function getUndefiend(obj, key) { var t = typeof obj; switch (t) { case "object": if (t === null) { return false; } break; case "string": case "number": case "boolean": case "null": return false; default: return true; } stack.push(key); for (k in obj) { if (obj.hasOwnProperty(k)) { v = getUndefiend(obj[k], k); if (v) { saveUndefined.push(convertPath(stack, k)); } } } stack.pop(); } getUndefiend({ "": object }, ""); return saveUndefined; } 

jsFiddle nuoroda

8
17 окт. Anoop atsakymas spalio 17 d 2011-10-17 14:22 „11 at 14:22 pm 2011-10-17 14:22

Sprendimas yra neteisingas. „Javascript“

 null == undefined 

grįžta tiesa, nes abu jie yra „nuspaudžiami“ už loginę vertę ir yra klaidingi. Teisingas būdas yra patikrinti

 if (something === undefined) 

kuris yra tapatybės operatorius ...

7
26 авг. atsakymas, kurį pateikė Ricky 26 rug. 2008-08-26 15:38 '08, 15:38, 2008-08-26 15:38

Palyginkite su void 0 kad būtų kantrūs.

 if (foo !== void 0) 

Tai ne taip, kaip if (typeof foo !== 'undefined')

7
02 янв. atsakymas pateikiamas bevacqua 02 jan. 2014-01-02 15:59 '14, 15:59, 2014-01-02 15:59

Просто что-то не определено в JavaScript, не определено , не имеет значения, является ли оно свойством внутри Object/Array или просто как переменная...

В JavaScript есть typeof благодаря которому очень просто обнаружить неопределенную переменную.

Просто проверьте, является ли typeof whatever === 'undefined' и он вернет логическое значение.

Вот как isUndefined() знаменитая функция isUndefined() в AngularJs v.1x:

 function isUndefined(value) {return typeof value === 'undefined';} 

Итак, как вы видите, функция получает значение, если это значение определено, она вернет false , в противном случае для неопределенных значений вернет true .