როგორ ხდება JSON-ის კოდირება/დეკოდირება Go-ში?

Question

Accepted Answer

Go-ის სტანდარტული ბიბლიოთეკის **`encoding/json`** პაკეტი ზღუპრობს JSON სერიალიზაციას (marshaling) და დესერიალიზაციას (unmarshaling), რომელიც აკავშირებს Go structures-ს და JSON-ს. **Struct tags** აკონტროლებს field-ების დასახელებას და ეს არის ყველაზე მეტ Go web API-ების საფუძველი.

## 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` მარტივად გადაიყვანს struct-ს JSON bytes-ში. **მხოლოდ exported (დიდი ასოებით დაწყებული) field-ები იკოდება** — unexported field-ები იგნორირდება.

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

Tag-ების გარეშე, JSON keys აბრუნებს point field-ის სახელს (დიდი ასოებით დაწყებული). Tag-ები საშუალებას გაძლევთ აკონტროლოთ JSON key-ის სახელი, გამოტოვოთ ცარი მნიშვნელობები (`omitempty`), და სრულად გამოტოვოთ field-ები (`-`) — აუცილებელი API კონვენციებთან შესაბამისობისთვის (მაგ. 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-ს struct-ში — თქვენ უნდა გადასცეთ **pointer** რომ მას შეძლოს struct-ის შევსება. Field-ები მოწვევილია tag/სახელის მიხედვით (case-insensitively).

## უცნობი/დინამიური 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!)
```

## Stream-ვით 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)
```

Web სერვერებისთვის, `Encoder`/`Decoder` პირდაპირ მუშაობს stream-ებით (request/response bodies) — ზოგადი pattern handler-ებში.

## რატომ მნიშვნელოვანია

JSON encoding/decoding ფუნდამენტური არის ყველაზე ყველა Go web development-ისთვის — REST API-ები, microservices-ები და კონფიგურაციები სულ დამოკიდებულნი არიან Go structures-ებისა და JSON-ის შორის კონვერტაციაზე.

`encoding/json` პაკეტი (სტანდარტული ბიბლიოთეკა, განუცდელი დამოკიდებულება) სტანდარტული ინსტრუმენტია, და მის კარგი ცოდნა აუცილებელი ყოველდღიური ცოდნაა: როგორ მუშაობს marshaling/unmarshaling, კრიტიკული წესი რომ **მხოლოდ exported field-ები არიან კოდირებული**, და განსაკუთრებით **struct tags** (JSON key-ის სახელების კონტროლი `json: