ערכי Truthy ו-Falsy ב-JavaScript: הרשימה המלאה

לכל ערך יש מצב רוח בוליאני

JavaScript מאפשרת לשים כל ערך במקום שבו מצופה בוליאני: בתוך if, כתנאי של while, ליד && או ||. כשעושים את זה, הערך מומר ל-true או ל-false. ערכים שמומרים ל-false נקראים falsy. כל השאר truthy.

if ("hello") console.log("מחרוזות הן truthy");
if (42) console.log("מספרים שונים מאפס הם truthy");
if ([]) console.log("מערכים ריקים הם truthy");
if ({}) console.log("אובייקטים ריקים הם truthy");

if (!0) console.log("אפס הוא falsy");
if (!"") console.log("מחרוזת ריקה היא falsy");

בלי פונקציית המרה, בלי cast מפורש: JavaScript עושה את זה אוטומטית. החוקים קבועים וקצרים, כך שברגע שמכירים את רשימת ה-falsy, כל מקרה אחר נגזר ממנה.

רשימת ה-Falsy המלאה

בדיוק שבעה ערכים הם falsy. כל השאר בשפה truthy.

const falsyValues = [false, 0, -0, 0n, "", null, undefined, NaN];

for (const v of falsyValues) {
    console.log(v, "->", Boolean(v));
}

זהו. הרשימה:

• false: הבוליאני עצמו.
• 0 ו--0: שני האפסים.
• 0n: אפס של BigInt.
• "": המחרוזת הריקה (במרכאות בודדות, כפולות או backticks, הכול אותו דבר).
• null: הערך של "כלום בכוונה".
• undefined: הערך של "לא הוגדר".
• NaN: התוצאה של חישוב לא חוקי כמו 0 / 0.

שננו את השבעה האלה. אחר כך, לגבי כל ערך שאתם לא בטוחים בו, שאלו: "האם הוא אחד מהשבעה?" אם לא, הוא truthy.

ההפתעות: "0", [] ו-{}

כאן מתחילים נכווים. הרבה ערכים נראים ריקים אבל הם truthy:

console.log(Boolean("0"));       // true: זו מחרוזת לא ריקה
console.log(Boolean("false"));   // true: עדיין מחרוזת לא ריקה
console.log(Boolean(" "));       // true: גם רווח נחשב
console.log(Boolean([]));        // true: מערך ריק הוא אובייקט
console.log(Boolean({}));        // true: אובייקט ריק הוא אובייקט
console.log(Boolean(new Date()));// true

מחרוזות הן falsy רק כשאין בהן אף תו. ב-"0" יש תו אחד, ולכן היא truthy. מערכים ואובייקטים הם תמיד truthy, גם כשהם ריקים, כי JavaScript מתייחסת אליהם כאובייקטים, וכל האובייקטים הם truthy בלי קשר למה שבתוכם.

אם אתם מגיעים מ-Python, זה השינוי המחשבתי הגדול ביותר. ב-Python, [] ו-{} הם falsy. ב-JavaScript הם לא.

לבדוק "ריק" בדרך הנכונה

מכיוון ש-[] ו-{} הם truthy, אי אפשר להשתמש בהם ישירות בתוך if כדי לבדוק אם הם ריקים. היו מפורשים:

const items = [];
const user = {};

// לא נכון, תמיד רץ:
if (items) console.log("יש משהו ב-items");

// נכון:
if (items.length === 0) console.log("items ריק");
if (Object.keys(user).length === 0) console.log("ל-user אין שדות");

אותו דבר עם מחרוזות, אם רוצים להתייחס למחרוזת שיש בה רק רווחים כריקה:

const input = "   ";
if (input) console.log("truthy, אבל לא באמת שימושי");
if (input.trim() === "") console.log("באמת ריק");

Truthy/falsy הוא קיצור נוח, לא תחליף לחשיבה על המשמעות של "ריק" עבור הנתונים שלכם.

המרה לבוליאני אמיתי

לפעמים רוצים true או false אמיתי, לא רק ערך שהוא truthy בערך. שני ביטויים מקובלים:

const name = "Rosa";

console.log(Boolean(name));  // true
console.log(!!name);         // true

const empty = "";
console.log(Boolean(empty)); // false
console.log(!!empty);        // false

Boolean(x) היא ההמרה המפורשת. !!x הוא אותו דבר בקיצור: ה-! הראשון ממיר לבוליאני והופך אותו, ה-! השני הופך אותו בחזרה. שניהם נפוצים. !! קצר יותר; Boolean() קריא יותר.

לעיתים קרובות תראו !! בהוראות return, כשפונקציה צריכה להחזיר בוליאני נקי:

function hasItems(arr) {
    return !!arr && arr.length > 0;
}

console.log(hasItems([1, 2]));   // true
console.log(hasItems([]));        // false
console.log(hasItems(null));      // false

Truthy/Falsy עם && ו-||

האופרטורים הלוגיים לא מחזירים true או false: הם מחזירים את אחד האופרנדים. איזה מהם, תלוי ב-truthiness:

console.log("a" && "b");       // "b"  - both truthy, returns the last
console.log(0 && "b");         // 0    - short-circuits on the falsy one
console.log("" || "fallback"); // "fallback" - first is falsy, returns the second
console.log("hi" || "fallback");// "hi" - first is truthy, returns it

זו הסיבה ש-value || defaultValue הוא דפוס כל כך נפוץ לערכי ברירת מחדל. אבל יש בו מלכודת: הוא מתייחס ל_כל_ ערכי ה-falsy באותה צורה, כולל 0 ו-"", שלעיתים קרובות הם קלט תקין:

function greet(name) {
    const who = name || "זר";
    console.log("שלום, " + who);
}

greet("Ada");   // שלום, Ada
greet("");      // שלום, זר, אבל אולי "" היה מכוון?
greet(0);       // שלום, זר, ו-0 יכול להיות id תקין

אם אתם רוצים ליפול לברירת המחדל רק כשהערך הוא null או undefined, השתמשו במקום זאת באופרטור nullish coalescing ??. יש לו מסמך משלו.

טבלת עזר מהירה

// Falsy - all seven:
Boolean(false);     // false
Boolean(0);         // false
Boolean(-0);        // false
Boolean(0n);        // false
Boolean("");        // false
Boolean(null);      // false
Boolean(undefined); // false
Boolean(NaN);       // false

// Truthy - everything else:
Boolean("0");       // true
Boolean("false");   // true
Boolean([]);        // true
Boolean({});        // true
Boolean(() => {});  // true
Boolean(Infinity);  // true
Boolean(-Infinity); // true

הדפיסו, הדביקו על המסך, והמשיכו בחיים.

הבא בתור: Iterators ו-Generators

אחרי שתנאים ולולאות כבר בכיס, הפרק הבא בוחן איך JavaScript מאפשרת לערכים לייצר את עצמם לפי דרישה. Iterators ו-generators הם המנגנון שמאחורי for...of, spread והרבה APIs מודרניים, והם מגיעים עכשיו.