📋 Lesson 8.2: Working with JSON

# These are PYTHON dictionaries — NOT valid JSON!
# Python is more relaxed than JSON.

python_dict = {
    'name': 'Alice',        # ❌ JSON requires DOUBLE quotes, not single
    "age": 28,              # ✅ Double quotes are fine
    "active": True,         # ❌ JSON uses lowercase: true, not True
    "score": None,          # ❌ JSON uses null, not None
    "tags": ["a", "b",],    # ❌ JSON does NOT allow trailing commas
}

# The VALID JSON equivalent would be:
valid_json_string = '''
{
    "name": "Alice",
    "age": 28,
    "active": true,
    "score": null,
    "tags": ["a", "b"]
}
'''
# Notice:
# - ALL strings use DOUBLE quotes (keys AND values)
# - Booleans are lowercase: true/false
# - null instead of None
# - NO trailing comma after the last item
# - NO comments allowed in JSON!

// These are JAVASCRIPT objects — NOT valid JSON!
// JavaScript is more relaxed than JSON.

let jsObject = {
    name: "Alice",          // ❌ JSON requires quotes around keys
    'age': 28,              // ❌ JSON requires DOUBLE quotes, not single
    "active": true,         // ✅ This one is actually valid JSON
    "score": undefined,     // ❌ JSON has no undefined — use null
    "tags": ["a", "b",],   // ❌ JSON does NOT allow trailing commas
};

// The VALID JSON equivalent would be:
let validJsonString = `
{
    "name": "Alice",
    "age": 28,
    "active": true,
    "score": null,
    "tags": ["a", "b"]
}
`;
// Notice:
// - ALL keys must be in DOUBLE quotes
// - ALL strings use DOUBLE quotes
// - No undefined — use null
// - NO trailing comma after the last item
// - NO comments allowed in JSON!
// - NO single quotes anywhere

// C# doesn't have JSON-like literal syntax for objects,
// but here are the JSON rules to remember:

// ✅ VALID JSON:
string validJson = @"
{
    ""name"": ""Alice"",
    ""age"": 28,
    ""active"": true,
    ""score"": null,
    ""tags"": [""a"", ""b""]
}
";

// ❌ INVALID JSON — common mistakes:
// { name: "Alice" }           — keys must be quoted
// { "name": 'Alice' }         — must use double quotes, not single
// { "active": True }          — must be lowercase true/false
// { "tags": ["a", "b", ] }   — no trailing comma
// { "name": "Alice", /* comment */ }  — no comments!

// C# note: In a verbatim string (@"..."), you escape
// double quotes by doubling them: "" instead of \"

import json

# --- Parse a JSON string into a Python dictionary ---
json_string = '{"name": "Alice", "age": 28, "courses": ["Python", "SQL"]}'

data = json.loads(json_string)   # loads = "load string"
print(type(data))     # <class 'dict'>
print(data["name"])   # Alice
print(data["age"])    # 28
print(data["courses"])  # ['Python', 'SQL']
print(data["courses"][0])  # Python

# --- JSON types → Python types ---
json_example = '''
{
    "text": "hello",
    "number": 42,
    "decimal": 3.14,
    "flag": true,
    "nothing": null,
    "items": [1, 2, 3],
    "nested": {"a": 1}
}
'''
result = json.loads(json_example)
print(type(result["text"]))     # str
print(type(result["number"]))   # int
print(type(result["decimal"]))  # float
print(type(result["flag"]))     # bool (True)
print(type(result["nothing"]))  # NoneType (None)
print(type(result["items"]))    # list
print(type(result["nested"]))   # dict

# --- Handling invalid JSON ---
try:
    bad = json.loads('{"name": "Alice",}')   # Trailing comma!
except json.JSONDecodeError as e:
    print(f"Invalid JSON: {e}")
    # Invalid JSON: Expecting property name enclosed in double quotes: line 1 column 18

// --- Parse a JSON string into a JavaScript object ---
let jsonString = '{"name": "Alice", "age": 28, "courses": ["Python", "SQL"]}';

let data = JSON.parse(jsonString);
console.log(typeof data);       // "object"
console.log(data.name);         // Alice
console.log(data.age);          // 28
console.log(data.courses);      // ['Python', 'SQL']
console.log(data.courses[0]);   // Python

