[ טוען... ]

JSON.parse ומספרים גדולים: איבוד דיוק שקט ואיך מונעים אותו

תאריך: 24.10.2026
זמן קריאה: 18 דקות
לידור כהן
מייסד, לידור דיגיטל

שיתוף:

הירשמו לניוזלטר - תובנות על אוטומציה ו-AI, בלי ספאם

איור של שרשרת ספרות שעוברת במשפך ומאבדת את סופה, לצד קפסולה ששומרת עליה שלמה, המחשה לאיבוד דיוק ב-JSON.parse

JSON.parse ומספרים גדולים הם שילוב שמייצר את אחד הבאגים השקטים ביותר ב-JavaScript. מזהה לקוח שיוצא ממערכת המקור כ-9123372036854000123 מגיע לקוד כ-9123372036854000000. אין חריגה, אין אזהרה בלוג, וה-JSON תקין לחלוטין (JSON Editor Online). הבאג מתגלה בדרך כלל רק כשרשומה "נעלמת", חשבונית מתעדכנת אצל הלקוח הלא נכון, או סנכרון בין שתי מערכות מפסיק להתאים רשומות.

הנושא רלוונטי במיוחד עכשיו משתי סיבות. הראשונה: יותר ויותר מערכות משתמשות במזהים של 64 ביט, כמו עמודות bigint ב-Postgres או מזהי Snowflake בסגנון טוויטר, שחורגים בקלות מהטווח שבו JavaScript מייצג מספרים שלמים במדויק (AI JSONMedic). השנייה: כמעט כל זרימת נתונים עוברת לפחות שכבה אחת של JavaScript, בין אם זה שרת Node.js, אפליקציית Frontend או כלי אוטומציה. כל שכבה כזו היא נקודה פוטנציאלית שבה המספר משתנה בשקט.

המאמר מפרק את הדרכים המרכזיות שבהן JSON.parse משנה נתונים בלי להודיע, מסביר למה פונקציית reviver קלאסית לא פותרת את הבעיה, ומציג קוד TypeScript מעשי לטיפול בטוח: העברת מזהים כמחרוזות, שימוש ב-BigInt, ה-API החדש של context.source והספרייה lossless-json. בהמשך יש התייחסות להשלכות על API, אינטגרציות CRM/ERP וזרימות n8n, וצ'קליסט לאיתור הבעיה במערכות קיימות.

הבעיה: JSON תקין, מספר שגוי

הדוגמה הקלאסית נראית תמימה לגמרי:

const raw = '{"count": 9123372036854000123}';
const data = JSON.parse(raw);

console.log(data.count); // 9123372036854000000

שלוש הספרות האחרונות התאפסו. הקלט הוא JSON תקין וגם ביטוי JavaScript תקין, ובכל זאת התוצאה שונה מהמקור (JSON Editor Online). אין SyntaxError, אין RangeError, ואין שום דרך לדעת שמשהו השתבש רק מהסתכלות על ערך ההחזרה.

למה זה קורה: IEEE 754 ו-Number.MAX_SAFE_INTEGER

ב-JavaScript יש טיפוס מספרי אחד "רגיל": Number, שהוא מספר נקודה צפה בדיוק כפול לפי תקן IEEE 754 (64 ביט). JSON.parse ממיר כל מספר ב-JSON לטיפוס הזה. המשמעות היא שאפשר לייצג במדויק רק בערך 15 עד 16 ספרות משמעותיות, ומספרים שלמים רק עד 2^53 - 1, כלומר 9007199254740991 (AI JSONMedic).

הערך הזה זמין בקוד כקבוע Number.MAX_SAFE_INTEGER. כל מספר שלם מעליו מעוגל בשקט לערך הנקודה הצפה הקרוב ביותר שניתן לייצג:

console.log(Number.MAX_SAFE_INTEGER);          // 9007199254740991
console.log(JSON.parse('9007199254740993'));   // 9007199254740992
console.log(Number.isSafeInteger(9007199254740991)); // true
console.log(Number.isSafeInteger(9007199254740992)); // false

הדוגמה של 9007199254740993 שהופך ל-9007199254740992 מתועדת כמקרה המובהק של עיגול מעל הגבול (AI JSONMedic). חשוב לשים לב שמעל הגבול לא כל המספרים "נשברים": חלקם מיוצגים במקרה במדויק, וזה מה שהופך את הבאג לחמקמק כל כך. בדיקה עם מזהה אחד יכולה לעבור, ובדיקה עם המזהה הבא תיכשל.

