Die opsporing van'n ongedefinieerde voorwerp eiendom

https://stackoverflow.com/questions/27509

09-06-2019
|

Vra

Wat is die beste manier van kontrole as'n voorwerp van eiendom in JavaScript is ongedefinieerd?

Oplossing

Gebruik:

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

As 'n voorwerp veranderlike wat 'n paar eienskappe kan jy dieselfde ding gebruik soos volg:

if (typeof my_obj.someproperties === "undefined"){
    console.log('the property is not available...'); // print into console
}

Ander wenke

Ek glo daar is 'n aantal verkeerde antwoorde op hierdie onderwerp. In teenstelling met algemene opvatting, "ongedefinieerde" is nie 'n navraag in JavaScript en kan in werklikheid het 'n waarde daaraan geheg.

korrekte kode

Die mees omvattende manier om dit te toets uit te voer is:

if (typeof myVar === "undefined")

Dit sal altyd die korrekte resultaat terugkeer, en selfs die situasie waar myVar nie verklaar word hanteer.

Gedegenereerde kode. Nie gebruik nie.

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

Verder myVar === undefined sal 'n fout in die situasie in te samel waar myVar is onverklaarde.

Ondanks die feit dat heftig aanbeveel deur baie ander antwoorde hier, typeof is 'n slegte keuse . Dit moet nooit gebruik word vir die beheer van of veranderlikes het die waarde undefined, want dit dien as 'n gekombineerde tjek vir die waarde undefined en vir of 'n veranderlike bestaan. In die oorgrote meerderheid van gevalle, weet jy wanneer 'n veranderlike bestaan, en typeof sal net voer die potensiaal vir 'n stille mislukking as jy 'n tikfout maak in die veranderlike naam of in die string letterlike '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!
}

So tensy jy doen funksie detection², waar daar onsekerheid of 'n gegewe naam sal wees in omvang (soos die nagaan van typeof module !== 'undefined' as 'n stap in kode wat spesifiek op 'n CommonJS omgewing), typeof is 'n skadelike keuse wanneer dit gebruik word op 'n veranderlike, en die korrekte opsie is om die waarde direk vergelyk:

var foo = …;

if (foo === undefined) {
    ⋮
}

Sommige algemene wanopvattings oor hierdie sluit in:

