Go Değişkenler

Değişken bir değeri saklamak için kullanılan bellek konumudur, sakladığı değerin çalışma zamanında dinamik olarak değişmesine izin verir. Her değişken tanımlandığında, karşılık gelen türün değerini saklamak için bir bellek bloğu tahsis edilir. Daha fazla detay için Referans El Kitabı - Değişkenler adresini ziyaret edin.

Tanımlama

Go'da tür tanımlaması sonda yapılır. Değişken tanımlama var anahtar kelimesini kullanır, format var değişkenAdı türAdı şeklindedir. Değişken adı tanıtıcı isimlendirme kurallarına uymalıdır.

var intNum int
var str string
var char byte

Birden fazla aynı türde değişken tanımlarken, türü sadece bir kez yazabilirsiniz:

var numA, numB, numC int

Birden fazla farklı türde değişken tanımlarken, () kullanabilirsiniz. Birden fazla () bulunabilir.

var (
  name    string
  age     int
  address string
)

var (
  school string
  class int
)

Bir değişken sadece tanımlanır ve değer atanmazsa, değişkenin sakladığı değer karşılık gelen türün sıfır değeridir.

Atama

Atama = operatörünü kullanır, örneğin:

var name string
name = "jack"

Tanımlarken doğrudan atama da yapabilirsiniz:

var name string = "jack"

Veya şu şekilde de yapabilirsiniz:

var name string
var age int
name, age = "jack", 1

İkinci yöntem her seferinde türü belirtmenizi gerektirir. Resmi tarafından sağlanan söz dizimi şekeri kullanabilirsiniz: kısa değişken başlatma. var anahtar kelimesini ve sondaki türü atlayabilirsiniz, türün ne olduğunu derleyiciye bırakın.

name := "jack" // string türü değişken.

Tür belirtilmese de, sonraki atamalarda tür tutarlı olmalıdır. Aşağıdaki kod derlenemez:

a := 1
a = "1"

Dikkat edilmesi gereken bir diğer nokta, kısa değişken başlatma nil ile kullanılamaz. Çünkü nil hiçbir türe ait değildir, derleyici türünü tahmin edemez.

name := nil // derlenemez

Kısa değişken tanımlama toplu başlatılabilir:

name, age := "jack", 1

Kısa değişken tanımlama yöntemi mevcut bir değişken için kullanılamaz, örneğin:

// Yanlış örnek
var a int
a := 1

// Yanlış örnek
a := 1
a := 2

Ancak bir durum hariç: eski değişkeni atarken aynı anda yeni bir değişken tanımlamak. Örneğin:

a := 1
a, b := 2, 2

Bu tür kod derlenebilir, a değişkeni yeniden atanır, b ise yeni tanımlanır.

Go dilinde bir kural vardır: fonksiyon içindeki tüm değişkenler kullanılmalıdır. Aşağıdaki kod sadece değişkeni tanımlar, ancak kullanmaz:

func main() {
  a := 1
}

Derleme sırasında hata verir, değişkenin tanımlandığı ancak kullanılmadığı belirtilir:

a declared and not used

Bu kural sadece fonksiyon içindeki değişkenler için geçerlidir, fonksiyon dışındaki paket seviyesi değişkenler için bu kısıtlama yoktur. Aşağıdaki kod derlenebilir:

var a = 1

func main() {

}

Anonim

Alt çizgi kullanılarak bir değişkenin gerekmediği belirtilebilir:

Open(name string) (*File, error)

Örneğin os.Open fonksiyonunun iki dönüş değeri vardır, sadece birincisini istiyoruz, ikincisini istemiyoruz. Aşağıdaki gibi yazabilirsiniz:

file, _ := os.Open("readme.txt")

Kullanılmayan değişken derlenemez. Bir değişkene ihtiyacınız olmadığında, alt çizgi _ kullanabilirsiniz.

Değiş Tokuş

Go'da iki değişkenin değerini değiştirmek isterseniz, pointer kullanmanıza gerek yoktur. Atama operatörünü doğrudan kullanarak değiş tokuş yapabilirsiniz. Söz dizimi açısından oldukça sezgiseldir. Örnek:

num1, num2 := 25, 36
num1, num2 = num2, num1

Üç değişken de aynı şekildedir:

num1, num2, num3 := 25, 36, 49
num1, num2, num3  = num3, num2, num1

Aşağıdaki kod parçasını düşünün, bu Fibonacci dizisini hesaplayan küçük bir kod parçasıdır. Hesaplamadan sonra üç değişkenin değeri nedir?