האם זה באג ב-JSON או ב-JavaScript?

לא בדיוק. מפרט JSON עצמו (RFC 8259, סעיף 6) לא מגביל את הטווח או את הדיוק של מספרים. הוא מתיר למימושים לקבוע מגבלות משלהם ומזהיר במפורש מבעיות תאימות בין מערכות (Neon). JSON.parse מממש בדיוק את מה שמצופה ממנו: המרה ל-float64. הבעיה נוצרת בפער שבין מערכת שמייצרת מספר שלם של 64 ביט לבין צרכן שמפרש אותו כנקודה צפה.

איפה פוגשים מספרים כאלה בפועל

המקרים הנפוצים ביותר:

  • עמודות bigint ב-Postgres: הטווח מגיע עד 9,223,372,036,854,775,807, הרבה מעבר לגבול הבטוח של JavaScript (AI JSONMedic).
  • מזהי Snowflake: מזהים של 64 ביט, שעלולים לחרוג מ-2^53 כשהם נשלחים כמספר ב-JSON (AI JSONMedic).
  • עמודות numeric ב-Postgres: דרייברים נוטים להחזיר אותן כמחרוזות, בדיוק כמו bigint (Neon). קוד שממיר את המחרוזת ל-Number חושף את הערך למגבלה של 15 עד 16 ספרות משמעותיות (AI JSONMedic).
  • מספרים שנוצרים במערכות חיצוניות: מזהי עסקאות, מספרי מסמכים או חותמות זמן ברזולוציה גבוהה, שמגיעים מ-API של צד שלישי.

JSON.parse, מספרים גדולים ובאגים: שלוש דרכים שבהן הנתונים משתנים בשקט

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

1. מספרים שלמים גדולים מאבדים ספרות

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

כמה תסמינים טיפוסיים:

  • בקשת GET /customers/{id} מחזירה 404 למרות שהלקוח קיים.
  • עדכון נכתב בטעות על רשומה שכנה שהמזהה שלה זהה לערך המעוגל.
  • שתי רשומות שונות מקבלות אותו מזהה בצד הלקוח ומתמזגות בממשק.
  • בדיקות יחידה עוברות כי משתמשות במזהים קטנים, והבאג מופיע רק בפרודקשן.

2. מספרים עשרוניים: עיגול, overflow, underflow ואובדן פורמט

גם מספרים עשרוניים לא יוצאים נקיים. מעבר לעיגול הרגיל של ספרות עשרוניות מעבר לדיוק של float64, יש שני מקרי קצה בולטים: מספר עם מעריך גדול מדי הופך ל-Infinity, ומספר עם מעריך קטן מדי הופך ל-0 (AI JSONMedic).

console.log(JSON.parse('1e400'));   // Infinity
console.log(JSON.parse('1e-400'));  // 0

// ובכיוון ההפוך:
console.log(JSON.stringify({ big: Infinity })); // '{"big":null}'

השורה האחרונה חשובה: JSON.stringify ממיר Infinity ל-null. כלומר, ערך כמו 2.3e+500 שעובר סבב של parse ואז stringify חוזר כ-null (lossless-json). מערכת שמקבלת נתונים, מעבדת אותם ומעבירה הלאה יכולה להפוך מספר תקין לערך ריק לגמרי.

גם הפורמט עצמו נאבד. אפסים נגררים נעלמים בסבב parse/stringify, כך ש-2.370 הופך ל-2.37 (lossless-json). מבחינה מתמטית זה אותו ערך, אבל אם הייצוג משמש לחתימה דיגיטלית, להשוואת hash או לתצוגה של מחיר בפורמט קבוע, ההבדל משמעותי.

ה-README של lossless-json מציג דוגמה שמרכזת את שלוש התופעות יחד:

const text = '{"decimal":2.370,"long":9123372036854000123,"big":2.3e+500}';

console.log(JSON.stringify(JSON.parse(text)));
// '{"decimal":2.37,"long":9123372036854000000,"big":null}'

שלושה שדות, שלוש השחתות שונות, ואפס שגיאות (lossless-json).

3. מקרי קצה נוספים: מפתחות כפולים, -0 ו-__proto__

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

