הבנת מפעילי Bitwise ב-JavaScript

אופרטורים Bitwise הם אלה שפועלים ברמה בינארית. לרוב הם מהירים מאוד לביצוע ובדרך כלל פועלים על שני אופרנדים.

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

מה הם מפעילים?

רוב שפות התכנות משתמשות במושג "מפעיל" - סמל שאומר למתורגמן לבצע פעולה מתמטית, התייחסותית או לוגית ספציפית.

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

אופרטור Bitwise AND (&).

ה-JavaScript bitwise AND (&) האופרטור משווה את הביטים התואמים של שניים אופרנדים בינאריים - מספרים המכילים רק 0 ו-1. עבור כל זוג סיביות קלט, סיבית הפלט המתאימה היא "1" אם שני סיביות הקלט הן "1" או "0" אחרת.

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

a & b

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

כך פועל האופרטור AND bitwise:

1. פעולת ה-AND חלה על כל זוג ביטים תואמים ב א ו ב מימין לשמאל.
2. אם שתי הסיביות הן 1, התוצאה היא 1. אם כל ביט הוא 0, התוצאה היא 0.
3. התוצאה היא מספר חדש שבו כל סיביות מייצגות את התוצאה של פעולת ה-AND על הסיביות התואמות של א ו ב.

לדוגמה:

לתת א = 50; // 00110010
לתת ב = 100; // 01100100
לתת תוצאה = a & b; // 00100000
לְנַחֵם.log (תוצאה); // 32

בדוגמה למעלה, א הוא 50 בעשרוני, שווה ערך למספר הבינארי 00110010, ו ב הוא 100 בעשרוני, שווה ערך למספר הבינארי 01100100. האופרטור AND משווה כל זוג ביטים תואמים מימין לשמאל ומפיק את המספר הבינארי המתקבל 00100000, שהוא 32 בעשרוני.

אופרטור Bitwise OR (|).

OR (|) האופרטור משווה את הביטים התואמים של שני אופרנדים ומחזיר "1" אם אחד או שניהם הם "1" ו- "0" אם שני הביטים הם "0".

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

א | ב

איפה א ו ב הם האופרנדים של הפעולה.

האופרטור OR (|) בכיוון סיביות פועל באותה צורה כמו האופרטור AND בכיוון סיביות. ההבדל היחיד הוא האופרטור OR מחזיר "1" אם "כל אחד" מהסיביות הוא "1" ו-"0" אם "שני הסיביות" הם "0".

לדוגמה:

לתת א = 50; // 00110010
לתת ב = 100; // 01100100
לתת תוצאה = א | ב; // 01110110
לְנַחֵם.log (תוצאה); // 118

בדוגמה שלמעלה, אופרטור ה-OR בשיטת סיביות משווה כל זוג ביטים מימין לשמאל (כלומר, 0 | 0 = 0, 0 | 1 = 1, 1 | 1 = 1, וכולי). המספר הבינארי המתקבל הוא 01110110, שהוא 118 בעשרוני.

אופרטור XOR (^) ביטוויזי

XOR (^אופרטור ) משווה את הביטים התואמים של שני אופרנדים ומחזיר "1" אם אחד מהאופרנדים אבל לא שניהם הוא "1" ו-"0" אם שני האופרנדים הם "1" או "0".

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

א ^ ב

איפה א ו ב הם האופרנדים של הפעולה.

האופרטור XOR בשיטת סיביות פועל באותה צורה כמו האופרטורים OR ו- AND. ההבדל היחיד הוא שהוא מחזיר "1" אם "אחד אבל לא שניהם" מהאופרנדים הוא "1" ו-"0" אם "שניהם" מהאופרנדים הם "1" או "0".

לדוגמה:

לתת א = 50; // 00110010
לתת ב = 100; // 01100100
לתת תוצאה = a ^ b; // 01010110
לְנַחֵם.log (תוצאה); // 86

בדוגמה שלמעלה, האופרטור XOR משווה כל זוג ביטים מימין לשמאל (כלומר, 0 ^ 0 = 0, 0 ^ 1 = 1, 1 ^ 1 = 0, וכולי). המספר הבינארי המתקבל הוא 01010110, שהוא 86 בעשרוני.

Bitwise NOT (~) מפעיל

ה- NOT (~אופרטור ) הוא אופרטור אונרי הפועל על מספר שלם בודד על ידי היפוך כל הביטים שלו. במילים אחרות, הוא משתנה כל סיביות "0" ל-"1" וכל סיביות "1" ל-"0".

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

~ ג

איפה ג הוא האופרנד.

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

לדוגמה:

לתת c = 10; // 00001010
לתת ד = -10; // 11110110 
לְנַחֵם.log(~c); // 11110101
לְנַחֵם.log(~d); // 00001001

בדוגמה שלמעלה, האופרטור NOT הופך את כל הביטים (כלומר, 0 → 1, 1 → 0וכו'), כולל פיסות השלטים.

מפעיל Shift שמאלה (<

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

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

a << ב

איפה א הוא האופרנד עבור מפעיל המשמרת השמאלית, ו ב הוא מספר הביטים שהאופרטור יעביר את האופרנד לפיו.

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

לדוגמה:

לתת א = 50; // 00110010
לתת ב = 2;
לתת תוצאה = a << b; // 11001000
לְנַחֵם.log (תוצאה); // 200

בדוגמה למעלה, אופרטור המשמרת השמאלי העביר את ה-50 העשרוני של 00110010 הבינארי בשני מקומות. הערך הבינארי המתקבל הוא 11001000, שהוא 200 כעשרוני.

אופרטור הילוך ימני (>>) המפיץ סימן

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

להלן התחביר לאופרטור ההזזה ימינה המפיץ סימן:

א >> ב

איפה א הוא האופרנד למפעיל המשמרת הימני, ו ב הוא מספר הביטים שהאופרטור יעביר את האופרנד לפיו.

האופרטור המשמרת ימני המפיץ סימן פועל בדומה לאופרטור המשמרת השמאלית; ההבדל היחיד במצב הפעולה הוא שההזזה הימנית שומרת על השלט.

לדוגמה:

לתת א = -50; // 11001110
לתת ב = 2;
לתת תוצאה = a >> b; // 11110011
לְנַחֵם.log (תוצאה); // -13

בדוגמה שלמעלה, אופרטור ההזזה הימני העביר את העשרוני -50 (11001110) שני רווחים ימינה וכתוצאה מכך העשרוני -13 (11110011).

מפעיל Shift לא חתום (>>>).

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

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

א >>> ב

איפה א הוא האופרנד למפעיל המשמרת הימני, ו ב הוא מספר הביטים שהאופרטור יעביר את האופרנד לפיו.

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

לדוגמה:

לתת א = -5; // 11111111 11111111 11111111 11111011
לתת ב = 2;
לתת תוצאה = a >>> b; // 00111111 11111111 11111111 11111110
לְנַחֵם.log (תוצאה); // 1073741822

בדוגמה זו, אופרטור ההזזה ימינה ללא סימן העביר את "-5" שני רווחים ימינה, למעשה הסיר את הסימן והביא לסימן העשרוני "1073741822".

היישומים של מפעילי Bitwise

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

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