wat lees 'n "geïnitialiseerd" veranderlike (var foo) of parameter (function bar(foo) { … }, genoem as bar()) sal misluk. Dit is eenvoudig nie waar nie -. Veranderlikes sonder eksplisiete inisialisering en parameters wat nie waardes altyd undefined word gegee, en is altyd in omvang
dat undefined kan oorskryf. Daar is 'n baie meer om hierdie. undefined is nie 'n navraag in JavaScript. In plaas daarvan, is dit 'n eiendom op die globale voorwerp met die Undefined waarde. Maar sedert ES5, hierdie eiendom is read-only en nie-konfigureerbare . Geen moderne leser sal toelaat dat die undefined eiendom te verander, en as van 2017 dit die geval vir 'n lang tyd was. gedrag gebrek aan streng af raak nie undefined se óf - dit maak net stellings soos undefined = 5 doen niks in plaas van die gooi. Want dit is nie 'n navraag, al is, jy kan verklaar veranderlikes met die naam undefined, en daardie veranderlikes verander kan word, maak dit eens algemene patroon:
```
(function (undefined) {
    // …
})()
```
meer gevaarlik as die gebruik van die globale undefined. As jy ES3-versoenbaar te wees, te vervang undefined met void 0 - nie terugval op typeof. (void was nog altyd 'n unêre operateur wat evalueer die Undefined waarde vir enige operand nie.)

Met hoe veranderlikes werk uit die weg geruim, is dit tyd om die werklike vraag: voorwerp eienskappe. Daar is geen rede om ooit te gebruik typeof vir voorwerp eienskappe. Hoe vroeër uitsondering ten opsigte van funksie opsporing beteken hier nie van toepassing -. typeof het net spesiale gedrag op veranderlikes, en uitdrukkings wat voorwerp eienskappe verwys is nie veranderlikes

Dit:

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

is altyd presies ekwivalent om this³:

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

en met inagneming van die advies bo, om te verhoed dat verwarrend lesers aan te voer waarom jy gebruik typeof, want dit maak die meeste sin om === gebruik om te kyk vir gelykheid, want dit kan refactored om later te keur waarde 'n veranderlike se en omdat dit net plain beter lyk, jy moet altyd gebruik === undefined³ hier sowel .

Nog iets om te oorweeg wanneer dit kom by die eienskappe beswaar is of jy regtig wil om te kyk vir undefined at all. 'N Gegewe naam eiendom kan afwesig op 'n voorwerp wees (die vervaardiging van die waarde undefined wanneer lees), teenwoordig op die voorwerp self met die waarde undefined, teenwoordig op prototipe die voorwerp se met die waarde undefined, of teenwoordig op een van dié met 'n nie-undefined waarde. 'key' in obj sal jou vertel of 'n sleutel is oral op prototipe ketting 'n voorwerp se en Object.prototype.hasOwnProperty.call(obj, 'key') sal jou vertel of dit nou direk opdie voorwerp. Ek sal nie in detail in hierdie antwoord oor prototipes en die gebruik van voorwerpe soos-string ingesleutel kaarte, al is, want dit is meestal bedoel om al die slegte raad in ander antwoorde, ongeag die moontlike interpretasies van die oorspronklike vraag teen te werk. Lees meer oor voorwerp prototipes op MDN vir meer!

_{¹ ongewone keuse van byvoorbeeld veranderlike naam? hierdie is 'n ware dood kode van die NoScript uitbreiding vir Firefox.}
_{² nie aanvaar dat sonder om te weet wat is in omvang is okay in die algemeen, al is. bonus kwesbaarheid as gevolg van mishandeling van dinamiese omvang: Projek Zero 1225}
_{³ weereens die veronderstelling n ES5 + omgewing en dat undefined verwys na die undefined eiendom van die globale voorwerp. plaasvervanger void 0 anders.}

In JavaScript daar is null en daar is nie gedefinieer . Hulle het verskillende betekenisse.

undefined beteken dat die veranderlike waarde is nie gedefinieer; dit is nie bekend wat die waarde is.
null beteken dat die veranderlike waarde is gedefinieer en stel aan nul (geen waarde).

Marijn Haver Beke state, in sy vrye, online boek " Eloquent JavaScript " (klem myne):

Daar is ook 'n soortgelyke waarde, null, waarvan die betekenis is 'hierdie waarde word gedefinieer, maar dit beteken nie 'n waarde hê. Die verskil in betekenis tussen ongedefinieerde en nul is meestal akademiese en gewoonlik nie baie interessant. In praktiese programme, is dit dikwels nodig om te kyk of iets ' 'n waarde. In hierdie gevalle kan die uitdrukking iets == ongedefinieer gebruik word, omdat, selfs al is hulle nie presies dieselfde waarde, sal nul == ongedefinieer ware produseer.

So, ek dink die beste manier om te kyk of iets is ongedefinieer sal wees:

if (something == undefined)

Hoop dit help!

Edit:. In reaksie op jou wysig, moet voorwerp eienskappe op dieselfde manier te werk

var person = {
    name: "John",
    age: 28,
    sex: "male"
};

alert(person.name); // "John"
alert(person.fakeVariable); // undefined

Wat beteken dit? "ongedefinieerde voorwerp eiendom"

Eintlik is dit kan beteken twee heeltemal verskillende dinge! In die eerste plek kan dit beteken die eiendom wat nog nooit gedefinieer is in die voorwerp en, tweedens, kan dit beteken dat die eiendom wat 'n ongedefinieerde waarde het. Kom ons kyk na hierdie kode:

var o = { a: undefined }

Is o.a undefined? Ja! Die waarde daarvan is ongedefinieerd. Is o.b undefined? Seker! Daar is geen eiendom 'b' at all! OK, sien nou hoe verskillende benaderings op te tree in beide situasies:

typeof o.a == 'undefined' // true
typeof o.b == 'undefined' // true
o.a === undefined // true
o.b === undefined // true
'a' in o // true
'b' in o // false

Ons kan duidelik sien dat typeof obj.prop == 'undefined' en obj.prop === undefined is ekwivalent, en hulle het nie die verskillende situasies onderskei. En 'prop' in obj kan die situasie wanneer 'n eiendom is nie gedefinieer nie en nie aandag gee aan die eiendom se waarde wat kan ongedefinieer op te spoor.

So wat om te doen?

1) Jy wil weet of 'n eiendom is ongedefinieerd deur óf die eerste of tweede betekenis (die mees tipiese situasie).

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

2) Jy wil net weet of voorwerp het 'n paar goed en gee nie om oor die waarde daarvan.