// --- JSON types → JavaScript types ---
let jsonExample = `
{
    "text": "hello",
    "number": 42,
    "decimal": 3.14,
    "flag": true,
    "nothing": null,
    "items": [1, 2, 3],
    "nested": {"a": 1}
}
`;
let result = JSON.parse(jsonExample);
console.log(typeof result.text);      // "string"
console.log(typeof result.number);    // "number"
console.log(typeof result.decimal);   // "number" (JS has only one number type)
console.log(typeof result.flag);      // "boolean"
console.log(result.nothing);          // null
console.log(Array.isArray(result.items));  // true
console.log(typeof result.nested);    // "object"

// --- Handling invalid JSON ---
try {
    let bad = JSON.parse('{"name": "Alice",}');  // Trailing comma!
} catch (err) {
    console.log(`Invalid JSON: ${err.message}`);
    // Invalid JSON: Expected double-quoted property name in JSON at position 17
}

// Fun fact: JSON was inspired by JavaScript object syntax,
// which is why JSON.parse and JSON.stringify are built-in!

using System.Text.Json;

// --- Method 1: Parse to JsonDocument (dynamic, no class needed) ---
string jsonString = @"{""name"": ""Alice"", ""age"": 28, ""courses"": [""Python"", ""SQL""]}";

JsonDocument doc = JsonDocument.Parse(jsonString);
JsonElement root = doc.RootElement;

Console.WriteLine(root.GetProperty("name").GetString());   // Alice
Console.WriteLine(root.GetProperty("age").GetInt32());      // 28
Console.WriteLine(root.GetProperty("courses")[0].GetString()); // Python

// --- Method 2: Deserialize to a typed class (recommended!) ---
class Student
{
    public string Name { get; set; } = "";
    public int Age { get; set; }
    public List<string> Courses { get; set; } = new();
}

var options = new JsonSerializerOptions
{
    PropertyNameCaseInsensitive = true    // "name" matches Name
};

Student? student = JsonSerializer.Deserialize<Student>(jsonString, options);
Console.WriteLine(student?.Name);         // Alice
Console.WriteLine(student?.Age);          // 28
Console.WriteLine(student?.Courses[0]);   // Python

// --- Method 3: Deserialize to Dictionary (flexible) ---
var dict = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(jsonString);
Console.WriteLine(dict?["name"].GetString());  // Alice

// --- Handling invalid JSON ---
try
{
    JsonDocument.Parse(@"{""name"": ""Alice"",}");  // Trailing comma!
}
catch (JsonException ex)
{
    Console.WriteLine($"Invalid JSON: {ex.Message}");
}

import json

# --- Convert Python dict → JSON string ---
student = {
    "name": "Alice",
    "age": 28,
    "courses": ["Python", "SQL"],
    "active": True,       # Python True → JSON true (automatic!)
    "gpa": None,          # Python None → JSON null (automatic!)
}

json_string = json.dumps(student)   # dumps = "dump string"
print(json_string)
# {"name": "Alice", "age": 28, "courses": ["Python", "SQL"], "active": true, "gpa": null}

# --- Pretty-printed JSON (human readable) ---
pretty = json.dumps(student, indent=4)
print(pretty)
# {
#     "name": "Alice",
#     "age": 28,
#     "courses": [
#         "Python",
#         "SQL"
#     ],
#     "active": true,
#     "gpa": null
# }

# --- Other useful options ---
# Sort keys alphabetically:
sorted_json = json.dumps(student, indent=2, sort_keys=True)

# Handle non-ASCII characters:
data = {"city": "Zürich", "greeting": "こんにちは"}
print(json.dumps(data))                          # Escaped: "\u00fc", "\u3053..."
print(json.dumps(data, ensure_ascii=False))       # Raw: "Zürich", "こんにちは"

# --- What CANNOT be converted to JSON ---
import datetime
try:
    json.dumps({"now": datetime.datetime.now()})
except TypeError as e:
    print(f"Error: {e}")
    # Error: Object of type datetime is not JSON serializable
    # Fix: convert to string first: str(datetime.datetime.now())