מפתחות כפולים. JSON.parse המובנה מקבל אובייקט עם אותו מפתח פעמיים בלי לזרוק שגיאה, בניגוד ל-lossless-json שזורקת שגיאת פענוח במקרה כזה (lossless-json). לפי מפרט ECMAScript, כשיש שמות כפולים באובייקט, ערכים שמופיעים מוקדם יותר נדרסים על ידי הערך האחרון (ECMA-262, JSON.parse):

const obj = JSON.parse('{"id": 1, "id": 2}');
console.log(obj.id); // 2

הבעיה היא שמחוץ ל-JavaScript אין התנהגות אחידה. RFC 8259 קובע שהשמות באובייקט צריכים (SHOULD) להיות ייחודיים, ומציין שכאשר הם לא ייחודיים, ההתנהגות של התוכנה המקבלת אינה צפויה: מימושים רבים מחזירים רק את הזוג האחרון, אחרים מדווחים על שגיאה, וחלקם מחזירים את כל הזוגות כולל הכפולים (RFC 8259, סעיף 4). כך שירות אחד יכול לקרוא ערך אחד מאותו מסמך, שירות אחר ערך אחר, ושניהם בטוחים שהם קוראים את אותו מידע.

אפס שלילי. בנקודה צפה קיים -0 כערך נפרד מ-0. JSON.parse('-0') מחזיר -0, כי הטקסט מוערך כביטוי ECMAScript (ECMA-262, JSON.parse). לעומת זאת, JSON.stringify(-0) מחזיר '0': מספר סופי מסודר באמצעות המרה למחרוזת (ECMA-262, SerializeJSONProperty), וההמרה הזו מחזירה "0" גם עבור -0 (ECMA-262, Number::toString). התוצאה: הסימן נאבד בסבב parse/stringify.

const parsed = JSON.parse('-0');
console.log(Object.is(parsed, -0));   // true
console.log(JSON.stringify(-0));      // '0'

const roundTrip = JSON.parse(JSON.stringify(-0));
console.log(Object.is(roundTrip, -0)); // false

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

המפתח __proto__. לפי MDN, ההבדל היחיד בין JSON.parse לבין ביטוי JavaScript שקול הוא בטיפול במפתח "__proto__": JSON.parse מתייחס אליו כמאפיין רגיל של האובייקט ולא משנה את ה-prototype (MDN JSON.parse). זה מגן מפני מתקפה ישירה בשלב הפענוח, אבל אם התוצאה מועברת אחר כך לפונקציית merge רקורסיבית שמעתיקה מאפיינים, המפתח הזה עלול לגרום ל-prototype pollution. לכן כדאי לסנן את המפתח או לוודא שפונקציות העתקה מדלגות עליו.

למה JSON.parse reviver לבד לא מספיק, ומה context.source משנה

הפתרון האינטואיטיבי הראשון הוא פונקציית reviver: הארגומנט השני של JSON.parse, שמקבל כל זוג מפתח-ערך ויכול להחליף את הערך. הרעיון נשמע הגיוני: אם מספר גדול מדי, ממירים אותו ל-BigInt.

הבעיה ב-reviver הקלאסי

קוד כזה מופיע בהרבה מקומות, כולל gist פופולרי שממיר מספרים מעל הגבול הבטוח ל-BigInt (gist):

const data = JSON.parse(raw, (key, value) => {
  if (
    typeof value === 'number' &&
    Number.isInteger(value) &&
    !Number.isSafeInteger(value)
  ) {
    return BigInt(value); // מאוחר מדי: value כבר מעוגל
  }
  return value;
});

הבעיה היא סדר הפעולות. הטקסט מפוענח קודם למספר, ורק אז הערך מועבר ל-reviver. כשהפונקציה רצה, value כבר מעוגל, וההמרה ל-BigInt רק משמרת את הערך השגוי בטיפוס אחר (JSON Editor Online). זה אולי מרגיש כמו פתרון, אבל בפועל הוא מסתיר את הבאג עוד יותר טוב.

הארגומנט השלישי: context.source

MDN מתעד ארגומנט שלישי ל-reviver בשם context, עם מאפיין source שמכיל את הטקסט המקורי של ערכים פרימיטיביים מתוך ה-JSON. הארגומנט הזה מועבר רק לערכים פרימיטיביים, לא לאובייקטים או למערכים (MDN JSON.parse). המשמעות: ה-reviver מקבל גם את המספר המעוגל וגם את המחרוזת המקורית, ויכול לבנות ממנה BigInt מדויק.