'prop' in obj

Notes:

Jy kan nie 'n voorwerp en sy eiendom te kontroleer terselfdertyd. Byvoorbeeld, hierdie x.a === undefined of hierdie typeof x.a == 'undefined' verhoog ReferenceError: x is not defined as x nie gedefinieer word.
Veranderlike undefined is 'n globale veranderlike (so eintlik is dit window.undefined in blaaiers). Dit is ondersteun sedert ECMAScript 1st Edition en sedert ECMAScript 5 dit is lees net . So in moderne blaaiers kan dit nie wees geherdefinieer om ware soveel skrywers is lief vir om ons te skrik met, maar dit is nog steeds 'n ware vir ouer blaaiers.

Finale stryd: `obj.prop === undefined` vs `typeof obj.prop == 'undefined'`

Plussen van obj.prop === undefined:

Dit is 'n bietjie korter en lyk 'n bietjie mooier
Die JavaScript-enjin sal jy 'n fout gee as jy undefined het verkeerd gespel

minuses van obj.prop === undefined:

undefined kan geneutraliseer word in ou blaaier

Plussen van typeof obj.prop == 'undefined':

Dit is regtig universele! Dit werk in 'n nuwe en ou blaaiers.

minuses van typeof obj.prop == 'undefined':

'undefned' ( gespel ) hier is net 'n string konstante, so die JavaScript-enjin kan jy nie help as jy dit het verkeerd gespel soos ek nou net gedoen het.

Update (vir bediener-kant JavaScript):

Node.js ondersteun die globale veranderlike undefined as global.undefined (dit kan ook gebruik word sonder die voorvoegsel "globale"). Ek weet nie van ander implementering van bediener-kant JavaScript.

Die kwessie kom neer op drie gevalle:

Die voorwerp het die eiendom en die waarde daarvan is nie undefined.
Die voorwerp het die eiendom en die waarde daarvan is undefined.
Die voorwerp het nie die eiendom.

Dit sê vir ons iets wat ek as belangrik beskou:

Daar is 'n verskil tussen 'n ongedefinieerde lid en 'n gedefinieerde lid met 'n ongedefinieerde waarde.

Maar ongelukkig typeof obj.foo nie vir ons sê watter een van die drie gevalle wat ons het. Maar ons kan dit kombineer met "foo" in obj om die gevalle te onderskei.

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

Die opmerklik dat hierdie toetse is dieselfde vir null inskrywings te

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

Ek wil argumenteer dat in sommige gevalle is dit maak meer sin (en is duideliker) om vas te stel of die eiendom is daar, as die nagaan of dit undefined, en die enigste geval waar hierdie tjek sal anders wees is die geval 2, die seldsame geval van 'n werklike inskrywing in die voorwerp met 'n ongedefinieerde waarde.

Byvoorbeeld:. Ek het so pas refactoring 'n klomp van die kode wat 'n klomp van tjeks of 'n voorwerp het 'n gegewe eiendom gehad

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

Watter was duidelik toe geskryf sonder 'n tjek vir undefined.

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

Maar soos reeds genoem is dit nie presies dieselfde (maar is meer as goed genoeg vir my behoeftes).

if ( typeof( something ) == "undefined")

Dit werk vir my terwyl die ander nie.

Ek is nie seker waar die oorsprong van die gebruik van === met typeof vandaan kom, en as 'n konvensie Ek sien dit gebruik in baie biblioteke, maar die typeof operateur terug 'n string letterlike, en ons weet dat voorlangs, so hoekom sou jy wil ook om te tik check dit ook?

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

kruispos my beantwoord van verwante vrae hoe om te kyk vir" ongedefinieerde "in JavaScript?

Spesifieke op hierdie vraag, sien toets gevalle met someObject.<whatever>.

