מאמת JSON

מהי ולידציית JSON?

JSON (JavaScript Object Notation) הוא פורמט להחלפת נתונים, קל משקל ופופולרי במיוחד, שמתוכנן להיות קריא לבני אדם ונוח לעיבוד ויצירה על ידי מכונות. מטרתו העיקרית היא לייצג נתונים מובנים — עצמים, מערכים, מחרוזות, מספרים, ערכים בוליאניים ו־null — בצורה שאינה תלויה בשפה.

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

• אימות סינטקטי: הבטחת שהטקסט הגולמי עומד בכללי הדקדוק הפורמלי כפי שהוגדרו במפרט JSON של ECMA-404. מפרשי JSON בשפות תכנות מודרניות רבות (למשל, JSON.parse() ב-JavaScript, json.loads() ב-Python, JSONDecoder ב-Java) מצפים לסינטקס תקין ויזרקו שגיאות אם הקלט שגוי.
• אימות מבני (סקימה): מעבר לסינטקס, אימות סכימה בודק שהנתוני JSON תואמים למבנה הצפוי, כולל סוגי נתונים, תכונות נדרשות, מגבלות ערך ואובייקטים/מערכים מקוננים. אימות סכימה מתבצע בדרך כלל באמצעות JSON Schema, שמגדיר כללים למה שנחשב לנתונים תקפים.

מדוע לאמת JSON?

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

• מניעת שגיאות: זיהוי ודיווח על שגיאות תחביר (למשל, פסיקים חסרים, סוגריים לא תואמים, תווים לא חוקיים) בשלב מוקדם — לפני ניסיון לעבד את הנתונים.
• שלמות ואבטחת נתונים: דחיית מטעני JSON מקולקלים או זדוניים, המסייעים במניעת התמוטטויות במערכת, התקפות הזרקה או פגיעות בנתונים.
• בטיחות טיפוס: אכוף טיפוסים מחמירים—מבטיח, לדוגמה, ששדה הצפוי להיות בוליאני לא יישלח כמחרוזת, או ש-UUIDים, אימיילים ומספרים יעמדו בפורמט הנכון.
• תאימות בין שפות: הבטחה ש-JSON המיוצר בסביבה אחת (כגון Node.js) יהיה ניתן לעיבוד בצורה בטוחה בסביבה אחרת (כגון Python, Go, Java), תוך מניעת תקלות בסריאליזציה/דסריאליזציה.
• תחזוקתיות ועמידות: מבני נתונים מאומתים משפרים את האפשרות למעקב ומפחיתים את הסיכון לשגיאות שקשה לאבחן בקבצי קונפיגורציה, בלוגים או בבקשות/תשובות API.
• פרטיות ואבטחה: האימות יכול להתבצע כולו בצד הלקוח (בדפדפן), מה שמונע יציאת נתונים גולמיים או רגישים מהמכשיר של המשתמש לאימות.

שגיאות נפוצות באימות JSON (עם דוגמאות מפורטות)

מפתחות ללא גרשיים

כל המפתחות באובייקטים של JSON חייבים להיות מחרוזות במרכאות כפולות.

{ name: "אליס" }

{ "name": "אליס" }

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

מרכאות פשוטות

מחרוזות JSON חייבות להשתמש במרכאות כפולות בלבד; מרכאות בודדות אינן מותרים.

{ 'name': 'בוב' }

{ "name": "בוב" }

שימוש במירכאות בודדות יגרום לשגיאות במנתח בתחומי כל ספריות JSON התואמות.

פסיקים בסוף

אין פסיק מיותר בסוף הפריט האחרון באובייקט או במערך.

{
  "a": 1,
  "b": 2,
}

{
  "a": 1,
  "b": 2
}

פסיקים מיותרים עשויים לעבוד ב-JavaScript, אך אינם מתקבלים במפרשי JSON קפדניים.

בריחת תווים לא תקינה

ציטוטים ותווים מיוחדים בתוך מחרוזות חייבים להיות מבורדים באמצעות תו לסלאש (\).

{ "quote": "תום אמר 'שלום'" }

{ "quote": "תום אמר \"שלום\"" }

רצפי בריחה נוספים כוללים \\ עבור סלאש הפוך, \n עבור שורות חדשות, ו-\t עבור טאבים.

סוגי נתונים שגויים

אין להשתמש במחרוזות לייצוג מספרים, ערכי בוליאן או ערכים ריקים (null).

