Bir değişkenin 'tanımsız' veya 'boş' olup olmadığını nasıl belirleyebilirim?

Değişkenin undefinedya da olup olmadığını nasıl belirleyebilirim null?

Kodum aşağıdaki gibidir:

var EmpName = $("div#esd-names div#name").attr('class');
if(EmpName == 'undefined'){
  // DO SOMETHING
};

<div id="esd-names">
  <div id="name"></div>
</div>

Ancak bunu yaparsam JavaScript yorumlayıcısı yürütmeyi durdurur.

Bunu yapmak için soyut eşitlik operatörünün niteliklerini kullanabilirsiniz :

if (variable == null){
    // your code here.
}

Çünkü null == undefineddoğrudur, yukarıdaki kod hem yakalayacak nullve undefined.

Yakalamanın nullve undefinedeşzamanlı olarak standart yol şudur:

if (variable == null) {
     // do something 
}

- hangi daha açık ama daha az özlü% 100 eşdeğer:

if (variable === undefined || variable === null) {
     // do something 
}

Profesyonel JS yazarken, o hafife almış tip eşitlik ve davranışları ==vs=== anlaşılmaktadır. Bu nedenle ==sadece kullanırız null.

Tekrar düzenle

Kullanımını öneren yorumlar typeofsade yanlış. Evet, değişkenim yoksa yukarıdaki çözümüm ReferenceError hatasına neden olur. Bu iyi birşey. Bu ReferenceError arzu edilir: kodunuzu göndermeden önce hatalarınızı bulmanıza ve düzeltmenize yardımcı olacaktır, tıpkı derleyici hatalarının diğer dillerde olduğu gibi. Kullanım try/ catchGirilecek ile çalışıyorsanız eğer üzerinde kontrole sahip değildir.

Kodunuzda bildirilmemiş değişkenlere referansınız olmamalıdır.

Yukarıdaki cevapları birleştirerek, en eksiksiz cevap şöyle görünecektir:

if( typeof variable === 'undefined' || variable === null ){
    // Do stuff
}

Bu, bildirilmemiş veya beyan edilmiş ve açıkça null veya undefined olarak ayarlanmış herhangi bir değişken için çalışmalıdır. Boole ifadesi, gerçek null olmayan bir değere sahip bildirilen herhangi bir değişken için false olarak değerlendirilmelidir.

if (variable == null) {
    // Do stuff, will only match null or undefined, this won't match false
}