Sommige scenario illustreer die resultate van die verskillende antwoorde: http://jsfiddle.net/drzaus/UVjM4/

(Let daarop dat die gebruik van var vir in toetse maak 'n verskil wanneer in 'n scoped wrapper)

Kode vir verwysing:

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

En resultate:

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

As jy dit doen

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

dit sal misluk wanneer die veranderlike myvar nie bestaan nie, want myvar is nie gedefinieer nie, so die script is gebreek en die toets het geen effek.

Omdat die venster voorwerp het'n globale omvang (standaard voorwerp) buite'n funksie, 'n verklaring sal wees "geheg" aan die venster voorwerp.

Byvoorbeeld:

var myvar = 'test';

Die globale veranderlike myvar is die dieselfde as venster.myvar of venster['myvar']

Om te verhoed dat foute te toets wanneer'n globale veranderlike bestaan, jy beter gebruik:

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

Die vraag as'n veranderlike regtig bestaan nie saak nie, die waarde daarvan is verkeerd.Anders, dit is dom om te inisialiseer veranderlikes met undefined, en dit is beter om te gebruik om die waarde vals te inisialiseer.Wanneer jy weet dat al die veranderlikes wat jy verklaar is geïnisialiseer met vals is, kan jy net check sy tipe of staatmaak op !window.myvar om te kyk of dit'n behoorlike/geldige waarde.So, selfs wanneer die veranderlike is nie gedefinieer nie dan !window.myvar is dieselfde vir myvar = undefined of myvar = false of myvar = 0.

Wanneer jy verwag dat'n spesifieke tipe, die toets van die tipe van die veranderlike.Om die bespoediging van die toets van'n toestand wat jy beter doen:

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

Wanneer die eerste en eenvoudige toestand is waar, die tolk spring die volgende toetse.

Dit is altyd beter om te gebruik om die instansie/voorwerp van die veranderlike te kyk of dit het'n geldige waarde.Dit is meer stabiel en is'n beter manier van ontwikkeling.

(y)

Ek het nie gesien (hoop ek het dit nie misloop nie) enigiemand nagaan van die voorwerp voor die eiendom. So, dit is die kortste en mees effektiewe (hoewel nie noodwendig die mees duidelike):

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

As die obj of obj.prop ongedefinieerd, nul, of "falsy", die as verklaring van die kode blok nie sal kan uitvoer. Dit is gewoonlik die gewenste gedrag in die meeste kode blok state (in JavaScript).

In die artikel Verken die afgrond van Null en ongedefinieerde in JavaScript Ek lees dat raamwerke soos Underscore.js hierdie funksie te gebruik:

function isUndefined(obj){
    return obj === void 0;
}

' as (window.x) {} ' is fout veilig

Heel waarskynlik jy wil if (window.x). Hierdie tjek is veilig, selfs as x is nog nie verklaar (var x;) - leser nie 'n fout te gooi.

Voorbeeld: Ek wil weet of my leser geskiedenis API ondersteun

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

Hoe dit werk:

venster is 'n voorwerp wat al globale veranderlikes as sy lede inhou, en dit is reg om te probeer om toegang te verkry tot 'n nie-bestaande lid. As x nog nie verklaar word of nie dan stel window.x opbrengste undefined . undefined lei tot valse wanneer as () evalueer dit.

"propertyName" in obj //-> true | false

Lees deur hierdie, ek is verbaas ek het dit nie sien nie. Ek het verskeie algoritmes wat sal werk vir hierdie gevind.

Nooit gedefinieerde

As die waarde van 'n voorwerp nooit gedefinieer, dit sal verhoed dat die terugkeer van true indien dit gedefinieer as null of undefined. Dit is nuttig as jy getrou aan teruggestuur word vir waardes te stel as undefined wil

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

Gedefinieer as undefined of nooit gedefinieerde

As jy wil hê dit moet lei as true vir waardes gedefinieer met die waarde van undefined, of nooit gedefinieer, kan jy net gebruik === undefined

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

gedefinieer as 'n falsy waarde, ongedefinieerde, nul, of nooit gedefinieer.

Algemeen, mense het my gevra vir 'n algoritme om uit te vind of 'n waarde is nie falsy, undefined, of null. Die volgende werke.

