הבאג הראשון שלימד אותי לכבד רוחבי סיביות היה דגל הרשאה שהמשיך לנקות את עצמו. I was ORing a bitmask into an integer column, and every so tenowly the whole field reset.The cause was breaking on there from the bits as if they lived in 32 slots, but the value had alreaded and a stray NOT somewhere upstream had flipped bits I never accounted for.I fixed it by sitting down with a calculator that showed me the actual bits at the actual width, not the tidy decimal my language printed מדריך זה עוסק בהרגל הזה, באמצעות ה מחשבון בינארי על Toolz.dev, ולמה לעשות מתמטיקה bitwise שבו אתה יכול לראות כל בסיס בבת אחת חוסך שעות של ניחוש.
TL;DR: מחשבון בינארי מבצע פעולות אריתמטיות (הוספה, חיסור, הכפלה, חלוקה) ופעולות סיביות (AND, OR, XOR, NOT, הזזות) על מספרים שלמים הכתובים בבינארי, אוקטלי, עשרוני או משושה, ומציג את התוצאה בכל ארבעת הבסיסים בבת אחת. אריתמטיקה מדויקת בכל גודל; פעולות סיביות תלויות ברוחב סיביות נבחר. ה מחשבון בינארי עושה את שניהם, לגמרי בדפדפן שלך, ומדווח על קריאות חתומות ולא חתומות לתוצאות סיביות.
מהו מחשבון בינארי?
מחשבון בינארי הוא כלי שפועל על מספרים שלמים בבסיס שני, אבל השימושיים אינם מוגבלים לבסיס שני בכלל אתה בוחר את הבסיס שאתה חושב בו, בינארי, אוקטלי, עשרוני או הקסדצימלי, הקלד את המספרים שלך, בחר פעולה וקרא את התשובה הטובים מראים את התשובה הזו בכל בסיס בו זמנית, כך שלעולם לא תריץ המרה נפרדת לשפיות - בדוק מה קיבלת.
הסיבה שזה משנה היא שעבודה ברמה נמוכה מצטלבת כל הזמן בין בסיסים צבע הוא hex, מסכת הרשאה היא בינארית בראש שלך אבל עשרונית במסד הנתונים, ערך רשת הוא אוקטלי בתצורה אחת ועשרוני במקום אחר. ביצוע המתמטיקה במקום אחד, עם כל הייצוגים גלויים, מסיר מחלקה שלמה של טעויות תמלול. אתה לא מעתיק ערך hex למחשבון עשרוני ומקווה שהמרת אותו נכון קודם.
על Toolz.dev הזרימה קצרה בחרו את בסיס הקלט הקלידו את הערך הראשון בחרו פעולה הקלידו את הערך השני התוצאה מופיעה בבינארי, אוקטלי, עשרוני, ומשושה יחד, ולפעולות bitwise היא מציגה גם את הקריאה החתומה ואת פריסת הסיביות ברוחב שבחרת.
באילו פעולות הוא תומך?
שתי משפחות, ולשמור אותם ישר זה כל המשחק הפעולות האריתמטיות הן הוספה, חיסור, כפל, חלוקה, ומודולו אלה פועלים על הערך המספרי האמיתי, כך שהם מתנהגים כמו מתמטיקה רגילה ולא אכפת להם מרוחב סיביות חלוקה מחזירה את המנה של המספרים השלמים ומדווחת על כל שארית, ומודולו מחזירה רק את השארית, שהיא ההבחנה שאנשים מקבלים לרוב לאחור.
הפעולות בסיביות הן AND, OR, XOR, NAND, NOR, XNOR, NOT, וההזזות שמאלה וימינה. אלה פועלים על הסיביות הגולמיות בתוך אוגר קבוע, כך שהתשובה שלהם תלויה לחלוטין במידת הרוחב של האוגר הזה. AND, OR ו-XOR הם שלושת היומיום: AND מסווה ביטים, OR מפעיל ביטים, XOR מחליף אותם. הצורות שנשללו, NAND, NOR ו-XNOR, הן המשלימות שלהן ברוחב. לא מתהפך כל סיביות. ההזזות מזיזות את כל התבנית שמאלה או ימינה במספר מיקומים, ומפילות את הביטים שנופלים מהקצה.
הנה המודל המנטלי המהיר שבו אני משתמש כשאני מחליט באיזה מהם אני רוצה:
| מבצע | סמל | משפחה | שימוש אופייני |
|---|---|---|---|
| הוסף / הפחת | + / - | אריתמטיקה | מתמטיקה רגילה של מספרים שלמים, בכל גודל |
| הכפל / חלק | × / ÷ | אריתמטיקה | החטיבה מדווחת על מנה ושארית |
| מודולו | mod | אריתמטיקה | השאר בלבד, למשל אינדקס עוטף |
| ו | & | Bitwise | מסיכה מנותקת, בדוק דגל |
| או | | | Bitwise | הגדר דגלים, שלב מסכות |
| XOR | ^ | Bitwise | החלף ביטים, זוגיות זולה והחלפות |
| לא | ~ | Bitwise | הפוך כל סיביות ברוחב |
| העבר שמאלה / ימינה | << / >> | Bitwise | הכפל או חלק בחזקות של שניים, חבילת שדות |
למה אני צריך לבחור קצת רוחב?
זו השאלה שמעבירה את כולם חדשים למתמטיקה של סיביות, והיא זו שהמחשבון הכי דעתן עליה. לאריתמטיקה יש תשובה ברורה לא משנה הגודל: חמש ועוד שלוש זה שמונה בין אם אתה מדמיין את זה בבייט או במילה של 64 סיביות. אבל מבחינה סיביות אין תשובה כלל עד שאתה יודע כמה ביטים קיימים. לא של חמש זה " flip every bit," והתוצאה תלויה אם יש שמונה ביטים או שישים וארבע להעיף.
להזזות יש את אותה תלות מהכיוון השני העבר ערך שמאלה מספיק רחוק וביטים צועדים מהקצה העליון האם הם נעלמים או עוטפים תלוי בגודל האוגר סוג מספר שלם ברוחב קבוע ב-C, Java, Go או Rust עונה על כך על ידי הגדרת הרוחב מלפנים: א uint8 הוא שמונה ביטים, א uint32 האם שלושים ושתיים, וכל פעולה ביטבית מתרחשת בתוך התיבה הזו. המחשבון משקף את זה בדיוק בכך שהוא מאפשר לך לבחור 8, 16, 32 או 64 סיביות, כך שהתוצאה תואמת את מה שהקוד האמיתי שלך יפיק ולא הפשטה אידיאלית ברוחב אינסופי.
בחירת רוחב שגוי אינה שגיאת עיגול, היא תשובה שונה NOT של חמש הוא 250 בשמונה סיביות ו 4294967290 בשלושים ושתיים שניהם נכונים לרוחב שלהם, ואף אחד מהם אינו נכון לשני להיכנס להרגל של הגדרת הרוחב כך שיתאים לסוג הנתונים שלך הוא הדיסציפלינה השימושית ביותר היחידה שכלי זה מעודד.
כיצד מופיעים שני 's משלימים בתוצאות?
כמעט כל מעבד מייצג מספרים שלמים חתומים באמצעות two's משלימים, והמחשבון עוקב אחר אותה מוסכמה כך שהפלט שלו תואם את החומרה שלך. ב-two's משלים, הסיבית העליונה של האוגר נושאת משקל שלילי, כך שתבנית שמונה סיביות של 11111010 נקראת כ-250 אם אתה מתייחס אליה כלא חתומה, או כ- –6 אם אתה קורא את הסיבית העליונה כסימן.
זו הסיבה שהכלי מדווח על שתי הקריאות לתוצאה של סיביות כאשר אתה מפעיל לא על חמש מתוך שמונה סיביות, אתה מקבל את תבנית הסיביות 11111010 המחשבון מציג את הערך הלא חתום 250, הערך החתום –6 והפריסה הבינארית, כך שתוכל לראות שהם אותם סיביות מתפרשים בשתי דרכים. קריאה כפולה זו בדיוק מה שאתה צריך כאשר ערך חוצה בין סוג חתום לסוג לא חתום בקוד שלך, שהוא מקור קלאסי של " בלתי אפשרי" מספרים המופיעים ביומנים.
תוצאות אריתמטיות עוקבות אחר אותו כלל כשהן הופכות לשליליות. הפחת שתים עשרה מחמש והתשובה האמיתית היא -7, שהמחשבון מציג בעשרוניות עם סימן מינוס, בעוד שהצורות הבינאריות, האוקטליות והמשושות שלו משתמשות בתבנית המשלימה של שני 's ברוחב שבחרת, 11111001 בשמונה סיביות. לראות את הערך השלילי ואת תבנית הסיביות שלו זה לצד זה הוא איך הרעיון המופשט של " הסימן הוא רק הסיביות והמרכאות העליונות; לבסוף לוחץ.
איך אני מוסיף או מוריד מספרים בינאריים ביד, ובודק את זה כאן?
חיבור בינארי עוקב אחר אותם כללי נשיאה כמו עשרוני, עם אלפבית קטן יותר אפס פלוס אפס הוא אפס, אפס פלוס אחד הוא אחד, אחד פלוס אחד הוא אפס נשא אחד, ואחד פלוס אחד פלוס נשיאה הוא אחד נשא אחד אז 1010 פלוס 1100 עובד עמודה אחר עמודה מימין: 0+0 הוא 0, 1+0 הוא 1, 0+1 הוא 1, 1+1 הוא 0 נשא 1, והנשיאה הופכת לסיבית המובילה, ונותנת 10110, שהוא 22 בעשרוני. ניקוב זה לתוך המחשבון מאשר את זה בכל בסיס בבת אחת, וכך אני בודק את אריתמטיקה היד שלי כשאני לומד אותו מחדש לראיון או מלמד אותו למישהו.
חיסור הוא המקום שבו שני's משלים מרוויח את השמירה שלו. במקום לשאול על פני עמודות, מחשבים מחסירים על ידי הוספת השלילי, והשלילי נוצר על ידי היפוך הסיביות והוספת אחת. לעתים רחוקות אתה צריך לעשות זאת ביד, אבל זה מסביר מדוע המחשבון יכול להחסיר לטריטוריה שלילית בצורה נקייה: 5 מינוס 12 הופך ל-5 פלוס שני 's-השלמה של 12, והתוצאה היא תבנית −7 שתוארה לעיל. אם אתה רוצה להעביר ערך בודד בין בסיסים מבלי לעשות עליו מתמטיקה, ה ממיר בסיס מספרים הוא הכלי הנלווה, וה מתרגם בינארי מטפל במקרה שבו אתה הופך טקסט לביטים במקום לעשות חשבון.
מתי פעולות סיביות חשובות למעשה?
לעתים קרובות יותר ממה שמתחילים מצפים, ובמקומות שאינם ברורים "low level." מערכות הרשאות הן המקרה הקלאסי: קבוצה של דגלים ארוזים במספר שלם אחד, שבו אתה או כדי להעניק הרשאה, ועם השלמה כדי לבטל אותה, ו - AND כדי לבדוק אחד. feature toggles, מצבי קובץ Unix ומפות רישום חומרה כולם משתמשים באותו דפוס אם אי פעם ראית ערך כמו 0o755 או קבוע המוגדר כ 1 << 3, פגשת קצת אריזה.
XOR מופיע בטריקים זולים ובאלגוריתמים אמיתיים כאחד: החלפת קצת, זוגיות מחשוב והחלפה-ללא-טמפ' הקלאסית. משמרות מכפילות ומחלקות בחזקות של שתיים הרבה יותר מהר מהכפל הכללי, והן אורזות כמה שדות קטנים למילה אחת, וכך ערכי צבע, כותרות רשת ופורמטים קומפקטיים של סדרה נשארים קטנים. פגעתי באלה כל הזמן בונים על פני המחסנית, מ-API של Laravel המאחסן דגלי תפקידים כמסכת סיביות ועד לקנבס של React שקורא RGBA מתוך מספר שלם ארוז. הבנת הפעולות היא השקעה קטנה שמחזירה בכל מקום, וכתבתי על איך אלה מתאימים לערכה רחבה יותר ב- כלי פרודוקטיביות למפתחים חתיכה.
הכשלים העדינים הם מה שהופך מחשבון גלוי לשווה שימוש מסכה המוחלת ברוחב הלא נכון שומרת בשקט או מפילה ביטים שלא התכוונתם אליהם תזוזה שהניחה ש-32 ביטים מתנהגים אחרת ב-64 ערך חתום ANDed מול מסכה לא חתומה מייצרת מספר שנראה בלתי אפשרי עד שרואים את שני 's-סיביות משלימות צפייה בפריסת הסיביות משתנה תוך כדי התאמת הרוחב הופכת את הבאגים האלה ממסתורין לטעויות ברורות.
יש כאן זווית הוראה גם כן כשאני מסביר מסכות סיביות למישהו חדש, מספרים עשרוניים הם חסרי תועלת: 12 ו-10 להיות 8 לא אומר כלום עד שאתה מסדר 1100 ו-1010 וצופה ב-AND שומר רק את העמודה שבה שניהם 1. מכיוון שהמחשבון מציג את הפריסה הבינארית לצד העשרוני, האוקטלי והמשושה, הוא עושה את היישור הזה עבורך, והפעולה מפסיקה להיות כלל לשנן והופכת למשהו שאתה יכול לראות אותו הדבר נכון לגבי משמרות, כאשר מראה שהזזה שמאלה באחד מכפילה את הערך תוך החלקה של כל סיביות עמודה אחת שמאלה מחברת את המשמעות האריתמטית למכונאי ברמת הסיביות באופן שמספר בודד לעולם לא יכול.
מהם הגבולות, והאם הנתונים שלי פרטיים?
לצד האריתמטי אין למעשה מגבלת גודל המחשבון משתמש ב-JavaScript's BigInt, סוג מספר שלם בעל דיוק שרירותי המתוקנן ב ECMAScript, אז הוספה או הכפלה של מספרים עם עשרות ספרות נשארת מדויקת ללא הצפה שקטה. זהו יתרון אמיתי על פני מחשבונים הבנויים על מספרי נקודה צפה רגילים, אשר מאבדים דיוק מעבר לחמש עשרה ספרות ואינם יכולים לייצג מספרים שלמים גדולים בדיוק בכלל.
הצד הסיבי מוגבל בכוונה על ידי הרוחב שתבחר, כי זו הנקודה: פעולת רוחב קבוע הגיונית רק בתוך אוגר קבוע. אם אתה מזין ערך גדול ממה שהרוחב יכול להחזיק, המחשבון מקטין אותו לרוחב הזה ומזהיר אותך, כך שקטע לעולם לא קורה בשקט. משמרות מוגבלות למקסימום שפוי כך שכמות משמרת בורחת לא יכולה לתלות את הדף.
על פרטיות, הכל פועל בדפדפן שלך שום דבר שאתה מקליד לא מועלה, נרשם או מאוחסן, והכלי ממשיך לעבוד אם אתה מתנתק מהאינטרנט לאחר טעינת הדף. זה חשוב יותר ממה שזה נשמע: הערכים שאנשים מריצים דרך מחשבון סיביות הם לעתים קרובות מסכות הרשאות, אסימונים או כתובות חומרה ממערכות שהם מעדיפים לא להדביק בשרת שהם לא שולטים בהם. אם אכפת לך אילו כלים שומרים את הנתונים שלך במחשב שלך, ה פרטיות נתונים בכלים מקוונים המדריך מכסה כיצד להבחין בין כלים בצד הלקוח לבין כלים שמתקשרים הביתה. לעבודה ברמה נמוכה שכנה, ה ממיר IEEE 754 וה שולחן ASCII לעגל את הסט.
שאלות נפוצות
איך אני מוסיף שני מספרים בינאריים?
הגדר את בסיס הקלט לבינארי, הקלד את המספר הראשון, בחר הוסף, הקלד את המספר השני וקרא את התוצאה. לדוגמה, 1010 פלוס 1100 הוא 10110, שהכלי מציג גם כ-22 בעשרוני, 26 באוקטלי ו-16 בהקסוס. האריתמטיקה מדויקת בכל אורך.
מה ההבדל בין פעולות אריתמטיות וביטיות?
פעולות אריתמטיות (הוספה, חיסור, הכפלה, חלוקה, מודולו) פועלות על הערך המספרי האמיתי ואינן תלויות ברוחב הסיביות פעולות Bitwise (AND, OR, XOR, NOT והזזות) פועלות על הסיביות הגולמיות בתוך אוגר ברוחב קבוע, כך שהתוצאה שלהן תלויה אם תבחר 8, 16, 32 או 64 סיביות.
למה אני צריך לבחור קצת רוחב?
לפעולות NOT ו-shift יש תשובה מוגדרת רק לאחר שגודל האוגר ידוע, מכיוון שהן תלויות באילו ביטים קיימים ובאילו נופלים מהסוף. בחירה ב-8, 16, 32 או 64 סיביות גורמת למחשבון להתאים לאופן שבו סוג מספר שלם ספציפי מתנהג בשפת תכנות אמיתית.
כיצד מטפל המחשבון בתוצאות שליליות?
תוצאות אריתמטיות שליליות מוצגות עם סימן מינוס בעשרוני, והצורות הבינאריות, האוקטליות והמשושה שלהן משתמשות בשני 's-השלמה ברוחב הנבחר. לתוצאות סיביות, הכלי מדווח הן על הערך הלא חתום והן על הערך המסומן 's-השלמה.
האם אני יכול לערבב בסיסים, כמו הוספת מספר משושה למספר עשרוני?
שני האופרנדים נקראים בבסיס הבודד שתבחר, כך שלא תוכל לערבב בסיסים בחישוב אחד כדי לשלב ערך משושה ועשרוני, תחילה המר אחד מהם, ולאחר מכן הזן את שניהם באותו בסיס התוצאה מוצגת תמיד בכל ארבעת הבסיסים.
מה עושה המחשבון כשאני מחלק?
חלוקה מחזירה את המנה השלמה, ואם החלוקה אינה מדויקת הכלי מדווח על השאר כהערה. כדי לקבל את השארית בעצמה, השתמש במקום זאת בפעולת Modulo, שמחזירה רק את השארית.
כמה גדולים יכולים להיות המספרים?
אריתמטיקה משתמשת ב-JavaScript BigInt, כך שמספרים עם עשרות רבות של ספרות מטופלים בדיוק ללא הצפה. פעולות Bitwise מוגבלות ברוחב הנבחר; ערכים שחורגים ממנו מצטמצמים לרוחב הזה, והכלי מזהיר אותך כשזה קורה.
האם הנתונים שלי נשלחים לכל מקום?
מס 'כל חישוב פועל כמו JavaScript בדפדפן שלך שום דבר שאתה מקליד מועבר, נרשם, או מאוחסן, והכלי ממשיך לעבוד אם אתה מתנתק מהאינטרנט לאחר טעינת הדף.
נסה את המתמטיקה בעצמך עם החינם מחשבון בינארי. הוא מטפל בפעולות אריתמטיות וביטיות על פני בינארי, אוקטלי, עשרוני ומשושה, כולו בדפדפן שלך, בלי שום דבר שהועלה.
