Go'da JSON nasıl encode/decode edilir?

Question

Accepted Answer

Go'nun standart kütüphanesi **`encoding/json`** paketi JSON serileştirmesini (marshaling) ve deserileştirmesini (unmarshaling) işler, Go struct'ları ile JSON arasında eşleme yapar. **Struct tag'leri** alan adlandırmasını kontrol eder ve çoğu Go web API'sinin temelini oluşturur.

## Marshaling: Go struct → JSON

```go
type User struct {
    Name    string `json:"name"`              // tag maps the field to a JSON key
    Email   string `json:"email"`
    Age     int    `json:"age,omitempty"`     // omitempty → skip if zero/empty
    private string                             // unexported → NOT serialized (lowercase)
}

u := User{Name: "Ann", Email: "ann@x.com", Age: 30}
data, err := json.Marshal(u)
fmt.Println(string(data))   // {"name":"Ann","email":"ann@x.com","age":30}
```

`json.Marshal` bir struct'ı JSON bayt'larına dönüştürür. **Yalnızca export edilmiş (büyük harfle başlayan) alanlar serileştirilir** — export edilmemiş alanlar atlanır.

## Struct tag'lerinin rolü

```go
type Product struct {
    ID    int    `json:"id"`                  // → "id"
    Name  string `json:"product_name"`        // → "product_name" (rename)
    Price float64 `json:"price,omitempty"`     // omit if 0
    Notes string `json:"-"`                    // "-" → NEVER serialize this field
}
```

Tag'ler olmadan, JSON anahtarları varsayılan olarak tam (büyük harfle başlayan) alan adını alır. Tag'ler JSON anahtar adını kontrol etmenizi, boş değerleri atlamanızı (`omitempty`), ve alanları tamamen hariç tutmanızı (`-`) sağlar — API kurallarıyla eşleşmek için gereklidir (örn. snake_case JSON).

## Unmarshaling: JSON → Go struct

```go
jsonData := []byte(`{"name":"Bob","email":"bob@x.com","age":25}`)

var user User
err := json.Unmarshal(jsonData, &user)   // pass a POINTER to populate it
if err != nil { log.Fatal(err) }
fmt.Println(user.Name)   // "Bob"
```

`json.Unmarshal` JSON'ı bir struct'a ayrıştırır — struct'ı doldurabileceği için **bir pointer geçirmelisiniz**. Alanlar tag/ad tarafından (büyük/küçük harf duyarlılığı olmaksızın) eşleştirilir.

## Bilinmeyen/dinamik JSON ile çalışmak

```go
// when the structure is unknown, unmarshal into a map or interface{}
var result map[string]interface{}
json.Unmarshal(data, &result)
name := result["name"].(string)        // type-assert the value (JSON numbers → float64!)
```

## Encoder/Decoder ile Streaming (I/O için)

```go
// encode directly to an io.Writer (e.g. an HTTP response) — efficient, no intermediate buffer
json.NewEncoder(w).Encode(user)

// decode directly from an io.Reader (e.g. an HTTP request body)
json.NewDecoder(r.Body).Decode(&user)
```

Web sunucuları için, `Encoder`/`Decoder` doğrudan akışlarla (istek/yanıt gövdeleri) çalışır — handler'larda yaygın patern budur.

## Neden önemli

JSON encoding/decoding, neredeyse tüm Go web geliştirmesinin temelini oluşturur — REST API'ları, mikro hizmetler ve konfigürasyonların tümü Go struct'ları ile JSON arasında dönüşüme dayanır.

`encoding/json` paketi (standart kütüphane, hiçbir bağımlılık yok) standart araçtır ve bunu iyi anlamak gereklidir: marshaling/unmarshaling nasıl çalıştığı, **yalnızca export edilmiş alanların serileştirildiği** kritik kuralı ve özellikle **struct tag'leri** (JSON anahtar adlarını `json:"..."` ile kontrol etmek, boş değerleri atlamak için `omitempty`, hariç tutmak için `-`) gerçek dünya API kurallarıyla (snake_case gibi) eşleşmek için gereklidir.

`Unmarshal`'a bir pointer geçirmeyi bilmek, dinamik JSON'ı map/`interface{}` aracılığıyla işlemek (JSON sayılarının `float64`'e decode olduğu gotcha'sı ile), ve HTTP gövdeleri için streaming `Encoder`/`Decoder` kullanmak API'lar oluşturmanın pratik ihtiyaçlarını kapsar.

Bu, Go backend çalışmasının sabit, pratik bir parçasıdır.