JSON를 언어별로 비교하기

<span class="kw">import</span> <span class="pk">kotlinx.serialization.*</span>
<span class="kw">import</span> <span class="pk">kotlinx.serialization.json.*</span>

<span class="an">@Serializable</span>
<span class="kw">data class</span> <span class="ty">User</span>(
    <span class="kw">val</span> id: <span class="ty">Int</span>,
    <span class="kw">val</span> name: <span class="ty">String</span>,
    <span class="an">@SerialName</span>(<span class="str">"email_address"</span>)
    <span class="kw">val</span> email: <span class="ty">String</span>,
    <span class="kw">val</span> active: <span class="ty">Boolean</span> = <span class="kw">true</span>
)

<span class="kw">fun</span> <span class="fn">main</span>() {
    <span class="kw">val</span> json = Json {
        prettyPrint = <span class="kw">true</span>
        ignoreUnknownKeys = <span class="kw">true</span>
        encodeDefaults = <span class="kw">false</span>
    }

    <span class="kw">val</span> user = User(<span class="num">1</span>, <span class="str">"Alice"</span>, <span class="str">"alice@test.com"</span>)

    <span class="cm">// 직렬화</span>
    <span class="kw">val</span> jsonStr = json.<span class="fn">encodeToString</span>(user)
    <span class="fn">println</span>(jsonStr)

    <span class="cm">// 역직렬화</span>
    <span class="kw">val</span> decoded = json.<span class="fn">decodeFromString</span>&lt;<span class="ty">User</span>&gt;(jsonStr)
    <span class="fn">println</span>(decoded.name)

    <span class="cm">// 리스트 직렬화</span>
    <span class="kw">val</span> users = listOf(user, user.copy(id = <span class="num">2</span>, name = <span class="str">"Bob"</span>))
    <span class="fn">println</span>(json.<span class="fn">encodeToString</span>(users))
}

from pathlib import Path
import json

# pathlib — 경로 조작
base = Path("/home/user/projects")
file = base / "data" / "config.json"   # / 연산자로 결합

print(file.name)        # config.json
print(file.stem)        # config
print(file.suffix)      # .json
print(file.parent)      # /home/user/projects/data

# 파일 읽기 (with문으로 자동 닫기)
sample = Path("sample.txt")
sample.write_text("Hello\nWorld\nPython", encoding="utf-8")

# 전체 읽기
content = sample.read_text(encoding="utf-8")

# 줄 단위 읽기
with sample.open(encoding="utf-8") as f:
    for line in f:                  # 메모리 효율적
        print(line.rstrip())

# 파일 쓰기
with open("output.txt", "w", encoding="utf-8") as f:
    f.write("첫 번째 줄\n")
    f.writelines(["두\n", "세\n"])

# JSON 처리
data = {"name": "Alice", "scores": [95, 87, 92]}
Path("data.json").write_text(
    json.dumps(data, ensure_ascii=False, indent=2),
    encoding="utf-8"
)
loaded = json.loads(Path("data.json").read_text(encoding="utf-8"))

# 디렉토리 순회
for p in Path(".").glob("*.py"):
    print(p)

for p in Path(".").rglob("*.json"):  # 재귀
    print(p)

package main

import (
	"encoding/json"
	"fmt"
)

type Address struct {
	City    string `json:"city"`
	Country string `json:"country"`
}

type User struct {
	ID        int       `json:"id"`
	Name      string    `json:"name"`
	Email     string    `json:"email,omitempty"`  // 빈 값 생략
	Password  string    `json:"-"`                // JSON 제외
	Address   Address   `json:"address"`
	Tags      []string  `json:"tags,omitempty"`
}