היכולת מגיעה מהצעת TC39 בשם JSON.parse source text access, שמנוהלת במאגר ייעודי שבו מתועדים הסטטוס העדכני וההתקדמות שלה בתהליך התקינה (TC39 proposal-json-parse-with-source). לפי AI JSONMedic, היא חלק מ-ES2026 (AI JSONMedic). את נתוני התמיכה בדפדפנים ובגרסאות Node.js יש לבדוק בטבלת התאימות שבעמוד של MDN JSON.parse לפני שמסתמכים על התכונה בפרודקשן.

type ReviverContext = { source?: string };

const INTEGER_TEXT = /^-?\d+$/;

function bigIntReviver(
  key: string,
  value: unknown,
  context?: ReviverContext
): unknown {
  if (
    typeof value === 'number' &&
    context?.source !== undefined &&
    INTEGER_TEXT.test(context.source) &&
    !Number.isSafeInteger(value)
  ) {
    return BigInt(context.source); // הספרות המקוריות, בלי עיגול
  }
  return value;
}

export function parseWithBigInt(text: string): unknown {
  // הטיפוסים של TypeScript לא בהכרח כוללים את context
  return JSON.parse(text, bigIntReviver as (key: string, value: any) => any);
}

בדיקת תמיכה בזמן ריצה

כיוון שהתמיכה תלויה בסביבה, כדאי לזהות אותה בזמן ריצה ולבחור מסלול חלופי אם היא חסרה:

export const supportsReviverSource: boolean = (() => {
  let supported = false;
  JSON.parse('1', ((_key: string, value: unknown, ctx?: ReviverContext) => {
    supported = typeof ctx?.source === 'string';
    return value;
  }) as (key: string, value: any) => any);
  return supported;
})();

if (!supportsReviverSource) {
  // מעבר לספריית פענוח כמו lossless-json
}

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

טיפול בטוח ב-TypeScript: מחרוזות, BigInt ב-JavaScript ו-lossless-json

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

אסטרטגיה 1: מזהים גדולים ב-JSON כמחרוזות

הפתרון הנקי ביותר הוא למנוע את הבעיה במקור: לשלוח מזהים כמחרוזות. זו בדיוק הגישה של רוב הדרייברים של Postgres, שמחזירים bigint ו-numeric כמחרוזות. לדוגמה, (1e16+1)::bigint חוזר כ-'10000000000000001', והמקובל הוא להעביר את המחרוזת ל-BigInt() רק כשצריך (Neon).

interface Customer {
  id: string;            // מזהה תמיד כמחרוזת
  name: string;
  balanceAgorot: string; // סכום כמחרוזת כשהדיוק קריטי
}

const customer = JSON.parse(
  '{"id":"9123372036854000123","name":"ישראל ישראלי","balanceAgorot":"1250050"}'
) as Customer;

// השוואה והתאמה נעשות על המחרוזת עצמה
const isMatch = customer.id === '9123372036854000123'; // true

// המרה ל-BigInt רק כשיש צורך בחישוב
const idAsBigInt = BigInt(customer.id);

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

אסטרטגיה 2: BigInt ב-JavaScript, ומה חשוב לדעת עליו

BigInt הוא טיפוס מובנה שמייצג מספרים שלמים בגודל שרירותי. הוא נחשב Baseline "זמין באופן רחב" מאז ספטמבר 2020, כך שאפשר להסתמך עליו כמעט בכל סביבה מודרנית (MDN BigInt). אבל יש לו כמה מגבלות שצריך להכיר:

  • אי אפשר לערבב עם Number בחישובים. ביטוי כמו 1n + 1 זורק שגיאה, וצריך להמיר במפורש (MDN BigInt).
  • המרה חזרה ל-Number עלולה לאבד דיוק. Number(bigValue) מחזיר בדיוק את אותה בעיה שהפתרון נועד למנוע (MDN BigInt).
  • JSON.stringify לא מסדר BigInt באופן מובנה, ולכן צריך replacer שמטפל בו (Neon).
  • אין תמיכה בערכים עשרוניים. BigInt מתאים למזהים ולסכומים במספרים שלמים (למשל אגורות), לא לשברים.