// --- Convert JavaScript object → JSON string ---
let student = {
    name: "Alice",
    age: 28,
    courses: ["Python", "SQL"],
    active: true,
    gpa: null,
};

let jsonString = JSON.stringify(student);
console.log(jsonString);
// {"name":"Alice","age":28,"courses":["Python","SQL"],"active":true,"gpa":null}

// --- Pretty-printed JSON ---
let pretty = JSON.stringify(student, null, 4);
console.log(pretty);
// {
//     "name": "Alice",
//     "age": 28,
//     ...
// }

// The second argument is a "replacer" — use null to include everything.
// The third argument is the indent (spaces or a string).

// --- Replacer: control which properties are included ---
let filtered = JSON.stringify(student, ["name", "age"], 2);
console.log(filtered);
// {
//   "name": "Alice",
//   "age": 28
// }

// --- What CANNOT be converted to JSON ---
let problematic = {
    func: function() {},     // Functions are DROPPED silently!
    undef: undefined,        // undefined is DROPPED silently!
    date: new Date(),        // Dates become strings (ISO format)
    regex: /abc/,            // RegExp becomes {}
};

console.log(JSON.stringify(problematic, null, 2));
// {
//   "date": "2026-04-13T10:30:00.000Z",
//   "regex": {}
// }
// Notice: func and undef are completely gone!

using System.Text.Json;

// --- Method 1: Serialize from a class ---
class Student
{
    public string Name { get; set; } = "";
    public int Age { get; set; }
    public List<string> Courses { get; set; } = new();
    public bool Active { get; set; }
    public double? Gpa { get; set; }    // nullable → JSON null
}

var student = new Student
{
    Name = "Alice",
    Age = 28,
    Courses = new List<string> { "Python", "SQL" },
    Active = true,
    Gpa = null
};

string jsonString = JsonSerializer.Serialize(student);
Console.WriteLine(jsonString);
// {"Name":"Alice","Age":28,"Courses":["Python","SQL"],"Active":true,"Gpa":null}

// --- Pretty-printed JSON ---
var options = new JsonSerializerOptions { WriteIndented = true };
string pretty = JsonSerializer.Serialize(student, options);
Console.WriteLine(pretty);

// --- Use camelCase keys (common for JSON) ---
var camelOptions = new JsonSerializerOptions
{
    WriteIndented = true,
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};
Console.WriteLine(JsonSerializer.Serialize(student, camelOptions));
// {
//   "name": "Alice",
//   "age": 28,
//   ...
// }

// --- Method 2: Serialize from Dictionary ---
var dict = new Dictionary<string, object?>
{
    ["name"] = "Alice",
    ["age"] = 28,
    ["active"] = true,
    ["gpa"] = null,
};
Console.WriteLine(JsonSerializer.Serialize(dict, options));

import json
from pathlib import Path

# --- Write JSON to a file ---
students = [
    {"name": "Alice", "age": 28, "gpa": 3.9},
    {"name": "Bob", "age": 22, "gpa": 3.2},
    {"name": "Charlie", "age": 25, "gpa": 3.7},
]

# Method 1: json.dump() writes directly to a file
with open("students.json", "w", encoding="utf-8") as file:
    json.dump(students, file, indent=4)
    # Note: dump() not dumps() — no 's' means "to file"

# Method 2: Pathlib
Path("students.json").write_text(
    json.dumps(students, indent=4),
    encoding="utf-8"
)

# --- Read JSON from a file ---
# Method 1: json.load() reads directly from a file
with open("students.json", "r", encoding="utf-8") as file:
    loaded = json.load(file)   # load() not loads()

print(loaded[0]["name"])  # Alice

# Method 2: Pathlib
loaded = json.loads(Path("students.json").read_text(encoding="utf-8"))

# --- The pattern: Load → Modify → Save ---
# This is the most common JSON file workflow:
with open("students.json", "r") as f:
    data = json.load(f)                        # 1. Load

data.append({"name": "Diana", "age": 24, "gpa": 3.5})  # 2. Modify

with open("students.json", "w") as f:
    json.dump(data, f, indent=4)               # 3. Save

const fs = require("fs");

