Yanlış değerler, boş, tanımsız veya boş dizeye karşılık

Yıllar boyunca jQuery ile çalıştım. Ancak, son zamanlarda kendimi JavaScript dilini derinleştirdiğimi gördüm. Son zamanlarda, "doğruluk" ve falsey değerlerini duydum. Ancak, onları tam olarak anlamıyorum. Şu anda, böyle görünüyor bazı kod var:

var fields = options.fields || ['id', 'query'];

Alanların boş, tanımsız veya uzunluğu 0 olup olmadığını tanımlamak gerekir. Uzun yolu yapmak olduğunu biliyorum:

if ((fields === null) || (fields === undefined) || (fields.length === 0)) {
 ...                    
}

Benim sorum şudur:

if (!fields)  {
 ...
}

Programlamada doğruluk ya da sahtecilik, gerçek bir boole değerine çözümlenmeyen, ancak yine de bir boole sonucu olarak yorumlanan bu boole ifadelerinin kalitesidir.

C durumunda, sıfıra değerlendirilen herhangi bir ifade yanlış olarak yorumlanır. In JavaScript, ifade valueiçinde

if(value) {
}

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

null
undefined
NaN
empty string ("")
0
false

Ayrıca Bkz
. JavaScript'te null, undefined veya blank değişkenleri kontrol etmek için standart bir işlev var mı?

JavaScript'teki "doğruluk" ve "falsey" değerleri kümesi, bir değeri bir boole değerine zorlarken kullanılan ToBooleanECMAScript spesifikasyonunda tanımlanan soyut işlemden gelir :

+--------------------------------------------------------------------------+
| Argument Type | Result                                                   |
|---------------+----------------------------------------------------------|
| Undefined     | false                                                    |
|---------------+----------------------------------------------------------|
| Null          | false                                                    |
|---------------+----------------------------------------------------------|
| Boolean       | The result equals the input argument (no conversion).    |
|---------------+----------------------------------------------------------|
| Number        | The result is false if the argument is +0, −0, or NaN;   |
|               | otherwise the result is true.                            |
|---------------+----------------------------------------------------------|
| String        | The result is false if the argument is the empty String  |
|               | (its length is zero); otherwise the result is true.      |
|---------------+----------------------------------------------------------|
| Object        | true                                                     |
+--------------------------------------------------------------------------+

Bu tablodan bunu görebiliriz nullve undefinedher ikisi de falseboole bağlamında zorlanır . Ancak, fields.length === 0genellikle yanlış bir değerle eşleşmez. Eğer fields.lengthbir dizi, o zaman olarak kabul edilir false(sıfır uzunlukta bir dizi olduğu için false), bu (bir dizi dahil olmak üzere) bir amacı ise, ancak için zorlamak olacaktır true.

Eğer fieldsbir dize olmalı, o zaman !fieldsyeterli bir yüklemdir. Bir fieldsdizi ise, en iyi kontrolünüz şu olabilir:

if (!fields || fields.length === 0)

Kısa cevap:

Hayır , aynı değiller.

Ama bu:

if (!fields) { ... }

Şununla aynı:

if ((fields === null) || (fields === undefined) || (fields === 0) || (fields === '') || (fields === NaN) || (fields === flase)) { ...
}

Uzun (ve daha iyisi) Cevap:

Önce doğruluk ve tahrif değerleri hakkında konuşalım.

Her şey bir şeyi bir boole olarak değerlendirdiğinizde olanlarla ilgilidir. JavaScript'te bu, ififadeler gibi şeyler kullandığınızda olur ; Mantıksal operatörler gibi ||, !ya da &&; veya Boolean()işlev.

Boolean()Fonksiyon ve bir değer iade kabul eden trueya da false.

Örneğin:

var age = 1; // Let's evaluate age as a boolean Boolean(age); // true

Devam edin ve bunu bir düğüm yanıtında deneyin.

Boolean sadece olabilir trueya da falsedönüş değeri, yani Boolean() gereken olarak mevcut trueya da false. Bu durumda, değer geçmiş 1ve bir mantıksal olarak değerlendirildiğinde, 1bir true.

Önemli: Bir boole olarak değerlendirildiğinde, bir değer doğru veya yanlış olmalıdır. Bunlar sadece iki seçenek.

JavaScript'te yalnızca 6 yanlış değer vardır. falseBir boolean olarak değerlendirildiğinde değerlendirilecek değerler . Bunlar: false, 0, "", null, undefined, ve NaN. Dolayısıyla, bu değerlerden herhangi biri bir boole olarak değerlendirilirse, yanlış olurlar:

Boolean(false) // false Boolean(0) // false Boolean("") // false Boolean(null) // false Boolean(undefined) // false Boolean(NaN) // false

Bu, JavaScript'teki diğer tüm değerlerin trueboole olarak değerlendirileceği anlamına gelir . JavaScript'teki diğer tüm değerler doğrudur.

Bir şeyi olduğu gibi değerlendirmenin bir başka kolay yolu booleanda !operatörü kullanmaktır . Tıpkı Booleanişlev gibi , bu da bir değeri boole olarak değerlendirir. Fakat gerçek değerler olur falseve yanlış değerler olur true.

!false // true !0 // true !"" / true !null // true !undefined // true !NaN // true

Yine, bunu anladığınızdan emin olmak için bir düğüm yanıtında veya başka bir şeyde deneyin.

Yani bu açıklama:

if (!fields) { ... }

Şunu söylüyor: "eğer fieldsbir boole olarak değerlendirildiğinde yanlışsa, bu if ifadesinin içindeki kodu çalıştırın."

İlk ifadenize gelince:

var fields = options.fields || ['id', 'query'];

Anladığınızdan emin olmak için okumaya değer mantıksal OR operatörü ile çalışıyorsunuz. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators

Kodunuz:

var fields;
if (options.fields)
    fields = options.fields;
else
    fields = ['id', 'query'];

Şimdi options.fieldsbir boole değerine dönüştürülür. Tanım olarak null, undefined, 0, ""dönüştürülür false, başka (çoğunlukla) şey dönüştürülür true(ama çok hassas olmak istemiyorum).

Bu, aynı anlama çünkü gelmez fields.length === 0hattı. Boş diziler ve diğer nesneler dönüştürülür true.

not: Javascript bazen büyük bir karışıklıktır ... Örneğin, 2 tip kontrol operatörüne (typeof ve instanceof) gerçek bir ihtiyaç yoktur. Otomatik tamamlama olmadan bir dize yazdığı için true instanceof Booleançalışmadığı ve kullanmanın typeof(true) == "boolean"hataya eğilimli olduğu durumlarda sadece ppl'yi karıştırır . Belki bazı yeni versiyonlarda bu problemler çözülecektir.

Fields öğesi null, undefined veya 0 uzunluğa sahipse true değerini döndürürse (!! fields) öğesini deneyebilirsiniz. Veya (!!! alan) o zaman bu doğru dönecektir.

çift ​​! veya !! doğru ya da yanlış zorlar. Keşke bunun için iyi bir tanım bulabilsem de bir daha bulamadım.