typeof! == “undefined” vs.! = null

Genellikle tanımsız parametreleri vb. Kontrol eden JavaScript kodunu bu şekilde görüyorum:

if (typeof input !== "undefined") {
    // do stuff
}

Bu, hem tür arama hem de dize karşılaştırması içerdiğinden, ayrıntılarından bahsetmeden, biraz savurgan görünüyor. Yine de gerekli çünkü undefinedyeniden adlandırılabilir.

Benim sorum:
Bu kod bu yaklaşımdan daha iyi nasıl:

if (null != input) {
    // do stuff
}

Bildiğim kadarıyla yeniden tanımlayamazsınız null, bu yüzden beklenmedik bir şekilde kırılmaz. Ve, çünkü tip zorlama !=operatörü, bu ikisi için kontroller undefinedve nullsık sık ... Eğer (örneğin isteğe bağlı fonksiyon parametreleri için) istediğiniz tam olarak ne.

Yine de bu form yaygın görünmüyor ve JSLint'in kötü !=operatörü kullandığınız için size bağırmasına bile neden oluyor .

Bu neden kötü stil olarak kabul edilir?

typeof tanımlayıcının daha önce hiç bildirilmemesine izin verdiği için daha güvenlidir:

if(typeof neverDeclared === "undefined") // no errors

if(neverDeclared === null) // throws ReferenceError: neverDeclared is not defined

Değişken bildirilirse ( varanahtar sözcükle, işlev bağımsız değişkeni olarak veya genel değişken olarak), bunu yapmanın en iyi yolunun bence:

if (my_variable === undefined)

jQuery yapar, bu yüzden benim için yeterince iyi :-)

Aksi takdirde, typeofönlemek için kullanmanız gerekir ReferenceError.

Undefined öğesinin yeniden tanımlanmasını bekliyorsanız, kodunuzu şu şekilde sarabilirsiniz:

(function(undefined){
    // undefined is now what it's supposed to be
})();

Veya voidoperatör üzerinden alın :

const undefined = void 0;
// also safe

iyi bir yol:

if(typeof neverDeclared == "undefined") //no errors

Ancak en iyi görünen yol şu yollarla kontrol etmektir:

if(typeof neverDeclared === typeof undefined) //also no errors and no strings

Tanımsız olarak yeniden adlandırılması konusunda gerçekten endişelenmemelisiniz. Birisi undefined olarak yeniden adlandırırsa, kontrol başarısız olursa birkaç tanesinden çok daha fazla sorun yaşarsınız. Kodunuzu gerçekten korumak istiyorsanız, aşağıdaki gibi bir IFFE (hemen çağrılan işlev ifadesi) içine sarın:

(function($, Backbone, _, undefined) {
    //undefined is undefined here.
})(jQuery, Backbone, _);

Bir tarayıcı ortamında küresel değişkenlerle (zaten yanlış olan) çalışıyorsanız, şu şekilde tanımsız olup olmadığını kontrol ederim:

if(window.neverDefined === undefined) {
    //Code works
}

Global değişkenler pencere nesnesinin bir parçası olduğundan, bir dizeye yayın yapmak ve dizeleri karşılaştırmak yerine tanımsızlara karşı kontrol edebilirsiniz.

Üstelik değişkenleriniz neden tanımlanmadı? Değişkenlerin varlığını kontrol ettikleri ve buna dayalı bazı eylemler gerçekleştirdikleri bir sürü kod gördüm. Bu yaklaşımın nerede doğru olduğunu bir kez görmedim.

Eğer tanımsızın yeniden tanımlanmasından gerçekten endişeleniyorsanız, buna karşı bazı yardımcı yöntemlerle korunabilirsiniz:

function is_undefined(value) {
   var undefined_check; // instantiate a new variable which gets initialized to the real undefined value
   return value === undefined_check;
}

Bu işe yarar çünkü birisi yazdığında undefined = "foo", adın yalnızca undefinedyeni bir değere başvurmasına izin verir , ancak gerçek değerini değiştirmez undefined.

Tanımlanmamış bir değer elde etmek için void operatörünü de kullanabilirsiniz:

if (input !== void 0) {
    // do stuff    
}

(Ve evet, başka bir cevapta belirtildiği gibi, değişken bildirilmezse bu bir hata atar, ancak bu durum genellikle kod denetimi veya kod yeniden düzenleme yoluyla, örneğin window.input !== void 0genel değişkenleri test etmek veya eklemek için devre dışı bırakılabilir var input.)

Ben aslında (typeof input !== 'undefined')varsayılan fonksiyon parametreleri sağlamak için kullanılan bu senaryoda rastlamak :

function greet(name, greeting) {
  name = (typeof name !== 'undefined') ?  name : 'Student';
  greeting = (typeof greeting !== 'undefined') ?  greeting : 'Welcome';

  return `${greeting} ${name}!`;
}

greet(); // Welcome Student!
greet('James'); // Welcome James!
greet('Richard', 'Howdy'); // Howdy Richard!

ES6, varsayılan işlev parametrelerini bu şekilde tanıtmanın yeni yollarını sunar:

function greet(name = 'Student', greeting = 'Welcome') {
  return `${greeting} ${name}!`;
}

greet(); // Welcome Student!
greet('James'); // Welcome James!
greet('Richard', 'Howdy'); // Howdy Richard!

Bu, ilk seçenekten daha az ayrıntılı ve daha temizdir.

if (input == undefined) { ... }

gayet iyi çalışıyor. Tabii ki bu bir nullkarşılaştırma değil , ama genellikle undefinedve arasında bir ayrım yapmam gerekirse null, aslında undefinedve sadece herhangi bir yanlış değeri ayırt etmem gerektiğini buluyorum.

else if (input) { ... }

yapar.

Bir program yeniden undefinedtanımlıyorsa, zaten gerçekten cesur olur.

Aklıma gelen tek nedeni o anlamadı, IE4 uyumluluk için oldu undefined(ne yazık ki, aslında bir anahtar kelime değildir) anahtar kelime, ama tabii ki değerler olabilir olmak undefined buna sahip zorunda:

var undefined;

ve yukarıdaki karşılaştırma işe yarayacaktır.

İkinci örneğinizde, tiftikleri mutlu etmek için muhtemelen çift parantezlere ihtiyacınız var mı?