Golang Fonksiyonlar: Tanımlama, Çağırma ve Fonksiyon Aktarma

Fonksiyon tanımlamak

Bir fonksiyon tanımı func, bir ad, parametreler, sonuç tipi ve bir gövdeden oluşur. Tip, parametre adından önce değil sonra gelir.

package main

import "fmt"

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

func greet(name string) {
	fmt.Println("Hello,", name)
}

func main() {
	sum := add(3, 4)
	fmt.Println(sum)
	greet("Gopher")
}

add iki int değer alır ve bir int döndürür. greet hiçbir şey döndürmez, bu yüzden imzasında sonuç tipi yoktur ve gövdesinin return'e ihtiyacı yoktur.

Bir sonuç bildiren fonksiyon sonlandırıcı bir ifadeyle bitmelidir. Bir yol dönmeden kapanış süslü parantezine ulaşabiliyorsa derleyici missing return ile durur.

Tipi ortak olan parametreler

Aynı tipteki ardışık parametreler tek bir tip adını paylaşabilir. func add(a, b int) int, func add(a int, b int) int ile tamamen aynı anlama gelir. Karıştırmak da serbesttir:

func scale(x, y float64, factor int) (float64, float64)

Burada x ve y float64, factor ise bir int'tir.

Dönüş değerleri

Bir fonksiyon sıfır, bir ya da birkaç değer döndürebilir. Birden fazla sonuç parantez içine yazılır ve çağıran onları çoklu atamayla alır:

package main

import "fmt"

func divmod(a, b int) (int, int) {
	return a / b, a % b
}

func main() {
	q, r := divmod(17, 5)
	fmt.Println(q, r)
}

Bu 3 2 yazdırır. (value, error) çifti bu özelliğin Go'daki en yaygın kullanımıdır ve birden fazla dönüş değeri hakkında kendi sayfası vardır.

Argümanlar kopyalanır

Go her argümanı değerle aktarır. Fonksiyon bir kopya üzerinde çalışır, bu yüzden bir parametreye atama yapmak çağıranın değişkenini asla değiştirmez.

package main

import "fmt"

type Point struct{ X, Y int }

func moveCopy(p Point) {
	p.X = 100
}

func movePtr(p *Point) {
	p.X = 100
}

func fillFirst(s []int) {
	s[0] = 99
}

func main() {
	p := Point{1, 2}
	moveCopy(p)
	fmt.Println(p) // unchanged

	movePtr(&p)
	fmt.Println(p) // changed through the pointer

	nums := []int{1, 2, 3}
	fillFirst(nums)
	fmt.Println(nums) // the slice header was copied, the elements were not
}

Çıktı şöyledir:

{1 2}
{100 2}
[99 2 3]

Üçüncü satır insanları şaşırtır. Bir slice değeri küçük bir başlıktır (pointer, uzunluk, kapasite). Kopya aynı arka diziye işaret eder, bu yüzden s[0]'a yazmak çağıranın elemanına yazar. Ama fonksiyonun içindeki append yeni bir dizi ayırabilir ve çağıran o yeni başlığı asla görmez. Bir fonksiyon bir slice'ı büyütüyorsa yeni slice'ı döndürün. Aynı mantık map'ler için de geçerlidir: fonksiyon çağıranın göreceği anahtarlar ekleyebilir, çünkü map değeri paylaşılan veriye işaret eder.

Fonksiyonun çağıranın değişkenini değiştirmesi gerektiğinde ya da değer her çağrıda kopyalamak istemediğiniz büyük bir struct olduğunda pointer parametre kullanın.

Fonksiyonlar değerdir

Bir fonksiyonun, adı olmadan yazılan bir tipi vardır: func(int, int) int. Bir fonksiyonu bir değişkende saklayabilir, bir map ya da slice'a koyabilir ve başka bir fonksiyona aktarabilirsiniz.

package main

import (
	"fmt"
	"strings"
)

