Piye carane ngsandi/mbuka sandi JSON ing Go?

Question

Accepted Answer

Paket **`encoding/json`** ing pustaka standar Go nangani serialisasi JSON (marshaling) lan deserialisasi (unmarshaling), nggambar antarane struct Go lan JSON. **Struct tags** ngontrol jeneng lombok, lan iku tulang punggung umume Go web APIs.

## Marshaling: struct Go → 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` ngowahi struct dadi byte JSON. **Mung lombok sing diekspor (akeh huruf besar) sing disambung** — lombok sing ora diekspor kalowen.

## Peran struct tags

```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
}
```

Tanpa tag, kunci JSON nggawa jeneng lombok sing tepat (akeh huruf besar). Tag nyadhiake sampeyan ngontrol jeneng kunci JSON, ngilangi nilai kosong (`omitempty`), lan ngasingake lombok (`) - `) — penting kanggo matchting API conventions (contone snake_case JSON).

## Unmarshaling: JSON → struct Go

```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` nganalisa JSON menyang struct — sampeyan kudu ngirim **pointer** supaya bisa isi struct. Lombok dicocogake kanthi tag/jeneng (ora sensitif ing case).

## Kerja kanthi JSON sing ora dikenal/dinamis

```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!)
```

## Streaming kanthi Encoder/Decoder (kanggo I/O)

```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)
```

Kanggo web server, `Encoder`/`Decoder` kerja langsung kanthi stream (badan request/response) — pola umum ing handler.

## Apa Sing Penting

Penyandian/pemecahan sandi JSON penting banget kanggo ampir kabeh pangembangan web Go — REST API, microservices, lan konfigurasi kabeh ngandelake ngowahi antarane struct Go lan JSON.

Paket `encoding/json` (pustaka standar, ora ana ketergantungan) yaiku alat standar, lan ngerti kanthi apik yaiku pengetahuan penting saben dinten: piye marshaling/unmarshaling kerja, aturan krusial yen **mung lombok sing diekspor sing disambung**, lan utamane **struct tags** (ngontrol jeneng kunci JSON kanthi `json:"..."`, `omitempty` kanggo ngilangi nilai kosong, `-` kanggo ngasingake) sing dibutuhake kanggo matchting API conventions nyata kayata snake_case.

Ngerti yen kudu ngirim pointer menyang `Unmarshal`, nangani JSON dinamis liwat peta/`interface{}` (kanthi gotcha yen angka JSON metu dadi `float64`), lan nggunakake streaming `Encoder`/`Decoder` kanggo badan HTTP ngrembakani kabutuhan praktis saka bangunan API.

Iku bagean sing tetep lan praktis saka karya backend Go.