אופרטורים להשוואה

אופרטורים של השוואה משווים את הערכים של שני אופרנדים ובוחנים אם ההצהרה שהם מגישים היא true או false. הדוגמה הבאה משתמשת אופרטור שוויון מחמיר (===) כדי להשוות בין שתי אופרנדים: הביטוי 2 + 2 והערך 4. בגלל שהתוצאה של הביטוי והמספר הערך 4 זהה, הביטוי הבא מוערך ל-true:

2 + 2 === 4
> true

סוג כפייה ושוויון

שניים מהאופרטורים הנפוצים ביותר להשוואה הם == כדי לציין שוויון משוחרר ו-=== לשוויון מחמיר. == מבצע השוואה רפויה בין שתיים באמצעות אילוץ של האופרנדים לסוגי נתונים תואמים, אם אפשר. עבור לדוגמה, הפונקציה 2 == "2" מחזירה את הערך true, למרות שההשוואה מתבצעת בין ערך של מספר לערך במחרוזת.

2 == 2
> true

2 == "2"
> true

כך גם לגבי הפונקציה !=, שמחזירה את true רק אם האופרנדים בהשוואה לא שווה כמעט.

2 != 3
> true

2 != "2"
> false

השוואות מחמירות באמצעות === או !== לא מבצעות כפייה של סוגים. עבור לביצוע השוואה מחמירה ל-true, הערכים להשוואה חייבים להיות אותו סוג נתונים. לכן, הפונקציה 2 == "2" מחזירה true, אבל 2 === "2" מחזירה false:

2 === 3
> false

2 === "2"
> false

כדי למנוע אי בהירות שעשויה להיגרם מאילוץ אוטומטי, יש להשתמש ב-=== כאשר ככל האפשר.

מפעיל	תיאור	שימוש	תוצאה
===	שווה באופן מובהק	2 === 2	true
!==	לא שוויוני לחלוטין	2 !== "2"	true
==	שווה (או 'שוויון חלש')	"2" ==2 2	true
=!	לא שווה	2 != "3"	true
>	גדול מ-	3 > 2	true
>=	גדול מ- או שווה ל-	2 >= 2	true
<	פחות מ-	2 < 3	true
<=	פחות מ- או שווה ל-	3 <= 2	true

דמויות מתוקות וקופאיות

כל הערכים ב-JavaScript הם true או false מרומזים, וניתן לאלץ אותם: בערך הבוליאני התואם - לדוגמה, באמצעות הפונקציה שמשווה. קבוצה מוגבלת של ערכים תגרום לאילוץ false:

• 0
• null
• undefined
• NaN
• מחרוזת ריקה ("")

כל שאר הערכים מאלצים את אל true, כולל כל מחרוזת שמכילה אחד או יותר. ואת כל המספרים שאינם אפס. הן נקראות בדרך כלל "truthy" וגם 'falsy' ערכים.

"My string" == true
> true

100 == true
> true

0 == true
> false

אופרטורים לוגיים

משתמשים באופרטורים הלוגיים AND (&&), OR (||) ו-NOT (!) כדי לשלוט בזרימת הסקריפט, על סמך ההערכה של שתי הצהרות מותנות או יותר:

2 === 3 || 5 === 5;
> true

2 === 2 && 2 === "2"
> false

2 === 2 && !"My string."
> false

ביטוי לוגי מסוג NOT (!) מבטל את ערך האמת או ה-Falsy של אופרנד, ומחזיר את הערך true אם האופרנד שווה ל-false, ואת false אם האופרנד שווה ל-true:

true
> true

!true
> false

!false
> true

שימוש באופרטור הלוגי NOT (!) לפני סוג נתונים אחר, כמו מספר או מחרוזת, מאלצים את הערך לערך בוליאני והופכים את הערכים ערך מדומה של התוצאה.

"string"
> "string"

!"string"
> false

0
> 0

!0
> true

מקובל להשתמש בשני אופרטורים של NOT כדי לאלץ במהירות נתונים ערך בוליאני תואם:

!!"string"
> true

!!0
> false

האופרטורים הלוגיים AND ו-OR לא מבצעים כפייה בעצמם. הם מחזירה את הערך של אחד משני האופרנדים שנבדקים, עם הערך שנבחר באופרנד שנקבע על ידי ההערכה הזו.

האופרנד הלוגי AND (&&) מחזירה רק את האופרנד הראשון מבין שני האופרנדים האלה. הפונקציה מחשבת את false, ואת האופרנד השני אם לא. בהשוואה הפונקציה מחזירה את הערך true רק אם האופרים בשני הצדדים מהפונקציה AND הלוגית 'true'. אם אחד מהצדדים שווה ל-false, הפונקציה מחזירה את הערך false.