if(obj.prop == false || obj.prop === null || obj.prop === undefined) {
    console.log("The value is falsy, null, or undefined");
}

Jy kan 'n verskeidenheid alle undefined met pad kry met behulp van die volgende kode.

 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 skakel

Net iets is nie gedefinieer in JavaScript, is undefined, maak nie saak of dit is'n eiendom binne'n Voorwerp/Skikking of as net'n eenvoudige veranderlike...

JavaScript het typeof wat maak dit baie maklik om op te spoor'n ongedefinieerde veranderlike.

Net kyk as typeof whatever === 'undefined' en dit sal terugkeer'n boole.

Dit is hoe die bekende funksie isUndefined() in AngularJs v. 1x geskryf:

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

So as jy sien die funksie ontvang'n waarde, as wat die waarde is gedefinieer, dit sal terugkeer false, andersins vir ongedefinieerde waardes, terugkeer true.

So laat ons'n blik wat nou eers word die resultate wanneer ons verby waardes, insluitend voorwerp eienskappe soos hieronder, hierdie is die lys van die veranderlikes wat ons het:

var stackoverflow = {};
stackoverflow.javascipt = 'javascript';
var today;
var self = this;
var num = 8;
var list = [1, 2, 3, 4, 5];
var y = null;

en ons gaan hulle soos hieronder, kan jy sien die resultate in die voorkant van hulle as'n kommentaar:

isUndefined(stackoverflow); //false
isUndefined(stackoverflow.javascipt); //false
isUndefined(today); //true
isUndefined(self); //false
isUndefined(num); //false
isUndefined(list); //false
isUndefined(y); //false
isUndefined(stackoverflow.java); //true
isUndefined(stackoverflow.php); //true
isUndefined(stackoverflow && stackoverflow.css); //true

Soos jy sien, kan ons gaan iets met die gebruik van iets soos hierdie in ons kode, soos genoem, kan jy eenvoudig gebruik typeof in jou kode, maar as jy gebruik dit oor en oor, skep'n funksie soos die hoek monster wat ek deel en hou hergebruik soos volg DROË kode patroon.

Ook een ding, vir die beheer van die eiendom op'n voorwerp in'n ware aansoek wat jy nie seker is nie, selfs die voorwerp bestaan of nie, kyk of die voorwerp bestaan die eerste.

As jy'n eiendom op'n voorwerp en die doel bestaan nie, sal gooi'n fout en stop die hele aansoek hardloop.

isUndefined(x.css);
VM808:2 Uncaught ReferenceError: x is not defined(…)

So eenvoudig jy kan draai die binnekant van'n if-stelling soos hieronder:

if(typeof x !== 'undefined') {
  //do something
}

Wat ook gelyk is aan isDefined in 1 Hoek.x...

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

Ook ander javascript raamwerke soos onderstreep het soortgelyke definisie kyk, maar ek beveel aan jy gebruik typeof as jy nie reeds met behulp van enige raamwerke.

Ek het ook by hierdie afdeling van MDN wat het nuttige inligting oor typeof, ongedefinieerd en nietig(0).

Streng gelykheid en ongedefinieerde
Jy kan gebruik ongedefinieerde en die streng gelykheid en ongelykheid operateurs om te bepaal of'n veranderlike het 'n waarde.In die volgende kode, die veranderlike x is nie gedefinieer nie, en die as stelling evalueer om te ware.

var x;
if (x === undefined) {
   // these statements execute
}
else {
   // these statements do not execute
}

Let daarop:Die streng gelykheid operateur eerder as die standaard gelykheid operateur moet hier gebruik word, omdat x == ongedefinieerde ook tjeks of x is nul, terwyl streng gelykheid nie.nul is nie gelykstaande aan undefined.Sien vergelyking operateurs vir besonderhede.

Typeof operateur en ongedefinieerde
Alternatiewelik, typeof gebruik kan word:

var x;
if (typeof x === 'undefined') {
   // these statements execute
}

Een rede te gebruik typeof is dat dit nie gooi'n fout as die veranderlike het nie verklaar is.

// x has not been declared before
if (typeof x === 'undefined') { // evaluates to true without errors
   // these statements execute
}

if (x === undefined) { // throws a ReferenceError

}