// replacer שמסדר BigInt כמחרוזת
function bigIntReplacer(_key: string, value: unknown): unknown {
  return typeof value === 'bigint' ? value.toString() : value;
}

const payload = { invoiceId: 9123372036854000123n, total: 100 };
const json = JSON.stringify(payload, bigIntReplacer);
// '{"invoiceId":"9123372036854000123","total":100}'

ה-replacer הזה מחזיר מחרוזת עם מרכאות. אם הצרכן בצד השני מצפה למספר, זה שינוי בחוזה של ה-API שצריך לתאם מראש.

אסטרטגיה 3: lossless-json

כשאין שליטה על צד היצרן והנתונים מגיעים כמספרים גולמיים, צריך מפענח ששומר על הטקסט המקורי. lossless-json (נכון לגרסה 4.3.1) מפענחת כל מספר לאובייקט LosslessNumber ששומר את הערך כמחרוזת. המרה ל-number זורקת שגיאה אם היא הייתה מאבדת מידע, הספרייה תומכת ב-bigint דרך numberParser מותאם, ואין לה תלויות (lossless-json). הגודל שלה מתחת ל-4 kB אחרי minify ו-gzip, והיא כוללת טיפוסי TypeScript (lossless-json).

import { parse, stringify, LosslessNumber } from 'lossless-json';

const text = '{"decimal":2.370,"long":9123372036854000123,"big":2.3e+500}';

const data = parse(text) as Record<string, LosslessNumber>;

console.log(data.long.toString()); // '9123372036854000123'
console.log(stringify(data));
// '{"decimal":2.370,"long":9123372036854000123,"big":2.3e+500}'

הסבב parse/stringify של הספרייה שומר על הפורמט המקורי, כולל 2.370 (lossless-json). למי שמעדיף לעבוד עם טיפוסים מובנים ולא עם LosslessNumber, אפשר להעביר numberParser שממיר מספרים שלמים ל-BigInt ושאר המספרים ל-Number:

import { parse, isInteger } from 'lossless-json';

function numberParser(value: string): number | bigint {
  return isInteger(value) ? BigInt(value) : parseFloat(value);
}

const parsed = parse('{"id":9123372036854000123,"rate":0.17}', null, numberParser);
// { id: 9123372036854000123n, rate: 0.17 }

כדאי לזכור שני דברים. ראשית, הספרייה איטית יותר מ-JSON.parse המובנה, וה-README מזהיר מפני שימוש בה במקומות שבהם ביצועים הם צוואר בקבוק (lossless-json). שנית, היא זורקת שגיאה על מפתחות כפולים, מה שעלול לשבור קוד שעבד עם פענוח מובנה, אבל בדרך כלל זה בדיוק מה שרוצים: כשל מפורש במקום כשל שקט. לפי Neon, json-custom-numbers היא חלופה נוספת באותה משפחה (Neon).

טבלת השוואה

גישה

יתרונות

חסרונות

מתי לבחור

מזהים כמחרוזות + BigInt() לפי צורך

מסלקת את הבעיה במקור, BigInt נתמך באופן רחב מאז 2020

דורשת שינוי ב-API או ביצרן, BigInt לא מתערבב עם Number

כשיש שליטה על החוזה של ה-API

reviver עם context.source

ללא תלויות, מהיר, נותן גישה לספרות המקוריות

תמיכה תלויה בסביבה, לא מועבר לאובייקטים ומערכים

בסביבות שבהן נבדקה תמיכה

reviver קלאסי בלבד

פשוט לכתיבה

מקבל ערך שכבר עוגל, לא פותר את הבעיה

לא מתאים לשמירת דיוק

lossless-json

שומרת כל ספרה ופורמט, תמיכה ב-bigint, שגיאה על מפתחות כפולים

איטית יותר, דורשת התאמת קוד ל-LosslessNumber

נתונים מצד שלישי שאין שליטה עליהם

המקורות להשוואה: lossless-json, MDN JSON.parse, Neon.

באגים באינטגרציות API: CRM, ERP וזרימות n8n

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

תכנון API: החוזה הוא קו ההגנה הראשון

