Go 1.21.0 Sürüm Yenilikleri

Merhaba, bu makalede Go programlama diline Ağustos ayında gelen 1.21 sürümündeki yenilik ve güncellemeleri örnek kullanımlarla birlikte aktaracağım.

Dil Değişiklikleri

Go 1.21 sürümü ile min, max ve clear olmak üzere 3 yeni yerleşik (built-in) fonksiyon eklendi. İsimlerinden de anlaşılacağı üzere min fonksiyonu kendisine parametre olarak verilen değerler arasından en küçük olanı döndürürken max fonksiyonu kendisine verilen parametreler arasından en büyük değeri döndürmektedir. clear fonksiyonu ise parametre olarak map, slice ve type parameter alarak bunların tüm öğelerini siler veya sıfırlar. Bu fonksiyonlara birer örnek verecek olursak;

x := min(1, -5, 3, 2, 0)
fmt.Println(x)
// Output: -5

y := max(1, -5, 3, 2, 0)
fmt.Println(y)
// Output: 3

cities := map[string]int{
 "Adana":  1,
 "Ankara": 6,
 "Istanbul": 34,
}
fmt.Println(cities)
clear(cities)
fmt.Println(cities)
// Output: 
// map[Adana:1 Ankara:6 Istanbul:34]
// map[]

Go Komutu ve Flag Güncellemeleri

• -pgo derleme flag’i varsayılan olarak -pgo=auto olarak ayarlandı.
• Komut satırında yalnızca tek bir ana paketi belirtme kısıtlaması kaldırıldı.
• Ana paketin dizininde default.pgo adında bir dosya bulunuyorsa bu dosya otomatik olarak optimizasyonu etkinleştirmek için kullanılacak.
• go test komutu için -fullpath parametresi eklendi. Bu sayede log mesajlarında tam yolun yazdırılma opsiyonu eklendi.

Derleyici

• Go 1.20 sürümünde önizleme olarak eklenen profile-guide optimization (PGO) 1.21.0 sürümü ile birlikte genel kullanıma hazır hale getirildi. Bununla birlikte temsili bir Go programında PGO etkinleştirilirse %2 ile %7 arasında iyileşme görülebileceği belirtiliyor. PGO hakkında daha detaylı bilgi için bağlantıdan dokümanlara ulaşabilirsiniz.
• Ayrıca Go 1.21.0 sürümü ile derleyicinin kendisini PGO ile oluşturması sayesinde build alma hızının %6'ya kadar arttığı belirtiliyor.

Yeni Kütüphane Paketleri

log/slog Paketi

Yeni paketin popüler log analiz araçları ve servisler ile entegre desteği olmasıyla beraber Go’da loglama işlemleri için kullanılan 3. parti kütüphanelerin kullanımı azalacak gibi görünüyor. Yapısal loglama (structured logging) anahtar/değer çiftleri ile gerçekleştirildiğinden dolayı büyük miktardaki log kayıtlarının hızlı ve doğru bir şekilde işlenmesi sağlanıyor.

Paket için ufak bir örnek yapacak olursak aşağıdaki kullanılan Info fonksiyonunun imzası slog.Info(msg string, args …any) şeklindedir. Görüldüğü üzere ilk parametre log mesajıdır. diğer parametreler ise anahtar-değer çiftlerini temsil eder.

package main
import "log/slog"
func main() {
 slog.Info("Yetkisiz erişim", "Ad", "John", "Soyad", "Doe")
}
// Output: 
// 2023/09/05 21:07:14 INFO Yetkisiz erişim Ad=John Soyad=Doe

Ayrıca çıktı formatında daha çok hakimiyet için slog.New(h handler) *Logger imzalı bir fonksiyon da bulunuyor. Bu fonksiyon ile ihtiyaç duyulan handler belirtilerek logger örneği oluşturulabiliyor. Örneğin alttaki örnekte JSONHandler kullanarak bir logger örneği bulunuyor.

package main
import (
 "log/slog"
 "os"
)
func main() {
 logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
 logger.Info("Yetkisiz erişim", "Ad", "John", "Soyad", "Doe")
}
// Output:
// {"time":"2023-09-05T21:10:29.2848066+03:00","level":"INFO","msg":"Yetkisiz erişim","Ad":"John","Soyad":"Doe"}

Örnekler ve slog paketi hakkında detaylı bilgi için dokümanları inceleyebilirsiniz.

testing/slogtest Paketi

Bu paketin slog.Handler implementasyonlarını doğrulamaya yardımcı olabilmesi amacıyla eklendiği belirtiliyor. Paketin içerisinde func TestHandler(h slog.Handler, results func() []map[string]any) error imzasına sahip bir fonksiyon bulunuyor. Bu fonksiyon kullanıldığı takdirde yanlış giden bir durum olduğunda oluşan hataların her birini error.Join ile birleştirerek döndürülür.

Yalnızca TestHandler fonksiyonu bulunan bu paket için detayları ve örnekleri incelemek isterseniz paket dokümanlarını inceleyebilirsiniz.

slices Paketi