{ "enabled": "true", "count": "10" }

{ "מאופשר": true, "ספירה": 10 }

JSON מבדילה בין בוליאנים, מספרים ומחרוזות—ודא שהסוג הנכון משמש.

מפתחות לא פרימיטיביים

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

{ 123: "אבג" }

{ "123": "אבג" }

מפתחות כפולים

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

{ "name": "אליס", "name": "בוב" }

רוב המנתחים ישמרו רק את הערך האחרון ("בוב"), תוך התעלמות שקטה מהערכים הקודמים.

שימוש בהערות

תקן JSON אינו מאפשר הערות, אף על פי שחלק מהעורכים תומכים בהן.

{
  // מידע על המשתמש
  "name": "אליס"
}

{
  "name": "אליס"
}

אימות סכימה: אכיפת מבנה וסוגי נתונים

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

• שדות חובה (`required`)
• סוגי נתונים (`type`: מחרוזת, מספר, בוליאני, אובייקט, מערך, ערך ריק)
• פורמטים של מחרוזות (`format`: אימייל, UUID, תאריך-שעה, ועוד)
• התאמת תבניות למחרוזות (`pattern`)
• תחומי מספרים (`מינימום`, `מקסימום`)
• אימות אורך מערך ופריטים (`minItems`, `maxItems`, `items`)
• אימות מורכב לאובייקטים ומערכים
• מגבלות enum (`enum`)

דוגמה: סכמת משתמש (טיוטה-07)

{
  "type": "object",
  "properties": {
    "id":    { "type": "string", "format": "uuid" },
    "name":  { "type": "string", "minLength": 1, "description": "שם משתמש" },
    "email": { "type": "string", "format": "email", "description": "כתובת אימייל" },
    "is_active": { "type": "boolean", "description": "משתמש פעיל" }
  },
  "required": ["id", "name", "email"],
  "additionalProperties": false
}

מה שזה מכתיב:

• המזהה חייב להיות מחרוזת UUID תקפה.
• השם חייב להיות מחרוזת שאינה ריקה.
• האימייל חייב להיות בפורמט אימייל תקני.
• is_active (אופציונלי) חייב להיות מסוג בוליאני.
• אין לאפשר נכסים אחרים מלבד אלו שהוגדרו לעיל.

דוגמה מהעולם האמיתי: אימות תגובות API של Stripe

נניח שאתה מקבל תגובות JSON מ-API של Stripe (למשל, PaymentIntent). אימות הסכימה יכול להבטיח שאתה לא מעבד לעולם נתונים חסרים או לא תקינים בטיפוסם.

