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

אופרטורים להשוואה משווים בין הערכים של שני אופרטנדים ומעריכים אם ההצהרה שהם יוצרים היא 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"	TRUE
=!	לא שווה	2 != "3"	TRUE
>	גדול מ-	3 > 2	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

אופרטור coalescing של Nullish

האופרטור 'nullish coalescing operator'‏ (??) נוסף ב-ES2020, והוא מחזיר את האופרטנד הראשון רק אם לאותו אופרטנד יש ערך שאינו 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

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

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

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

בדיקת ההבנה

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

===

==

=

!=