Egter, hierdie soort van die tegniek moet vermy word.JavaScript is'n staties scoped taal, so weet as'n veranderlike verklaar kan gelees word deur te sien of dit word verklaar in'n omringende konteks.Die enigste uitsondering is die globale omvang, maar die globale omvang is gebind om te die globale voorwerp, sodat die beheer van die bestaan van'n veranderlike in die globale konteks kan gedoen word deur die nagaan van die bestaan van'n eiendom op die globale voorwerp (met behulp van die in-operateur, byvoorbeeld).

Leemte operateur en ongedefinieerde

Die leemte operateur is'n derde alternatief nie.

var x;
if (x === void 0) {
   // these statements execute
}

// y has not been declared before
if (y === void 0) {
   // throws a ReferenceError (in contrast to `typeof`)
}

meer > hier

Vergelyk met void 0, vir terseness.

if (foo !== void 0)

Dit is nie so verbose as if (typeof foo !== 'undefined')

Die oplossing is nie korrek nie. In JavaScript,

null == undefined

sal terugkeer waar is, omdat hulle albei "gegooi" na 'n Boolese en is vals. Die korrekte manier sou wees om seker te maak

if (something === undefined)

wat is die identiteit operateur ...

Hier is my situasie:

Ek gebruik die gevolg van 'n rus oproep. Die resultaat moet ontleed word uit into om 'n JavaScript voorwerp.

Daar is 'n fout wat ek nodig het om te verdedig. As die argumente om die res oproep verkeerde sover die gebruiker spesifiseer die argumente verkeerd was, die res oproep kom terug basies leeg.

Terwyl die gebruik van hierdie post om my te help verdedig teen hierdie, hierdie het ek probeer.

if( typeof restResult.data[0] === "undefined" ) { throw  "Some error"; }

Vir my situasie, as restResult.data [0] === "voorwerp", dan kan ek veilig begin inspekteer die res van die lede. As undefined dan gooi die fout as hierbo.

Wat ek sê, is dat vir my situasie, al die voorstelle hierbo in hierdie post het nie gewerk nie. Ek sê nie ek is reg en almal is verkeerd. Ek is nie 'n JavaScript meester te wees, maar hopelik sal dit iemand help.

Daar is 'n mooi en elegante manier om 'n bepaalde eiendom aan 'n nuwe veranderlike toewys indien dit omskryf of 'n verstek waarde toewys om dit as 'n terugval as it's ongedefinieer.

var a = obj.prop || defaultValue;

Dit is geskik as jy 'n funksie, wat 'n bykomende config eiendom ontvang het:

var yourFunction = function(config){

   this.config = config || {};
   this.yourConfigValue = config.yourConfigValue || 1;
   console.log(this.yourConfigValue);

}

Nou uitvoering

yourFunction({yourConfigValue:2});
//=> 2

yourFunction();
//=> 1

yourFunction({otherProperty:5});
//=> 1

Al die antwoorde is onvolledig. Dit is die regte manier om te weet dat daar 'n eiendom 'gedefinieer as undefined':

var hasUndefinedProperty = function hasUndefinedProperty(obj, prop){
  return ((prop in obj) && (typeof obj[prop] == 'undefined')) ;
} ;

Voorbeeld:

var a = { b : 1, e : null } ;
a.c = a.d ;

hasUndefinedProperty(a, 'b') ; // false : b is defined as 1
hasUndefinedProperty(a, 'c') ; // true : c is defined as undefined
hasUndefinedProperty(a, 'd') ; // false : d is undefined
hasUndefinedProperty(a, 'e') ; // false : e is defined as null

// And now...
delete a.c ;
hasUndefinedProperty(a, 'c') ; // false : c is undefined

Te sleg dat hierdie is die regte antwoord is begrawe in verkeerde antwoorde> _ <

So, vir almal wat met die pad verbygaan, sal Ek jou gee undefineds gratis !!

var undefined ; undefined ; // undefined
({}).a ;                    // undefined
[].a ;                      // undefined
''.a ;                      // undefined
(function(){}()) ;          // undefined
void(0) ;                   // undefined
eval() ;                    // undefined
1..a ;                      // undefined
/a/.a ;                     // undefined
(true).a ;                  // undefined

