Golang const: Tipli ve Tipsiz Sabitler

Sabit, derleme zamanında belirlenen bir değerdir. const ile tanımlayın; Go onu değiştirme girişimlerinin hepsini reddeder.

package main

import (
	"fmt"
	"time"
)

const AppName = "inventory"
const MaxRetries = 3
const Timeout = 2 * time.Second

const (
	KB = 1024
	MB = 1024 * KB
	GB = 1024 * MB
)

func main() {
	fmt.Println(AppName, MaxRetries, Timeout)
	fmt.Println("1 GB =", GB, "bytes")
	fmt.Printf("upload limit: %.1f MB\n", 15_000_000.0/MB)
}

Sabitler paket seviyesinde ya da bir fonksiyonun içinde, her satıra bir tane ya da bir const ( ... ) bloğunda gruplanarak tanımlanabilir. MB ve GB başka sabitlerden hesaplanır ve derleyici bu aritmetiği bir kez, derleme sırasında yapar.

MaxRetries = 5 gibi bir sabite atama yapmak derleme hatasıdır:

./main.go:8:2: cannot assign to MaxRetries (neither addressable nor a map index expression)

Neler Sabit Olabilir

Yalnızca üç tür değer: boolean'lar, sayılar (tam sayılar, ondalıklı sayılar, karmaşık sayılar ve rune'lar) ve string'ler. Değerin derleyici tarafından hesaplanabilir olması gerekir; bu da literal'ler, diğer sabitler, bunlar üzerindeki aritmetik ve sabit bir string'in len'i gibi birkaç yerleşik fonksiyon demektir.

Kod çalıştırmayı ya da bellek ayırmayı gerektiren her şey dışarıda kalır:

const Colors = []string{"red", "green"} // slice
const Started = time.Now()              // function call

./main.go:9:16: []string{…} (value of type []string) is not constant
./main.go:10:13: time.Now() (value of struct type time.Time) is not constant

Go'da Neden Sabit Slice ya da Map Yok

Slice'lar, map'ler ve bunları içeren struct'lar çalışma zamanında var olan belleğe referanslardır, bu yüzden derleyici onları programa sabit değerler olarak gömemez; Go'da değişkenler için readonly ya da final niteleyicisi de yoktur. Yaygın geçici çözümler:

package main

import (
	"fmt"
	"slices"
)

// A package-level var: fine when your own code is the only writer.
var weekdays = []string{"Mon", "Tue", "Wed", "Thu", "Fri"}

// A function returning a fresh copy: callers cannot change the original.
func Weekdays() []string {
	return slices.Clone(weekdays)
}

// An array has a fixed length, but it is still a var, not a const.
var primes = [5]int{2, 3, 5, 7, 11}

func main() {
	days := Weekdays()
	days[0] = "Monday" // changes the copy only

	fmt.Println(days)
	fmt.Println(weekdays)
	fmt.Println(primes, len(primes))
}

Kopya her çağrıda bir bellek ayırmaya mal olur; bu, yapılandırma boyutundaki veriler için sorun değildir. Anahtarla arama için bir fonksiyonun içindeki switch sabite benzer başka bir seçenektir: func statusText(code int) string { switch code { ... } }.

Tipsiz Sabitler

Tip belirtilmeden tanımlanan bir sabit tipsizdir. Bir türü (tam sayı, ondalıklı, rune, string, bool) vardır ama kullanılana kadar belirli bir Go tipi yoktur ve bağlama uyum sağlar:

package main

import "fmt"

const Ratio = 2 // untyped integer constant

func main() {
	var a int = Ratio
	var b float64 = Ratio
	var c uint8 = Ratio
	var d float32 = Ratio * 1.5

	fmt.Println(a, b, c, d)
	fmt.Printf("%T %T %T %T\n", a, b, c, d)

	// When nothing forces a type, the default type is used.
	x := Ratio
	y := Ratio * 1.5
	fmt.Printf("x is %T, y is %T\n", x, y)
}

Ratio, dönüşüm olmadan bir int, bir float64, bir uint8 ve bir float32 olarak çalışır. time.Sleep(2 * time.Second) ifadesinin derlenmesinin nedeni budur: 2 tipsizdir ve bir time.Duration olur.

Bağlam bir tip istemediğinde, x := Ratio örneğinde olduğu gibi, sabit kendi varsayılan tipini alır:

Kesin aritmetik

Tipsiz sayısal sabitler kesindir. Derleyici tam sayıları en az 256 bitle temsil eder, bu yüzden ara değerler herhangi bir Go tipinden çok daha büyük olabilir:

package main

import "fmt"

const Huge = 1 << 100
const Scaled = Huge >> 98 // 4: fits in an int

func main() {
	fmt.Println(Scaled)
	fmt.Println(Huge / (1 << 90)) // 1024
}

Huge'ın kendisi bir tam sayı olarak yazdırılamaz, çünkü onu fmt.Println'e vermek int'e dönüştürür ve derleyici bunu yakalar (float64(Huge) çalışır, çünkü bir float bu büyüklüğü tutabilir):

cannot use Huge (untyped int constant 1267650600228229401496703205376) as int value in argument to fmt.Println (overflows)

Aynı kontrol daha küçük hataları da derleme zamanında durdurur, örneğin var b byte = 300:

cannot use 300 (untyped int constant) as byte value in variable declaration (overflows)

Tipli Sabitler

Bir sabite tip verdiğinizde, Go'nun tipleri karıştırmayı reddetmesi dahil her yerde o tipin bir değeri gibi davranır:

const Limit int = 10

var f float64 = 2
fmt.Println(Limit * f)

invalid operation: Limit * f (mismatched types int and float64)

const Limit = 10 (tipsiz) ile Limit * f derlenir ve 20 verir. Bu yüzden tip bir anlam taşımadıkça sabitleri tipsiz bırakın. Kendi adlandırılmış tipinizde sabitler tanımladığınızda tip anlam taşır; Go enum'ları böyle kurar:

type Weekday int

const (
	Sunday Weekday = iota
	Monday
	Tuesday
)

Burada asıl mesele tiptir: Weekday alan bir fonksiyon ne istediğini belgeler. iota ve onun üzerine kurulan enum kalıpları enum'lar ve iota sayfasında anlatılıyor.

const ve var

Gerçekten sabit olan her şey için const kullanın: limitler, boyutlar, adlar, protokol kodları, format string'leri. Derleme zamanı taşma kontrollerini ve kesin aritmetiği bedavaya alırsınız.

Tuzaklar

Tipli sabitler uyum sağlamaz. const Timeout int = 5, dönüşüm yapılmadan time.Duration beklenen bir yere verilemez; tipsiz bir const Timeout = 5 ise çarpılabilir: Timeout * time.Second.

Tam sayı sabitlerinde tam sayı bölmesi yapılır. const Half = 1 / 2 değeri 0'dır, çünkü iki işlenen de tipsiz tam sayıdır. 0.5 elde etmek için 1.0 / 2 yazın.

Adres yok. &MaxRetries derlenmez. Bir API *int istiyorsa önce sabiti bir değişkene kopyalayın.