ค่า Falsy กับ null, undefined หรือสตริงว่าง

ฉันทำงานกับ jQuery มาหลายปีแล้ว อย่างไรก็ตามเมื่อเร็ว ๆ นี้ฉันพบว่าตัวฉันเองมีความลึกซึ้งยิ่งขึ้นในภาษา JavaScript เมื่อเร็ว ๆ นี้ฉันเคยได้ยินเกี่ยวกับ "ความจริง" และค่าเท็จ อย่างไรก็ตามฉันไม่เข้าใจพวกเขาทั้งหมด ขณะนี้ฉันมีรหัสที่มีลักษณะเช่นนี้:

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

ฉันจำเป็นต้องระบุว่าฟิลด์ใดเป็นโมฆะไม่ได้กำหนดหรือมีความยาว 0 ฉันรู้ว่าต้องทำอย่างไร:

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

คำถามของฉันคือต่อไปนี้เหมือนกัน:

if (!fields)  {
 ...
}

ในการเขียนโปรแกรมความจริงหรือความผิดพลาดคือคุณภาพของนิพจน์บูลีนเหล่านั้นซึ่งไม่ได้แก้ไขค่าบูลีนที่แท้จริง แต่ที่ได้รับการตีความว่าเป็นผลบูลีน

ในกรณีของ C นิพจน์ใด ๆ ที่ประเมินค่าเป็นศูนย์จะถูกตีความว่าเป็นเท็จ ใน Javascript หมายถึงนิพจน์valueใน

if(value) {
}

จะประเมินเป็นจริงหากvalueไม่:

null
undefined
NaN
empty string ("")
0
false

ดูเพิ่มเติม
มีฟังก์ชันมาตรฐานเพื่อตรวจสอบตัวแปรว่างเปล่า, ไม่ได้กำหนดหรือเปล่าใน JavaScript หรือไม่?

ชุดของค่า "ความจริง" และ "เท็จ" ใน JavaScript มาจากการToBooleanดำเนินการเชิงนามธรรมที่กำหนดไว้ในข้อมูลจำเพาะ ECMAScriptซึ่งจะใช้เมื่อบีบบังคับค่าให้กับบูลีน:

+--------------------------------------------------------------------------+
| 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                                                     |
+--------------------------------------------------------------------------+

จากตารางนี้เราจะเห็นว่าnullและundefinedจะมีทั้งการบังคับให้falseในบริบทแบบบูล อย่างไรก็ตามfields.length === 0โดยทั่วไปแล้วคุณจะไม่จับคู่กับค่าเท็จ ถ้าfields.lengthเป็นสตริงแล้วก็จะถือว่าเป็นfalse(เพราะสตริงความยาวเป็นศูนย์เป็นfalse) แต่ถ้ามันเป็นวัตถุ (รวมทั้งอาร์เรย์) trueมันจะบีบบังคับไป

หากfieldsควรเป็นสตริงแสดงว่า!fieldsเป็นเพรดิเคตที่เพียงพอ ถ้าfieldsเป็นอาร์เรย์การตรวจสอบที่ดีที่สุดของคุณอาจเป็น:

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

คำตอบสั้น ๆ :

ไม่พวกเขาไม่เหมือนกัน

แต่นี่:

if (!fields) { ... }

เหมือนกับสิ่งนี้:

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

ยาว (และดีกว่า) คำตอบ:

ก่อนอื่นเรามาพูดเกี่ยวกับค่าความจริงและความเท็จ

มันคือทั้งหมดที่เกี่ยวกับสิ่งที่เกิดขึ้นเมื่อคุณประเมินบางสิ่งเป็นบูลีน ใน JavaScript สิ่งนี้เกิดขึ้นเมื่อคุณใช้สิ่งต่าง ๆ เช่นifข้อความสั่ง ดำเนินการทางตรรกะชอบ||, !หรือ&&; หรือBoolean()ฟังก์ชั่น

Boolean()ฟังก์ชั่นรับค่าและผลตอบแทนอย่างใดอย่างหนึ่งหรือtruefalse

ตัวอย่างเช่น:

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

