Golang Dizi (Array): Sabit Uzunluk, Değer Semantiği, Slice Farkı

Dizi tanımlamak

Bir dizi tipi [N]T şeklinde yazılır: bir uzunluk, sonra bir eleman tipi. Uzunluk derleme zamanında sabitlenir ve tipin bir parçasıdır.

package main

import "fmt"

func main() {
	var scores [5]int // five zeros
	scores[0] = 90
	scores[4] = 75
	fmt.Println(scores, len(scores))

	days := [3]string{"Mon", "Tue", "Wed"}
	fmt.Println(days[1])

	primes := [...]int{2, 3, 5, 7, 11} // compiler counts: [5]int
	fmt.Printf("%T %v\n", primes, primes)

	// Index keys: unset positions get the zero value.
	sparse := [5]string{1: "b", 3: "d"}
	fmt.Printf("%q\n", sparse)
}

Çıktı:

[90 0 0 0 75] 5
Tue
[5]int [2 3 5 7 11]
["" "b" "" "d" ""]

Bir dizi her zaman tamamen başlatılmıştır. Ayarlamadığınız elemanlar eleman tipinin sıfır değerini tutar: 0, "", false, nil.

İndeksleme ve sınırlar

İndeksler 0'dan len(a)-1'e kadar gider. Aralık dışındaki sabit bir indeks derleme hatasıdır. Aralık dışındaki değişken bir indeks çalışma zamanında panic'e yol açar.

var a [3]int
a[5] = 1 // compile error: invalid argument: index 5 out of bounds [0:3]

i := 5
a[i] = 1 // panic: runtime error: index out of range [5] with length 3

Dolaşmak

for i, v := range a her elemanı sırayla ziyaret eder. v elemanın bir kopyasıdır, bu yüzden v'ye atama yapmak diziyi değiştirmez. Bunun yerine indeks üzerinden yazın.

package main

import "fmt"

func main() {
	temps := [4]float64{21.5, 23.0, 19.8, 25.1}

	sum := 0.0
	for _, t := range temps {
		sum += t
	}
	fmt.Printf("average: %.2f\n", sum/float64(len(temps)))

	for i := range temps {
		temps[i] += 1 // modifies the array
	}
	fmt.Println(temps)
}

Dizilere özgü bir incelik daha var: bir dizi değeri üzerinde range, başta dizinin bir kopyasını değerlendirir. Gövde sonraki elemanları değiştirirse v hâlâ eski değerleri gösterir. &a ya da a[:] üzerinde range yapmak kopyadan kaçınır.

Diziler değerdir

C, Java ya da JavaScript'teki dizilerden asıl fark budur. Bir diziyi atamak her elemanı kopyalar. Bir diziyi bir fonksiyona aktarmak da onu kopyalar.

package main

import "fmt"

func reset(a [3]int) {
	a[0] = 0 // changes the function's copy
}

func resetPtr(a *[3]int) {
	a[0] = 0 // changes the caller's array
}

func main() {
	a := [3]int{1, 2, 3}
	b := a // full copy
	b[0] = 99
	fmt.Println(a, b)

	reset(a)
	fmt.Println(a)

	resetPtr(&a)
	fmt.Println(a)
}

Çıktı:

[1 2 3] [99 2 3]
[1 2 3]
[0 2 3]

Kopyalamak küçük diziler için ucuz, büyükler için pahalıdır: bir [1_000_000]int'i değerle aktarmak sekiz megabayt kopyalar. Dizi büyükse ya da fonksiyonun onu değiştirmesi gerekiyorsa bir pointer (*[N]T) ya da bir slice (a[:]) aktarın. Bir dizi pointer'ı üzerinden indekslemek açık bir * gerektirmez: a[0] bir *[3]int üzerinde çalışır.

Dizileri karşılaştırmak ve map anahtarı olarak kullanmak

Karşılaştırılabilir elemanlardan oluşan diziler == ve != destekler. Her elemanı eşit olan iki dizi eşittir. Bu, onları slice'ların olamadığı geçerli map anahtarları da yapar.

package main

import "fmt"

func main() {
	x := [3]int{1, 2, 3}
	y := [3]int{1, 2, 3}
	fmt.Println(x == y)

	// A grid position as a map key.
	type pos [2]int
	visited := map[pos]bool{}
	visited[pos{0, 0}] = true
	visited[pos{2, 1}] = true
	fmt.Println(visited[pos{2, 1}], visited[pos{1, 1}])
}

Farklı uzunluktaki diziler farklı tiplerdir ve hiç karşılaştırılamaz: [3]int{} == [4]int{} derlenmez (mismatched types [3]int and [4]int).

Çok boyutlu diziler

Dizilerden oluşan bir dizi size sabit bir ızgara verir. Izgaranın tamamı tek bir bitişik bellek bloğudur.

package main

import "fmt"

func main() {
	var board [3][3]rune
	for r := range board {
		for c := range board[r] {
			board[r][c] = '.'
		}
	}
	board[1][1] = 'X'
	board[0][2] = 'O'

	for _, row := range board {
		fmt.Println(string(row[:]))
	}
}

row[:], [3]rune satırını string()'in kabul ettiği bir []rune slice'ına çevirir.

Diziler ve slice'lar

Pratikte dizilerle çoğunlukla birkaç yerde karşılaşırsınız: sha256.Sum256 bir [32]byte döndürür, boyutu hiç değişmeyen arama tabloları ve bir slice'ın arka deposu olarak. Bir diziyi a[:] ya da a[1:3] ile dilimlemek belleğini paylaşan bir slice oluşturur; bu paylaşımın ne anlama geldiğini slices sayfası anlatıyor.

Diziler ile slice'lar arasında dönüşüm

package main

import "fmt"

func main() {
	arr := [4]int{1, 2, 3, 4}
	s := arr[:] // slice view: shares memory with arr
	s[0] = 100
	fmt.Println(arr)

	nums := []int{7, 8, 9}
	a := [3]int(nums) // Go 1.20: slice to array, copies
	nums[0] = 0
	fmt.Println(a, nums)

	p := (*[3]int)(nums) // Go 1.17: array pointer, shares memory
	p[1] = 0
	fmt.Println(nums)
}

Bir slice'ı bir diziye (Go 1.20) ya da bir dizi pointer'ına (Go 1.17) dönüştürmek, slice dizi uzunluğundan kısaysa panic'e yol açar: panic: runtime error: cannot convert slice with length 2 to array or pointer to array with length 3.

Sık yapılan hatalar

• Bir fonksiyonun dizi argümanını değiştirmesini beklemek. Fonksiyon bir kopya alır. *[N]T ya da bir slice aktarın.
• Slice istenen yerde dizi kullanmak. []int{1, 2} bir slice, [2]int{1, 2} bir dizidir. []int alan bir fonksiyon bir [2]int kabul etmez; a[:] aktarın.
• range döngüsünde büyük diziler. for _, v := range bigArray önce dizinin tamamını kopyalar. &bigArray ya da bir slice üzerinde range yapın.