// --- Write JSON to a file ---
let students = [
    { name: "Alice", age: 28, gpa: 3.9 },
    { name: "Bob", age: 22, gpa: 3.2 },
    { name: "Charlie", age: 25, gpa: 3.7 },
];

// Stringify with indent, then write
fs.writeFileSync("students.json", JSON.stringify(students, null, 4));

// --- Read JSON from a file ---
let jsonText = fs.readFileSync("students.json", "utf-8");
let loaded = JSON.parse(jsonText);

console.log(loaded[0].name);  // Alice

// --- The pattern: Load → Modify → Save ---
let data = JSON.parse(fs.readFileSync("students.json", "utf-8"));  // 1. Load
data.push({ name: "Diana", age: 24, gpa: 3.5 });                  // 2. Modify
fs.writeFileSync("students.json", JSON.stringify(data, null, 4));  // 3. Save

// --- Helper functions (common pattern) ---
function loadJSON(filename) {
    if (!fs.existsSync(filename)) return null;
    return JSON.parse(fs.readFileSync(filename, "utf-8"));
}

function saveJSON(filename, data) {
    fs.writeFileSync(filename, JSON.stringify(data, null, 4));
}

// Usage:
let students2 = loadJSON("students.json") || [];
students2.push({ name: "Eve", age: 23, gpa: 3.8 });
saveJSON("students.json", students2);

using System.IO;
using System.Text.Json;

class Student
{
    public string Name { get; set; } = "";
    public int Age { get; set; }
    public double Gpa { get; set; }
}

var options = new JsonSerializerOptions
{
    WriteIndented = true,
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};

// --- Write JSON to a file ---
var students = new List<Student>
{
    new() { Name = "Alice", Age = 28, Gpa = 3.9 },
    new() { Name = "Bob", Age = 22, Gpa = 3.2 },
    new() { Name = "Charlie", Age = 25, Gpa = 3.7 },
};

string json = JsonSerializer.Serialize(students, options);
File.WriteAllText("students.json", json);

// --- Read JSON from a file ---
string jsonText = File.ReadAllText("students.json");
var readOptions = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
var loaded = JsonSerializer.Deserialize<List<Student>>(jsonText, readOptions);

Console.WriteLine(loaded?[0].Name);  // Alice

// --- The pattern: Load → Modify → Save ---
string raw = File.ReadAllText("students.json");
var data = JsonSerializer.Deserialize<List<Student>>(raw, readOptions) ?? new();
data.Add(new Student { Name = "Diana", Age = 24, Gpa = 3.5 });    // Modify
File.WriteAllText("students.json", JsonSerializer.Serialize(data, options)); // Save

import json

# A realistic JSON structure (imagine this from an API response)
company_json = '''
{
    "company": "TechCorp",
    "founded": 2015,
    "departments": [
        {
            "name": "Engineering",
            "head": "Alice Chen",
            "employees": [
                {"name": "Bob", "role": "Backend", "skills": ["Python", "SQL"]},
                {"name": "Carol", "role": "Frontend", "skills": ["React", "CSS"]}
            ]
        },
        {
            "name": "Marketing",
            "head": "Dave Kim",
            "employees": [
                {"name": "Eve", "role": "Content", "skills": ["Writing", "SEO"]}
            ]
        }
    ]
}
'''

data = json.loads(company_json)

# --- Navigating the structure ---
print(data["company"])                             # "TechCorp"
print(data["departments"][0]["name"])               # "Engineering"
print(data["departments"][0]["employees"][1]["name"])  # "Carol"
print(data["departments"][0]["employees"][0]["skills"][0])  # "Python"

# --- Iterating over nested structures ---
for dept in data["departments"]:
    print(f"\n{dept['name']} (Head: {dept['head']})")
    for emp in dept["employees"]:
        skills = ", ".join(emp["skills"])
        print(f"  • {emp['name']} — {emp['role']} ({skills})")

# Output:
# Engineering (Head: Alice Chen)
#   • Bob — Backend (Python, SQL)
#   • Carol — Frontend (React, CSS)
# Marketing (Head: Dave Kim)
#   • Eve — Content (Writing, SEO)

# --- Safe access for missing keys ---
# Use .get() to avoid KeyError:
phone = data.get("phone", "N/A")         # "N/A" — key doesn't exist
dept0 = data.get("departments", [])[0]   # Safe even if departments missing

