Golang Veri Tipleri: int, float64, string, bool, byte, rune

Go'nun temel tipleri sayılar, boolean'lar ve string'lerdir. Her değişkenin derleme zamanında belirlenen tam olarak bir tipi vardır ve Go sizin yerinize tipler arasında asla dönüşüm yapmaz. %T herhangi bir değerin tipini yazdırır:

package main

import "fmt"

func main() {
	count := 42
	price := 19.99
	name := "gopher"
	ok := true
	initial := 'G'
	raw := byte('G')
	z := 3 + 4i

	fmt.Printf("%-8v %T\n", count, count)
	fmt.Printf("%-8v %T\n", price, price)
	fmt.Printf("%-8v %T\n", name, name)
	fmt.Printf("%-8v %T\n", ok, ok)
	fmt.Printf("%-8v %T\n", initial, initial)
	fmt.Printf("%-8v %T\n", raw, raw)
	fmt.Printf("%v %T\n", z, z)
}

'G''nin int32 tipiyle 71 olarak yazdırıldığına dikkat edin: tek tırnaklı bir karakter bir rune'dur ve rune bir sayıdır (Unicode kod noktası). rune, int32 için bir takma addır (ikinci bir adla aynı tip), bu yüzden %T int32 raporlar. Aynı şekilde byte da uint8 raporlar.

Tam Sayılar

Varsayılan olarak int kullanın. len() bir int döndürür, slice indeksleri int'tir ve döngü sayaçları int'tir. Her 64 bit platformda int 64 bittir. Boyut bir sözleşmenin parçası olduğunda boyutlu tiplere başvurun: ikili bir dosya formatında int32, ham baytlar için uint8, nanosaniye cinsinden bir Unix zaman damgası için int64.

Sayılar gibi "negatif olamayan" miktarlar için işaretsiz tiplerden kaçının. Sıfırın altına düşen bir çıkarma, yakalayabileceğiniz negatif bir sayı üretmek yerine çok büyük bir sayıya sarar.

Sınırlar ve taşma

math paketinde her sınır için bir sabit vardır. Çalışma zamanında taşan tam sayı aritmetiği sessizce başa sarar:

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxInt:  ", math.MaxInt)
	fmt.Println("MaxInt32:", math.MaxInt32)
	fmt.Println("MaxUint8:", math.MaxUint8)

	var small int8 = 127
	small++
	fmt.Println("127 + 1 as int8:", small)

	var u uint = 0
	u--
	fmt.Println("0 - 1 as uint:", u)

	var n int32 = math.MaxInt32
	fmt.Println("MaxInt32 * 2:", n*2)
}

Panic yok, hata yok: 127 + 1, -128 olur. Yalnızca sabit ifadeler derleme zamanında kontrol edilir (var b int8 = 128 derlenmez). Verinizde taşma olasılığı varsa işlemden önce kontrol edin ya da math/big kullanın.

Tam sayı literal'leri

million := 1_000_000   // underscores for readability (Go 1.13+)
mask := 0xFF           // hexadecimal
perm := 0o755          // octal (also the older form 0755)
flags := 0b1010        // binary

Ondalıklı Sayılar

Ondalık noktası ya da üssü olan bir literal (2.5, 1e6) varsayılan olarak float64'tür ve math paketi float64 alıp döndürür. Büyük bir dizide bellek önemli değilse bunu kullanın.

Float'lar ikili tabanda tutulur, bu yüzden çoğu ondalık kesir yaklaşık değerdir:

package main

import (
	"fmt"
	"math"
)

func main() {
	a := 0.1
	b := 0.2
	fmt.Println(a+b, a+b == 0.3)

	// compare with a tolerance instead
	fmt.Println(math.Abs((a+b)-0.3) < 1e-9)

	// integer division vs float division
	fmt.Println(7/2, 7.0/2, float64(7)/2)

	// special values
	zero := 0.0
	fmt.Println(1/zero, -1/zero, math.NaN())
}

Buradan iki kural çıkar. Aritmetikten sonra float'ları asla == ile karşılaştırmayın. Ve parayı asla bir float'ta saklamayın: kuruş cinsinden bir tam sayı ya da bir decimal kütüphanesi kullanın.

Bir float'ı sıfıra bölmek panic yerine +Inf, -Inf ya da NaN verir. Bir tam sayıyı sıfıra bölmek çalışma zamanında panic'e yol açar (runtime error: integer divide by zero), sabit bir sıfır bölen ise derleme hatasıdır.

Boolean'lar

bool, true ya da false tutar ve sıfır değeri false'tur. Go sayıları, boş string'leri ya da nil'i boolean olarak görmez. if count {} derleme hatasıdır; if count > 0 {} yazın. Operatörler &&, || ve !'dir; && ve || kısa devre yapar.

String'ler

Bir string, genellikle UTF-8 metin olan değiştirilemez bir bayt dizisidir. len(s) karakterleri değil baytları sayar:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "héllo"
	fmt.Println(len(s))                    // bytes
	fmt.Println(utf8.RuneCountInString(s)) // characters
	fmt.Println(s[0], string(s[0]))        // indexing gives a byte

	multiline := `raw string:
backslashes \n stay as written`
	fmt.Println(multiline)
}

é UTF-8'de iki bayt tutar, bu yüzden len beş karakter için 6 raporlar. Çift tırnaklı string'ler \n gibi kaçış dizilerini işler; ters tırnaklı ham string'ler işlemez ve birden fazla satıra yayılabilir. strings sayfası strings paketini, runes and bytes sayfası da UTF-8'i derinlemesine anlatıyor.

byte ve rune

Bunlar yeni tipler değil, takma adlardır: bir byte ile bir uint8 dönüşüm olmadan birbirinin yerine kullanılabilir. Adlar, sayının ne anlama geldiğini söyler.

Karmaşık Sayılar

Go'nun complex64 ve complex128 adında yerleşik karmaşık sayı tipleri vardır; real, imag ve math/cmplx paketiyle birlikte gelirler:

package main

import (
	"fmt"
	"math/cmplx"
)

func main() {
	c := complex(3, 4) // complex128
	fmt.Println(c, real(c), imag(c))
	fmt.Println(cmplx.Abs(c))
	fmt.Println(cmplx.Sqrt(-1))
}

Az sayıda program bunlara ihtiyaç duyar, ama sinyal işleme ve bazı sayısal kodlar duyar.

Bileşik ve Referans Tipleri

Temel tipler bileşik tiplere dönüşür. Her birinin kendi sayfası var:

any, interface{} için bir takma addır (Go 1.18'den beri) ve her tipten bir değer tutabilir.

Adlandırılmış Tipler

Var olan bir tipten yeni bir tip tanımlayabilirsiniz. Aynı temsile sahiptir ama ayrı bir tiptir ve metotları olabilir:

type Celsius float64
type UserID int64

var t Celsius = 21.5
var f float64 = t // compile error: cannot use t (variable of float64 type Celsius) as float64 value in variable declaration

Bu katılığın amacı şudur: bir UserID, OrderID beklenen bir yere yanlışlıkla verilemez. Bunu kastettiğinizde açıkça dönüştürün: float64(t). Kurallar için tip dönüşümü sayfasına, sayılar ile string'ler arasında geçiş için strconv fonksiyonlarına bakın.

Sıfır Değerler

Her tipin bir sıfır değeri vardır; bu, bir şey atamadan önce değişkenin tuttuğu değerdir: sayılar için 0, bool için false, string'ler için "" ve pointer'lar, slice'lar, map'ler, channel'lar, fonksiyonlar ve interface'ler için nil. Go'da ilk değeri verilmemiş değişken yoktur.