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

אופרטורים של השוואה משווים בין הערכים של שני אופרנדים ובוחנים אם ההצהרה שהם יוצרים היא true או false. בדוגמה הבאה נשתמש באופרטור Strict equality (===) כדי להשוות בין שני אופרנדים: הביטוי 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

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

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

גביע ניצחון

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

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

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

"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 (!) לוגיים שוללים את ערך המהימנות או המזויף של אופרנד, ומתבצעת הערכה ל-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"

האופרטור הלוגי OR (||) מחזיר את הראשון מבין שני האופרנדים שלו רק אם האופרנד הזה מוערך ל-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, האופרטור nullish coalescing (??) מחזיר את האופרנד הראשון רק אם לאופרנד יש ערך אחר מלבד 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, צריך להקצות לו את הערך של האופרנד השני:"

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

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

בחינת ההבנה

איזה אופרטור מציין 'שווה ביותר'?

===

==

=

!=