let companyJson = `
{
    "company": "TechCorp",
    "founded": 2015,
    "departments": [
        {
            "name": "Engineering",
            "head": "Alice Chen",
            "employees": [
                {"name": "Bob", "role": "Backend", "skills": ["Python", "SQL"]},
                {"name": "Carol", "role": "Frontend", "skills": ["React", "CSS"]}
            ]
        },
        {
            "name": "Marketing",
            "head": "Dave Kim",
            "employees": [
                {"name": "Eve", "role": "Content", "skills": ["Writing", "SEO"]}
            ]
        }
    ]
}
`;

let data = JSON.parse(companyJson);

// --- Navigating the structure ---
console.log(data.company);                           // "TechCorp"
console.log(data.departments[0].name);               // "Engineering"
console.log(data.departments[0].employees[1].name);  // "Carol"
console.log(data.departments[0].employees[0].skills[0]); // "Python"

// --- Iterating over nested structures ---
for (let dept of data.departments) {
    console.log(`\n${dept.name} (Head: ${dept.head})`);
    for (let emp of dept.employees) {
        console.log(`  • ${emp.name} — ${emp.role} (${emp.skills.join(", ")})`);
    }
}

// --- Safe access with optional chaining (?.) ---
// If any part of the chain is null/undefined, returns undefined instead of crashing
console.log(data?.departments?.[0]?.employees?.[0]?.name);   // "Bob"
console.log(data?.departments?.[5]?.name);                    // undefined (no crash!)
console.log(data?.phone ?? "N/A");                            // "N/A"

// Optional chaining (?.) is one of JavaScript's best features for JSON!

using System.Text.Json;

// --- Using JsonDocument for dynamic navigation ---
string companyJson = @"
{
    ""company"": ""TechCorp"",
    ""founded"": 2015,
    ""departments"": [
        {
            ""name"": ""Engineering"",
            ""head"": ""Alice Chen"",
            ""employees"": [
                {""name"": ""Bob"", ""role"": ""Backend"", ""skills"": [""Python"", ""SQL""]},
                {""name"": ""Carol"", ""role"": ""Frontend"", ""skills"": [""React"", ""CSS""]}
            ]
        },
        {
            ""name"": ""Marketing"",
            ""head"": ""Dave Kim"",
            ""employees"": [
                {""name"": ""Eve"", ""role"": ""Content"", ""skills"": [""Writing"", ""SEO""]}
            ]
        }
    ]
}";

JsonDocument doc = JsonDocument.Parse(companyJson);
JsonElement root = doc.RootElement;

// --- Navigating the structure ---
Console.WriteLine(root.GetProperty("company").GetString());
Console.WriteLine(root.GetProperty("departments")[0].GetProperty("name").GetString());
Console.WriteLine(root.GetProperty("departments")[0]
    .GetProperty("employees")[1]
    .GetProperty("name").GetString());   // "Carol"

// --- Iterating over nested structures ---
foreach (JsonElement dept in root.GetProperty("departments").EnumerateArray())
{
    string name = dept.GetProperty("name").GetString()!;
    string head = dept.GetProperty("head").GetString()!;
    Console.WriteLine($"\n{name} (Head: {head})");

    foreach (JsonElement emp in dept.GetProperty("employees").EnumerateArray())
    {
        string empName = emp.GetProperty("name").GetString()!;
        string role = emp.GetProperty("role").GetString()!;
        var skills = emp.GetProperty("skills").EnumerateArray()
            .Select(s => s.GetString());
        Console.WriteLine($"  • {empName} — {role} ({string.Join(", ", skills)})");
    }
}

// --- Safe access with TryGetProperty ---
if (root.TryGetProperty("phone", out JsonElement phoneEl))
    Console.WriteLine(phoneEl.GetString());
else
    Console.WriteLine("N/A");  // Key doesn't exist

import json

# --- Pitfall 1: Single quotes ---
bad = "{'name': 'Alice'}"       # ❌ Python-style, not JSON!
# json.loads(bad)  → JSONDecodeError
good = '{"name": "Alice"}'      # ✅ Double quotes
data = json.loads(good)