מי שמתכנן API שחושף מזהים מבסיס נתונים כדאי שיחליט מראש: מזהים יוצאים כמחרוזות. ההחלטה הזו חוסכת לכל צרכן עתידי, בין אם זו אפליקציית React, שרת Node.js או כלי אוטומציה, את הצורך לטפל בבעיה. העובדה שדרייברים של Postgres כבר מחזירים bigint כמחרוזת (Neon) מקלה על זה: פשוט לא ממירים את המחרוזת למספר לפני הסידור ל-JSON.

כמה כללים מעשיים לחוזה API:

  • כל שדה שמסתיים ב-id או משמש להתאמה יוצא כמחרוזת, גם אם כרגע הערכים קטנים.
  • סכומים כספיים יוצאים כמחרוזת עשרונית או כמספר שלם ביחידה הקטנה (אגורות), לא כ-float.
  • מתעדים את הפורמט ב-OpenAPI או ב-JSON Schema עם type: string ו-pattern מתאים.
  • לא משנים חוזה קיים בלי גרסה חדשה, כי צרכנים קיימים מצפים לטיפוס הנוכחי.

אינטגרציות CRM/ERP

באינטגרציות בין מערכות CRM, ERP, מערכות הנהלת חשבונות ומערכות חיוב, כולל מערכות ישראליות נפוצות, מזהים הם הדבק שמחבר הכל: מזהה לקוח, מספר חשבונית, מספר מסמך, מזהה הזמנה. האופן שבו מערכות מחזירות מזהים משתנה ממערכת למערכת, ולכן כדאי לבדוק כל אחת בנפרד: האם היא מחזירה מזהים כמספרים או כמחרוזות, ומה הטווח שלהם בפועל. מערכות שמשתמשות במזהים של 64 ביט ושולחות אותם כמספרים גולמיים ב-JSON הן בדיוק המקרה המסוכן.

התסמין הקלאסי באינטגרציה: סנכרון שעובד חודשים, ואז רשומה אחת "לא נמצאת" או מתעדכנת במקום אחרת. כיוון שחלק מהמספרים מעל הגבול מיוצגים במקרה במדויק, הבאג יכול להופיע באופן שנראה אקראי. אם התגובה הראשונה היא להוסיף ניסיונות חוזרים, חשוב לזכור שניסיון חוזר עם מזהה שגוי פשוט ייכשל שוב, ובמקרה הגרוע ייצור עומס מיותר, כפי שמוסבר במאמר על retry storm ואיך מונעים אותו. למבט רחב יותר על חיבור CRM לאוטומציה, אפשר לעיין במדריך המלא לחיבור CRM לאוטומציה.

זרימות n8n ושכבות JavaScript באוטומציה

ב-n8n, צומת Code מריץ קוד JavaScript (ותומך גם ב-Python) (n8n Docs: Code node), וביטויים נכתבים ב-JavaScript (n8n Docs: Expressions). כל מקום שבו נתונים עוברים דרך JSON.parse או דרך קוד שעובד עם Number חשוף לאותה בעיה. לפני שמניחים משהו על טיפול במספרים גדולים בצומת מסוים, כדאי לבדוק אותו בפועל בזרימה עצמה.

בדיקה מעשית לזרימת n8n שמעבירה מזהים:

  1. שולחים ל-Webhook בקשה עם שדה מספרי 9007199254740993.
  2. מעבירים אותו דרך כל הצמתים בזרימה, כולל צמתי Code.
  3. בודקים מה מגיע ליעד הסופי: אם הגיע 9007199254740992, יש איבוד דיוק.
  4. חוזרים על הבדיקה כשהשדה נשלח כמחרוזת "9007199254740993" ומוודאים שהוא נשאר מחרוזת לאורך כל הדרך.

בתוך צומת Code, הכלל פשוט: לא ממירים מזהים ל-Number. השוואות נעשות על מחרוזות, ואם חייבים חישוב, עוברים ל-BigInt ומחזירים מחרוזת בסוף. רקע שימושי למי שמתחיל לעבוד עם הכלי זמין במדריך למתחילים לאוטומציה עם n8n.

זווית עברית: RTL ומספרים ארוכים

במסמכים, בתיעוד ובממשקי ניהול בעברית, מחרוזות ספרות ארוכות ומזהים בתוך טקסט RTL עלולים להיראות מבולגנים או להיקרא לא נכון, במיוחד כשהם צמודים לסימני פיסוק. מומלץ להציג מזהים בתוך בלוקים או תגיות בכיוון LTR (למשל dir="ltr" או רכיב <bdi> בממשק), ובתיעוד פנימי להשתמש בקטעי קוד. זה לא מונע איבוד דיוק, אבל מונע טעויות העתקה והשוואה ידנית בזמן דיבאג.