true && false
> false

false && true
> false

false && false
> false

true && true
> true

כשמשתמשים ב-&& עם שני אופרנדים לא בוליאניים, מוחזר האופרנד הראשון ללא שינוי, אם אפשר לאלץ אותו להיות false. אם אפשר לאלץ את האופרנד הראשון אל true, האופרנד השני מוחזר ללא שינוי:

false && "My string"
> false

null && "My string"
> null

"My string" && false
> false

"My string" && "My second string"
> "My second string"

2 === 2 && "My string"
> "My string"

האופרנד הלוגי (||) מחזיר את האופרנד הראשון שלו רק אם האופרנד הזה הוא הפונקציה מחשבת את true, ואת האופרנד השני אם לא. בהשוואה הפונקציה מחזירה ערכים בוליאניים, כלומר היא מחזירה את הערך true אם אחד מהאופרנדים הפונקציה מחזירה את הערך true, ואם אף אחד מהצדדים לא מקבל ערך של true, הפונקציה מחזירה false:

true || false
> true

false || true
> true

true || true
> true

false || false
> false

כשמשתמשים ב-|| עם שני אופרנדים לא בוליאניים, היא מחזירה את האופרנד הראשון. ללא שינוי אם אפשר לאלץ אותו להיות true. אם אפשר לאלץ את האופרנד הראשון אל false, האופרנד השני מוחזר ללא שינוי:

false || "My string"
> "My string"

null || "My string"
> "My string"

"My string" || false
> "My string"

"My string" || "My second string"
> "My string"

2 === 2 || "My string"
> true

אופרטור איחוד ריק

הופעלה ב-ES2020, את 'אופרטור איחוד null' (??) מחזירה את האופרנד הראשון רק אם ל-operand יש כל ערך מלבד null או undefined. אחרת, הפונקציה מחזירה האופרנד השני.

null ?? "My string"
> "My string"

undefined ?? "My string"
> "My string"

true ?? "My string";
> true

?? דומה ל-OR לוגי, אבל מחמיר יותר מבחינת האופרנד הראשון עוד לא בדקתם. || מחזירה את האופרנד השני עבור כל ביטוי שיכול להיות נכפה אל false, כולל undefined ו-null. ?? מחזירה את השנייה אופרנד כשהאופרנד הראשון הוא כל דבר מלבד null או undefined, גם אם ניתן לאלץ: false:

0 ?? "My string";
> 0

false ?? "My string";
> false

undefined ?? "My string";
> "My string"

אופרטורים לוגיים של הקצאות לוגיות

השתמשו באופרטורים של הקצאות כדי להקצות את הערך של אופרטור שני לאופרטור הראשון . הדוגמה הנפוצה ביותר לכך היא סימן שוויון יחיד (=), המשמש מקצים ערך למשתנה מוצהר.

איך משתמשים באופרטורים לוגיים של הקצאות לוגיות כדי להקצות ערך למשתנה באופן מותנה על סמך הערך האמיתי או הפיזי של המשתנה הזה.

האופרטור הלוגי AND (&&=) מעריך את האופרנד השני ו משויך לאופרנד הראשון, אם האופרנד הראשון מחשב true - למעשה, "אם האופרנד הראשון נכון, מקצים לו את הערך של במקום זאת, את האופרנד השני:"

let myVariable = false;
myVariable &&= 2 + 2;
> false

myVariable = true;
myVariable &&= 2 + 2;
> 4

הערך המוחלט או הפיזי של האופרנד הראשון קובע אם מטלה לביצוע. עם זאת, בניסיון להעריך את האופרנד הראשון באמצעות השוואה התוצאה של אופרטור זה היא ערך בוליאני true או false, שלא ניתן להקצות אותו ערך:

let myVariable = 5;
myVariable > 2 &&= "My string"
> SyntaxError: Invalid left-hand side in assignment

אופרטור ההקצאה הלוגי OR (||=) מבצע הערכה של האופרנד השני ו מקצים לאופרנד הראשון אם האופרנד הראשון שווה ל-false — בפועל, "אם האופרנד הראשון הוא False, צריך להקצות לו את הערך של operand במקום זאת:"

let myVariable = false;
myVariable ||= 2 + 2;
> 4

myVariable = true;
myVariable ||= 2 + 2;
> true

בדיקת ההבנה