בפעם הראשונה המרה בסיס עלה לי ערב עבודה, האשם היה באג הרשאות. סקריפט פריסה כתב מצבי קובץ כ chmod 755, ומטעין תצורה קרא את אותו ערך מתוך קובץ JSON כמו המספר 755. ל-JSON אין מילולי אוקטלי. המעמיס עבר 755 ל-syscall שציפה למצב אוקטלי, המצב התפרש כעשרוני 755, ועשרוני 755 בבינארי הוא 1011110011- עשר פיסות שטויות בשדה של תשע סיביות. קבצים הגיעו בסופו של דבר עם הרשאות שאף אחד לא ביקש ואף אחד לא יכול היה להסביר.
כך נראה בלבול בסיס בפועל. זו כמעט אף פעם לא בעיה מתמטית קשה. זהו ערך שנכון בסימון אחד וקטסטרופלי באחר, נע על פני גבול שבו אף אחד לא רשם לאיזה בסיס נועד. בינארי, אוקטלי, עשרוני והקסדצימלי הן ארבע דרכים לכתוב את אותו מספר שלם, ומחשב יאפשר לך בשמחה לערבב אותם.
אז בניתי את ממיר בסיס מספרים על Toolz.dev להיות הדבר שאליו אני בעצם מושיט יד באותו רגע: להדביק ערך, להגיד באיזה בסיס הוא נמצא, ולראות אותו בכל בסיס אחר בבת אחת - יחד עם ספירת הסיביות, ספירת הבתים והבינארי המונח בנשנושים כך שהוא מתיישר עם ספרות המשושה שמעליו הוא מטפל בכל רדיוס מ-2 עד 36, הוא מקבל 0x, 0b, ו 0o קידומות, והוא עושה את כל החשבון שלו ב-BigInt, כך ש-hash של 256 סיביות הופך בדיוק במקום לעגל בשקט לאשפה.
TL;DR: ערך מספר 's לעולם אינו משתנה כאשר אתה ממיר אותו - רק הסימון עושה זאת. ה ממיר בסיס מספרים ממיר מספרים שלמים בין כל בסיסים מ-2 עד 36, מציג בינארי, אוקטלי, עשרוני והקסדצימלי בו-זמנית, מדווח על אורך סיביות ובייט, משתמש ב-BigInt כך שהדיוק מתקיים בכל גודל ופועל כולו בדפדפן שלך.
תכונות מפתח
כל בסיס מ-2 עד 36
בינארי, אוקטלי, עשרוני והקסדצימלי מקבלים כפתורי קיצור ייעודיים מכיוון שהם הארבעה המופיעים בקוד אמיתי. אבל התוספות של המקור והיעד פועלות בכל הטווח מבסיס 2 לבסיס 36 - התקרה היא הנקודה שבה נגמרים לך האלפאנומריות חסרות האותיות (עשר ספרות ועוד עשרים ושש אותיות). בסיס 3, בסיס 12, בסיס 20, בסיס 32 ובסיס 36 נמצאים כולם במרחק קליק אחד, וכל אחד מהם מוצג עם התקן 0-9A-Z אלפבית ספרתי.
חשבון BIGINT מדויק
זוהי התכונה החשובה ביותר ומופיעה הכי פחות בעותק שיווקי מספרי JavaScript הם IEEE-754 כפולים, והם מייצגים מספרים שלמים בדיוק רק עד 2^53 - 1, שזה 9,007,199,254,740,991. עבר את זה, parseInt ו Number התחל לעגל - בשקט, ללא שגיאה, לייצר ערך שנראה סביר ושגוי רוב ממירי הבסיס ברשת בנויים בדיוק על הפונקציות האלה.
זה מנתח ספרה אחר ספרה לתוך מצבר BigInt (value = value * base + digit) ומציג חזרה על ידי חלוקה חוזרת אין תקרת דיוק מזהה 64 סיביות, גיבוב של 256 סיביות, מודול RSA, עשרוני בן 500 ספרות - כולם ממירים בדיוק.
כל הבסיסים בבת אחת
קלט אחד, ארבע יציאות, בשידור חי החלונית מציגה בינארי, אוקטלי, עשרוני והקסדצימלי בו זמנית, בתוספת הבסיס המותאם אישית שבחרת אם הוא לא אחד מאותם ארבעה רוב המרות הבסיס הן באמת בדיקות צולבות - אתה רוצה לאשר שהמשושה ב-debugger שלך והעשרוני בשורת היומן שלך הם אותו מספר - ולראות את כל הארבעה בבת אחת הופך משימה בת שלושה שלבים למבט חטוף.
אורך סיביות, אורך בתים וקיבוץ נשנושים
הסיבה שאנשים ממירים לבינארי היא בדרך כלל לא סקרנות לגבי הסיביות, זו שאלת גודל: האם זה מתאים לבייט, ב-int של 32 סיביות, בקיצור חתום? אז הממיר מדווח על אורך הסיביות המשמעותי (255 → 8 סיביות, 256 → 9 סיביות) ואורך הבתים מעוגל כלפי מעלה הפלט הבינארי מרופד למספר שלם של נשנושים ומקובץ ברביעיות, כך שכל קבוצה של ארבע סיביות יושבת ישירות מתחת לספרה המשושה שהיא מקודדת.
קלט סלחן, שגיאות מדויקות
ערכים מהעולם האמיתי מגיעים עם קישוט. 0xDEADBEEF מתוך עקבות מחסנית, 0b1010_1111 מתוך חלודה מילולית, 0o755 מ-chmod, FF FF FF מועתק מתוך עורך hex. כל זה מתקבל: קידומות מופשטות כשהן מתאימות לבסיס שנבחר, ומתייחסים לקווים תחתונים ולרווחים כמפרידי ספרות.
כאשר ספרה אינה חוקית עבור הבסיס שבחרת, השגיאה נותנת לה שמות. סוּג 1092 בבסיס 8 ומקבלים "9" is not valid in base 8. Base 8 uses 0-7.- לא " קלט" לא חוקי;, שלא אומר לך כלום על איזו דמות ללכת להסתכל.
תמיכה במספר שלילי
ערכים שליליים ממירים ומעבדים עם סימן מינוס מוביל. זו סימון בגודל סימן, וזו התשובה הכנה, מסיבות המכוסות בסעיף המשלים של שני 's למטה.
פועל כולו בדפדפן שלך
אין נסיעה הלוך ושוב ברשת, אין העלאה, אין רישום התוצאה מתעדכנת בכל הקשה מכיוון שהחשבון מתרחש במרחק של כמה מיקרו שניות, והדף ממשיך לעבוד ללא חיבור כלל לאחר טעינתו.
כיצד להשתמש בממיר בסיס המספרים
שלב 1: הזן את המספר שלך
הקלד או הדבק את הערך בשדה From. אתה לא צריך להפשיט קישוט קודם - 0xFF, 0b1010, 0o755, 1010_1111, ו DE AD BE EF כולם מתקבלים. leading + ו - סימנים עובדים אפסים מובילים אינם מזיקים.
שלב 2: בחר את בסיס המקור
אמור לממיר כיצד לקרוא את מה שהקלדת זהו הצעד שאנשים מדלגים עליו, והוא זה שחשוב: 101 הוא 5 בבינארי, 65 באוקטלי, 101 בעשרוני ו-257 בהקסדצימלי. ארבעה מספרים שונים, מחרוזת תווים אחת. כפתורי הקיצור מכסים בינארי, אוקטלי, עשרוני ומשושה; הנפתח מכסה הכל מ-2 עד 36.
אם בסיס המקור אינו יכול לקרוא תו שהקלדת, אתה מקבל הודעה ששמה את התו הזה ולא תשובה שגויה שקטה.
שלב 3: בחר את בסיס היעד
בחר את הבסיס שאתה רוצה לצאת התוצאה מופיעה מיד ומתעדכנת תוך כדי הקלדה - אין כפתור המרה, כי אין שרת לחכות לחצן ההחלפה הופך את הכיוון ומזיז את התוצאה לתוך הקלט, שזו הדרך המהירה ביותר הלוך ושוב ערך ולאשר שהוא שורד.
שלב 4: קרא את הלוחות
מתחת להמרה שאתה מקבל:
- כל הבסיסים בבת אחת- אותו ערך בבינארי, אוקטלי, עשרוני והקסדצימלי, בתוספת הבסיס המותאם אישית שלך אם בחרת אחד.
- אורך סיביות, אורך בתים, ספרות משושה- מספרי המידות.
- בינארי מקובץ- הביטים מרופדים ומפוצלים לנשנושים, מיושרים עם ספרות המשושה.
שלב 5: העתק
העתק את התוצאה החשופה, או העתק את הביטוי המלא (255 (base 10) = FF (base 16)) כאשר אתה רוצה שההמרה תהיה תיעוד עצמי בהודעת commit, הערת קוד או דוח באג האפשרות השנייה היא זו שבה אתה מסביר מספר למישהו אחר, מכיוון שהיא נושאת את הבסיס יחד עם הספרות.
איך סימון מיקום עובד בפועל
כל בסיס שאנו משתמשים בו הוא א מיקום מערכת, שמשמעותה ספרה's תרומה תלויה במקום שבו היא יושבת. בבסיס b, הספרה במיקום i (ספירה מאפס מימין) שווה digit × b^i. הכלל היחיד הזה מייצר כל בסיס.
קח 1,234 בעשרוני:
1×10³ + 2×10² + 3×10¹ + 4×10⁰ = 1000 + 200 + 30 + 4 = 1234
עכשיו קח 1A3 בהקסדצימלי, כאשר A הוא 10:
1×16² + 10×16¹ + 3×16⁰ = 256 + 160 + 3 = 419
אותו כלל, בסיס שונה. ו 10101111 בבינארי:
1×2⁷ + 0 + 1×2⁵ + 0 + 1×2³ + 1×2² + 1×2¹ + 1×2⁰ = 128 + 32 + 8 + 4 + 2 + 1 = 175
שני האלגוריתמים שנופלים מכלל זה הם הממיר כולו:
קריאת מספר בבסיס ב הוא קיפול משמאל לימין התחל באפס, ולכל ספרה: value = value × b + digit. זוהי שיטת Horner's, וזו הסיבה שהממיר לעולם לא צריך לחשב b^i במפורש - ללא אקספוננציה, ללא נקודה צפה, ללא שגיאה מצטברת.
כתיבת ערך בבסיס c חוזרת חלוקה מחלקים ב c, שומרים את השארית בתור הספרה הבאה (מימין), חוזרים עם המנה עד שהיא מגיעה לאפס השאריות, קוראים לאחור, הן הספרות.
שתי הפעולות מדויקות על מספרים שלמים, וזו הסיבה שביצוען ב-BigInt נותן לך המרה ללא עיגול בשום מקום בצנרת הערך 123456789012345678901234567890 ממיר ל-hex as 18EE90FF6C373E0EE4E3F0AD2- 97 סיביות, 13 בתים - וממיר חזרה בדיוק לעשרוני שהתחלת איתו נסה את זה בממיר בנוי על parseInt.
יש פרט אחד ראוי לציון על האלפבית ספרתי בסיס 36 הוא התקרה המעשית כי זה הבסיס האחרון שאתה יכול לכתוב עם אלפאנומרי ASCII לא רגיש רישיות: 0-9 נותן לך עשר ספרות, A-Z נותן לך עוד עשרים ושש, ו-10 + 26 = 36. דחוף על פניו ואתה צריך רגישות רישיות (בסיס 62) או אלפבית סמלים (בסיס 64), ובשלב זה אתה כבר לא עושה סימון אריתמטי - אתה עושה בינארי -קידוד לטקסט, שזו עבודה אחרת עם כללים שונים אם זה מה שאתה באמת צריך, השתמש ב ממיר Base64 במקום.
מדוע מפות הקסדצימליות כל כך נקיות לבינארי
הקס לא פופולרי בתכנות כי הוא קומפקטי בסיס 10 יותר קומפקטי מבסיס 16 לאותו ערך מבחינת היכרות אנושית, ואם קומפקטיות הייתה המטרה היינו משתמשים בבסיס 36. הקס ניצח מסיבה מבנית אחת: 16 זה 24.
כלומר ספרה הקסדצימלית אחת מקודדת בדיוק ארבע ספרות בינאריות - נשנוש אחד - ללא נשיאה לעולם חוצה את הגבול ביניהן המיפוי הוא טבלת חיפוש, לא פעולה אריתמטית:
| בינארי | Hex | בינארי | Hex |
|---|---|---|---|
| 0000 | 0 | 1000 | 8 |
| 0001 | 1 | 1001 | 9 |
| 0010 | 2 | 1010 | א |
| 0011 | 3 | 1011 | ב |
| 0100 | 4 | 1100 | ג |
| 0101 | 5 | 1101 | ד |
| 0110 | 6 | 1110 | E |
| 0111 | 7 | 1111 | F |
לְהַ 11111111 על ידי פיצול זה ל 1111 1111, קריאת כל נשנש מהשולחן, ושרשור: FF. אין חשבון. לְהַמֵר 0xDEADBEEF לבינארי על ידי הרחבת כל ספרה: 1101 1110 1010 1101 1011 1110 1110 1111. המבנה שורד.
כי בית הוא שמונה סיביות וספרת משושה היא ארבע, בית אחד הוא תמיד בדיוק שתי ספרות משושה. 0x00 דרך 0xFF מכסה כל בייט אפשרי, וזו הסיבה ש-hex dump, כתובות MAC, קודי צבע וכתובות זיכרון כולם כתובים ב-hex. 0xFF אומר לך במבט חטוף שאתה מסתכל על בייט אחד מלא. 255 עשרוני לא אומר לך שום דבר כזה - אתה צריך לדעת ש-255 הוא 28 - 1, ואתה צריך לעשות את אותו ריקול עבור 65535 ו-4294967295.
אוקטל עובד על אותו עיקרון עם 8 = 2³, אז ספרה אוקטלית אחת היא בדיוק שלוש סיביות. בדיוק בגלל זה הרשאות קובץ Unix הן אוקטליות: המצב הוא שלוש קבוצות של שלוש סיביות (קריאה, כתיבה, הפעלה עבור משתמש, קבוצה, אחר), ושלוש סיביות הן ספרה אוקטלית אחת. chmod 755 הוא 111 101 101- ועכשיו הספרות אומרות משהו במקום להיות מספר קסם ששיננת. זו גם הסיבה שבאג ההרשאות שלי קרה: 755 בעשרוני זה לא 755 באוקטלי, ושום דבר על המיתר 755 מכריז איזה מהם זה. ה ממיר בסיס מספרים קיים בחלקו כדי שתוכל ליישב את השאלה הזו בשלוש שניות.
Two's משלימים, ומדוע הכלי הזה משתמש בסימן מינוס
להיכנס -42 והממיר חוזר -101010. יש אנשים שמצפים 11010110 ולשקול סימן מינוס באג זה לא, ואת הסיבה שווה להבין כי זה הדבר היחיד הכי לא מובן על בינארי.
Two's משלים אינו מאפיין של מספר. זהו מאפיין של אוגר ברוחב קבוע.
לערך –1 אין ייצוג בינארי קנוני. ב-8 סיביות שני ' זה משלים רישום 11111111 (0xFF). ב-16 סיביות זה כן 0xFFFF. ב-32 סיביות, 0xFFFFFFFF. ב-64 סיביות, שש עשרה Fs. אלו אינן ארבע דרכים שונות לכתוב את אותה תבנית סיביות; הם ארבעה תבניות סיביות שונות, ואיזה מהם נכון תלוי לחלוטין ברוחב שחי בהצהרת הסוג שלך, לא במספר.
למספר שלם בעל דיוק שרירותי - שזה מה זה BigInt, ועם מה הממיר הזה עובד - אין רוחב. אז הייצוג היחיד שיש לו משמעות ללא הקשר נוסף הוא גודל סימן: סימן מינוס ואחריו הגודל 's ספרות. זה מה שאתה מקבל, וזו התשובה הכנה ולא שגויה בביטחון.
כאשר אתה לעשות צריך תבנית משלימה של שניים 's, המתכון פשוט, ואתה יכול להפעיל אותו בכלי זה:
- תחליט על הרוחב שלך,
nביטים. - לחשב
2^n + value(עםvalueשלילי). עבור –42 ב-8 סיביות: 256 - 42 = 214. - המר 214 לבסיס היעד שלך:
11010110בבינארי,D6בהקס.
קיצור הדרך המכני שאולי למדת - הפוך כל סיביות, ואז הוסף אחת - מייצר את אותה תוצאה, כי היפוך של כל n סיביות x נותן (2^n − 1) − x, והוספת אחד נותן 2^n − x. הזהות האריתמטית היא אותה פעולה; גרסת היפוך הסיביות היא בדיוק איך אתה עושה את זה בלי מחלק.
הפניה מהירה לרוחבים שאנשים משתמשים בהם בפועל:
| רוחב | טווח (חתום) | -1 בהקס | הערך השלילי ביותר |
|---|---|---|---|
| 8 סיביות | -128 עד 127 | FF |
80 (–128) |
| 16 סיביות | −32,768 עד 32,767 | FFFF |
8000 |
| 32 סיביות | −2,147,483,648 עד 2,147,483,647 | FFFFFFFF |
80000000 |
| 64 סיביות | ±9.22 × 10¹8 | FFFFFFFFFFFFFFFF |
8000000000000000 |
שימו לב לאסימטריה בכל שורה: יש ערך שלילי אחד יותר מאשר חיובי, כי אפס תופס חריץ בצד החיובי. זה המקור של באג ההצפה הקלאסי שבו שלילת המספר השלם השלילי ביותר מחזירה את עצמה. אם אתה רוצה לראות את הסיביות של ערך או מחרוזת מונחים ישירות, ה מתרגם בינארי הוא הכלי הנלווה לכך.
בשביל מה בסיס 36?
בסיס 36 נראה כמו קוריוז והוא למעשה השימושי ביותר מבין "exotic" בסיסים, מסיבה אחת: זהו סימון המספרים הצפוף ביותר ששורד את קיפול המקרים, הקלדה על ידי אדם ונפילה לכתובת URL מבלי לברוח.
השווה את אותו ערך של 64 סיביות על פני בסיסים:
| בסיס | ספרות הדרושות לערך של 64 סיביות | דוגמה |
|---|---|---|
| בינארי (2) | 64 | 1111... |
| עשרוני (10) | 20 | 18446744073709551615 |
| הקסדצימלי (16) | 16 | FFFFFFFFFFFFFFFF |
| בסיס 36 | 13 | 3W5E11264SGSF |
| בסיס 62 | 11 | רגיש למקרה |
בסיס 36 משיג לך חיסכון של 35% מעל hex וחיסכון של 35% מעל עשרוני, תוך שימוש רק בתווים בטוחים בנתיב כתובת URL, בטוחים בשם קובץ, חד משמעי בטלפון, וזהים בין אם המשתמש מקליד אותם במכסים או לא. לכן הוא מופיע במזהי קישורים קצרים, מספרי חשבוניות, קודי קופונים, הפניות להזמנות וחותמות זמן קומפקטיות. Date.now().toString(36) הוא טריק נפוץ ליצירת מזהה קצר, ניתן למיון, שניתן להקליד על ידי אדם.
הפשרה היא קריאות: 3W5E11264SGSF הוא לא משהו שאתה יכול גלגל עין עבור מבנה כמו שאתה יכול עם hex, ואין יישור סיביות נקי כי 36 הוא לא חזקה של שתיים השתמש בבסיס 36 כאשר המספר הוא מזהה אטום והמטרה היא קומפקטיות השתמש hex כאשר המספר 's מבנה סיביות הוא הנקודה.
מקרי שימוש נפוצים
ניפוי באגים בזיכרון ו-hex dump. מאתר הבאגים שלך מראה 0x7FFE4A3C, היומן שלך מראה 2147330620, ואתה צריך לדעת אם הם אותה כתובת. Paste אחד, לקרוא את השני.
הרשאות קובץ. לְהַ 755 מאוקטלי לבינארי וראה 111 101 101, שזה בדיוק תשעת סיביות ההרשאה בסדר ששדה המצבים מגדיר אותם זו הדרך המהירה ביותר להסביר למישהו למה chmod 644 ו chmod 664 הבדל בסיבית כתיבה קבוצתית אחת.
ערכי צבע. #FF5733 הוא שלושה בתים: אדום 255, ירוק 87, כחול 51. פיצול צבע משושה למרכיביו העשרוניים הוא המרה של שתי ספרות משושה בכל פעם. עבור זרימת העבודה המלאה - פלטות, ניגודיות, המרת פורמט - ה בוחר צבעים מטפל בזה מקצה לקצה, אבל החשבון הבסיסי הוא בדיוק זה.
מסכות ביט ודגלים. שדה דגלים של 0b00101100 הוא 0x2C ועשרוני 44. כאשר אתה בודק אילו דגלים מוגדרים, בינארי הוא הצורה היחידה הניתנת לקריאה; כאשר אתה כותב את הקבוע לקוד, hex הוא. אתה צריך את שניהם, כל הזמן.
עבודת רשת ופרוטוקול. מסכות רשת משנה, כתובות MAC, קבוצות IPv6, מספרי פרוטוקול וסכומי בדיקה הם כולם משושה או בינאריים במפרט ועשרוניים במחצית הכלים. אוקטטים של כתובות IP בפרט הם עשרוניים בסימון מנוקד ובינארי ברגע שאתה נוגע במסכה.
גיבובים ומזהים. א SHA-256 הפלט הוא 64 תווים משושה - 256 סיביות, 32 בתים. המרתו לעשרוני מייצרת מספר בן 78 ספרות, וזה בדיוק המקום שבו כל ממיר נאיבי נשבר, כי הוא גדול בערך פי 10^25 מתקרת המספרים השלמים הבטוחים. אם אתה מייצר את הגיבובים האלה במקום להמיר אותם, ה מְחוּגָה מייצר אותם בצד הלקוח.
בעיות ראיונות וקורסים. המרת בסיס היא מרכיב עיקרי ביסודות CS, ויישום התייחסות המציג את הערך בכל ארבעת הבסיסים הנפוצים בו-זמנית - עם ספירת הסיביות - הופך את בדיקת העבודה שלך למהירה.
השוואת בסיס במבט חטוף
| בסיס | לִקְ | ספרות | סיביות לספרה | איפה שאתה רואה את זה |
|---|---|---|---|---|
| 2 | בינארי | 0-1 | 1 | מסכות סיביות, דגלים, אוגרי חומרה |
| 8 | אוקטל | 0-7 | 3 | הרשאות קובץ יוניקס, מילוליות C מדור קודם |
| 10 | עשרוני | 0-9 | ~3.32 | כל מה שבן אדם כותב |
| 16 | הקסדצימלי | 0-9, AF | 4 | כתובות זיכרון, צבעים, גיבובים, בתים |
| 32 | בסיס 32 | 0-9, AV | 5 | קידודים קומפקטיים ללא רישיות |
| 36 | בסיס 36 | 0-9, AZ | ~5.17 | תעודות זהות קצרות, קודי חשבונית, מספרים בטוחים לכתובת URL |
ה-"bits לכל ספרה" העמודה מסבירה את כל הטבלה. לבסיסים שהם חזקות של שתיים (2, 8, 16, 32) יש מספר שלם של סיביות לכל ספרה, מה שאומר שספרות ממפות על קבוצות סיביות ללא נשיאה שחוצה את הגבול - זה מה שהופך את hex-to-בינארי לחיפוש ולא לחישוב לבסיסים שאינם חזקות של שתיים (10, 36) יש סיביות חלקיות לכל ספרה, וזו הסיבה שהמרת עשרוני לבינארי באמת דורשת אריתמטיקה ולא ניתן לעשות זאת על ידי החלפה.
ואותה מחרוזת קלט יכולה להיות מספר חוקי במספר בסיסים עם ערכים שונים לחלוטין. 101 האם טוב לזכור:
| קרא כ | ערך |
|---|---|
| בינארי | 5 |
| אוקטל | 65 |
| עשרוני | 101 |
| הקסדצימלי | 257 |
| בסיס 36 | 1,297 |
חמישה מספרים, מחרוזת אחת הבסיס הוא לא העדפת תצוגה - הוא חלק מהנתונים, וכל באג במאמר הזה מגיע ממקום כלשהו ששכח לרשום אותו.
למבט רחב יותר על אילו כלי עזר מבוססי דפדפן כדאי לשמור בהישג יד, אספתי את אלה שאני משתמש בהם מדי יום מפתח האינטרנט's ערכת כלים.
שָׁוא
איך אני ממיר עשרוני לבינארי?
חלקו את המספר ב-2 שוב ושוב וקראו את השאריות מהאחרון לראשון. עבור 42: 42÷2 = 21 שארית 0, 21÷2 = 10 שארית 1, 10÷2 = 5 שארית 0, 5÷2 = 2 שארית 1, 2÷2 = 1 שארית 0, 1÷2 = 0 שארית 1. קריאת השאריות מלמטה למעלה נותנת 101010. הממיר מריץ את זה בחשבון BigInt, כך שהוא נשאר מדויק עבור ערכים הרבה מעבר לכל מה שמחשבון כיס יכול להחזיק.
איך אני ממיר hex לעשרוני?
להכפיל כל ספרה הקסדצימלית ב 16 מורם בחזקת המיקום שלה, לספור מאפס בצד ימין, ואז להוסיף את המוצרים.F.F. הוא (15 × 16) + 15 = 255. 1A3 הוא (1 × 256) + (10 × 16) + 3 = 419. הגדר את בסיס המקור ל 16, הדבק את הערך עם או בלי קידומת 0x, ואת העשרוני מופיע מיד.
איך אני ממיר בינארי ל-hex?
מקבצים את הספרות הבינאריות לנשנושים של ארבע, החל מימין, ומפים כל ניבל לספרת משושה אחת. 1111111 מתפצל ל-1111 ו-1111, שהם F ו-F, אז התשובה היא FF. הקיבוץ עובד כי 16 הוא 2 בחזקת רביעית, אז ספרת משושה אחת מקודדת בדיוק ארבע סיביות ואף נשיאה לא חוצה גבול קבוצתי. לכן משתמשים בהקסדצימלי עבור בתים: בית אחד הוא תמיד בדיוק שתי ספרות משושה.
מדוע מתכנתים משתמשים בהקסדצימלי במקום עשרוני?
מכיוון שהקס ממפה בצורה נקייה על בינארי ועשרוני לא. ספרת משושה אחת היא בדיוק ארבע סיביות ובית אחד הוא בדיוק שתי ספרות משושה, כך ש-0xFF הוא באופן גלוי בית מלא ו-0xDEADBEEF הוא באופן גלוי ארבעה בתים. עשרוני לא נותן לך מבנה כזה: שום דבר ב-255 לא מכריז שהוא ממלא בית. Hex שומר על פריסת הסיביות קריא תוך שהוא רבע מאורך הבינארי הגולמי.
האם הממיר הזה יכול להתמודד עם מספרים גדולים מאוד?
כן כל ערך מנותח ספרה אחר ספרה לתוך BigInt, כך שאין תקרה של 2^53 ואין עיגול נקודה צפה בכל גודל גיבוב של 256 סיביות, מודול RSA מלא או עשרוני בן 500 ספרות ממיר בדיוק ממירים הבנויים על parseInt או Number מושחתים בשקט ערכים מעל 9,007,199,254,740,991, שזה בדיוק הטווח שבו השגיאה הכי קשה לזהות.
האם הוא תומך במספרים שליליים ובשני 's משלימים?
ערכים שליליים נתמכים ומעובדים עם סימן מינוס מוביל, שהוא סימון בגודל סימן. Two's משלים לא מיושם בכוונה, מכיוון שהוא תכונה של אוגר ברוחב קבוע ולא של מספר: -1 הוא FF ב-8 סיביות, FFFF ב-16 סיביות ו-FFFFFFF ב-32 סיביות. כדי לייצר תבנית משלימה של שני 's, הוסף 2 בחזקת הרוחב שבחרת לערך השלילי והמר את התוצאה - עבור -42 ב-8 סיביות, 256 - 42 = 214, שהוא D6 ב-hex.
למה משמש בסיס 36?
בסיס 36 משתמש בספרות 0-9 ואחריהן האותיות AZ, מה שהופך אותו לסימון המספרים הצפוף ביותר שאתה יכול לבנות מאלפאנומריות ASCII חסרות רישיות. הוא מייצר מחרוזות קצרות, בטוחות לכתובת URL, חסרות רישיות, וזו הסיבה שהוא מופיע במזהי קישורים קצרים, קודי חשבוניות, קודי קופון וחותמות זמן קומפקטיות. ערך של 64 סיביות לוקח 13 תווים בסיס-36 במקום 20 ספרות עשרוניות או 16 ספרות hex.
מה המשמעות של אורך סיביות ואורך בתים?
אורך סיביות הוא מספר הסיביות המשמעותיות בערך ' גודל s, תוך התעלמות מאפסים מובילים: ל-255 יש אורך סיביות של 8 ול-256 יש אורך סיביות של 9. אורך בתים הוא הנתון הזה מעוגל כלפי מעלה לכפולה הבאה של שמונה. יחד הם אומרים לך את הסוג השלם הקטן ביותר שהערך מתאים אליו, וזו בדרך כלל הסיבה האמיתית שמישהו ממיר מספר לבינארי מלכתחילה.
האם הנתונים שלי נשלחים לשרת כשאני ממיר מספר?
מס 'כל המרה מחושבת ב - JavaScript בדפדפן שלך, וזו הסיבה שהתוצאה מתעדכנת בכל הקשה ולא לאחר נסיעה הלוך ושוב ברשת שום דבר שאתה מקליד לא מועבר, נרשם או מאוחסן, והממיר ממשיך לעבוד ללא חיבור לרשת בכלל ברגע שהדף נטען.