func apply(xs []int, f func(int) int) []int {
	out := make([]int, 0, len(xs))
	for _, x := range xs {
		out = append(out, f(x))
	}
	return out
}

func double(n int) int { return n * 2 }

func main() {
	fmt.Println(apply([]int{1, 2, 3}, double))

	square := func(n int) int { return n * n }
	fmt.Println(apply([]int{1, 2, 3}, square))

	ops := map[string]func(string) string{
		"upper": strings.ToUpper,
		"lower": strings.ToLower,
	}
	fmt.Println(ops["upper"]("go"), ops["lower"]("GO"))
}

square, bir değişkene atanmış anonim bir fonksiyondur. Anonim fonksiyonlar çevreleyen kapsamdaki değişkenleri okuyup değiştirebilir de; bu da onları closure yapar.

Adlandırılmış bir fonksiyon tipi, aynı biçim birçok yerde göründüğünde imzaları daha okunaklı yapar:

type Transform func(int) int

func apply(xs []int, f Transform) []int

Bir fonksiyon tipinin sıfır değeri nil'dir. Nil bir fonksiyonu çağırmak invalid memory address or nil pointer dereference ile panic'e yol açar, bu yüzden isteğe bağlı callback'leri çağırmadan önce kontrol edin. Fonksiyon değerleri yalnızca nil ile karşılaştırılabilir, birbirleriyle asla.

Özyineleme

Bir fonksiyon kendini çağırabilir. Go'da tail-call optimizasyonu yoktur, ama goroutine stack'leri ihtiyaç halinde büyür, bu yüzden sıradan özyineleme derinlikleri sorun olmaz.

package main

import "fmt"

func factorial(n int) int {
	if n <= 1 {
		return 1
	}
	return n * factorial(n-1)
}

func main() {
	for i := range 6 {
		fmt.Println(i, factorial(i))
	}
}

for i := range 6, 0'dan 5'e sayar ve Go 1.22 ya da sonrasını gerektirir.

Go fonksiyonlarında olmayanlar

• Aşırı yükleme yok. Bir paketteki iki fonksiyon, parametreleri farklı olsa bile aynı adı paylaşamaz.
• Varsayılan ya da adlandırılmış argüman yok. Her parametre her çağrıda sırayla aktarılır. Bir yapılandırma struct'ı size adlandırılmış, isteğe bağlı alanlar verir: NewServer(Config{Port: 8080}).
• İç içe adlandırılmış fonksiyon yok. Bir fonksiyon gövdesinin içinde yalnızca anonim fonksiyonlar tanımlayabilirsiniz; bunlar genellikle bir değişkene atanır.

Değişken uzunlukta argüman listeleri variadic fonksiyonlar ile desteklenir.

Dışa açık ve dışa kapalı fonksiyonlar

Adı büyük harfle başlayan bir fonksiyon (Parse) dışa açıktır ve başka paketlerden çağrılabilir. Küçük harfli bir ad (parse) yalnızca kendi paketinin içinde görünür. public ya da private anahtar kelimeleri yoktur; kuralın tamamı büyük harftir.

Sık yapılan hatalar

• Bir parametre değişikliğinin çağırana ulaşmasını beklemek. Bir parametreye atama yapmak yalnızca kopyayı değiştirir. Yeni değeri döndürün ya da bir pointer alın.
• Bir fonksiyonun içinde append yapıp sonucu yok saymak. func add(s []int) { s = append(s, 1) } çağıranın slice uzunluğunu etkilemez. func add(s []int) []int yazın ve s = add(s) kullanın.
• Kullanılmayan sonuçlar. Go bir dönüş değerini yok saymaya izin verir. go vet atlanan bir hatayı işaretlemez, ama errcheck gibi linter'lar (golangci-lint'in bir parçası) işaretler. _ ='yi yalnızca yok saymak bilinçli bir karar olduğunda kullanın.