Bir değişkenin başlatılmış olup olmadığını kontrol etmek için hangi yöntem daha iyi / doğrudur? (Değişkenin herhangi bir şeyi tutacağı varsayılarak (dize, int, nesne, işlev vb.)

if (elem) { // or !elem

veya

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

veya

if (elem != null) {

Sen istediğiniz operatörü . özellikle:typeof

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

typeofDeğişken gerçekten tanımsız varsa operatör kontrol edecektir.

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

typeofOperatör, diğer operatörler aksine, atmaz ReferenceError bir bildirilmemiş değişken ile kullanıldığında istisna.

Ancak, typeof nullgeri döneceğini unutmayın "object". Bir değişkenin başlatılması hatasını önlemek için dikkatli olmalıyız null. Güvende olmak için bunun yerine kullanabiliriz:

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

===Basit eşitlik yerine katı karşılaştırma kullanma hakkında daha fazla bilgi için ==, bkz
. JavaScript karşılaştırmalarında hangi işleç (== vs ===) kullanılmalıdır?

Çoğu durumda:

if (elem) { // or !elem

işi sizin için yapacak! ... bu aşağıdaki durumları kontrol edecektir:

1. undefined : değer tanımlanmamışsa veundefined
2. null : boşsa, örneğin bir DOM öğesi yoksa ...
3. boş dize :''
4. 0 : sıfır sayısı
5. NaN : sayı değil
6. yanlış

Bu yüzden tüm vakaları kapsayacak, ancak her zaman tutabileceğimiz tuhaf durumlar da var, örneğin, bunun gibi boşluklara sahip bir dize, bu dize içinde boşluklar ' 'olduğu için javascript'te tanımlanacak ... örneğin bu durumda trim () kullanarak bir tane daha kontrol eklersiniz, örneğin:

if(elem) {

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

Ayrıca, bu kontroller yalnızca değerler içindir, çünkü nesneler ve diziler Javascript'te farklı çalışır, boş dizi []ve boş nesne {}her zaman doğrudur .

Cevabın kısa bir özetini göstermek için aşağıdaki resmi oluşturuyorum:

JavaScript'te bir değişken tanımlanabilir, ancak değeri saklayabilir undefined, bu nedenle en yaygın yanıt teknik olarak doğru değildir ve bunun yerine aşağıdakileri gerçekleştirir:

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
}

Bu sizin amaçlarınız için yeterli olabilir. Aşağıdaki test daha basit anlambilime sahiptir, bu da kodunuzun davranışını tam olarak tanımlamanızı ve kendiniz anlamayı kolaylaştırır (bu tür şeyleri önemsiyorsanız):

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

Bu, elbette, bir tarayıcıda çalıştığınızı varsayar (burada windowglobal nesne için bir addır). Ancak böyle küresellerle uğraşıyorsanız muhtemelen bir tarayıcıdasınız demektir. Sübjektif olarak, 'name' in windowkullanım window.name, globallere atıfta bulunmak için kullanım ile stilistik olarak tutarlıdır . Globallere windowdeğişken olarak değil , özellikler olarak erişmek , kodunuzda (linting yararına) başvurduğunuz bildirilmemiş değişkenlerin sayısını en aza indirmenize izin verir ve globalinizin yerel bir değişken tarafından gölgelenmesi olasılığını önler. Ayrıca, eğer globaller cildinizi tararsa, sadece bu nispeten uzun çubukla dokunmaktan daha rahat hissedebilirsiniz.

Çoğu durumda şunları kullanırsınız:

elem != null

Bir basit aksine if (elem), izin verir 0, false, NaNve ''ancak reddeder nullveya undefinedbir nesnenin bir argüman varlığında veya özellik için oa iyi, genel test yapma.

Diğer kontroller de yanlış değil, sadece farklı kullanımları var:

• if (elem): Durumunda kullanılabilecek elembir nesne olması sağlanır, veya eğer false, 0vb (eşdeğer dolayısıyla "varsayılan" değerleri olarak kabul edilir undefinedya da null).

• typeof elem == 'undefined'belirtilen null, başlatılmamış bir değişken veya özellik için farklı bir anlama sahip olduğu durumlarda kullanılabilir .

  • Bu yalnızca olmadığını kontrol etmektir bir hata atmaz eğer elemdeğildir beyan (yani hiçbir varaçıklama, değil bir özellik windowveya bir fonksiyon argümanı). Bence bu, yazım hatalarının fark edilmeden kaymasına izin verdiği için oldukça tehlikelidir. Bundan kaçınmak için aşağıdaki yönteme bakın.

Ayrıca yararlı bir katı karşılaştırma undefined:

if (elem === undefined) ...

Ancak, global undefinedbaşka bir değerle geçersiz kılınabildiğinden, değişkeni undefinedkullanmadan önce geçerli kapsamda bildirmek en iyisidir :

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

Veya:

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

Bu yöntemin ikincil bir avantajı, JS minifiers undefineddeğişkenini tek bir karaktere indirgeyerek her seferinde birkaç bayt tasarruf etmesidir .

Kontrol edin window. hasOwnProperty( " varname" )

typeofCevapların bolluğuna bir alternatif ;

Globalvar varname = value; kapsamda ifade ile beyan edilen global değişkenler

pencere nesnesinin özellikleri olarak erişilebilir.

Gibi, hasOwnProperty()yöntem, hangi

nesnenin belirtilen özelliği kendi özelliği olarak (devralma yerine) olup olmadığını gösteren bir boole döndürür

olup olmadığını belirlemek için kullanılabilir

Bir varait "varName" küresel ilan edilmiştir , yani bir özelliktir 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
] );

Hakkında harika olan şey hasOwnProperty(), onu çağırırken, henüz bildirilmemiş olan bir değişkeni kullanmamamızdır - ki bu da sorunun ilk etapta yarısıdır.

Olmasa da hep de mükemmel ya İdeal çözelti, bazı durumlarda, sadece iş!

notlar

Kullanırken, yukarıda doğru vardeğişken tanımlamak aksine, letburada:

isteğe bağlı olarak bir değere başlatan bir blok kapsamı yerel değişkeni bildirir.

varblok kapsamından bağımsız olarak bir değişkeni global olarak veya yerel olarak tüm bir işleve tanımlayan anahtar kelimeden farklıdır .

En üst düzeyde programlar ve işlevler let, aksine var, genel nesne üzerinde bir özellik oluşturmaz.

Tamlık için: const sabitler, tanım gereği, aslında değişken değildir (içerikleri olmasına rağmen); daha alakalı olarak:

Genel sabitler, vardeğişkenlerin aksine, pencere nesnesinin özellikleri haline gelmez . Bir sabit için bir başlatıcı gereklidir; yani, değerini bildirildiği ifadeyle belirtmeniz gerekir.

Bir sabitin değeri, yeniden atama yoluyla değiştirilemez ve yeniden belirtilemez.

Sabit bildirimi bir değere salt okunur bir başvuru oluşturur. Sahip olduğu değerin değişmez olduğu anlamına gelmez, sadece değişken tanımlayıcının yeniden atanamayacağı anlamına gelir.

Yana letdeğişkenler ya da constsabitler miras kalan herhangi bir nesnenin özellikleri asla hasOwnProperty()yöntemi, onların varlığını kontrol etmek üzere kullanılamaz.

Kullanılabilirliği ve kullanımı ile ilgili olarak hasOwnProperty():

Soyundan Her nesne Nesne devralır hasOwnProperty()yöntemi. [...] inoperatörün aksine , bu yöntem nesnenin prototip zincirini kontrol etmez.

Bir değişkenin olup olmadığını kontrol etme

Bu, bir değişkenin var olup olmadığını ve başlatılmış olup olmadığını test etmek için oldukça kurşun geçirmez bir çözümdür:

var setOrNot = typeof variable !== typeof undefined;

Belirli bir değişkenin başlatılmamış olması durumunda varsayılan olarak ayarlamak için üçlü bir operatörle birlikte kullanılır :

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

Kapsülleme ile ilgili sorunlar

Maalesef çekinizi bir işlevde satamazsınız.

Böyle bir şey yapmayı düşünebilirsiniz:

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

Ancak, ör. isset(foo)ve değişken footanımlanmadı, çünkü var olmayan bir değişken boyunca bir fonksiyona geçemezsiniz:

Yakalanmayan ReferenceError: foo tanımlanmamış

Fonksiyon parametrelerinin tanımlanıp tanımlanmadığını test etme

İşlevimiz issetbir değişkenin var olup olmadığını test etmek için kullanılamaz (yukarıda açıklanan nedenlerle), bir fonksiyonun parametrelerinin tanımlanıp tanımlanmadığını test etmemize izin verir:

var a = '5';

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

test(a);

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

yİşlev için hiçbir değer iletilmemesine rağmen test, issetişlevimiz bu bağlamda mükemmel çalışır, çünkü yişlevde testbir undefineddeğer olarak bilinir .

Basit ödevler ve ilgili kontroller yaptığınızda bunu kontrol etmenin bir başka kısa yolu daha vardır. Basitçe kullanmak Koşullu (Üçlü) Operatör.

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

Referans değişkenin örnek atamasıyla Global değişkeni bildirmeye çalıştığınızda da bu yardımcı olacaktır.

Eğer kontrol etmek istiyorsanız değişken olmamalıdır undefinedveya null. Sonra aşağıdaki kontrolü yapın.

Değişken bildirildiğinde ve değeri kontrol etmek istiyorsanız, bu bile Basit: ve birlikte gerçekleştirir undefinedve nullkontrol eder.

var values = variable ? variable : '';

Bir değişkeni test etmenin kısa yolu bildirilmemiştir (tanımsız değil)

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

Ben bir tarayıcı dışında çalışan komut dosyası tespit etmek için yararlı buldum ( windowdeğişken beyan değil ).

Değişkenin tanımlanmış olmasına ya da anlamlı bir değere sahip olmasını isteyip istemediğinize bağlıdır.

Türün tanımsız olup olmadığını kontrol etmek, değişkenin henüz tanımlanıp tanımlanmadığını kontrol edecektir.

=== nullveya !== nullyalnızca değişkenin değerinin tam olarak olup olmadığını kontrol eder null.

== nullveya != nulldeğer olup olmadığını kontrol edecek undefinedveya null.

if(value)Değişken olup olmadığını kontrol edecek undefined, null, 0, veya boş bir dize.

En yüksek cevap doğrudur, typeof kullanın.

Ancak, işaret etmek istediğim JavaScript'te undefineddeğişken (bazı ungodly nedenlerden dolayı) oldu. Bu yüzden sadece bir kontrol yapmak varName !== undefined, beklediğiniz gibi her zaman geri dönme potansiyeline sahip değildir, çünkü diğer kütüphaneler tanımsız değişmiş olabilir. Birkaç cevap (bir tanesi için @ skalee), kullanmamayı tercih ediyor gibi görünüyor typeofve bu da başını belaya sokabilir.

Bunun üstesinden gelmenin "eski" yolu, herhangi bir olası sessizliği / aşırı sürmeyi dengelemek için tanımsız olarak bildirmektir undefined. Bununla birlikte, en iyi yol hala kullanmaktır, typeofçünkü undefineddiğer kodlardan herhangi bir geçersiz kılmayı yoksayar . Özellikle, sayfada başka neler çalıştığını bilen vahşi doğada kullanmak için kod yazıyorsanız ...

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

Ya da daha iyisi

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

Tüm tarayıcılarda çalışır

Tartışmaya katkıda bulunmak için, değişkenin her zaman tercih ettiğim bir dize veya bir nesne olması gerektiğini biliyorsanız if (!variable), bu yüzden onun falsisi olup olmadığını kontrol edin. Bu, daha temiz bir kod getirebilir, böylece:

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

.. azaltılabilir:

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

Undefined ve null arasında ayrım yapmak zordur. Null , değişkenin belirli bir değeri olmadığını belirtmek istediğinizde bir değişkene atayabileceğiniz bir değerdir. Tanımsız , atanmamış değişkenlerin varsayılan değeri olacak özel bir değerdir.

var _undefined;
var _null = null;

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

Null, JavaScript'teki bir değerdir ve typeof nulldöndürür"object"

Bu nedenle, null değerleri iletirseniz kabul edilen cevap çalışmaz. Boş değerler iletirseniz, boş değerler için fazladan bir kontrol eklemeniz gerekir:

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

En sağlam 'tanımlanmış' kontrol tipeof ile

if (typeof elem === 'undefined')

Yalnızca varsayılan bir atamak için tanımlı bir değişkeni kontrol ediyorsanız, okunması kolay bir astar için genellikle bunu yapabilirsiniz:

elem = elem || defaultElem;

Kullanmak genellikle iyidir, bkz: Javascript'te varsayılan değeri ayarlamanın deyimsel yolu

Typeof anahtar sözcüğünü kullanan bu bir astar da vardır :

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

typeofoperatörü kullanabilirsiniz .

Örneğin,

var dataSet;

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

Yukarıdaki kod snippet'i çıktıyı aşağıdaki gibi döndürecektir

değişken dataSet: tanımsız.

Bir değişkenin bildirildiğini / ayarlandığını kontrol etmek için bu kirli numarayı yaptım.

Hatta, bir işleve kodu ayıklamak için bir yol bulamadım 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");
}

Bu cevaplar (Fred Gandt çözümünün yanı sıra) ya yanlış ya da eksik.

Diyelim ki variableName;bir undefineddeğer taşımam gerekiyor ve bu nedenle var variableName;zaten başlatıldığı anlamına gelen bir şekilde bildirildi ; - Önceden beyan edilmiş olup olmadığını nasıl kontrol ederim?

Ya da daha iyisi - "Book1.chapter22.paragraph37" nin tek bir çağrı ile var olup olmadığını nasıl kontrol edebilirim, ancak bir referans hatası ortaya çıkarmaz mı?

Bunu, en güçlü JasvaScript operatörünü, in operatörünü kullanarak yaparız :

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

AJAX zirve popülerlik zamanlarında "Book1.chapter22.paragraph37" ve çok daha fazlası gibi özellik adları için derin testler de dahil olmak üzere ad alanının var olup olmadığını belirleme yeteneğine sahip bir yöntem (daha sonra adlandırılmış) isNS () yazdım.

Ancak daha önce yayınlanmış olduğundan ve büyük önemi nedeniyle ayrı bir iş parçacığında yayınlanmayı hak ettiği için burada yayınlamayacağım, ancak tüm kodlarla desteklenen kaynak kodunu bulmanıza yardımcı olacak anahtar kelimeler ( javascript + isNS ) sağlayacaktır. gerekli açıklamalar.

Soruda belirtilen özel durumda,

typeof window.console === "undefined"

ile aynı

window.console === undefined

Daha kısa olduğu için ikincisini tercih ederim.

Lütfen consoleyalnızca global kapsamda ( windowtüm tarayıcılarda bir nesne olan) arama yaptığımızı unutmayın . Bu özel durumda arzu edilir. consoleBaşka bir yerde tanımlanmak istemiyoruz .

@BrianKelley büyük cevabında teknik detayları açıklıyor. Sadece eksik bir sonuç ekledim ve okunması daha kolay bir şeye sindirdim.

Nesneye bağlı olarak iki farklı yol kullanıyorum.

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

Bazen boş bir dizeyi falsey olarak değerlendirmek istemiyorum, o zaman bu durumu kullanıyorum

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

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

Bunun tersine ihtiyacınız varsa, ilk durumda! Değişkeni !! değişkeni olur ve geçersiz işlevde === olur! = Ve işlev adları değişmez.

Benim tercihim typeof(elem) != 'undefined' && elem != null .

Ne kadar seçerseniz seçin, çeki böyle bir işleve koymayı düşünün

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

Değişkenin bildirildiğini bilmiyorsanız typeof (x) != 'undefined' && x != null;

Değişkenin bildirildiğini, ancak var olmayabileceğini bildiğiniz durumlarda,

existy(elem) && doSomething(elem);

Denetlediğiniz değişken bazen iç içe geçmiş bir özellik olabilir. Prop || kullanabilirsiniz {} söz konusu mülkün hat kontrol varlığını aşağıya çekmek için:

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

Her özellikten sonra (... '|| {}') kullanın. NextProp, eksik bir özelliğin hata atmaması için.

Ya da var olanı kullanabilirsiniz existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

Bu duruma bağlıdır. Kodunuzun dışında (belki de jQuery gibi) global olarak tanımlanmış veya tanımlanmamış bir şeyi kontrol ediyorsanız:

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

(Burada katı bir eşitliğe gerek yoktur, typeof her zaman bir dize döndürür.) Ancak geçirilmiş veya geçmemiş bir işleve ilişkin argümanlarınız varsa, bunlar her zaman tanımlanır, ancak atlanırsa null olur.

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

Try-catch

Değişken hiç tanımlanmadıysa, try-catch bloğunu kullanarak kesme kodu yürütme olmadan bunu aşağıdaki gibi kontrol edebilirsiniz ( use strictmod yapmanız gerekmez )

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: (diğer cevaplara atıfta bulunarak) Neden ===daha net ==( kaynak )

eğer (a == b)

eğer (a === b)

Henüz belirtilmediğine şaşırdım ...

İşte birkaç ek varyasyon kullanarak this['var_name']

bir değişken tanımlanmadan önce kullanılabilecek bu yöntemi kullanmanın yararı.

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!

Bir try ... catch bloğunu aşağıdaki gibi kullanabilirsiniz:

var status = 'Variable exists'

try {
	myVar
} catch (ReferenceError) {
	status = 'Variable does not exist'
}

console.log(status)

Bir dezavantajı, ReferenceError atar gibi bir işlevi koyamazsınız

function variableExists(x) {
  var status = true
  try {
	  x
  } catch (ReferenceError) {
	  status = false
  }
  
  return status
}

console.log(variableExists(x))