func main() {
	// 인코딩 (Marshal)
	user := User{
		ID:    1,
		Name:  "Alice",
		Email: "alice@test.com",
		Address: Address{"Seoul", "Korea"},
		Tags:  []string{"admin", "dev"},
	}

	data, err := json.Marshal(user)
	if err != nil { panic(err) }
	fmt.Println(string(data))

	// 들여쓰기 있는 JSON
	pretty, _ := json.MarshalIndent(user, "", "  ")
	fmt.Println(string(pretty))

	// 디코딩 (Unmarshal)
	jsonStr := `{"id":2,"name":"Bob","address":{"city":"Busan","country":"Korea"}}`
	var decoded User
	if err := json.Unmarshal([]byte(jsonStr), &decoded); err != nil {
		panic(err)
	}
	fmt.Printf("이름: %s, 도시: %s
", decoded.Name, decoded.Address.City)

	// 동적 JSON — map 사용
	var dynamic map[string]interface{}
	json.Unmarshal([]byte(jsonStr), &dynamic)
	fmt.Println("name:", dynamic["name"])

	// json.Decoder — 스트림 디코딩
	// decoder := json.NewDecoder(r)
	// decoder.Decode(&obj)
}

import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.node.*;
import com.fasterxml.jackson.annotation.*;

// Jackson 어노테이션
@JsonIgnoreProperties(ignoreUnknown = true)
record User(
    @JsonProperty("user_id") int id,
    @JsonProperty("full_name") String name,
    @JsonIgnore String password,
    @JsonInclude(JsonInclude.Include.NON_NULL) String email
) {}

// 상속 처리
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type")
@JsonSubTypes({
    @JsonSubTypes.Type(value = Dog.class, name = "dog"),
    @JsonSubTypes.Type(value = Cat.class, name = "cat")
})
abstract class Animal { public abstract String sound(); }
class Dog extends Animal { public String sound() { return "멍멍"; } }
class Cat extends Animal { public String sound() { return "야옹"; } }

public class JacksonDemo {
    public static void main(String[] args) throws Exception {
        var mapper = new ObjectMapper();
        mapper.enable(SerializationFeature.INDENT_OUTPUT);

        // 직렬화
        var user = new User(1, "Alice", "secret", "alice@test.com");
        String json = mapper.writeValueAsString(user);
        System.out.println(json);

        // 역직렬화
        String input = """
            {"user_id": 2, "full_name": "Bob", "unknown_field": "ignored"}
            """;
        User decoded = mapper.readValue(input, User.class);
        System.out.println(decoded.name()); // Bob

        // 컬렉션
        String listJson = "[1, 2, 3]";
        var list = mapper.readValue(listJson,
            mapper.getTypeFactory().constructCollectionType(
                java.util.List.class, Integer.class));

        // JsonNode — 동적 JSON
        JsonNode root = mapper.readTree(json);
        System.out.println(root.get("full_name").asText());
        System.out.println(root.has("password")); // false

        // ObjectNode 빌드
        ObjectNode node = mapper.createObjectNode();
        node.put("name", "Java");
        node.put("version", 21);
        node.putArray("features").add("Records").add("Sealed");
        System.out.println(mapper.writeValueAsString(node));
    }
}

<?php
header('Content-Type: application/json; charset=utf-8');
echo json_encode([
    'language' => 'php',
    'version' => PHP_VERSION,
], JSON_UNESCAPED_UNICODE);

// JSON 저장
console.log({ env: process.env.NODE_ENV ?? "development", args: process.argv.slice(2) });

// JSON 저장
console.log({ env: process.env.NODE_ENV ?? "development", args: process.argv.slice(2) });

// JSON 저장
using System;
using System.IO;

Console.WriteLine(Path.Combine("logs", "2026", "app-4.log"));

// JSON 저장
#include <filesystem>
#include <iostream>

int main() {
    std::cout << std::filesystem::path("logs") / "2026" / "app-4.log" << "\n";
}

// JSON 저장
use std::path::PathBuf;
fn main() {
    let path = PathBuf::from("logs").join("2026").join("app-4.log");
    println!("{}", path.display());
}