Jaki jest najlepszy sposób sprawdzenia, czy obiekt obiekt w JavaScript to undefined?

2963
Matt Sheppard 26 sierpień 2008, 11:25

26 odpowiedzi

Najlepsza odpowiedź

Posługiwać się:

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

Jeśli zmienna obiektu, które mają jakieś właściwości, możesz użyć takich samych rzeczy:

if (typeof my_obj.someproperties === "undefined"){
    console.log('the property is not available...'); // print into console
}
2776
Ry- 21 maj 2020, 23:51

Możesz także użyć proxy, będzie działać z zagnieżdżonych połączeń, ale będzie wymagać jednego dodatkowego sprawdzenia:

function resolveUnknownProps(obj, resolveKey) {
  const handler = {
    get(target, key) {
      if (
        target[key] !== null &&
        typeof target[key] === 'object'
      ) {
        return resolveUnknownProps(target[key], resolveKey);
      } else if (!target[key]) {
        return resolveUnknownProps({ [resolveKey]: true }, resolveKey);
      }

      return target[key];
    },
  };

  return new Proxy(obj, handler);
}

const user = {}

console.log(resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else); // { isUndefined: true }

Więc użyjesz go jak:

const { isUndefined } = resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else;
if (!isUndefined) {
  // do someting
}
4
Sarkis Arutiunian 21 marzec 2018, 17:35

Z Lodash.js.

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

Tworzy zmienną lokalną o nazwie undefined, która jest inicjowana z wartością domyślną - rzeczywistą undefined, a następnie porównuje value za pomocą zmiennej undefined.


Aktualizacja 9/9/2019.

Znalazłem Lodash zaktualizował swoje wdrożenie. Zobacz Mój problem i Kod.

Być kuloodpornym, po prostu użyj:

function isUndefined(value) {
  return value === void 0;
}
4
lzl124631x 9 wrzesień 2019, 22:01

Problem sprowadza się do trzech przypadków:

  1. Obiekt ma właściwość, a jego wartość nie jest undefined.
  2. Obiekt ma właściwość i jego wartość to undefined.
  3. Obiekt nie ma właściwości.

To mówi nam coś, co uważam za ważne:

Istnieje różnica między niezdefiniowanym członem a zdefiniowanym członem z niezdefiniowaną wartością.

Ale nieszczęśliwy typeof obj.foo nie mówi nam, które z trzech przypadków mamy. Jednak możemy połączyć to za pomocą "foo" in obj, aby odróżnić przypadki.

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

Warto zauważyć, że testy te są takie same dla wpisów null

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

Kłóciłbym się, że w niektórych przypadkach ma więcej sensu (i jest wyraźniejsze), aby sprawdzić, czy właściwość jest tam, niż sprawdzanie, czy jest niezdefiniowany, a jedynym przypadkiem, w którym sprawa będzie inna, jest przypadek 2, rzadki przypadek rzeczywisty wpis w obiekcie z niezdefiniowaną wartością.

Na przykład: właśnie refaktoryzowałem grupę kodu, która miała wiązkę kontroli, czy obiekt miał daną nieruchomość.

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

Który był wyraźniejszy, gdy jest napisany bez kontroli niezdefiniowanych.

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

Ale jak wspomniano, nie są dokładnie takie same (ale są wystarczająco dobre dla moich potrzeb).

70
Michael Anderson 30 styczeń 2014, 02:49
if ( typeof( something ) == "undefined") 

To działało dla mnie, podczas gdy inni nie.

46
Peter Ajtai 1 wrzesień 2010, 21:49

Nie jestem pewien, gdy pochodziło pochodzenie przy użyciu {X1}} z typeof z {x x x} Front, więc dlaczego chciałbyś również wpisać to zrobić?

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
42
Simon East 29 czerwiec 2011, 07:21

CrossPosting My Odpowiedź z powiązanego pytania Jak sprawdzić" Undefined "w JavaScript?

specyficzne dla tego pytania, patrz przypadki testowe z someObject.<whatever>.


Niektóre scenariusze ilustrujące wyniki różnych odpowiedzi: http://jsfiddle.net/drzaus/uvjm4/