איתור איבוד דיוק במספרים ב-JavaScript במערכות קיימות

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

סריקת payloads גולמיים

הבדיקה האמינה ביותר נעשית על הטקסט הגולמי, לפני שהוא עובר JSON.parse. אפשר להשתמש ב-lossless-json עם numberParser שמקבל את הטקסט המקורי של כל מספר (lossless-json), ולבדוק האם המרה ל-Number שומרת על כל הספרות המשמעותיות.

בדיקה שמסתמכת רק על Number.isSafeInteger תופסת מספרים שלמים גדולים, אבל מפספסת שברים ברזולוציה גבוהה, כמו 0.12345678901234567890, שמאבדים ספרות בהמרה ל-float64. לכן הגרסה הבאה משווה את הספרות המשמעותיות של הטקסט המקורי לאלה של String(n). ההשוואה מתעלמת מהבדלי פורמט כמו אפסים נגררים (2.370 מול 2.37), כך שהיא מסמנת רק מקרים שבהם הערך עצמו השתנה:

import { parse } from 'lossless-json';

// הספרות המשמעותיות בלבד: בלי סימן, נקודה, מעריך ואפסים מובילים/נגררים
function significantDigits(text: string): string {
  const mantissa = text.toLowerCase().split('e')[0].replace(/^[-+]/, '');
  return mantissa.replace('.', '').replace(/^0+/, '').replace(/0+$/, '');
}

export function findUnsafeNumbers(text: string): string[] {
  const unsafe: string[] = [];

  parse(text, null, (value: string) => {
    const n = Number(value);
    const lostDigits = significantDigits(value) !== significantDigits(String(n));
    if (!Number.isFinite(n) || lostDigits) {
      unsafe.push(value);
    }
    return n;
  });

  return unsafe;
}

console.log(
  findUnsafeNumbers(
    '{"a":1,"b":9123372036854000123,"c":1e400,"d":1e-400,"e":0.12345678901234567890,"f":2.370}'
  )
);
// ['9123372036854000123', '1e400', '1e-400', '0.12345678901234567890']

הפונקציה מזהה ארבעה סוגי בעיות: מספר שלם שאיבד ספרות, overflow ל-Infinity, underflow ל-0 ושבר עשרוני שעוגל. הערך 2.370 לא מסומן, כי רק הפורמט שלו משתנה ולא הערך. את הפונקציה אפשר להריץ כ-middleware בסביבת staging, לרשום ללוג כל payload שמכיל מספרים לא בטוחים, ולקבל תמונה מדויקת של אילו endpoints ומערכות בעייתיים.

בדיקות אוטומטיות עם ערכי גבול

בדיקות יחידה ואינטגרציה כמעט תמיד משתמשות במזהים קטנים כמו 1, 42 או 1001, ולכן לא תופסות את הבאג. כדאי להוסיף fixtures עם ערכי גבול:

  • 9007199254740991: הערך הבטוח האחרון, אמור לעבור.
  • 9007199254740993: הערך שמעוגל ל-9007199254740992 (AI JSONMedic).
  • 9123372036854000123: מזהה של 19 ספרות שמאבד את שלוש הספרות האחרונות (JSON Editor Online).
  • 2.370, 1e400, 1e-400: לבדיקת פורמט, overflow ו-underflow (lossless-json).
  • -0: לבדיקה שהסימן לא נדרש בצד המקבל, כי הוא לא שורד את JSON.stringify (ECMA-262, Number::toString).

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

צ'קליסט מעשי

  • [ ] כל המזהים ב-API יוצאים כמחרוזות, ומתועדים ככאלה בסכמה.
  • [ ] אין המרה של מזהים ל-Number בשום שכבה, כולל צמתי Code באוטומציות.
  • [ ] נתונים מצד שלישי שמכילים מספרים גדולים מפוענחים עם מפענח lossless או עם context.source אחרי בדיקת תמיכה.
  • [ ] אין reviver קלאסי שמתיימר "לתקן" מספרים גדולים.
  • [ ] יש replacer שמטפל ב-BigInt בכל מקום שבו נעשה JSON.stringify.
  • [ ] בדיקות כוללות ערכי גבול סביב Number.MAX_SAFE_INTEGER, שברים ברזולוציה גבוהה ומספרים עם מעריכים קיצוניים.
  • [ ] סכומים כספיים מועברים כמחרוזות או כמספרים שלמים ביחידה הקטנה ביותר.
  • [ ] נבדק בפועל איך כל מערכת CRM/ERP מחזירה מזהים, ולא רק מה מופיע בתיעוד שלה.