Adından da anlaşılacağı üzere yeni slices paketi slice yapısı için birçok yeni fonksiyon içermektedir. Bu fonksiyonlardan başlıcalarından birkaç tane örnek vereceğim.

package main
import (
 "fmt"
 "slices"
)
func main() {
 numbers := []int{0, 42, -10, 8}
 // Min: Parametre olarak verilen slice içerisindeki
 // en küçük elemanı döndürür.
 fmt.Println(slices.Min(numbers))
 //Output: -10

 // Max: Parametre olarak verilen slice içerisindeki
 // en büyük elemanı döndürür.
 fmt.Println(slices.Max(numbers))
 // Output: 42

 // Insert: İlk parametrede verilen slice içerisine
 // ikinci parametrede verilen index değerine 3. ve
 // diğer parametrelerdeki sayıları sırası ile ekler.
 fmt.Println(slices.Insert(numbers, 1, 1, 2))
 // Output: [0 1 2 42 -10 8]

 // Index: 2. parametrede verilen değer ilk parametrede verilen
 // slice içinde bulunuyorsa index'i döndürür.
 // Bulunmuyorsa -1 değerini döndürür.
 fmt.Println(slices.Index(numbers, -5))
 // Output: -1

 // Sort: Parametre olarak verilen slice'ı küçükten büyüğe sıralar
 slices.Sort(numbers)
 fmt.Println(numbers)
 // Output: [-10 0 8 42]

 // Reverse: Parametre olarak verilen slice'ı tersine çevirir
 slices.Reverse(numbers)
 fmt.Println(numbers)
 // Output: [42 8 0 -10]

 // Delete: İlk parametrede verilen slice içerisinden
 // [1:3] elemanlarını siler. (1 dahil, 3 dahil değil)
 fmt.Println(slices.Delete(numbers, 1, 3))
 // Output: [42 -10]
}

slices paketindeki diğer örnekleri, fonksiyonları ve detayları incelemek için lütfen dokümanları inceleyin.

maps Paketi

Bu paket de adından anlaşılacağı üzere map yapısı üzerinde birtakım operasyonlar olan Clone, Copy, DeleteFunc, Equal ve EqualFunc fonksiyonlarını içerir. Birkaç kullanım örneği vermek gerekirse:

package main
import (
 "fmt"
 "maps"
)
func main() {
 m := map[string]int{
  "one":   1,
  "two":   2,
  "three": 3,
  "four":  4,
 }
 // Clone: Parametre olarak verilen map'in bir kopyasını döndürür.
 fmt.Println(maps.Clone(m))
 // Output: map[four:4 one:1 three:3 two:2]

 // Copy: 2. parametrede verilen map'in anahtar/değer eşlerini
 // 1. parametrede verilen map'e eşitler. Kopyalanan map içerisinde
 // çakışma varsa yeni değerler eski değerlerin üzerine yazılır.
 copied := map[string]int{}
 maps.Copy(copied, m)
 fmt.Println(copied)
 // Output: map[four:4 one:1 three:3 two:2]

 // Equal: Parametre olarak verilen 2 map'in değerlerinin aynı
 // olup olmadığını karşılaştırır.
 fmt.Println(maps.Equal(m, map[string]int{"İstanbul": 34}))
 // Output: false

 // DeleteFunc: map için silme kurallarını belirleyeceğimiz
 // fonksiyonlar tanımlamamızı sağlar. Dokümanda verilen örnekte
 // tek değerleri silmek için aşağıdaki şekilde fonksiyon yazılabilir.
 maps.DeleteFunc(m, func(k string, v int) bool {
  return v%2 != 0
 })
 fmt.Println(m)
 // Output: map[four:4 two:2]
}

cmp Paketi

Bu paket Ordered (sıralı) değerler arasında karşılaştırma yapılabilmesini sağlayan Ordered type’ı ile Compare, Less fonksiyonlarını içerir. Dokümanlara göre Ordered type’ı <, <=, >= ve > operatörlerini destekleyen tipleri içeren türdür.

Compare fonksiyonu ilk parametre ikinciden azsa -1, eşitse 0 ve fazlaysa 1 değerlerini döndürür.

Less fonksiyonu ilk parametre ikinci parametreden azsa true değerini döndürür.

Birer örnek vermek gerekirse:

package main
import (
 "cmp"
 "fmt"
)
func main() {
 fmt.Print(cmp.Compare(1, 2))
 fmt.Print(cmp.Compare(1, 1))
 fmt.Print(cmp.Compare(2, 1))
 // Output:-101
}

Web Assembly

Ayrıca Go 1.21.0 sürümü ile WebAssembly ortamında Go dilini daha işlevsel ve esnek kullanmak için ilk adımlar atıldı. Dokümana göre özellikle asenkron olaylarda sık sık bloke olan uygulamalarda etkileşim daha verimli hale gelerek WebAssembly ortamında çalışan uygulamalar için performans artabilir.

Eklenen deneysel port ile (GOOS=wasip1, GOARCH=wasm) WebAssembly ortamında WASI (WebAssembly System Interface) kullanılabilir.

Bu makaleyi kendi blogumda görüntülemek isterseniz: https://gorkemarik.com/go-1-21-yenilikleri/