Która metoda sprawdzania, czy zmienna została zainicjowana, jest lepsza / poprawna? (Zakładając, że zmienna może pomieścić wszystko (łańcuch, int, obiekt, funkcja itp.))

if (elem) { // or !elem

lub

if (typeof(elem) !== 'undefined') {

lub

if (elem != null) {

Chcesz się z typeofoperatorem . Konkretnie:

if (typeof variable !== 'undefined') {
    // the variable is defined
}

typeofOperator sprawdzi, czy zmienna jest naprawdę niezdefiniowane.

if (typeof variable === 'undefined') {
    // variable is undefined
}

typeofOperator, w przeciwieństwie do innych operatorów, nie rzucać ReferenceError wyjątku w przypadku korzystania z zmiennej nierejestrowanej.

Pamiętaj jednak, że typeof nullwróci "object". Musimy uważać, aby uniknąć błędu inicjalizacji zmiennej null. Aby być bezpiecznym, możemy zamiast tego użyć:

if (typeof variable === 'undefined' || variable === null) {
    // variable is undefined or null
}

Aby uzyskać więcej informacji na temat używania ścisłego porównania ===zamiast prostej równości ==, zobacz:
Który operator równości (== vs ===) powinien być używany w porównaniach JavaScript?

W wielu przypadkach użycie:

if (elem) { // or !elem

zrobi to za Ciebie! ... sprawdzi następujące poniższe przypadki:

1. undefined : jeśli wartość nie jest zdefiniowana i jestundefined
2. null : jeśli jest pusty, na przykład jeśli element DOM nie istnieje ...
3. pusty ciąg :''
4. 0 : liczba zero
5. NaN : brak liczby
6. fałszywe

Będzie więc obejmował wszystkie przypadki, ale zawsze są dziwne przypadki, które chcielibyśmy również uwzględnić, na przykład ciąg znaków ze spacjami, taki jak ten ' ', zostanie zdefiniowany w javascript, ponieważ ma spacje wewnątrz ciągu ... na przykład w tym przypadku dodajesz jeszcze jedną kontrolę za pomocą trim (), na przykład:

if(elem) {

if(typeof elem === 'string' && elem.trim()) {
///

Ponadto te kontrole dotyczą tylko wartości , ponieważ obiekty i tablice działają inaczej w JavaScript, pusta tablica []i pusty obiekt {}są zawsze prawdziwe .

Tworzę obraz poniżej, aby pokazać krótki skrót odpowiedzi:

W JavaScript można zdefiniować zmienną, ale zachować tę wartość undefined, więc najczęstsza odpowiedź nie jest technicznie poprawna i zamiast tego wykonuje następujące czynności:

if (typeof v === "undefined") {
   // no variable "v" is defined in the current scope
   // *or* some variable v exists and has been assigned the value undefined
} else {
   // some variable (global or local) "v" is defined in the current scope
   // *and* it contains a value other than undefined
}

To może wystarczyć do twoich celów. Poniższy test ma prostszą semantykę, co ułatwia precyzyjne opisanie zachowania twojego kodu i zrozumienie go samemu (jeśli zależy Ci na takich rzeczach):

if ("v" in window) {
   // global variable v is defined
} else {
   // global variable v is not defined
}

To oczywiście zakłada, że ​​działasz w przeglądarce (gdzie windowjest nazwa obiektu globalnego). Ale jeśli bawisz się takimi globalami, prawdopodobnie jesteś w przeglądarce. Subiektywnie używanie 'name' in windowjest stylistycznie spójne z używaniem window.namew odniesieniu do globali. Dostęp do globałów jako właściwości windowzmiennych zamiast jako zmiennych pozwala zminimalizować liczbę niezadeklarowanych zmiennych, do których się odwołujesz w kodzie (na korzyść puchnięcia), i pozwala uniknąć cieniowania globalnej zmiennej lokalnej. Ponadto, jeśli globale powodują, że skóra się czołga, możesz czuć się bardziej komfortowo dotykając ich tylko tym stosunkowo długim kijem.

W większości przypadków użyłbyś:

elem != null

W przeciwieństwie do proste if (elem), umożliwia 0, false, NaNi '', lecz odrzuca nulllub undefined, co bardzo dobry, ogólny test na obecność argument lub właściwości obiektu.

Inne kontrole również nie są niepoprawne, mają tylko różne zastosowania:

• if (elem): Mogą być stosowane, jeżeli elemjest gwarancją obiektu, lub jeśli false, 0itd są uważane za wartości „domyślne” (stąd równoważne undefinedlub null).

• typeof elem == 'undefined'może być stosowany w przypadkach, gdy określony nullma odrębne znaczenie dla niezainicjowanej zmiennej lub właściwości.

  • Jest to jedyna kontrola, która nie zgłosi błędu, jeśli elemnie zostanie zadeklarowana (tj. Brak varinstrukcji, brak właściwości windowlub argument funkcji). Jest to, moim zdaniem, dość niebezpieczne, ponieważ pozwala na pomijanie literówek. Aby tego uniknąć, zobacz poniższą metodę.

Przydatne jest również ścisłe porównanie z undefined:

if (elem === undefined) ...

Ponieważ jednak globalny undefinedmożna zastąpić inną wartością, undefinedprzed użyciem należy zadeklarować zmienną w bieżącym zakresie:

var undefined; // really undefined
if (elem === undefined) ...

Lub:

(function (undefined) {
    if (elem === undefined) ...
})();

Druga zaleta tej metody polega na tym, że minizatory JS mogą zredukować undefinedzmienną do jednego znaku, oszczędzając za każdym razem kilka bajtów.

Sprawdź, czy window. hasOwnProperty( „ varname” )

Alternatywa dla mnóstwa typeofodpowiedzi;

Zmienne globalne zadeklarowane za pomocą var varname = value;instrukcji w zakresie globalnym

mogą być dostępne jako właściwości obiektu okna.

Jako taka hasOwnProperty()metoda, która

zwraca wartość logiczną wskazującą, czy obiekt ma określoną właściwość jako swoją własność (w przeciwieństwie do dziedziczenia)

można użyć do ustalenia, czy

a varnazwy „varname” zostało zadeklarowane globalnie, tj. jest własnością window.

// Globally established, therefore, properties of window
var foo = "whatever", // string
    bar = false,      // bool
    baz;              // undefined
//  window.qux does not exist

console.log( [
    window.hasOwnProperty( "foo" ), // true
    window.hasOwnProperty( "bar" ), // true
    window.hasOwnProperty( "baz" ), // true
    window.hasOwnProperty( "qux" )  // false
] );

Wspaniałe hasOwnProperty()jest to, że nazywając go, nie używamy zmiennej, która może być jeszcze niezadeklarowana - co oczywiście stanowi połowę problemu.

Chociaż nie zawsze jest to idealne lub idealne rozwiązanie, w pewnych okolicznościach jest to po prostu praca!

Notatki

Powyższe jest prawdziwe w przypadku używania vardo definiowania zmiennej , w przeciwieństwie do let:

deklaruje zmienną lokalną o zasięgu bloku, opcjonalnie inicjując ją do wartości.

różni się od varsłowa kluczowego, które definiuje zmienną globalnie lub lokalnie dla całej funkcji, niezależnie od zasięgu bloku.

Na najwyższym poziomie programów i funkcji, letw przeciwieństwie do tego var, nie tworzy właściwości na obiekcie globalnym.

Dla kompletności: const stałe z definicji nie są w rzeczywistości zmienne (chociaż ich treść może być); bardziej odpowiednio:

Stałe globalne nie stają się właściwościami obiektu okna, w przeciwieństwie do varzmiennych. Wymagany jest inicjator stałej; to znaczy, musisz podać jego wartość w tej samej instrukcji, w której jest zadeklarowana.

Wartość stałej nie może się zmienić poprzez zmianę przypisania i nie można jej ponownie zadeklarować.

Deklaracja const tworzy odwołanie do wartości tylko do odczytu. Nie oznacza to, że wartość, którą posiada, jest niezmienna, po prostu nie można przypisać identyfikatora zmiennej.

Ponieważ letzmienne lub conststałe nigdy nie są właściwościami żadnego obiektu, który odziedziczył hasOwnProperty()metodę, nie można go użyć do sprawdzenia ich istnienia.

W odniesieniu do dostępności i wykorzystania hasOwnProperty():

Każdy obiekt pochodzący od Object dziedziczy hasOwnProperty()metodę. [...] w przeciwieństwie do inoperatora, ta metoda nie sprawdza łańcucha prototypów obiektu.

Jak sprawdzić, czy zmienna istnieje

Jest to dość kuloodporne rozwiązanie do testowania, czy zmienna istnieje i została zainicjowana:

var setOrNot = typeof variable !== typeof undefined;

Najczęściej jest używany w połączeniu z operatorem trójskładnikowym, aby ustawić wartość domyślną w przypadku, gdy pewna zmienna nie została zainicjowana:

var dark = typeof darkColor !== typeof undefined ? darkColor : "black";

Problemy z enkapsulacją

Niestety nie można po prostu zawrzeć czeku w funkcji.

Możesz pomyśleć o zrobieniu czegoś takiego:

function isset(variable) {
    return typeof variable !== typeof undefined;
}

To jednak spowoduje błąd odniesienia, jeśli dzwonisz np. isset(foo)i zmienna foonie została zdefiniowana, ponieważ nie można przekazać nieistniejącej zmiennej do funkcji:

Uncaught ReferenceError: foo nie jest zdefiniowane

Testowanie, czy parametry funkcji są niezdefiniowane

Chociaż nasza issetfunkcja nie może być używana do testowania, czy zmienna istnieje, czy nie (z powodów wyjaśnionych powyżej), pozwala nam przetestować, czy parametry funkcji są niezdefiniowane:

var a = '5';

var test = function(x, y) {
    console.log(isset(x));
    console.log(isset(y));
};

test(a);

// OUTPUT :
// ------------
// TRUE
// FALSE

Mimo że ydo funkcji nie jest przekazywana żadna wartość test, nasza issetfunkcja działa idealnie w tym kontekście, ponieważ yjest znana w funkcji testjako undefinedwartość.

Istnieje inny krótki sposób sprawdzenia tego, gdy wykonujesz proste zadania i powiązane kontrole. Wystarczy użyć operatora warunkowego (trójskładnikowego).

var values = typeof variable !== 'undefined' ? variable : '';

Będzie to również pomocne, gdy spróbujesz zadeklarować zmienną globalną przy pomocy instancji zmiennej referencyjnej.

Jeśli chcesz sprawdzić zmienną nie powinna być undefinedlub null. Następnie wykonaj poniższe sprawdzenie.

Gdy zmienna jest zadeklarowana, a jeśli chcesz sprawdzić wartość, jest to nawet proste: wykona się undefinedi nullsprawdzi razem.

var values = variable ? variable : '';

Krótki sposób testowania zmiennej nie jest zadeklarowany (nie jest niezdefiniowany)

if (typeof variable === "undefined") {
  ...
}

Uznałem, że jest to przydatne do wykrywania skryptu działającego poza przeglądarką (bez deklarowania windowzmiennej).

To zależy, czy zależy ci tylko na tym, aby zmienna została zdefiniowana, czy na wartości, która ma mieć znaczenie.

Sprawdzenie, czy typ jest niezdefiniowany, sprawdzi, czy zmienna została jeszcze zdefiniowana.

=== nulllub !== nullsprawdzi tylko, czy wartość zmiennej jest dokładnie null.

== nulllub != nullsprawdzi, czy wartość wynosi undefinedlub null.

if(value)sprawdzi, czy zmienna jest undefined, null, 0lub pusty ciąg.

Najwyższa odpowiedź jest poprawna, użyj typeof.

Chciałem jednak zauważyć, że w JavaScript undefinedmożna modyfikować (z jakiegoś bezbożnego powodu). Więc po prostu sprawdzenie, czy varName !== undefinednie, może nie zawsze powrócić tak, jak tego oczekujesz, ponieważ inne biblioteki lib mogły ulec zmianie niezdefiniowane. Kilka odpowiedzi (na przykład @ Skalee'a) wydaje się, że wolą nie używać typeof, a to może sprawić kłopoty.

„Starym” sposobem radzenia sobie z tym było zadeklarowanie niezdefiniowanego jako var, aby zrównoważyć wszelkie potencjalne wyciszenie / przekroczenie undefined. Jednak najlepszym sposobem jest nadal używanie, typeofponieważ zignoruje wszelkie zastąpienie undefinedz innego kodu. Zwłaszcza jeśli piszesz kod do wykorzystania na wolności, gdzie kto wie, co jeszcze może być uruchomione na stronie ...

if (typeof console != "undefined") {    
   ...
}

Albo lepiej

if ((typeof console == "object") && (typeof console.profile == "function")) {    
   console.profile(f.constructor);    
}

Działa we wszystkich przeglądarkach

Aby wziąć udział w debacie, jeśli wiem, że zmienna powinna być łańcuchem lub obiektem, zawsze wolę if (!variable), więc sprawdzam, czy jest to fałsz. Może to doprowadzić do czystszego kodu, dzięki czemu na przykład:

if (typeof data !== "undefined" && typeof data.url === "undefined") {
    var message = 'Error receiving response';
    if (typeof data.error !== "undefined") {
        message = data.error;
    } else if (typeof data.message !== "undefined") {
        message = data.message;
    }
    alert(message); 
}

.. można zmniejszyć do:

if (data && !data.url) {
  var message = data.error || data.message || 'Error receiving response';
  alert(message)
} 

Trudno rozróżnić niezdefiniowane od zerowego. Null to wartość, którą można przypisać do zmiennej, jeśli chcesz wskazać, że zmienna nie ma określonej wartości. Niezdefiniowana to specjalna wartość, która będzie domyślną wartością nieprzypisanych zmiennych.

var _undefined;
var _null = null;

alert(_undefined); 
alert(_null); 
alert(_undefined == _null);
alert(_undefined === _null);

Null jest wartością w JavaScript i typeof nullzwraca"object"

Dlatego zaakceptowana odpowiedź nie zadziała, jeśli przekażesz wartości null. Jeśli przekażesz wartości null, musisz dodać dodatkowe sprawdzenie wartości null:

if ((typeof variable !== "undefined") && (variable !== null))  
{
   // the variable is defined and not null
}

Najbardziej niezawodna kontrola „jak to zdefiniowano” dotyczy typu typeof

if (typeof elem === 'undefined')

Jeśli po prostu sprawdzasz zdefiniowaną zmienną do przypisania wartości domyślnej, dla łatwego do odczytania jednego linijki często możesz to zrobić:

elem = elem || defaultElem;

Często jest dobrze używać, patrz: Idiomatyczny sposób ustawiania wartości domyślnej w javascript

Istnieje również jedna linijka wykorzystująca słowo kluczowe typeof :

elem = (typeof elem === 'undefined') ? defaultElem : elem;

możesz użyć typeofoperatora.

Na przykład,

var dataSet;

alert("Variable dataSet is : " + typeof dataSet);

Fragment powyższego kodu zwróci wynik jak

zmienna dataSet jest: niezdefiniowana.

Aby sprawdzić, czy zmienna została zadeklarowana / ustawiona, zrobiłem tę brudną sztuczkę.

Nie znalazłem sposobu na wyodrębnienie kodu do funkcji, nawet przy pomocy eval.

"use strict";

// var someVar;

var declared;
try {
  someVar;
  declared = true;
} catch(e) {
  declared = false;
}

if (declared) {
  console.log("someVar is declared; now has the value: " + someVar);
} else {
  console.log("someVar is not declared");
}

Te odpowiedzi (oprócz rozwiązania Freda Gandta) są niepoprawne lub niekompletne.

Załóżmy, że muszę variableName;mieć undefinedwartość, a zatem została zadeklarowana w taki sposób, że var variableName;oznacza to, że została już zainicjowana ; - Jak sprawdzić, czy jest już zadeklarowany?

Albo jeszcze lepiej - jak od razu sprawdzić, czy „Book1.chapter22.paragraph37” istnieje przy jednym wywołaniu, ale nie zgłosić błędu odniesienia?

Robimy to za pomocą najbardziej wydajnego operatora JasvaScript, operatora in . :

"[variable||property]" in [context||root] 
>> true||false

W czasach szczytowej popularności AJAX napisałem metodę (później nazwaną) isNS (), która jest w stanie określić, czy przestrzeń nazw istnieje, w tym szczegółowe testy nazw właściwości, takie jak „Book1.chapter22.paragraph37” i wiele innych.

Ale ponieważ został wcześniej opublikowany i ze względu na jego ogromne znaczenie zasługuje na opublikowanie w osobnym wątku, nie opublikuję go tutaj, ale podam słowa kluczowe ( javascript + isNS ), które pomogą Ci zlokalizować kod źródłowy, poparty wszystkimi niezbędne wyjaśnienia.

W szczególnej sytuacji opisanej w pytaniu

typeof window.console === "undefined"

jest identyczny z

window.console === undefined

Wolę ten drugi, ponieważ jest krótszy.

Pamiętaj, że szukamy consoletylko w zakresie globalnym (który jest windowobiektem we wszystkich przeglądarkach). W tej konkretnej sytuacji jest to pożądane. Nie chcemy consoledefiniować gdzie indziej.

@BrianKelley w swojej świetnej odpowiedzi wyjaśnia szczegóły techniczne. Dodałem tylko brak wniosków i przetrawiłem to w coś łatwiejszego do odczytania.

Używam dwóch różnych sposobów w zależności od obiektu.

if( !variable ){
  // variable is either
  // 1. '';
  // 2. 0;
  // 3. undefined;
  // 4. null;
  // 5. false;
}

Czasami nie chcę oceniać pustego ciągu jako falsey, więc używam tego przypadku

function invalid( item ){
  return (item === undefined || item === null);
}

if( invalid( variable )){
  // only here if null or undefined;
}

Jeśli potrzebujesz czegoś przeciwnego, to w pierwszej kolejności zmienna staje się zmienną !!, aw nieprawidłowej funkcji === staje się! =, A nazwy funkcji zmieniają się na notInvalid.

Moje preferencje to typeof(elem) != 'undefined' && elem != null.

Niezależnie od tego, co wybierzesz, zastanów się nad umieszczeniem czeku w takiej funkcji

function existy (x) {
    return typeof (x) != 'undefined' && x != null;
}

Jeśli nie wiesz, że zmienna została zadeklarowana, kontynuuj od typeof (x) != 'undefined' && x != null;

Jeśli wiesz, że zmienna jest zadeklarowana, ale może nie istnieć, możesz użyć

existy(elem) && doSomething(elem);

Sprawdzana zmienna może czasami być zagnieżdżoną właściwością. Możesz użyć prop || {}, aby przejść dalej, sprawdzając istnienie danej nieruchomości:

var exists = ((((existy(myObj).prop1||{}).prop2||{}).prop3||{})[1]||{}).prop4;

Po każdej właściwości użyj (... '|| {}'). NextProp, aby brakująca właściwość nie generowała błędu.

Lub możesz użyć egy like existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

To zależy od sytuacji. Jeśli szukasz czegoś, co mogło lub nie zostało zdefiniowane globalnie poza twoim kodem (na przykład jQuery), chcesz:

if (typeof(jQuery) != "undefined")

(Nie ma potrzeby ścisłej równości, typeof zawsze zwraca ciąg znaków.) Ale jeśli masz argumenty funkcji, które mogły lub nie zostały przekazane, zawsze będą zdefiniowane, ale zerowe, jeśli zostaną pominięte.

function sayHello(name) {
    if (name) return "Hello, " + name;
    else return "Hello unknown person";
}
sayHello(); // => "Hello unknown person"

Próbuj złapać

Jeśli zmienna w ogóle nie została zdefiniowana, możesz to sprawdzić bez wykonania kodu przerwania za pomocą bloku try-catch w następujący sposób (nie musisz use strictwłączać trybu)

try{
  notDefinedVariable;
} catch(e) {
  console.log('detected: variable not exists');
}

console.log('but the code is still executed');

notDefinedVariable; // without try-catch wrapper code stops here

console.log('code execution stops. You will NOT see this message on console');

BONUS: (odnosząc się do innych odpowiedzi) Dlaczego ===jest bardziej jasne niż ==( źródło )

jeśli (a == b)

jeśli (a === b)

Dziwię się, że nie wspomniano o tym jeszcze ...

oto kilka dodatkowych wariantów użycia this['var_name']

zaletą tej metody jest to, że można jej użyć przed zdefiniowaniem zmiennej.

if (this['elem']) {...}; // less safe than the res but works as long as you're note expecting a falsy value
if (this['elem'] !== undefined) {...}; // check if it's been declared
if (this['elem'] !== undefined && elem !== null) {...}; // check if it's not null, you can use just elem for the second part

// these will work even if you have an improper variable definition declared here
elem = null; // <-- no var here!! BAD!