כיצד להשתמש באופרטורים לוגיים ב-JavaScript

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

חקור את האופרטורים הלוגיים השונים שבהם JavaScript תומך, כולל אופרטור ההתאחדות ES6 Nullish.

המפעיל הלוגי AND (&&).

האופרטור AND (&&) הוא אופרטור לוגי שמחזיר נָכוֹן אם שני האופרנדים מעריכים נָכוֹן ו שֶׁקֶר אחרת.

להלן התחביר של האופרטור AND:

א && ב

הנה דוגמה לאופרטור AND בשימוש:

const א = 5;
const ב = 10;
const c = 15;
const result_1 = (a < b) && (b < c);
לְנַחֵם.log (result_1); // נכון
const result_2 = (a > b) && (b < c);
לְנַחֵם.log (result_2); // שקר

בדוגמה זו, תוצאה_1 מעריך ל נָכוֹן כי שני האופרנדים בביטוי מעריכים ל נָכוֹן. למרות זאת, תוצאה_2 מעריך ל שֶׁקֶר כי האופרנד הראשון (א > ב) החזרות שֶׁקֶר.

אם שני האופרנדים אינם בוליאניים, JavaScript ינסה להמיר אותם לערכים בוליאניים לפני הערכת הביטוי. כדי להמיר אותם לבוליאנים, JavaScript תחילה מעריך אם הערכים נכונים או שקריים.

JavaScript מחשיב כל ערך שאינו מזויף במפורש, כערך אמיתי. כשהם מומרים, הם מוערכים לבוליאני נָכוֹן.

עם זאת, ערכים מסוימים ו סוגי נתונים ב-JavaScript הם מזויפים, כך שכאשר JavaScript ממיר אותם, הם מוערכים לערך בוליאני שֶׁקֶר.

הערכים הכוזבים ב-JavaScript הם:

• שֶׁקֶר
• ריק
• לא מוגדר
• NaN (לא מספר)
• 0
• BigInt (0n)
• מחרוזת ריקה ("" אוֹ '' אוֹ ``)
• לא מוגדר

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

עם זאת, אם האופרנד הראשון נכון, הביטוי ממשיך להעריך את האופרנד השני. אם האופרנד השני נכון, הוא מחזיר אותו.

לדוגמה:

const א = 5;
const ב = 'שלום';
const c = ריק;
const result_1 = a && b;
לְנַחֵם.log (result_1); // "שלום"
const result_2 = c && b;
לְנַחֵם.log (result_2); // ריק

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

שימו לב שאם יש עוד אופרנדים, האופרטור AND ימשיך להעריך אותם עד שהוא יתקל בערך מזויף. אם הוא לא נתקל בערך מזויף הוא מחזיר את ערך האמת האחרון שהוא נתקל בו.

מפעיל ה-OR הלוגי (||).

האופרטור OR (||) הוא אופרטור לוגי שמחזיר נָכוֹן אם ורק אם אחד או יותר מהאופרנדים שלו נָכוֹן. זה רק חוזר שֶׁקֶר כאשר שני האופרנדים הם שֶׁקֶר.

הנה התחביר של האופרטור OR:

א || ב

הנה דוגמה לאופרטור OR שנמצא בשימוש:

const א = 5;
const ב = 10;
const c = 15;
const result_1 = (a < b) || (ב < c);
לְנַחֵם.log (result_1); // נכון
const result_2 = (a > b) || (ב < c);
לְנַחֵם.log (result_2); // נכון
const result_3 = (a > b) || (ב > ג);
לְנַחֵם.log (result_3); // שקר

בדוגמה למעלה, תוצאה_1 מעריך ל נָכוֹן כי שני האופרנדים בביטוי מעריכים ל נָכוֹן. תוצאה_2 מעריך ל נָכוֹן כי האופרנד השני מעריך ל נָכוֹן. תוצאה_3 מעריך ל שֶׁקֶר כי שני האופרנדים בביטוי מעריכים ל שֶׁקֶר.

כאשר אתה משתמש באופרטור OR בהקשרים לא בוליאניים, JavaScript מנסה להמיר לערכים בוליאניים לפני הערכת הביטוי.

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

לדוגמה:

const א = 5;
const ב = 'שלום';
const c = ריק;
const result_1 = a || ב;
לְנַחֵם.log (result_1); // 5
const result_2 = c || ב;
לְנַחֵם.log (result_2); // "שלום"
const result_3 = c || " ";
לְנַחֵם.log (result_3); // " "

בדוגמה למעלה, תוצאה_1 קצרים והחזרות 5 כי זה ערך אמיתי. תוצאה_2 מחזירה "Hello" כי זה הערך האמיתי הראשון שהוא פוגש בביטוי. תוצאה_3 מחזירה מחרוזת ריקה מכיוון שהיא הערך השגוי האחרון בביטוי.

המפעיל הגיוני לא (!).

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

הנה התחביר של האופרטור NOT:

!איקס

איפה איקס הוא ערך בוליאני או אמת או כוזב.

הנה דוגמה לאופרטור NOT בשימוש:

const א = 5;
const ב = '';
const c = נָכוֹן;
const result_1 = !a;
לְנַחֵם.log (result_1); // שקר
const result_2 = !b;
לְנַחֵם.log (result_2); // נכון
const result_3 = !c;
לְנַחֵם.log (result_3); // שקר

בדוגמה שלמעלה, האופרטור NOT מחזיר את הערך ההפוך של האופרנדים הבוליאניים. כאשר אתה משתמש באופרטור NOT בהקשרים לא בוליאניים (תוצאה_1 & תוצאה_2), הוא ממיר ערכי אמת לערך ההפוך של נָכוֹן וממיר את הערכים הכוזבים לערך ההפוך של שֶׁקֶר.

ה-Nullish Coalescing (??) מפעיל

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

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

הוא מספק דרך תמציתית לבחירת ערך ברירת מחדל בעת מפגש ריק אוֹ לא מוגדר ערכים.

הנה התחביר של אופרטור ההתלכדות האפסי:

איקס?? y

הנה דוגמה לאופרטור ההתאחדות האפסי בשימוש:

const שם = ריק;
const defaultName = "פלוני אלמוני";
const result_1 = שם?? defaultName;
לְנַחֵם.log (result_1); // "פלוני אלמוני"
const גיל = 0;
const defaultAge = 25;
const תוצאה_2 = גיל?? defaultAge;
לְנַחֵם.log (result_2); // 0

בדוגמה למעלה, תוצאה_1 מחזירה "ג'ון דו" כי לאופרנד הראשון היה ערך של ריק. תוצאה_2 החזרות 0 כי למרות שזה ערך שקרי, הוא לא ריק ולא לא מוגדר.

שימוש באופרטורים לוגיים בקוד שלך

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

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