מספרים ו-BigInt ב-JavaScript: שברים, דיוק ומספרים שלמים גדולים

טיפוס מספר אחד לכל דבר (כמעט)

רוב השפות נותנות לכם טיפוסים נפרדים למספרים שלמים ולשברים. JavaScript, מבחינה היסטורית, נתנה לכם טיפוס אחד: Number. בין אם כתבתם 42, 3.14 או -0.001, קיבלתם את אותו טיפוס פרימיטיבי: float בדיוק כפול של 64 ביט לפי IEEE 754.

console.log(typeof 42);         // "number"
console.log(typeof 3.14);       // "number"
console.log(typeof -0.001);     // "number"
console.log(typeof NaN);        // "number"
console.log(typeof Infinity);   // "number"

זה נוח: אין המרות בין int ל-float, ואין גלישה ב-2^31. אבל לייצוג כ-float יש השלכות, והן מפילות מתחילים לעתים קרובות. טיפוס מספרי שני, BigInt, נוסף ב-2020 כדי לטפל במקרים שבהם Number לא מספיק.

ההפתעה של Floating-Point

הריצו את זה:

console.log(0.1 + 0.2);
console.log(0.1 + 0.2 === 0.3);

השורה הראשונה מדפיסה 0.30000000000000004. השנייה מדפיסה false. זו לא מוזרות של JavaScript: Python, Java, C וכל שפה שמשתמשת ב-float לפי IEEE 754 מתנהגות אותו דבר.

הסיבה: אי אפשר לייצג את 0.1 ואת 0.2 בדיוק בבינארי, בדיוק כמו שאי אפשר לכתוב 1/3 בדיוק בעשרוני. נשמר הקירוב הבינארי הקרוב ביותר, ושגיאות זעירות מצטברות. המודל המנטלי: התייחסו לערכי Number עם נקודה עשרונית כאל קירובים שבמקרה קרובים מאוד למה שכתבתם.

לכסף, אל תשמרו $19.99 בתור 19.99. שמרו סנטים כמספרים שלמים, 1999, ועצבו בזמן התצוגה. זה ההרגל הטוב ביותר להתחמקות מבאגים של float.

השוואת שברים בבטחה

מכיוון ששוויון לא אמין, השוו עם סבולת כשצריך:

const a = 0.1 + 0.2;
const b = 0.3;

const EPSILON = Number.EPSILON;
console.log(Math.abs(a - b) < EPSILON);  // true

Number.EPSILON הוא ההפרש הקטן ביותר בין 1 לבין המספר הבא שאפשר לייצג: סבולת ברירת מחדל סבירה לערכים הקרובים ל-1. לגדלים גדולים מאוד או קטנים מאוד תרצו סבולת שגדלה יחד עם הקלט.

טווח המספרים השלמים הבטוח

מספרים שלמים עד גודל מסוים כן מדויקים ב-float של 64 ביט. מעבר לזה מתחילים לאבד דיוק, ביט אחרי ביט:

console.log(Number.MAX_SAFE_INTEGER);       // 9007199254740991
console.log(Number.MAX_SAFE_INTEGER + 1);   // 9007199254740992
console.log(Number.MAX_SAFE_INTEGER + 2);   // 9007199254740992  (!)

console.log(Number.isSafeInteger(9007199254740991));  // true
console.log(Number.isSafeInteger(9007199254740993));  // false

2^53 - 1 הוא המספר השלם האחרון שכל המספרים השלמים מתחתיו ניתנים לייצוג. מעבר לו, חלק מהמספרים השלמים פשוט לא קיימים בטיפוס Number: הם מעוגלים לשכן הקרוב ביותר. זה באג שקט של השחתת נתונים שמחכה לקרות אם אתם מפענחים מזהים של 64 ביט ממסד נתונים כמספרי JSON רגילים.

הכירו את BigInt

BigInt הוא טיפוס פרימיטיבי נפרד למספרים שלמים בדיוק שרירותי. יוצרים אותו על ידי הוספת n לליטרל של מספר שלם, או על ידי קריאה ל-BigInt(...):

const a = 9007199254740993n;
const b = BigInt("9007199254740993");
const c = BigInt(42);

console.log(a);           // 9007199254740993n
console.log(typeof a);    // "bigint"
console.log(a === b);     // true

ל-BigInt אין גבול עליון מלבד הזיכרון הזמין. זה הכלי הנכון עבור:

• מזהים ממסד נתונים או מזהי snowflake של Twitter/X שעוברים את 2^53.
• חישובים קריפטוגרפיים.
• כל אריתמטיקה של מספרים שלמים שבה תוצאות מדויקות חשובות יותר ממהירות גולמית.

זה לא הכלי הנכון למונים יומיומיים, לאינדקסים של מערכים או לכסף בסנטים: Number רגיל מהיר יותר ועובד עם כל API בשפה.

אריתמטיקה של BigInt

כל האופרטורים הרגילים עובדים, כל עוד שני האופרנדים הם BigInt:

