Golang Değişkenler: var, :=, Sıfır Değerler ve Gölgeleme

Go'da değişken tanımlamanın iki yolu vardır: her yerde çalışan var ve fonksiyonların içinde çalışıp tipi çıkaran kısa biçim :=.

package main

import "fmt"

func main() {
	var city string = "Lisbon" // explicit type and value
	var year = 2026            // type inferred as int
	var score int              // no value: zero value 0
	name := "Ana"              // short declaration, inferred string

	fmt.Println(city, year, score, name)
	fmt.Printf("%T %T %T %T\n", city, year, score, name)
}

Her değişkenin derleme zamanında belirlenen sabit bir tipi vardır. Bir değer verdiğinizde Go tipi o değerden çıkarır, bu yüzden tipi ayrıca yazmak (var city string = "Lisbon") geçerlidir ama gereksizdir.

var ve :=

Bir fonksiyonun içinde deyimsel seçim:

• Bir başlangıç değeriniz varsa x := value.
• Sıfır değeri, yani "bilerek boş" olduğunu belirtmek istediğinizde var x T: var buf bytes.Buffer, var total int.
• Çıkarılan tip istediğiniz tip değilse var x T = value, örneğin var ratio float64 = 1 (düz ratio := 1 bir int olurdu).

Fonksiyon dışında := bir söz dizimi hatasıdır:

./main.go:5:1: syntax error: non-declaration statement outside function body

Sıfır Değerler

Değer verilmeden tanımlanan bir değişken asla çöp değer taşımaz. Tipinin sıfır değerini tutar:

package main

import "fmt"

type Point struct {
	X, Y int
}

func main() {
	var i int
	var f float64
	var b bool
	var s string
	var p *int
	var sl []int
	var m map[string]int
	var pt Point

	fmt.Println(i, f, b, s == "", p, sl == nil, m == nil, pt)
	fmt.Println(len(sl), len(m), m["missing"])
}

İyi Go API'leri sıfır değer işe yarayacak şekilde tasarlanır: sıfır değerli bir sync.Mutex kilitli değildir, sıfır değerli bir bytes.Buffer boştur ve kullanıma hazırdır, len, range ve append nil bir slice üzerinde çalışır. Dikkat edilmesi gereken map'tir: nil bir map'ten okumak sıfır değerler döndürür, ama ona yazmak panic'e yol açar. İçine bir şey koymadan önce map'leri make ile ya da bir literal ile oluşturun.

Birden Fazla Değişken Tanımlamak

package main

import "fmt"

var (
	appName = "inventory"
	version = "1.4.0"
	debug   bool
)

func main() {
	var width, height int = 1920, 1080
	x, y := 3, 4
	first, count := "widget", 12

	fmt.Println(appName, version, debug)
	fmt.Println(width, height, x, y, first, count)

	// swap without a temporary variable
	x, y = y, x
	fmt.Println("after swap:", x, y)
}

var ( ... ) bloğu ilişkili paket seviyesi değişkenleri gruplar. x, y = y, x gibi bir çoklu atamada sağdaki her ifade herhangi bir atama yapılmadan önce değerlendirilir; takasın çalışmasının nedeni budur.

Birden fazla adla kullanılan :=, soldaki adlardan en az biri yeni olduğu sürece hiçbir şeyi yeniden tanımlamaz. Aynı kapsamda zaten var olan adlara yalnızca atama yapılır. err'i yeniden kullanmanızı sağlayan budur:

f, err := os.Open("a.txt")   // declares f and err
g, err := os.Open("b.txt")   // declares g, assigns to the existing err

Adların hiçbiri yeni değilse bu bir hatadır:

./main.go:7:4: no new variables on left side of :=

Zaten var olan bir değişkene atama yapmak için düz = kullanın.

Kullanılmayan Değişkenler Hatadır

Tanımlanıp hiç okunmayan yerel bir değişken derlemeyi durdurur:

./main.go:9:2: declared and not used: x

Bu, kapatabileceğiniz bir uyarı değildir. Değişkeni silin, kullanın ya da hata ayıklarken boş tanımlayıcıyla susturun: _ = x. Boş tanımlayıcı ihtiyacınız olmayan dönüş değerlerini de atar: _, err := fmt.Println("hi").

Paket seviyesindeki değişkenler ve fonksiyon parametreleri bu kuralın dışındadır.

Kapsam ve Gölgeleme

Bir değişken, tanımlandığı yerden onu içeren bloğun ({ ... }) sonuna kadar vardır. İç bir bloktaki :=, dışarıda aynı adda bir değişken olsa bile yeni bir değişken oluşturur. Dıştaki değişken değişmez, gölgelenir:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	count := 0
	input := "42"

	if input != "" {
		count, err := strconv.Atoi(input) // new count, only inside this block
		if err != nil {
			fmt.Println("error:", err)
			return
		}
		fmt.Println("inside:", count)
	}

	fmt.Println("outside:", count) // still 0
}

Program önce inside: 42, sonra outside: 0 yazdırır. if içindeki :=, iç blokta henüz ikisi de olmadığı için hem count'u hem de err'i yeni değişkenler olarak tanımladı. Kod sorunsuz derlenir ve klasik bir "değerim kayboldu" hatası kaynağıdır.

Çözüm, önce err'i tanımlamak ve = ile atamaktır:

var err error
count, err = strconv.Atoi(input)

go vet varsayılan olarak gölgelemeyi raporlamaz. Ayrı shadow analizcisi raporlar, golangci-lint gibi linter'lar da onu etkinleştirebilir.

Adlandırma

• camelCase kullanın: maxRetries, userID. max_retries değil.
• Kısaltmaları tek harf büyüklüğünde tutun: userID, httpClient, parseURL; userId değil.
• Kısa kapsamlar için kısa adlar: döngüde i, reader için r, hata için err. Paket seviyesindeki değişkenler için daha uzun, açıklayıcı adlar.
• Paket seviyesinde büyük harfle başlayan bir ad (var Timeout) diğer paketlere dışa açılır. Paketler ve import'lar sayfasına bakın.

Paket Seviyesindeki Değişkenler

Fonksiyonların dışında tanımlanan değişkenler programın tamamı boyunca yaşar ve main çalışmadan önce, bağımlılık sırasına göre başlatılır. Yapılandırma ve önbellekler için kullanışlıdırlar ve tüm goroutine'ler tarafından paylaşılırlar. Birden fazla goroutine birine yazıyorsa onu bir mutex ile koruyun ya da sync/atomic kullanın; aksi halde bir data race oluşur.

Hiç değişmeyen değerler için sabitleri tercih edin. Bir const yanlışlıkla değiştirilemez ve çalışma zamanında hiçbir maliyeti yoktur.