a, b, c := 0, 1, 1
a, b, c = b, c, a+b

Cevap:

1 1 1

Neden olmadığını merak edebilirsiniz:

1 1 2

a'ya b'nin değeri verildiği halde, neden a+b sonucu hala 1? Go birden fazla değişken atama işlemi yaparken, sırası önce değerleri hesaplar, sonra atar. Soldan sağa hesaplamaz.

a, b, c = b, c, a+b

Bunu aşağıdaki gibi açılacağını düşünebilirsiniz:

a = b
b = c
c = a + b

Ancak aslında a, b, c üç sayının değerini ayrı ayrı hesaplayıp sonra onlara atar. Aşağıdaki kod ile aynıdır:

a, b, c = 1, 1, 0+1

Fonksiyon çağrısı söz konusu olduğunda, bu etki daha belirgindir. İki sayının toplamını hesaplayan bir sum fonksiyonumuz var:

func sum(a, b int) int {
  return a + b
}

Fonksiyon kullanarak iki sayıyı toplama:

a, b, c := 0, 1, 1
a, b, c = b, c, sum(a, b)

Sonuç değişmez. sum fonksiyonunun dönüş değerini hesaplarken, parametreleri hala 0 ve 1'dir:

1 1 1

Bu yüzden kodu şu şekilde ayırmanız gerekir:

a, b = b, c
c = a + b

Karşılaştırma

Değişkenler arasındaki karşılaştırmanın büyük bir ön koşulu vardır: türleri aynı olmalıdır. Go dilinde örtük tür dönüştürme yoktur. Aşağıdaki kod derlenemez:

func main() {
  var a uint64
  var b int64
  fmt.Println(a == b)
}

Derleyici size ikisinin türünün aynı olmadığını söyler:

invalid operation: a == b (mismatched types uint64 and int64)

Bu yüzden zorla tür dönüştürme kullanmanız gerekir:

func main() {
  var a uint64
  var b int64
  fmt.Println(int64(a) == b)
}

Jeneriklerden önce, erken Go'da sağlanan yerleşik min, max fonksiyonları sadece ondalık sayıları destekliyordu. 1.21 sürümüne kadar, Go sonunda bu iki yerleşik fonksiyonu jeneriklerle yeniden yazdı. Artık min fonksiyonu ile minimum değeri karşılaştırabilirsiniz:

minVal := min(1, 2, -1, 1.2)

max fonksiyonu ile maksimum değeri karşılaştırma:

maxVal := max(100, 22, -1, 1.12)

Parametreleri tüm karşılaştırılabilir türleri destekler. Go'da karşılaştırılabilir türler şunlardır:

• Boolean
• Sayılar
• String'ler
• Pointer'lar
• Channel (sadece eşitlik判断 için desteklenir)
• Elemanları karşılaştırılabilir türden olan diziler (slice karşılaştırılamaz) (sadece eşitlik判断 için desteklenir) (sadece aynı uzunluktaki diziler arası karşılaştırma desteklenir, çünkü dizi uzunluğu da türün bir parçasıdır ve farklı türler karşılaştırılamaz)
• Alan türleri karşılaştırılabilir türden olan struct'lar (sadece eşitlik判断 için desteklenir)

Bunun dışında, standart cmp kütüphanesini içe aktararak da判断 edebilirsiniz, ancak sadece sıralı tür parametrelerini destekler. Go'da yerleşik sıralı türler sadece sayılar ve string'lerdir.

import "cmp"

func main() {
  cmp.Compare(1, 2)
  cmp.Less(1, 2)
}

Kod Bloğu

Fonksiyon içinde, süslü parantez kullanarak bir kod bloğu oluşturabilirsiniz. Kod blokları arasındaki değişken kapsamları birbirinden bağımsızdır. Aşağıdaki kod gibi:

func main() {
  a := 1

  {
    a := 2
    fmt.Println(a)
  }

  {
    a := 3
    fmt.Println(a)
  }
  fmt.Println(a)
}

Çıktı:

2
3
1

Blok ve blok arasındaki değişkenler birbirinden bağımsızdır, birbirini etkilemez, erişilemez. Ancak üst bloktan etkilenir.

func main() {
  a := 1

  {
    a := 2
    fmt.Println(a)
  }

  {
    fmt.Println(a)
  }
  fmt.Println(a)
}

Çıktı:

2
1
1