const big = 10n ** 30n;
console.log(big);                 // 1000000000000000000000000000000n
console.log(big + 1n);            // 1000000000000000000000000000001n
console.log(big * 2n);            // 2000000000000000000000000000000n

console.log(7n / 2n);             // 3n  (integer division, truncated)
console.log(7n % 2n);             // 1n

חילוק נחתך לכיוון אפס: אין BigInt עם שבר. אם אתם צריכים שבר, חזרתם לתחום של Number (או לספרייה עשרונית).

אל תערבבו טיפוסים

הכלל שמפיל אנשים: אי אפשר לערבב Number ו-BigInt באותו ביטוי.

try {
    console.log(1n + 1);
} catch (err) {
    console.log(err.message);
}

// Convert explicitly:
console.log(1n + BigInt(1));      // 2n
console.log(Number(1n) + 1);      // 2

ההשוואה היא החריג היחיד: <, > ו-== ממירים מעבר לגבול:

console.log(1n < 2);       // true
console.log(1n == 1);      // true
console.log(1n === 1);     // false  (different types)

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

המרה ביניהם

שתי המרות, שתי מלכודות:

// Number -> BigInt: must be a safe integer, no decimals
console.log(BigInt(42));          // 42n
try { BigInt(3.14); } catch (e) { console.log(e.message); }

// BigInt -> Number: may lose precision
const huge = 9007199254740993n;
console.log(Number(huge));        // 9007199254740992  (!)

המעבר Number → BigInt קפדני: שברים ו-NaN זורקים שגיאה. המעבר BigInt → Number מתירני אבל מאבד מידע: כל מה שמעל MAX_SAFE_INTEGER מעוגל. אם אתם ממירים BigInt שקיבלתם משרת, שאלו את עצמכם אם אתם באמת צריכים לעשות את זה.

ערכי Number מיוחדים

כבר שאנחנו כאן, שלושה ערכים בטיפוס Number שאינם מספרים במובן המתמטי:

console.log(1 / 0);              // Infinity
console.log(-1 / 0);             // -Infinity
console.log(0 / 0);              // NaN
console.log("abc" - 1);          // NaN

console.log(NaN === NaN);        // false  (!)
console.log(Number.isNaN(NaN));  // true

Infinity ו--Infinity מופיעים כשמחלקים באפס או חורגים מטווח ה-float. NaN ("not a number", לא מספר) מופיע כשפעולה אריתמטית לא מפיקה תוצאה בעלת משמעות.

NaN ידוע בכך שהוא לא שווה לעצמו: זה חלק מתקן IEEE 754, לא באג של JS. השתמשו ב-Number.isNaN(x) כדי לבדוק. הפונקציה הגלובלית הישנה isNaN ממירה קודם את הארגומנט שלה, וזה נותן תשובות שגויות (isNaN("hello") מחזירה true). תמיד העדיפו את הגרסה Number.isNaN.

פענוח מספרים ממחרוזות

קלט משתמש ומספרים ב-JSON מגיעים לעתים קרובות כמחרוזות. שלוש דרכים להמיר:

console.log(Number("42"));         // 42
console.log(Number("42px"));       // NaN   (strict)
console.log(parseInt("42px"));     // 42    (permissive, reads digits)
console.log(parseFloat("3.14em")); // 3.14
console.log(+"42");                // 42    (unary plus, same as Number)

console.log(Number(""));           // 0     (!)
console.log(Number(" "));          // 0     (!)

Number() קפדנית: כל דבר שאינו מספרי נותן NaN, חוץ מהמחרוזת הריקה ומרווחים, שנותנים 0. parseInt ו-parseFloat סלחניות: הן קוראות כמה שהן יכולות ועוצרות. בחרו את מה שמתאים לכוונה שלכם, ובדקו NaN לפני שמשתמשים בתוצאה.

לפענוח BigInt ממחרוזות, השתמשו ב-BigInt("123"): היא קפדנית וזורקת שגיאה על קלט לא תקין.

ספר כללים קצר

• למונים, מתמטיקה, קואורדינטות ורוב המספרים היומיומיים: השתמשו ב-Number.
• לכסף: המירו לסנטים שלמים והשתמשו ב-Number, או פנו לספרייה עשרונית.
• למספרים שלמים גדולים מ-2^53 (מזהים ממסד נתונים, קריפטו, קומבינטוריקה): השתמשו ב-BigInt עם הסיומת n.
• השוו שברים עם סבולת, לא עם ===.
• בדקו תוצאות לא תקינות עם Number.isNaN ו-Number.isFinite, לא עם הגרסאות הגלובליות.
• אל תערבבו Number ו-BigInt באותו ביטוי: המירו במפורש.

הבא בתור: null מול undefined

ל-JavaScript יש שתי דרכים להגיד "אין ערך", null ו-undefined, והן לא ניתנות להחלפה זו בזו. בהמשך: מה כל אחת מהן אומרת, במה הן שונות ובאיזו להשתמש מתי.