Sidà za ka ɓoye/buɗe JSON a cikin Go?

Question

IT Interview Practice · Accepted Answer

Jerin standard library na Go **`encoding/json`** yana karɓar aiki na JSON serialization (marshaling) da deserialization (unmarshaling), yana saita dangantaka tsakanin Go structs da JSON. **Struct tags** suna sarrafa suna filayen, kuma ita ce tushe na yawancin Go web APIs.

## 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` yana juyar da struct zuwa JSON bytes. **Kawai filayen da aka buɗe (capitalized) ne za a ɓoye** — filayen da ba a buɗi su ba a toshe su.

## Aiki na 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
}
```

Ba tare da tags ba, JSON keys zasu buɗe zuwa suna daidai (capitalized) na fili. Tags suna ba ka damar sarrafa suna JSON key, toshe bakin values (`omitempty`), da warware filayen jiya (`-`) — abin da ya zama mahimmanci don dangantaka API conventions (misali 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` yana buɗe JSON zuwa struct — dole ne ka lakayi **pointer** don ya iya buɗe struct. Filayen zasu danganta ta tag/name (ba tare da bambantawa na haruffa ba).

## Aiki tare da unknown/dynamic 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!)
```

## Streaming tare da Encoder/Decoder (don 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)
```

Gare web servers, `Encoder`/`Decoder` suna aiki kai tsaye tare da streams (request/response bodies) — alada kwatantaciyar shine a cikin handlers.

## Me ya sa ya zama mahimmanci

JSON encoding/decoding shine mahimmanci ga kusan duk Go web development — REST APIs, microservices, da configuration duk suna dogara kan jujuyar tsakanin Go structs da JSON.

`encoding/json` package (standard library, babu dogaro) shine kayan aikace-aikacen standard, kuma fahimtar shi sosai ya zama mahimmanci ilimi na kwana-kwana: yadda marshaling/unmarshaling ke aiki, tsarin mahimmanci cewa **kawai filayen da aka buɗe ne za a ɓoye**, da musamman **struct tags** (sarrafa suna JSON key tare da `json:"..."`, `omitempty` don toshe bakin values, `-` don warware) waɗanda aka buƙata don dangantaka conventions na ainihi na API kamar snake_case.

Sanin ka lakayi pointer ga `Unmarshal`, sarrafa dynamic JSON ta hanyar maps/`interface{}` (tare da wahawwar cewa JSON numbers zasu buɗe zuwa `float64`), da amfani da streaming `Encoder`/`Decoder` don HTTP bodies yana samin buƙatun aikace-aikacen gida na gina APIs.

Ita ce sanya ta yau da kullum, sanya aikace-aikace na Go backend work.

Marshaling: Go struct → JSON

Aiki na struct tags

Unmarshaling: JSON → Go struct

Aiki tare da unknown/dynamic JSON

Streaming tare da Encoder/Decoder (don I/O)

Me ya sa ya zama mahimmanci

Tambayoyi masu alaƙa