{
  "type": "object",
  "properties": {
    "id":      { "type": "string", "pattern": "^pi_" },
    "object":  { "type": "string", "const": "payment_intent" },
    "amount":  { "type": "integer", "minimum": 1 },
    "currency":{ "type": "string", "minLength": 3, "maxLength": 3 },
    "status":  { "type": "string", "enum": [
      "דורש_שיטת_תשלום",
      "דורש_אישור",
      "בתהליך_עיבוד",
      "הושלם_בהצלחה",
      "בוטל"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• הזיהוי חייב להתחיל ב־"pi_"
• העצם חייב תמיד להיות "payment_intent"
• הכמות חייבת להיות מספר שלם גדול או שווה ל-1
• המטבע חייב להיות מחרוזת בת שלוש אותיות (כגון "usd", "eur")
• הסטטוס חייב להיות אחד מהערכים שצוינו

יתרונות

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

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

פרטיות ואבטחה

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

דוגמאות קוד לאימות JSON

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

const jsonString = '{"name":"Alice","age":30}';
try {
  const obj = JSON.parse(jsonString);
  console.log("Valid JSON:", obj);
} catch (e) {
  console.error("Invalid JSON!", e.message);
}

const Ajv = require("ajv");
const ajv = new Ajv();
const schema = { type: "object", properties: { age: { type: "integer" } }, required: ["age"] };
const data = { age: 30 };
const validate = ajv.compile(schema);
console.log(validate(data) ? "Valid!" : ajv.errorsText(validate.errors));

import json
try:
    obj = json.loads('{"name":"Alice","age":30}')
    print("Valid JSON:", obj)
except json.JSONDecodeError as e:
    print("Invalid JSON:", e)

import json, jsonschema
schema = {
    "type": "object",
    "properties": { "age": { "type": "integer" } },
    "required": ["age"]
}
data = {"age": 30}
try:
    jsonschema.validate(data, schema)
    print("Valid!")
except jsonschema.ValidationError as e:
    print("Schema validation error:", e)

package main
import (
  "encoding/json"
  "fmt"
)
func main() {
  data := []byte(`{"name":"Alice","age":30}`)
  var obj map[string]interface{}
  if err := json.Unmarshal(data, &obj); err != nil {
    fmt.Println("Invalid JSON:", err)
  } else {
    fmt.Println("Valid JSON:", obj)
  }
}

import com.fasterxml.jackson.databind.ObjectMapper;
public class Main {
  public static void main(String[] args) {
    String json = "{\"name\":\"Alice\",\"age\":30}";
    try {
      Object obj = new ObjectMapper().readTree(json);
      System.out.println("Valid JSON: " + obj);
    } catch (Exception e) {
      System.out.println("Invalid JSON: " + e.getMessage());
    }
  }
}

using System;
using System.Text.Json;
class Program {
  static void Main() {
    string json = "{\"name\":\"Alice\",\"age\":30}";
    try {
      using var doc = JsonDocument.Parse(json);
      Console.WriteLine("Valid JSON!");
    } catch (JsonException e) {
      Console.WriteLine("Invalid JSON: " + e.Message);
    }
  }
}

<?php
$json = '{"name":"Alice","age":30}';
$obj = json_decode($json);
if (json_last_error() === JSON_ERROR_NONE) {
  echo "Valid JSON";
} else {
  echo "Invalid JSON: " . json_last_error_msg();
}

require 'json'
begin
  obj = JSON.parse('{"name":"Alice","age":30}')
  puts "Valid JSON!"
rescue JSON::ParserError => e
  puts "Invalid JSON: #{e.message}"
end

echo '{"name":"Alice","age":30}' | jq empty && echo "Valid" || echo "Invalid"

fn main() {
  let data = r#"{"name":"Alice","age":30}"#;
  match serde_json::from_str::<serde_json::Value>(data) {
    Ok(_) => println!("Valid JSON!"),
    Err(e) => println!("Invalid JSON: {}", e),
  }
}

import org.json.JSONObject
fun main() {
  try {
    val obj = JSONObject("{\"name\":\"Alice\",\"age\":30}")
    println("Valid JSON: $obj")
  } catch (e: Exception) {
    println("Invalid JSON: ${e.message}")
  }
}

import Foundation
let json = "{\"name\":\"Alice\",\"age\":30}"
if let data = json.data(using: .utf8) {
  do {
    let _ = try JSONSerialization.jsonObject(with: data)
    print("Valid JSON!")
  } catch {
    print("Invalid JSON: \(error)")
  }
}

const jsonString = '{"name":"Alice","age":30}';
try {
  const obj = JSON.parse(jsonString);
  console.log("Valid JSON:", obj);
} catch (e) {
  console.error("Invalid JSON!", e.message);
}

SELECT '{"name":"Alice","age":30}'::jsonb; -- Will error if not valid JSON

SELECT JSON_VALID('{"name":"Alice","age":30}');

$json = '{"name":"Alice","age":30}'
try {
  $obj = $json | ConvertFrom-Json
  Write-Output "Valid JSON!"
} catch {
  Write-Output "Invalid JSON: $($_.Exception.Message)"
}

use JSON;
my $str = '{"name":"Alice","age":30}';
eval { decode_json($str) };
print $@ ? "Invalid JSON: $@" : "Valid JSON!";

import 'dart:convert';
void main() {
  const jsonString = '{"name":"Alice","age":30}';
  try {
    final obj = jsonDecode(jsonString);
    print('Valid JSON: $obj');
  } catch (e) {
    print('Invalid JSON: $e');
  }
}

json = ~s({"name":"Alice","age":30})
case Jason.decode(json) do
  {:ok, _} -> IO.puts("Valid JSON!")
  {:error, err} -> IO.puts("Invalid JSON: #{err}")
end

import play.api.libs.json._
object Main extends App {
  val str = """{"name":"Alice","age":30}"""
  try {
    val json = Json.parse(str)
    println("Valid JSON!")
  } catch {
    case e: Exception => println("Invalid JSON: " + e.getMessage)
  }
}

אודות הכלי הזה