אופרטורים של השוואה משווים את הערכים של שני אופרנדים ובוחנים אם
ההצהרה שהם מגישים היא 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
בדיקת ההבנה
איזה אופרטור מציין "שווה באופן מוחלט"?
!=
==
===
=