if (typeof EmpName != 'undefined' && EmpName) {

değer değilse doğru olarak değerlendirilir:

• boş

• Tanımsız

• NaN

• boş dize ("")

• 0

• yanlış

jQuery attr()işlevi boş bir dize veya gerçek değer döndürür (ve asla nullveya undefined). Geri döndüğü undefinedtek zaman, seçicinizin herhangi bir öğe döndürmediği zamandır .

Böylece boş bir dizeye karşı test etmek isteyebilirsiniz. Alternatif olarak, boş dizeler, null ve undefined yanlış-y olduğundan, bunu yapabilirsiniz:

if (!EmpName) { //do something }

Bunun için kendi fonksiyonumu yazmaya geldim. JavaScript tuhaf.

Kelimenin tam anlamıyla her şeyde kullanılabilir. (Bu değişkenin kullanılabilir herhangi bir değer içerip içermediğini de kontrol eder . Ancak bu bilgi genellikle gerekli olduğundan, yayınlanmaya değer olduğunu düşünüyorum). Lütfen not bırakmayı düşünün.

function empty(v) {
    let type = typeof v;
    if (type === 'undefined') {
        return true;
    }
    if (type === 'boolean') {
        return !v;
    }
    if (v === null) {
        return true;
    }
    if (v === undefined) {
        return true;
    }
    if (v instanceof Array) {
        if (v.length < 1) {
            return true;
        }
    } else if (type === 'string') {
        if (v.length < 1) {
            return true;
        }
        if (v === '0') {
            return true;
        }
    } else if (type === 'object') {
        if (Object.keys(v).length < 1) {
            return true;
        }
    } else if (type === 'number') {
        if (v === 0) {
            return true;
        }
    }
    return false;
}

Typescript uyumlu.

Bu işlev yapmalıdır aynen PHP'nin gibi aynı şeyi empty()fonksiyonu (bkzRETURN VALUES )

Düşünüyor undefined, null, false, 0, 0.0, "0" {}, []olarak boşaltın.

"0.0", NaN, " ", trueBoş olmayan olarak kabul edilir.

Kontrol etmek istediğiniz değişken globalse,

if (window.yourVarName) {
    // Your code here
}

Bu şekilde kontrol etmek, yourVarNamedeğişken olmasa bile bir hata atmaz.

Örnek: Tarayıcımın Geçmiş API'sını destekleyip desteklemediğini bilmek istiyorum

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

Bu nasıl çalışır:

windowtüm global değişkenleri özellikleri olarak tutan bir nesnedir ve JavaScript'te var olmayan bir nesne özelliğine erişmeye çalışmak yasaldır. Eğer historyo zaman mevcut değil window.historydöner undefined. undefinedfalsey olduğundan, bir if(undefined){}bloktaki kod çalışmaz.

En kısa ve en kolay:

if(!EmpName ){
 // DO SOMETHING
}

EmpName:

• boş
• Tanımsız
• NaN
• boş
• dize ("")
• 0
• yanlış

Muhtemelen bunu yapmanın en kısa yolu:

if(EmpName == null) { /* DO SOMETHING */ };

İşte kanıt:

function check(EmpName) {
  if(EmpName == null) { return true; };
  return false;
}

var log = (t,a) => console.log(`${t} -> ${check(a)}`);

log('null', null);
log('undefined', undefined);
log('NaN', NaN);
log('""', "");
log('{}', {});
log('[]', []);
log('[1]', [1]);
log('[0]', [0]);
log('[[]]', [[]]);
log('true', true);
log('false', false);
log('"true"', "true");
log('"false"', "false");
log('Infinity', Infinity);
log('-Infinity', -Infinity);
log('1', 1);
log('0', 0);
log('-1', -1);
log('"1"', "1");
log('"0"', "0");
log('"-1"', "-1");

// "void 0" case
console.log('---\n"true" is:', true);
console.log('"void 0" is:', void 0);
log(void 0,void 0); // "void 0" is "undefined" 

Ve burada daha fazla ayrıntı ==(kaynak burada )

BONUS : neden ===daha açık ==( neden agc cevabına bakın )

Ben sadece bu nesne yani bir nesnenin boş olup olmadığını kontrol ettik.
Ben sadece bunu kullanın:

if (object) {
    // Your code
}

Örneğin:

if (document.getElementById("enterJob")) {
    document.getElementById("enterJob").className += ' current';
}

JQuery kullandığınızdan , bir değişkenin tanımsız olup olmadığını veya değerinin boş olup olmadığını tek bir işlev kullanarak belirleyebilirsiniz.

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;

jQuery kontrol öğesi boş değil:

var dvElement = $('#dvElement');

if (dvElement.length  > 0) {
    // Do something
}
else{
    // Else do something else
}

JavaScript'te, bildiklerime göre, aşağıdaki gibi tanımlanmamış, boş veya boş bir değişkeni kontrol edebiliriz.

if (variable === undefined){
}

if (variable === null){
}

if (variable === ''){
}

Tüm koşulları kontrol edin:

if(variable === undefined || variable === null || variable === ''){
}

Sadece aşağıdakileri kullanabilirsiniz (Bunu yapmanın daha kısa yolları olduğunu biliyorum, ancak bu en azından koda bakarak diğerleri için görsel olarak gözlemlemeyi kolaylaştırabilir).

if (x === null || x === undefined) {
 // Add your response code here, etc.
}

Kontrol etmenin en kolay yolu:

if(!variable) {
  // If the variable is null or undefined then execution of code will enter here.
}

Aşağıdaki çözümle:

const getType = (val) => typeof val === 'undefined' || !val ? null : typeof val;
const isDeepEqual = (a, b) => getType(a) === getType(b);

console.log(isDeepEqual(1, 1)); // true
console.log(isDeepEqual(null, null)); // true
console.log(isDeepEqual([], [])); // true
console.log(isDeepEqual(1, "1")); // false
etc...

Aşağıdakileri kontrol edebiliyorum:

• boş
• Tanımsız
• NaN
• boş
• dize ("")
• 0
• yanlış

Bir değişkenin null veya undefined olup olmadığını test etmek için aşağıdaki kodu kullanıyorum.

    if(typeof sVal === 'undefined' || sVal === null || sVal === ''){
      console.log('variable is undefined or null');
    }

Bu testi Chrome konsolunda çalıştırıyorum. (Void 0) kullanarak tanımsız olanları kontrol edebilirsiniz:

var c;
undefined
if (c === void 0) alert();
// output =  undefined
var c = 1;
// output =  undefined
if (c === void 0) alert();
// output =   undefined
// check c value  c
// output =  1
if (c === void 0) alert();
// output =  undefined
c = undefined;
// output =  undefined
if (c === void 0) alert();
// output =   undefined

Şuna bakalım,

1.  

   let apple; // Only declare the variable as apple
   alert(apple); // undefined

   Yukarıda, değişken sadece olarak bildirilmiştir apple. Bu durumda, yöntemi çağırırsak alerttanımsız görüntülenir.

2.  

      let apple = null; /* Declare the variable as apple and initialized but the value is null */
      alert(apple); // null

İkincisinde null değerini görüntüler, çünkü değişken apple değerini değer null olur.

Böylece bir değerin tanımsız veya boş olup olmadığını kontrol edebilirsiniz.

if(apple !== undefined || apple !== null) {
    // Can use variable without any error
}

En iyi yol:

if(typeof variable==='undefined' || variable===null) {

/* do your stuff */
}

(null == undefined)  // true

(null === undefined) // false

Çünkü === hem türü hem de değeri kontrol eder. Her ikisinin türü farklıdır, ancak değer aynıdır.

var i;

if (i === null || typeof i === 'undefined') {
    console.log(i, 'i is undefined or null')
}
else {
    console.log(i, 'i has some value')
}

foo == nullÇek hile yapmak ve en kısa şekilde "tanımlanmamış VEYA boş" davayı çözmelidir. ("Foo ilan edilmez" davası dikkate alınmaz.) Ancak 3 eşit değere sahip olan insanlar (en iyi uygulama olarak) kabul etmeyebilir. Sadece eqeqeq'e veya eslint ve tslint'te üçlü eşit kurallara bakın ...

Değişken n olup olmadığını kontrol ederken eklenir açık yaklaşım, undefinedya nullayrı ayrı, bu durumda uygulanır ve konuya katkım (şimdilik 27 negatif olmayan cevaplar!) Kullanmaktır edilmelidir void 0kontrolü gerçekleştirmek için hem kısa hem de güvenli yolu olarak içinundefined .

foo === undefinedUndefined ayrılmış bir sözcük olmadığından ve gölgelenebildiğinden ( MDN ) kullanmak güvenli değildir . Kullanımı typeof === 'undefined'çek güvenlidir ama umurumda gidiş değildir eğer foo-is-bildirilmemiş aşağıdaki yaklaşım kullanılabilir durumda:

if (foo === void 0 || foo === null) { ... }

kontrol etmek için bir işlev oluşturursanız:

export function isEmpty (v) {
 if (typeof v === "undefined") {
   return true;
 }
 if (v === null) {
   return true;
 }
 if (typeof v === "object" && Object.keys(v).length === 0) {
   return true;
 }

 if (Array.isArray(v) && v.length === 0) {
   return true;
 }

 if (typeof v === "string" && v.trim().length === 0) {
   return true;
 }

return false;
}

Özel null değeri boş bir nesne başvurusu olarak kabul edildiğinden, typeof null öğesi çağrıldığında bir "object" değeri döndürülür. Safari ile sürüm 5 ve Chrome ile sürüm 7 arasında, diğer tüm tarayıcıların “nesne” döndürürken normal ifadede typeof çağrılması “işlev” döndürülür.

var x;
if (x === undefined) {
    alert ("only declared, but not defined.")
};
if (typeof y === "undefined") {
    alert ("not even declared.")
};

Sadece ikincisini kullanabilirsiniz: hem tanım hem de beyanı kontrol edeceği için

Hala bu iki koşulu test etmenin en iyi / güvenli yolunun bir dizeye değer atmak olduğunu düşünüyorum:

var EmpName = $("div#esd-names div#name").attr('class');

// Undefined check
if (Object.prototype.toString.call(EmpName) === '[object Undefined]'){
    // Do something with your code
}

// Nullcheck
if (Object.prototype.toString.call(EmpName) === '[object Null]'){
    // Do something with your code
}

Yalnızca typeof komutunu kullanarak değerin tanımsız veya boş olup olmadığını kontrol edebilirsiniz:

if(typeof value == 'undefined'){

if(x==null)JavaScript'te kötü bir fikirdir. Yargıç "=="- bu beklenmedik tip zorlama neden olabilir ve CoffeeScript tarafından okunamaz koşul kararda "! =" Asla kullanma "==" veya!

if(x)daha iyi olur, ancak 0 ve "" ile dikkatli olun . Bu şekilde muamele edilmiş olan yanlış ile değil, aynı yöntem "!= null"olup gerçek .

Bkz. JavaScript En İyi Uygulamaları .