# --- Pitfall 2: Trailing comma ---
bad = '{"a": 1, "b": 2,}'      # ❌ Trailing comma after 2
# json.loads(bad)  → JSONDecodeError
good = '{"a": 1, "b": 2}'      # ✅ No trailing comma

# --- Pitfall 3: Forgetting that JSON values are strings ---
data = json.loads('{"age": "28"}')
# data["age"] is the STRING "28", not the number 28!
# age = data["age"] + 1  → TypeError!
age = int(data["age"]) + 1      # ✅ Convert first

# --- Pitfall 4: Trying to serialize non-JSON types ---
from datetime import datetime

data = {"created": datetime.now()}
# json.dumps(data)  → TypeError: datetime is not serializable

# Fix: convert to string first
data = {"created": datetime.now().isoformat()}
print(json.dumps(data))  # {"created": "2026-04-13T10:30:00.123456"}

# --- Pitfall 5: Not handling missing keys ---
data = {"name": "Alice"}
# print(data["age"])  → KeyError!
print(data.get("age", "unknown"))  # ✅ "unknown"

// --- Pitfall 1: Confusing JS objects with JSON strings ---
let obj = { name: "Alice" };        // JS object (live data)
let str = '{"name": "Alice"}';      // JSON string (text)

// You parse STRINGS, not objects:
// JSON.parse(obj)  → ERROR — it's already an object!
// JSON.stringify(str) → Wraps the string in MORE quotes!

// --- Pitfall 2: undefined disappears ---
let data = { name: "Alice", nickname: undefined };
console.log(JSON.stringify(data));
// {"name":"Alice"}  ← nickname is GONE!
// Fix: use null instead of undefined if you want it in JSON

// --- Pitfall 3: Date objects become strings ---
let event = { name: "Launch", date: new Date("2026-04-13") };
let json = JSON.stringify(event);
let parsed = JSON.parse(json);
console.log(typeof parsed.date);  // "string" — NOT a Date object!
// Fix: convert back manually:
parsed.date = new Date(parsed.date);

// --- Pitfall 4: Circular references ---
let a = {};
let b = { ref: a };
a.ref = b;                          // a → b → a → b → ...
// JSON.stringify(a)  → TypeError: circular structure!
// Fix: remove circular refs, or use a library like 'flatted'

// --- Pitfall 5: NaN and Infinity ---
console.log(JSON.stringify({ val: NaN }));       // {"val":null}
console.log(JSON.stringify({ val: Infinity }));  // {"val":null}
// NaN and Infinity become null in JSON — they're not valid JSON numbers!

using System.Text.Json;

// --- Pitfall 1: Case sensitivity ---
// JSON:  {"name": "Alice"}   (camelCase)
// C#:    public string Name  (PascalCase)
// Without PropertyNameCaseInsensitive, "name" won't match Name!

var options = new JsonSerializerOptions
{
    PropertyNameCaseInsensitive = true   // ✅ Always set this!
};

// --- Pitfall 2: Null handling ---
string jsonWithNull = @"{""name"": ""Alice"", ""age"": null}";

class Person
{
    public string Name { get; set; } = "";
    public int Age { get; set; }  // ❌ int can't be null!
}
// Fix: use nullable types
class PersonFixed
{
    public string Name { get; set; } = "";
    public int? Age { get; set; }  // ✅ int? can be null
}

// --- Pitfall 3: Strict deserialization ---
// System.Text.Json is STRICT by default.
// Extra properties in JSON are silently ignored — that's fine.
// But missing REQUIRED properties can cause issues.

// --- Pitfall 4: DateTime formatting ---
var data = new { Created = DateTime.Now };
Console.WriteLine(JsonSerializer.Serialize(data));
// {"Created":"2026-04-13T10:30:00.1234567"}
// ISO 8601 format — this is correct and standard!
// But when deserializing, make sure the format matches.

// --- Pitfall 5: Escaped quotes in verbatim strings ---
// In @"..." strings, double the quotes:
string json = @"{""name"": ""Alice""}";  // ✅
// Or use $ with regular strings:
string name = "Alice";
string json2 = $"{{\"name\": \"{name}\"}}";  // ✅ But messy!
// Best: build objects and serialize, don't hand-write JSON strings