JSON Toolkit

מערכים ואובייקטים ב-JSON: מבנה וקינון למתחילים

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

מתחילכ-6 דקות קריאהפורסם 2026-11-20עודכן 2026-11-20
שער היכרות למבני מערכים ואובייקטים ב-JSON

JSON נותן לכם רק שתי מכליות: אובייקט נושא שדות בעלי שם, מערך נושא רשימות מסודרות — וכמעט כל payload שבור מוסבר על ידי מרכאות, פסיקים, או רשימה שנכתבה כאובייקט מזויף.

אחד: ל-JSON יש רק שתי מכליות

לא משנה עד כמה מורכבת תשובת API, הכול מצטמצם לשתי מכליות ושישה סוגי ערך. אובייקט הוא אוסף של זוגות מפתח/ערך בסוגריים מסולסלים {}; מערך הוא רשימה מסודרת של ערכים בסוגריים מרובעים []. ערך יכול להיות מחרוזת, מספר, true, false, null — או שוב אובייקט או מערך. אובייקטים בתוך מערכים, מערכים בתוך אובייקטים: הרקורסיה הזו היא כל עוצמת הביטוי של JSON.

{
  "user": { "name": "Ada", "active": true },
  "roles": ["admin", "editor"],
  "lastLogin": null,
  "loginCount": 42
}

מכאן מסקנה מעשית: מול payload מבלבל, אל תקראו אותו תו בתו. בדקו קודם את התו החיצוני ביותר — { או [. אם זה אובייקט, קראו אותו כשדות בעלי שם; אם זה מערך, קראו אותו כרשימה ואז רדו מפלס למפלס. דיאגרמת התחביר ב-json.org מצטמצמת לעמוד אחד בדיוק כי שתי מבנים ועוד רקורסיה מכסים הכול.

שניים: כתיבת אובייקטים, ארבע כללים נוקשים

אובייקטים הם המקום שבו מתחילים טועים הכי הרבה, אבל הכללים מצטמצמים לארבעה:

  1. מפתחות חייבים להיות מחרוזות במרכאות כפולות. {name: "Ada"} וגם {'name': 'Ada'} אינם תקינים; צריך לכתוב {"name": "Ada"}. ליטרלים של אובייקט ב-JavaScript מרשים מפתחות חשופים וגרשיים בודדים, JSON לא — זו הבלבול השכיח ביותר בין השניים.
  2. הפרידו זוגות בפסיקים ואל תשאירו פסיק אחרי הזוג האחרון. {"a": 1, "b": 2,} נכשל עם Unexpected token } בסוגריים המסולסלים הסוגרים.
  3. מפתחות צריכים להיות ייחודיים. RFC 8259 נוסח זאת כ-SHOULD ולא MUST: מפתחות כפולים לא יוצרים שגיאה, אבל השארת הערך הראשון או האחרון תלויה במימוש, והשפות חלוקות. אל תסתמכו על זה לעולם.
  4. סדר המפתחות אינו משמעותי. {"a":1,"b":2} וגם {"b":2,"a":1} הם אותו אובייקט; כלי diff ופונקציות השוואה מתעלמים מסדר המפתחות. אם הסדר חשוב, הנתונים שייכים למערך.

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

מערכים מאחסנים ערכים לפי מיקום, והאינדוקס מתחיל ב-0: ב-["admin", "editor"] המחרוזת "editor" היא [1]. הסדר הזה משמעותי — זה ההבדל המהותי בין מערכים לאובייקטים. תוצאות חיפוש מדורגות לפי רלוונטיות, רשומות יומן מסודרות לפי תאריך: המידע הזה חי רק ברצף, והמרתו לאובייקט משמידה אותו.

שתי המלצות מעשיות. ראשית, שמרו על הומוגניות של איברים: [{"id":1},{"id":2}] קלים הרבה יותר לצריכה מאשר [1, "text", true] — חוקי, אבל מכריח כל צרכן לבדוק טיפוסים בכל שלב. שנית, מערך ריק [] הוא ערך תקין לחלוטין — כששדה רשימה עוד אינו מכיר תוכן, החזירו [] ולא null, כדי שהצרכן לא יצטרך לבדוק קיום ואז ריקנות.

[
  { "city": "Tokyo", "population": 13960000 },
  { "city": "Delhi", "population": 16780000 }
]

ארבעה: קינון, ארבעת הצורות של payload אמיתיים

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

צורה איך נראה שימוש אופייני
אובייקט מכיל מערך {"tags": ["a","b"]} שדה רשימה של ישות
מערך של אובייקטים [{"id":1},{"id":2}] רשימות רשומות, תוצאות מדורגות בעמודים
אובייקט מכיל אובייקט {"db": {"host": "..."}} קונפיגורציה מקובצת, בלוקי כתובות
מערך של מערכים [[1,2],[3,4]] מטריצות, שורות טבלה

תשובת API טיפוסית משתמשת באובייקט כקליפה ובמערך כתוכן:

{
  "code": 0,
  "data": {
    "items": [
      { "id": 1, "title": "first" },
      { "id": 2, "title": "second" }
    ],
    "page": 1,
    "total": 2
  }
}

אל תקננו למען הקינון. מעבר לשלושה-ארבעה מפלסים, נתיבי הגישה נעשים בלתי קריאים וקוד הצרכן מתנפח במקביל. שדות שנוסעים יחד תמיד שייכים לתת-אובייקט: החליפו את addrCity ו-addrZip ב-address: {city, zip}.

חמישה: אובייקט או מערך, טבלת החלטות

שאלה תשובה למה
לכל ערך יש שם? אובייקט גישה לפי מפתח; הוספה או הסרה של שדות לא שוברת דבר
רשימת רשומות דומות? מערך הסדר חשוב; אפשר map ו-filter
צריך חיפוש מהיר לפי מפתח? אובייקט ממופתח לפי מזהה גישה O(1) במקום מעבר
כמה תכונות של אותה ישות? אובייקט לתכונות אין סדר משלהן
אוסף גדל של איברים דומים? מערך האורך נמתח בחופשיות

אנטי-תבנית אחת ראויה לאזכור מיוחד: חיקוי מערך באובייקט שמפתחותיו "0", "1", "2". הוא מפורסר ללא שגיאה, אבל מאבדים את סמנטיקת האורך וכלי האיטרציה של מערך אמיתי, וצרכנים צריכים למיין Object.keys לפני שקוראים משהו. אם המפתחות הם מספרים סידוריים, כתבו מערך אמיתי. גם ההפך נכון: רשימת זוגות מפתח/ערך כמו [{"key":"theme","value":"dark"}] נחותה מהאובייקט {"theme": "dark"} — אלא אם המפתחות אמנם דינמיים ולא ניתנים להכרזה מראש.

שישה: שלוש שגיאות שכיחות וההודעות שלהן

צורה פגומה שגיאה אופיינית תיקון
פסיק בסוף {"a":1,} Unexpected token } להסיר את הפסיק האחרון
גרשיים בודדים / מפתחות חשופים {name:'Ada'} Unexpected token ' / Expected property name מרכאות כפולות למפתחות ולמחרוזות, תמיד
ליטרלים של Python True / None Unexpected token T להחליף ב-true / null
מערך מזויף במפתחות מספריים בלי שגיאה, סמנטיקה שגויה לכתוב מחדש כמערך אמיתי

