Kaip Go atlikti JSON kodavimą/dekodavimą?

Question

Accepted Answer

Go standartinės bibliotekos **`encoding/json`** paketas tvarko JSON serializaciją (marshaling) ir deserializaciją (unmarshaling), susidarydamas ryšį tarp Go strukturų ir JSON. **Struct tags** kontroliuoja lauko pavadinimą ir tai yra daugumos Go tinklo API-jų pagrindas.

## Marshaling: Go struktura → 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` konvertuoja struktūrą į JSON baitus. **Tik eksportuoti (didžiosiomis raidėmis pradėti) laukai yra serializuojami** — neeksportuoti laukai praleidiami.

## Struct tags vaidmuo

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

Be žymų, JSON raktai nustatomi į tikslų lauko pavadinimą (didžiosiomis raidėmis pradėtą). Žymos leidžia kontroliuoti JSON rakto pavadinimą, praleisti tuščias reikšmes (`omitempty`) ir visai neįtraukti laukus (`-`) — būtina atitikti API susitarimus (pvz. snake_case JSON).

## Unmarshaling: JSON → Go struktura

```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` analizuoja JSON į struktūrą — turite perduoti **rodyklę**, kad galėtų užpildyti struktūrą. Laukai suderinami pagal žymą/pavadinimą (neatsižvelgiant į dydį).

## Darbas su nežinomais/dinamišku JSON

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

## Srauto Encoder/Decoder (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)
```

Tinklo serveriams `Encoder`/`Decoder` dirba tiesiogiai su srautais (užklausų/atsakymų kūnai) — bendras modelis tvarkytuvuose.

## Kodėl tai svarbu

JSON kodavimas/dekodavimas yra fundamentalus beveik visoms Go tinklo plėtotės operacijoms — REST API, mikrotarnybos ir konfiguracija pasitiklia konversija tarp Go struktūrų ir JSON.

`encoding/json` paketas (standartinė biblioteka, jokios priklausomybės) yra standartinis įrankis, ir jo gerai suprasti yra esminė kasdienė žinios: kaip veikia marshaling/unmarshaling, kritinė taisyklė kad **tik eksportuoti laukai yra serializuojami**, ir ypač **struct tags** (JSON rakto pavadinimų kontrolė `json:"..."`, `omitempty` tuščioms reikšmėms praleisti, `-` norint neįtraukti) kurie būtini atitikti realius API susitarimus kaip snake_case.

Žinoti, kad reikia perduoti rodyklę į `Unmarshal`, tvarkyti dinaminį JSON per žemėlapius/`interface{}` (su kišeniniu nuotrauka, kad JSON skaičiai yra dekoduojami `float64`), ir naudoti srauto `Encoder`/`Decoder` HTTP kūnams apima praktines API kūrimo poreikius.

Tai pastovus, praktinis Go pagrindinio kodo darbas.