שאלות נפוצות

למה JSON.parse משנה את המזהה הגדול שלי?

כי Number ב-JavaScript הוא מספר נקודה צפה של 64 ביט, שמייצג מספרים שלמים במדויק רק עד 9007199254740991. מספרים גדולים יותר מעוגלים לערך הקרוב ביותר שניתן לייצג, בלי שום שגיאה (AI JSONMedic).

האם פונקציית reviver יכולה לתקן את זה?

לא ב-JSON.parse הקלאסי, כי כשה-reviver רץ המספר כבר עוגל (JSON Editor Online). הארגומנט החדש context.source חושף את הטקסט המקורי של ערכים פרימיטיביים (MDN JSON.parse), אבל צריך לבדוק תמיכה בסביבת הריצה ואת סטטוס ההצעה (TC39) לפני שמסתמכים עליו.

מה הדרך הבטוחה ביותר להעביר מזהים ב-JSON?

לשלוח אותם כמחרוזות ולהמיר עם BigInt() רק כשנדרשת פעולה מספרית. זו גם הסיבה שדרייברים של Postgres מחזירים bigint כמחרוזת (Neon).

איזו ספרייה שומרת על מספרים גדולים?

lossless-json מפענחת מספרים ל-LosslessNumber, עם אפשרות לפלט bigint ושגיאה על מפתחות כפולים (lossless-json). Neon מציגה את json-custom-numbers כחלופה נוספת (Neon).

האם JSON.parse פוגע גם במספרים עשרוניים גדולים או קטנים מאוד?

כן. 1e400 הופך ל-Infinity, 1e-400 הופך ל-0, ו-Infinity מסודר חזרה כ-null. גם אפסים נגררים כמו ב-2.370 נעלמים בסבב parse/stringify (lossless-json).

האם זה באג ב-JSON.parse או במפרט JSON?

לא. המפרט לא מגביל מספרים ורק מזהיר מבעיות תאימות (Neon), ו-JSON.parse מממש נכון את ההתנהגות של float64. הבעיה היא חוסר התאמה בין יצרן שמייצר מספרים שלמים של 64 ביט לבין צרכן שמפרש אותם כנקודה צפה.

סיכום

JSON.parse לא נכשל כשהוא פוגש מספר שהוא לא יכול לייצג. הוא מעגל אותו, מחזיר ערך שנראה הגיוני, וממשיך הלאה. מזהים מעל Number.MAX_SAFE_INTEGER מאבדים ספרות, מספרים עם מעריכים קיצוניים הופכים ל-Infinity או ל-0, Infinity הופך ל-null בסידור חוזר, ופורמט עשרוני נמחק. לצד אלה יש מקרי קצה כמו מפתחות כפולים שבהם הערך האחרון דורס את הקודמים, -0 שמאבד את הסימן ב-JSON.stringify, והטיפול המיוחד ב-__proto__.

הפתרון מתחיל בתכנון: מזהים יוצאים כמחרוזות, וסכומים כספיים לא עוברים כ-float. כשאין שליטה על היצרן, משתמשים במפענח ששומר על הטקסט המקורי, כמו lossless-json, או ב-context.source בסביבות שבהן התמיכה אומתה. reviver קלאסי לבדו לא פותר את הבעיה, ו-BigInt דורש טיפול מפורש בחישובים ובסידור.

באינטגרציות CRM/ERP ובזרימות n8n, שבהן מזהים הם הבסיס להתאמת רשומות, הבאג הזה יכול להתבטא כרשומות שנעלמות או מתעדכנות במקום הלא נכון. בדיקות עם ערכי גבול, סריקה של payloads גולמיים וצ'קליסט פשוט מספיקים כדי לתפוס את רוב המקרים לפני שהם מגיעים לפרודקשן.

מקורות

וואטסאפ