(Należy pamiętać, że stosowanie testów var dla {{x1}

Kod odniesienia:

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

I wyniki:

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
25
Peter Mortensen 25 lipiec 2020, 00:29

Jeśli zrobisz

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

Nie powiedzie się, gdy zmienna myvar nie istnieje, ponieważ myvar nie jest zdefiniowany, więc skrypt jest uszkodzony, a test nie ma efektu.

Ponieważ obiekt okna ma globalny zakres (domyślny obiekt) poza funkcją, deklaracja będzie "dołączona" do obiektu okna.

Na przykład:

var myvar = 'test';

Zmienna globalna myvar jest taka sama jak okno .Myvar lub ["myvar ']

Aby uniknąć badania błędów, gdy istnieje zmienna globalna, lepiej wykorzystujesz:

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

Pytanie Jeśli zmienna naprawdę istnieje, nie ma znaczenia, jego wartość jest nieprawidłowa. W przeciwnym razie jest to głupie, aby zainicjować zmienne z niezdefiniowaną, a jest lepiej wykorzystać wartość false, aby zainicjować. Gdy wiesz, że wszystkie zmienne, które deklarują, są inicjowane fałszywe, możesz po prostu sprawdzić jego typ lub polegać na !window.myvar, aby sprawdzić, czy ma odpowiedni / prawidłowy wartość. Więc nawet gdy zmienna nie jest zdefiniowana, !window.myvar jest taka sama dla myvar = undefined lub myvar = false lub myvar = 0.

Kiedy oczekujesz konkretnego typu, przetestuj typ zmiennej. Aby przyspieszyć testowanie warunku, który lepiej wykonasz:

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

Gdy pierwszy i prosty stan jest prawdziwy, tłumacz pomija następne testy.

Zawsze lepiej jest użyć instancji / obiektu zmiennej, aby sprawdzić, czy ma prawidłową wartość. Jest bardziej stabilny i jest lepszym sposobem programowania.

(y)

21
Codebeat 20 maj 2016, 18:11

Nie widziałem (mam nadzieję, że nie przegapiłem tego), kto sprawdza obiekt przed nieruchomością. Jest to najkrótsze i najbardziej skuteczne (choć niekoniecznie najbardziej jasne):

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

Jeśli OBJ lub OBJ.Prop jest niezdefiniowany, null, lub "falsja", instrukcja Jeśli nie będzie wykonywać blokady kodu. Jest to zwykle pożądane zachowanie w większości wyciągów blokowych (w JavaScript).

19
Joe Johnson 5 luty 2013, 18:39

W artykule Eksplorowanie otchłani z NULL i niezdefiniowany w JavaScript Przeczytałem to frameworki, takie jak podkreślenia .Js używa tej funkcji:

function isUndefined(obj){
    return obj === void 0;
}
15
Peter Mortensen 9 listopad 2014, 12:22

Po prostu wszystko nie jest zdefiniowane w JavaScript, jest niezdefiniowany , nie ma znaczenia, czy jest to właściwość wewnątrz obiektu obiekt / tablicę lub jako prosta zmienna ...

JavaScript ma typeof, co ułatwia wykrywanie niezdefiniowanej zmiennej.

Wystarczy sprawdzić, czy typeof whatever === 'undefined' i zwróci boolean.

W ten sposób napisany jest słynna funkcja isUndefined() w Angularjs V.1X:

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

Tak więc, jak widzisz funkcję, otrzymasz wartość, jeśli ta wartość zostanie zdefiniowana, powróci false, w przeciwnym razie dla niezdefiniowanych wartości, zwróć {X1}}.

Spójrzmy więc, co będzie wynikiem wyników, gdy przekazujemy wartości, w tym właściwości obiektów, takich jak poniżej, jest to lista zmiennych, które mamy:

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

I sprawdzamy je jak poniżej, możesz zobaczyć wyniki przed nimi jako komentarz:

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

Jak widać, możemy sprawdzić cokolwiek z użyciem czegoś takiego w naszym kodzie, jak wspomniano, możesz po prostu użyć typeof w swoim kodzie, ale jeśli używasz go w kółko, utwórz funkcję jak próbka kątowa, którą I Udostępnij i utrzymuj ponowne wykorzystanie jako następującego wzoru kodu suchego.

Jeszcze jedna rzecz, do sprawdzania nieruchomości na obiekcie w prawdziwej aplikacji, której nie jest pewien, czy nie istnieje, czy nie, sprawdź, czy obiekt istnieje pierwszy.

Jeśli sprawdzasz właściwość na obiekcie, a obiekt nie istnieje, rzuci błąd i zatrzymaj cały bieg aplikacji.

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

Tak proste, możesz owinąć wewnątrz oświadczenia, takiego jak poniżej:

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

Co również równe jest izdefiniowane w kątowym 1.x ...

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

Również inne struktury JavaScript, takie jak podkreślenie, mają podobną kontrolę definiującą, ale polecam użyć typeof, jeśli nie używasz już żadnych ram.

Dodam również tę sekcję z MDN, który ma przydatne informacje o TypeOf, Undefined and Void (0).

ścisła równość i niezdefiniowana
Możesz użyć niezdefiniowanych i surowych operatorów równości i nierówności, aby ustalić, czy zmienna ma wartość. W poniższym kodzie zmienna X nie jest zdefiniowana, a Jeśli oświadczenie ocenia się prawdą.

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

Uwaga: Należy tutaj użyć ścisłego operatora równości, a nie standardowy operator równości, ponieważ x == niezdefiniowany również sprawdza, czy x jest null, podczas gdy ścisła równość nie. NULL nie jest równoważny niezdefiniowany. Szczegółowe informacje można znaleźć w operatorach porównawczych.


Operator Typeof i niezdefiniowany
Alternatywnie można użyć typu TypeOf:

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

Jednym z powodów, aby użyć typuF, jest to, że nie rzuca błąd, jeśli zmienna nie została zadeklarowana.

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

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

}

Należy jednak unikać tego rodzaju techniki. JavaScript jest językiem skróconym statycznie, więc wiedząc, czy zadeklarowano zmienną, można odczytać, widząc, czy jest on zadeklarowany w kontekście załączania. Jedynym wyjątkiem jest globalny zakres, ale globalny zakres jest związany z obiektem globalnym, więc sprawdzenie istnienia zmiennej w kontekście globalnym można wykonać, sprawdzając istnienie nieruchomości na obiekcie globalnym (przy użyciu operatora, na przykład).


Void operator i niezdefiniowany

Operator Void jest trzecią alternatywą.

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

Więcej & gt; Oto

15
Alireza 2 październik 2019, 02:51

" if (window.x) {} " Czy błąd jest bezpieczny

Najprawdopodobniej chcesz if (window.x). Ta sprawdza jest bezpieczna, nawet jeśli x nie została zadeklarowana (var x;) - przeglądarka nie rzuca błędu.

Przykład: Chcę wiedzieć, czy moja przeglądarka obsługuje API historii

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

Jak to działa:

Okno jest obiektem, który posiada wszystkie zmienne globalne jako jego członków i jest legalny, aby uzyskać dostęp do nieistniejącego członka. Jeśli x nie został zadeklarowany lub nie został ustawiony, wtedy window.x zwraca niezdefiniowany . niezdefiniowany prowadzi do false , gdy if () ocenia go.

13
Peter Mortensen 23 listopad 2014, 13:19

Odczytaj to, jestem zdumiony, że tego nie widziałem. Znalazłem wiele algorytmów, które działałyby na to.

Nigdy nie zdefiniowany

Jeśli wartość obiektu nigdy nie została zdefiniowana, zapobiec to przed powrotem true, jeśli zostanie zdefiniowany jako null lub undefined. Jest to pomocne, jeśli chcesz, aby wierny został zwrócony dla wartości ustawionych jako undefined

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

Zdefiniowane jako niezdefiniowane lub nigdy nie zdefiniowane

Jeśli chcesz, aby było to true dla wartości zdefiniowanych wartością undefined lub nigdy nie zdefiniowano, możesz po prostu użyć === undefined

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

Zdefiniowane jako wartość falsja, niezdefiniowana, null, lub nigdy nie zdefiniowana.

Zwykle ludzie poprosili mnie o algorytm, aby dowiedzieć się, czy wartość jest falsyjna, undefined lub null. Następujące prace.

if(obj.prop == false || obj.prop === null || obj.prop === undefined) {
    console.log("The value is falsy, null, or undefined");
}
13
Travis 15 luty 2015, 03:10
"propertyName" in obj //-> true | false
12
sam 5 maj 2014, 00:13

Rozwiązanie jest nieprawidłowe. W javascript,

null == undefined

Zwróci prawdziwe, ponieważ obaj są "rzucani" do boolowskiej i są fałszywe. Właściwy sposób byłby sprawdzenie

if (something === undefined)

Który jest operatorem tożsamości ...

11
Peter Mortensen 9 listopad 2014, 12:07

Porównaj za pomocą void 0, dla teryczności.

if (foo !== void 0)

To nie jest tak samo-if (typeof foo !== 'undefined')

10
bevacqua 2 styczeń 2014, 12:59

Możesz dostać tablicę wszystkich niezdefiniowanych ścieżką przy użyciu następującego kodu.

 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 link

10
Peter Mortensen 9 listopad 2014, 12:16

Istnieje ładny i elegancki sposób na przypisanie zdefiniowanej właściwości do nowej zmiennej, jeśli jest zdefiniowany lub przypisać wartość domyślną do niej jako fallback, jeśli jest niezdefiniowany.

var a = obj.prop || defaultValue;

Nadaje się, jeśli masz funkcję, która odbiera dodatkową właściwość konfiguracji:

var yourFunction = function(config){

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

}

Teraz wykonuje

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

yourFunction();
//=> 1

yourFunction({otherProperty:5});
//=> 1
8
Peter Mortensen 25 lipiec 2020, 00:23

Wszystkie odpowiedzi są niekompletne. Jest to właściwy sposób na wiedząc, że istnieje nieruchomość "zdefiniowana jako niezdefiniowana":

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

Przykład:

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

Szkoda, że była to właściwa odpowiedź jest pochowana w niewłaściwych odpowiedzi> _ <

Więc dla każdego, kto przechodzi, dam ci undefineds za darmo !!

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
7
Peter Mortensen 25 lipiec 2020, 00:20

Przejście przez komentarze, dla tych, którzy chcą sprawdzić oba, to niezdefiniowane, czy jego wartość jest null:

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

Jeśli używasz biblioteki jQuery, jQuery.isEmptyObject() wystarczy w obu przypadkach,

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;
6
Peter Mortensen 9 listopad 2014, 12:26

Jeśli używasz kątu:

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

Underscore.js:

_.isUndefined(obj) 
_.isUndefined(obj.prop) 
6
Vitalii Fedorenko 14 grudzień 2014, 22:35

Dostarczam trzy sposoby dla tych, którzy oczekują dziwnych odpowiedzi:

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:

Spróbuj uzyskać właściwość wartości wejściowej, sprawdź komunikat o błędzie, jeśli istnieje. Jeśli wartość wejściowa jest niezdefiniowana, komunikat o błędzie byłby komunikat o błędzie byłby nieufany TypeError: Nie można odczytać właściwości "B" niezdefiniowanego

Isundefined2:

Konwertuj wartość wejściową do ciągu, aby porównać z "undefined" i zapewnić jego wartość ujemną.

Isundefined3:

W JS opcjonalny parametr działa, gdy wartość wejściowa jest dokładnie undefined.

6
Peter Mortensen 25 lipiec 2020, 00:11

Używam if (this.variable), aby sprawdzić, czy zostanie zdefiniowany. Proste if (variable), Zalecane powyżej, nie powiedzie się dla mnie. Okazuje się, że działa tylko wtedy, gdy zmienna jest polem niektórych obiektu, obj.someField, aby sprawdzić, czy jest zdefiniowany w słowniku. Ale możemy użyć this lub window jako obiekt słownika, ponieważ jakakolwiek zmienna jest pole w bieżącym oknie, jak to rozumiem. Dlatego tutaj jest test

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

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

Najpierw wykrywa, że zmienna abc jest niezdefiniowana i jest zdefiniowana po inicjalizacji.

6
Peter Mortensen 25 lipiec 2020, 00:17
function isUnset(inp) {
  return (typeof inp === 'undefined')
}

Zwraca false, jeśli ustawia się zmienna, i prawda, jeśli jest niezdefiniowana.

Następnie użyj:

if (isUnset(var)) {
  // initialize variable here
}
4
Simon East 15 czerwiec 2011, 01:43

Chciałbym pokazać ci coś, którego używam, aby chronić zmienną undefined:

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

To zabrania każdemu, aby zmienić wartość window.undefined Dlatego niszcząc kod w oparciu o tę zmienną. Jeśli używasz "use strict", cokolwiek próbuje zmienić jego wartość, zakończy błąd, w przeciwnym razie byłby większy ignorowany.

4
Peter Mortensen 9 listopad 2014, 12:27

Oto moja sytuacja:

Używam wyniku połączenia odpoczynkowego. Wynik należy przenikać od JSON do obiektu JavaScript.

Jest jeden błąd, którego muszę bronić. Jeśli Args do wywołania reszty były nieprawidłowe, jeśli użytkownik określił błąd argsów, połączenie reszty wraca zasadniczo pusta.

Podczas korzystania z tego posta, aby pomóc mi bronić przeciwko temu, próbowałem tego.

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

W mojej sytuacji, jeśli Restresult.Data [0] === "Obiekt", a potem mogę bezpiecznie zacząć sprawdzać resztę członków. Jeśli nieokreślony wyrzuć błąd jak powyżej.

Mówiąc, że dla mojej sytuacji wszystkie sugestie powyżej w tym poście nie działały. Nie mówię, że mam rację, a wszyscy są złe. W ogóle nie jestem mistrzem javascript, ale mam nadzieję, że to pomoże komuś.

7
Peter Mortensen 25 lipiec 2020, 00:26