Go'da değişkenleri nasıl bildirir ve Go'nun temel türleri nelerdir?

Question

Accepted Answer

Go statik tipli bir dildir ve değişken bildirmenin birkaç yolu vardır. En yaygın olanı **kısa bildirim** `:=` operatörüdür ve bu operatör türü otomatik olarak belirler. Go'nun temel türleri sayıları, stringler, boolean değerleri ve daha pek çok şeyi kapsar.

## Değişkenleri bildirme

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

`:=` fonksiyon içinde idiyomatik bir yoldur — kısa ve tür çıkarımıyla. `var` paket seviyesinde ve açık bir tür istediğinizde ya da sadece sıfır değerini kullanmak istediğinizde kullanılır.

## Temel türler

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

## Sıfır değerleri — "başlatılmamış" değişken yoktur

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

Önemli bir Go özelliği: her bildirilen değişken otomatik olarak bir **sıfır değer** alır — tanımlanmamış/çöp değerler yoktur. Bu kodu daha güvenli hale getirir ve sık sık açık başlatmayı atlamanız anlamına gelir.

## Tür dönüşümleri açıktır

```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 **açık** tür dönüşümleri gerektirir — asla türleri dolaylı olarak karışmaz ve bu da bir sınıf incelikli hatayı engeller.

## Neden önemli

Go'nun değişken bildirimleri ve türlerini anlamak, herhangi bir Go kodu yazmak için temeldir.

Tür çıkarımı ile idiyomatik `:=` kısa bildirimi kodu kısa tutar, `var` ve sabitler ise kendi rollerini oynarlar.

**Sıfır değer garantisi** (her değişken güvenle başlatılmıştır) Go'nun ayırt edici ve önemli bir özelliğidir, başlatılmamış değişken hatalarını ortadan kaldırır ve idiyomatik desenleri şekillendirir (örneğin sıfır değerli bir struct sıklıkla kullanılabilir).

Ve Go'nun **açık tür dönüşümlerine** (kapalı coercion yok) ısrarı, diğer dillerin izin verdiği sessiz sayısal hataları engelleyen kasıtlı bir güvenlik seçimidir.

Temel türleri bilmek (özellikle Unicode için `rune`, `byte` ve varsayılanların `int`/`float64` olması) günlük hayatta gerekli bilgidir.