როგორ დეკლარირებთ ცვლადებს და რა არის Go-ს ძირითადი ტიპები?

Question

Accepted Answer

Go არის სტატიკურად ტიპიზირებული მრავალი გზით ცვლადების დეკლარაციისთვის. ყველაზე გავრცელებული არის **მოკლე დეკლარაცია** `:=`, რომელიც ამჯამებს ტიპს. Go-ს ძირითადი ტიპები მოიცავს რიცხვებს, სტრიქონებს, ლოგიკური მნიშვნელობებს და ა.შ.

## ცვლადების დეკლარაცია

```go
var x int = 42        // full form: explicit type and value
var y = 42            // type inferred → int
var z int             // declared, ZERO-valued (z = 0)

name := "Ann"         // short declaration (:=) — infers type, INSIDE functions only
count := 10

var a, b = 1, "two"   // multiple at once
const Pi = 3.14159     // constant (compile-time)
```

`:=` არის დიოტიმატური ფუნქციის შიგნით გზა — მოკლე ტიპის დამაჯამებელი. `var` გამოიყენება პაკეტის დონეზე და როდესაც გსურთ აშკარა ტიპი ან მხოლოდ ნულოვანი მნიშვნელობა.

## ძირითადი ტიპები

```go
// integers
int, int8, int16, int32, int64     // signed (int is platform-sized, usually 64-bit)
uint, uint8, ..., uint64           // unsigned
byte                                // alias for uint8
rune                                // alias for int32 — a Unicode code point

// floating point
float32, float64                    // float64 is the default for decimals

// others
string                              // immutable UTF-8 text
bool                               // true / false
complex64, complex128              // complex numbers
```

## ნულოვანი მნიშვნელობები — "არაინიციალიზებული" ცვლადები არ არის

```go
var i int       // 0
var f float64   // 0.0
var s string    // "" (empty)
var b bool      // false
var p *int      // nil
```

Go-ს გადამწყვეტი ფუნქცია: ყველა დეკლარირებული ცვლადი ავტომატურად იღებს სამეტო **ნულოვან მნიშვნელობას** — არ არის განუსაზღვრელი/쓰레기ი მნიშვნელობები. ეს ხდის კოდს უფრო უსაფრთხო და ნიშნავს, რომ ხშირად შეგიძლიათ გამოტოვოთ აშკარა ინიციალიზაცია.

## ტიპის კონვერტაციები აშკარაა

```go
var i int = 42
var f float64 = float64(i)   // MUST convert explicitly — no implicit coercion
var u uint = uint(f)
// i + f  → ❌ compile error: mismatched types
```

Go მოითხოვს **აშკარა** ტიპის კონვერტაციას — ის არასდროს აურიოს ტიპებს აშკარად, რაც ხელს უშლის დახვეწილი ბაგების კლასს.

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

Go-ს ცვლადების დეკლარაციის და ტიპების გამოცნობა ფუნდამენტალურია ნებისმიერი Go-ს დაწერისთვის.

დიოტიმატური `:=` მოკლე დეკლარაცია დამაჯამებელი ინფერენციით ხელს უშლის კოდის სიმფონიას, ხოლო `var` და მუდმივები ასრულებენ მათ როლს.

**ნულოვანი მნიშვნელობის გარანტია** (ყველა ცვლადი უსაფრთხოდ ინიციალიზებული) არის Go-ს განსაკუთრებული, მნიშვნელოვანი ფუნქცია, რომელიც აღმოფხვრის არაინიციალიზებული ცვლადების ბაგებს და ხაზავს დიოტიმატურ შაბლონებს (მაგ. ნულოვანი სტრუქტურა ხშირად გამოსაყენებელია).

და Go-ს ამჟამინობა **აშკარა ტიპის კონვერტაციის** შესახებ (არ არის ნაგულისხმევი დაპირებელი) არის განზრახ უსაფრთხოების არჩევანი, რომელიც ხელს უშლის ჩუმი რიცხვითი ბაგებს, რომლებსაც სხვა ენები იძლევის.

ძირითადი ტიპების ცოდნა (განსაკუთრებით `rune` უნიკოდის জন্য, `byte` და რომ `int`/`float64` არის ნაგულისხმევი) ყოველდღიური აუცილებელი ცოდნაა.