שתי הרגלי דיבוג: פרסרים בדרך כלל מדווחים על מיקום אחרי התו האשם, כך שכשאתם רואים position 42 תביטו תו אחד או שניים אחורה; ו-JSON ענק בשורה אחת כדאי לפרמט קודם — מספרי שורה ועמודה מנצחים היסטי תווים בכל פעם. קטלוג השגיאות המלא בטבלת חיפוש שגיאות JSON, ותהליך המיון שלב-אחר-שלב באיך מתקנים שגיאות פרסור של JSON.

שבעה: אחרי הכתיבה, אמתו את המבנה

JSON שנכתב ידנית צריך תמיד לעבור פרסר לפני מסירה. הבדיקה הקלה ביותר מצטמצמת לשורת פקודה אחת:

python3 -m json.tool config.json > /dev/null && echo OK
jq empty config.json && echo OK

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

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

האם אפשר להמיר מערכים ואובייקטים ב-JSON זה לזה?

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

האם מפתחות אובייקט יכולים להיות כפולים?

תחבירית כן — RFC 8259 אומר רק שמפתחות צריכים להיות ייחודיים. אבל JavaScript שומר את הערך האחרון בעוד שספריות משפחת C מסוימות שומרות את הראשון: ההתנהגות שונה בין פרסרים. בחתימות, diff או hash, מפתחות כפולים מייצרים סתירות ישירות. הימנעו בצד המפיק, והתייחסו לכפילויות ממקור לא מוכר כסיכון בצד הצרכן.

האם מערך יכול להכיל ערכים מטיפוסים שונים?

תחבירית כן: [1, "a", true] הוא JSON תקין. אבל מערכים הטרוגניים מכריחים את הצרכן לבדוק טיפוסים בכל מיקום, וקשה לבטא אותם בסכמה. פרט למטריצות וטאפלים — שם המיקום הוא הסמנטיקה עצמה — שמרו על מערכים הומוגניים.

למה {name:'json'} נכשל באימות?

כי JSON מחייב מרכאות כפולות סביב כל מפתח וכל ערך מחרוזתי. {name:'json'} הוא ליטרל אובייקט של JavaScript, לא JSON. החליפו ב-{"name": "json"} והאימות יעבור. גרשיים בודדים, מפתחות חשופים והערות שייכים לניבים כמו JSON5/JSONC, שדורשים פרסרים משלהם במקום JSON.parse התקני.