ไปข้างหน้าและลองสิ่งนี้ในการจำลองโหนด

บูลีนจะไม่สามารถtrueหรือfalseเพื่อให้ค่าตอบแทนของBoolean() ต้องเป็นได้ทั้งหรือtrue falseในกรณีนี้เราผ่านในค่า1และเมื่อประเมินเป็นแบบบูล, คือ1true

สำคัญ: เมื่อประเมินเป็นบูลีนค่าต้องเป็นจริงหรือเท็จ นี่เป็นเพียงสองทางเลือกเท่านั้น

ใน JavaScript มีค่าเท็จเพียง6ค่า ค่าที่จะถูกfalseประเมินเมื่อเป็นบูลีน พวกเขาจะ: false, 0, "", null, และundefined NaNดังนั้นหากค่าใด ๆ เหล่านี้ถูกประเมินว่าเป็นบูลีนค่าเหล่านั้นจะเป็นเท็จ:

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

ซึ่งหมายความว่าค่าอื่น ๆ ใน JavaScript จะถูกtrueประเมินเมื่อเป็นบูลีน ดังนั้นคุณค่าอื่น ๆ ใน JavaScript จึงเป็นจริง

อีกวิธีง่าย ๆ ในการประเมินบางสิ่งบางอย่างตามbooleanคือโดยใช้ตัว!ดำเนินการ เช่นเดียวกับBooleanฟังก์ชั่นนี้ประเมินค่าเป็นบูลีน แต่ค่า truthy กลายเป็นfalseและค่า falsy trueกลายเป็น

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

ลองอีกครั้งในการจำลองโหนดหรือบางสิ่งเพื่อให้แน่ใจว่าคุณเข้าใจ

ดังนั้นคำสั่งนี้:

if (!fields) { ... }

กำลังพูดถึงสิ่งต่อไปนี้: "ถ้าfieldsเมื่อประเมินว่าเป็นบูลีนเป็นเท็จให้รันโค้ดภายในคำสั่ง if นี้"

สำหรับข้อความแรกของคุณ:

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

คุณกำลังทำงานกับโอเปอเรเตอร์หรือตรรกะซึ่งควรค่าแก่การอ่านเพื่อให้แน่ใจว่าคุณเข้าใจ https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators

รหัสของคุณหมายถึง:

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

ตอนนี้options.fieldsถูกแปลงเป็นค่าบูลีน ตามคำนิยามnull, undefined, 0, ""จะถูกแปลงเป็นfalse(ส่วนใหญ่) สิ่งอื่น ๆ ที่จะถูกแปลงเป็นtrue( แต่ฉันไม่ต้องการที่จะแม่นยำดังนั้น)

มันไม่ได้หมายความว่าเหมือนกันเพราะfields.length === 0สาย อาร์เรย์ที่ว่างเปล่าและวัตถุอื่น ๆ trueจะถูกแปลงเป็น

หมายเหตุ: Javascript บางครั้งอาจเป็นเรื่องใหญ่ ... ตัวอย่างเช่นไม่มีความต้องการตัวดำเนินการตรวจสอบ 2 ประเภท (typeof และ instanceof) มันแค่สับสน ppl เมื่อtrue instanceof Booleanไม่ทำงานและการใช้typeof(true) == "boolean"เป็นข้อผิดพลาดได้ง่ายเนื่องจากการพิมพ์สตริงโดยไม่ต้องเติมข้อความอัตโนมัติ บางทีในบางเวอร์ชั่นใหม่ปัญหาเหล่านี้จะได้รับการแก้ไข

คุณสามารถลอง (!! เขตข้อมูล) ถ้าองค์ประกอบเขตข้อมูลเป็นโมฆะไม่ได้กำหนดหรือมีความยาวเป็น 0 มันจะกลับมาจริง หรือ (!!! ฟิลด์) จากนั้นนี่จะคืนค่าจริง

สองเท่า ! หรือ !! จะบังคับจริงหรือเท็จ ฉันหวังว่าฉันจะสามารถหาคำจำกัดความที่ดีสำหรับสิ่งนี้ แต่ฉันดูเหมือนจะไม่สามารถหามันได้อีก