Gaan deur die kommentaar, vir diegene wat wil om beide kyk is dit nie gedefinieer of die waarde daarvan is null:

//Just in JavaScript
var s; // Undefined
if (typeof s == "undefined" || s === null){
    alert('either it is undefined or value is null')
}

As jy 'jQuery biblioteek dan sal jQuery.isEmptyObject() genoeg vir beide gevalle,

var s; // Undefined
jQuery.isEmptyObject(s); // Will return true;

s = null; // Defined as null
jQuery.isEmptyObject(s); // Will return true;

//Usage
if (jQuery.isEmptyObject(s)) {
    alert('Either variable:s is undefined or its value is null');
} else {
     alert('variable:s has value ' + s);
}

s = 'something'; // Defined with some value
jQuery.isEmptyObject(s); // Will return false;

As jy 'Hoekige:

angular.isUndefined(obj)
angular.isUndefined(obj.prop)

Underscore.js:

_.isUndefined(obj) 
_.isUndefined(obj.prop)

Ek gebruik if (this.variable) om te toets of dit word gedefinieer. Eenvoudige if (variable), bo aanbeveel, versuim vir my. Dit blyk dat dit werk net vir veranderlike is 'n gebied van 'n paar voorwerp, obj.someField om te kyk of dit word gedefinieer in die woordeboek. Maar ons kan this of window gebruik as die woordeboek voorwerp sedert enige veranderlike is 'n veld in huidige venster, soos ek dit verstaan. Daarom is hier 'n toets

if (this.abc) alert("defined"); else alert("undefined");

abc = "abc";
if (this.abc) alert("defined"); else alert("undefined");

Dit spoor eerste wat veranderlike abc ongedefinieerd en dit word gedefinieer na inisialisering.

function isUnset(inp) {
  return (typeof inp === 'undefined')
}

Returns vals as veranderlike is ingestel, en waar as ongedefinieerd is.

Gebruik dan:

if (isUnset(var)) {
  // initialize variable here
}

Ook dieselfde dinge geskryf kan word korter:

if (!variable){
    //do it if variable is Undefined
}

if (variable){
    //do it if variable is Defined
}

Ek wil graag vir jou iets Ek gebruik om te wys ten einde die undefined veranderlike te beskerm:

Object.defineProperty(window, 'undefined', {});

Dit verbied enige iemand om die window.undefined waarde te verander dus die wetboek saamgestel gegrond op die veranderlike te vernietig. As die gebruik van "use strict", enigiets probeer om sy waarde te verander sal eindig in die fout, anders sou dit stilweg geïgnoreer word nie.

Van lodash.js.

var undefined;
function isUndefined(value) {
  return value === undefined;
}

Dit skep 'n lokale veranderlike genoem undefined wat geïnisialiseer met die verstek waarde - die ware undefined, vergelyk dan value met die veranderlike undefined

Ek gee drie maniere hier vir diegene wat verwag dat vreemde antwoorde:

function isUndefined1(val) {
    try {
        val.a;
    } catch (e) {
        return /undefined/.test(e.message);
    }
    return false;
}
function isUndefined2(val) {
    return !val && val+'' === 'undefined';
}
function isUndefined3(val) {
    const defaultVal={};
    return ((input=defaultVal)=>input===defaultVal)(val);
}
function test(func){
    console.group(`test start :`+func.name);
    console.log(func(undefined));
    console.log(func(null));
    console.log(func(1));
    console.log(func("1"));
    console.log(func(0));
    console.log(func({}));
    console.log(func(function () { }));
    console.groupEnd();
}
test(isUndefined1);
test(isUndefined2);
test(isUndefined3);

isUndefined1:

Probeer om 'n eiendom van die insetwaarde te kry, gaan die fout boodskap as dit bestaan. As die invoerwaarde ongedefinieerd, sou die fout boodskap wees Uncaught TypeError: Kan nie lees eiendom 'b' van ongedefinieerde

isUndefined2:

Skakel insetwaarde te string te vergelyk met "undefined" en verseker dit is negatiewe waarde.

isUndefined3:

In JS, opsionele parameter werk wanneer die insette waarde is presies undefined.

Gelisensieer onder: CC-BY-SA met toeskrywing

Nie verbonde aan StackOverflow