go

Sözlük

Derslerde geçen teknik terimlerin Türkçe karşılıkları, İngilizce adları ve kısa tanımları.

186 terim

A

Açgözlü algoritmaGreedy algorithmAlgoritmalar
Her adımda o an en iyi görünen seçimi yapıp geri dönmeyen algoritma. Yalnızca açgözlü seçim özelliği ve optimal alt yapı varsa en iyi sonucu verir; örneğin {1, 3, 4} bozuk paralarıyla 6 için 4+1+1 seçer, oysa en iyisi 3+3'tür. Açgözlü (Greedy) Algoritmalar →
Açık adreslemeOpen addressingVeri Yapıları
Tüm girdilerin tablonun kendi dizisinde tutulduğu, çakışmada belirli bir sırayla başka boş slot arandığı yöntem. En basit türü doğrusal yoklamadır (i+1, i+2, ...); silinen slotlar arama zincirini kırmamak için mezar taşı (tombstone) ile işaretlenebilir. Hash Tabloları →
AğaçTreeVeri Yapıları
Bir kök düğümden başlayıp çocuk düğümlere dallanan, döngü içermeyen hiyerarşik yapı. n düğümlü bir ağaçta tam n-1 kenar bulunur ve kökten her düğüme tek bir yol vardır. Ağaçlar ve İkili Ağaçlar →
Alan karmaşıklığıSpace complexityAlgoritmalar
Bir algoritmanın girdi dışında ihtiyaç duyduğu ek belleğin girdi boyutuna göre büyümesi. Özyinelemede çağrı yığınının derinliği de bu belleğe dahildir. Karmaşıklık Analizi (Big-O) →
AlıcıReceiverGo
Metodun hangi tipe ait olduğunu belirten özel parametre. Değer alıcı (func (c Counter)) kopya üzerinde çalışır; işaretçi alıcı (func (c *Counter)) orijinal değeri değiştirebilir ve büyük struct'ların kopyalanmasını önler. Struct'lar ve Metotlar →
Alt sınırLower bound (binary search)Algoritmalar
Sıralı bir dizide hedefe eşit veya ondan büyük ilk elemanın indeksi; üst sınır (upper bound) ise hedeften büyük ilk elemanın indeksidir. slices.BinarySearch hedef bulunamasa bile bu konumu, yani hedefin ekleneceği yeri döndürür. Arama Algoritmaları →
Amortize analizAmortized analysisAlgoritmalar
Tek tek pahalı olabilen işlemlerin, en kötü durumdaki bir işlem dizisi boyunca ortalama maliyetini hesaplama. Olasılığa dayanmaz; örneğin dinamik diziye ekleme ara sıra O(n) kopyalama gerektirse de amortize O(1)'dir. Karmaşıklık Analizi (Big-O) →
Anonim structAnonymous structGo
Ayrı bir tip adı tanımlamadan yerinde kullanılan struct: point := struct{ X, Y int }{1, 2}. Tablo güdümlü testlerde ve tek seferlik JSON yapılarında sıkça kullanılır. Struct'lar ve Metotlar →
anyany (empty interface)Go
Hiç metodu olmayan interface{} tipinin Go 1.18'de eklenen takma adı. Her tip bu arayüzü uygular; değeri geri almak için tip iddiası veya tip switch gerekir. Arayüzler (Interfaces) →
appendappendGo
Dilimin sonuna eleman ekleyip sonucu döndüren yerleşik fonksiyon. Kapasite yeterliyse aynı alttaki diziyi kullanır, değilse yeni dizi ayırır; bu yüzden sonuç her zaman s = append(s, x) biçiminde geri atanmalıdır. Diziler ve Dilimler (Slices) →
ArayüzInterfaceGo
Metot imzalarından oluşan tip. Bir tip, gerekli metotlara sahipse arayüzü örtük olarak uygular; implements gibi bir anahtar kelime yoktur. Arayüzler (Interfaces) →
Arayüz değeriInterface valueGo
Çalışma zamanında (dinamik tip, dinamik değer) çiftinden oluşan değer. Arayüz yalnızca ikisi de boşsa nil'e eşittir; nil bir *MyError taşıyan error değeri nil değildir. Arayüzler (Interfaces) →
AVL ağacıAVL treeVeri Yapıları
Her düğümde sol ve sağ alt ağaç yükseklikleri arasındaki farkın en fazla 1 olduğu kendini dengeleyen ikili arama ağacı. Denge bozulunca dönüşlerle düzeltilir; arama, ekleme ve silme O(log n)'dir. Dengeli Ağaçlar: AVL →
Ayrı zincirlemeSeparate chainingVeri Yapıları
Her kovanın, o kovaya düşen tüm girdileri bir liste (zincir) içinde tuttuğu çakışma çözüm yöntemi. Yük faktörü 1'i aşsa bile çalışır, ancak zincirler uzadıkça arama yavaşlar. Hash Tabloları →

B

B-ağacıB-treeVeri Yapıları
Her düğümünde çok sayıda anahtar ve çocuk bulunan, tüm yaprakları aynı derinlikte olan dengeli arama ağacı. Düşük yüksekliği sayesinde disk okumalarını azaltır; veritabanı indeksleri ve dosya sistemleri genellikle B-ağacı türevlerini kullanır. Dengeli Ağaçlar: AVL →
Bağlı listeLinked listVeri Yapıları
Her düğümün değeri ve bir sonraki düğüme işaretçiyi tuttuğu doğrusal yapı. Bilinen bir düğümün yanına ekleme ve silme O(1), indeksle erişim ise O(n)'dir. Bağlı Listeler →
BenchmarkBenchmarkGo
func BenchmarkX(b *testing.B) biçimindeki performans ölçüm fonksiyonu; go test -bench=. ile çalıştırılır. Go 1.24'ten beri ölçülecek kod for b.Loop() { ... } döngüsünün içine yazılır. Test ve Benchmark →
Biçimlendirme fiiliFormat verbGo
fmt.Printf ve benzerlerinde değerin nasıl yazılacağını belirleyen yer tutucu. Örneğin %d tamsayı, %s string, %v varsayılan biçim, %+v alan adlarıyla struct, %T ise tip adı yazar. Go'ya Giriş →
Big-OBig-O notationAlgoritmalar
Bir fonksiyonun büyüme hızına üst sınır koyan gösterim: yeterince büyük her n için f(n) ≤ c·g(n) sağlanıyorsa f(n) = O(g(n)) olur. Sabitler ve küçük terimler atılır; 3n² + 5n ifadesi O(n²)'dir. Karmaşıklık Analizi (Big-O) →
Big-OmegaBig-Omega notation (Ω)Algoritmalar
Büyüme hızına alt sınır koyan gösterim: yeterince büyük her n için f(n) ≥ c·g(n) ise f(n) = Ω(g(n)) olur. Örneğin karşılaştırma tabanlı her sıralama algoritması en kötü durumda Ω(n log n) karşılaştırma yapar. Karmaşıklık Analizi (Big-O) →
Big-ThetaBig-Theta notation (Θ)Algoritmalar
Hem üst hem alt sınırı aynı fonksiyon olan sıkı sınır: f(n) = Θ(g(n)) ancak ve ancak f(n) = O(g(n)) ve f(n) = Ω(g(n)) ise geçerlidir. Birleştirmeli sıralama her durumda Θ(n log n) sürer. Karmaşıklık Analizi (Big-O) →
Birinci sınıf fonksiyonFirst-class functionGo
Fonksiyonların değişkene atanabilmesi, argüman olarak geçirilebilmesi ve döndürülebilmesi. Go'da func(int) int gibi fonksiyon tipleri vardır ve fonksiyon değerinin sıfır değeri nil'dir. Fonksiyonlar →
Birleştirmeli sıralamaMerge sortAlgoritmalar
Diziyi ikiye bölüp her yarıyı özyinelemeli sıralayan ve iki sıralı yarıyı birleştiren böl ve fethet algoritması. Her durumda O(n log n) sürer ve kararlıdır, ancak dizilerde O(n) ek bellek gerektirir. Verimli Sıralama Algoritmaları →
Boş tanımlayıcıBlank identifierGo
Bir değeri yok saymak için kullanılan _ sembolü. Örneğin for _, v := range items indeksi, _ = x ise kullanılmayan değişken hatasını yok sayar. Operatörler ve Kontrol Akışı →
Böl ve fethetDivide and conquerAlgoritmalar
Problemi aynı türden daha küçük alt problemlere bölüp bunları özyinelemeli olarak çözen ve sonuçları birleştiren paradigma. Birleştirmeli sıralama, hızlı sıralama ve ikili arama bu yaklaşımı kullanır. Böl ve Fethet →
BudamaPruningAlgoritmalar
Geri izleme veya aramada, geçerli ya da daha iyi bir çözüme götüremeyeceği anlaşılan dalları hiç keşfetmeden kesme. En kötü durum karmaşıklığını her zaman değiştirmese de pratikte arama uzayını büyük ölçüde küçültür. Geri İzleme (Backtracking) →
bufio.Scannerbufio.ScannerGo
Bir io.Reader'dan satır, kelime veya özel ayraçlarla belirlenen parçaları sırayla okuyan tip. Varsayılan en büyük token boyutu 64 KB'tır; daha uzun satırlar için Buffer metoduyla artırılmalıdır. Dosyalar, I/O ve JSON →
ByteByteGo
uint8 tipinin takma adı; 0 ile 255 arasında değer tutar. Bir string'i s[i] ile indekslemek bir rune değil, o konumdaki byte'ı verir. String, Byte ve Rune →

C

clearclearGo
Go 1.21'de eklenen yerleşik fonksiyon. Haritadaki tüm girdileri siler; dilimde ise uzunluğu değiştirmeden tüm elemanları sıfır değere çeker. Haritalar (Maps) →
ClosureClosureGo
Tanımlandığı kapsamdaki değişkenlere başvuran ve onları yakalayan fonksiyon değeri (kapanış). Yakalanan değişkenler kopyalanmaz, paylaşılır; closure onları çağrılar arasında yaşatabilir. Fonksiyonlar →
comparablecomparableGo
== ve != ile karşılaştırılabilen tipleri kapsayan önceden tanımlı kısıt. Harita anahtarı olarak kullanılacak tip parametreleri için gerekir; dilim, harita ve fonksiyon tipleri karşılaştırılabilir değildir. Jenerikler (Generics) →
Contextcontext.ContextGo
İptal sinyallerini, son tarihleri (deadline) ve istek kapsamlı değerleri API sınırları boyunca taşıyan arayüz. context.WithCancel ve context.WithTimeout ile türetilir; geleneksel olarak fonksiyonların ilk parametresi ctx olarak geçirilir. Context ve Eşzamanlılık Desenleri →
copycopyGo
Kaynak dilimden hedef dilime eleman kopyalayan yerleşik fonksiyon. min(len(dst), len(src)) kadar eleman kopyalar ve bu sayıyı döndürür; hedefin uzunluğu önceden ayarlanmış olmalıdır. Diziler ve Dilimler (Slices) →

Ç

Çağrı yığınıCall stackAlgoritmalar
Etkin fonksiyon çağrılarının yerel değişkenlerini ve dönüş adreslerini çerçeveler hâlinde tutan LIFO yapı. Her çağrı yığına bir çerçeve ekler, fonksiyon dönünce çerçeve çıkarılır. Özyineleme (Recursion) →
ÇakışmaCollisionVeri Yapıları
Farklı iki anahtarın aynı kovaya veya konuma eşlenmesi. Anahtar uzayı kova sayısından büyük olduğu için kaçınılmazdır; zincirleme veya açık adresleme ile çözülür. Hash Tabloları →
Çalışma alanıWorkspace (go work)Go
Birden fazla modülü aynı anda yerel olarak geliştirmeyi sağlayan go.work dosyası. go work init ve go work use komutlarıyla yönetilir; replace yönergesi yazmadan modüller birbirini görür. Paketler ve Modüller →
Çift uçlu kuyrukDeque (double-ended queue)Veri Yapıları
Hem baştan hem sondan O(1) ekleme ve çıkarma yapılabilen kuyruk. Kayan pencere maksimumu gibi problemlerde monoton deque olarak kullanılır. Kuyruk (Queue) ve Deque →
Çift yönlü bağlı listeDoubly linked listVeri Yapıları
Her düğümün hem sonraki hem önceki düğüme işaretçi tuttuğu bağlı liste. İki yönde gezinmeye ve bir düğümü önceki düğümü aramadan O(1)'de silmeye izin verir; Go'daki container/list paketi bu yapıdadır. Bağlı Listeler →
Çöp toplayıcıGarbage collector (GC)Go
Artık erişilemeyen heap belleğini otomatik olarak geri kazanan çalışma zamanı bileşeni. Go'nun toplayıcısı programla eşzamanlı çalışan, nesneleri taşımayan bir işaretle-süpür (mark-and-sweep) toplayıcıdır; GOGC ve GOMEMLIMIT ile ayarlanır. İşaretçiler (Pointers) →

D

Dairesel tamponRing buffer (circular buffer)Veri Yapıları
Sabit boyutlu bir dizide baş ve son indekslerinin modüler aritmetikle sona gelince başa sardığı yapı. Yeniden bellek ayırmadan O(1) kuyruk işlemleri sağlar. Kuyruk (Queue) ve Deque →
deferdeferGo
Bir fonksiyon çağrısını, çevreleyen fonksiyon dönene kadar (panik durumunda da) erteleyen ifade. Ertelenen çağrılar LIFO sırasıyla çalışır ve argümanları defer satırı çalıştığı anda değerlendirilir. Fonksiyonlar →
Değer ile geçirmePass by valueGo
Go'da tüm argümanlar kopyalanarak geçirilir. Dilim, harita veya işaretçi geçirildiğinde kopyalanan şey başlık ya da adrestir; bu yüzden alttaki veriye yapılan değişiklikler çağırana yansıyabilir. Fonksiyonlar →
Denge faktörüBalance factorVeri Yapıları
Bir düğümün sol alt ağaç yüksekliği ile sağ alt ağaç yüksekliği arasındaki fark. AVL ağacında her düğüm için -1, 0 veya 1 olmalıdır; ±2 olduğunda dönüş gerekir. Dengeli Ağaçlar: AVL →
Dengeli ağaçBalanced treeVeri Yapıları
Yüksekliği düğüm sayısına göre O(log n) olarak tutulan ağaç. AVL ve kırmızı-siyah ağaçlar ekleme ve silmeden sonra kendilerini yeniden dengeleyerek bu garantiyi sağlar. Dengeli Ağaçlar: AVL →
Dışa aktarılan tanımlayıcıExported identifierGo
Büyük harfle başlayan ve bu nedenle paket dışından erişilebilen isim (ör. fmt.Println). Küçük harfle başlayan tanımlayıcılar yalnızca kendi paketi içinde görünür. Paketler ve Modüller →
DilimSliceGo
Alttaki bir diziye işaretçi, uzunluk (len) ve kapasiteden (cap) oluşan dinamik görünüm. make([]int, 0, 10) ile oluşturulur ve append ile büyütülür; sıfır değeri nil'dir. Diziler ve Dilimler (Slices) →
Dinamik diziDynamic arrayVeri Yapıları
Kapasitesi dolduğunda daha büyük bir diziye taşınarak büyüyen dizi. Kapasite sabit bir çarpanla (büyüme faktörü) artırıldığı için sona ekleme amortize O(1) olur; Go dilimleri bu fikre dayanır. Diziler ve Dinamik Diziler →
Dinamik programlamaDynamic programming (DP)Algoritmalar
Örtüşen alt problemleri olan ve optimal alt yapı gösteren problemleri, her alt problemi yalnızca bir kez çözüp sonucunu saklayarak çözme tekniği. Durum, geçiş ve temel durumların tanımlanmasıyla kurulur; memoization veya tabulation ile uygulanır. Dinamik Programlama I: Temeller →
DiziArrayVeri Yapıları
Aynı tipteki sabit sayıda elemanı bitişik bellekte tutan yapı; indeksle erişim O(1)'dir. Go'da uzunluk tipin parçasıdır ([5]int ile [3]int farklı tiplerdir) ve diziler atamada kopyalanır. Diziler ve Dinamik Diziler →
Döngü değişkeni kapsamıPer-iteration loop variableGo
Go 1.22'den itibaren for döngüsünde := ile tanımlanan değişkenler her yinelemede yeniden oluşturulur. Böylece closure'ların veya goroutine'lerin hepsinin son değeri yakalaması tuzağı ortadan kalktı. Goroutine'ler →
DönüşRotationVeri Yapıları
İkili arama ağacı sırasını koruyarak birkaç işaretçiyi O(1) sürede yeniden bağlayan yerel yapı değişikliği. LL durumu sağa, RR durumu sola dönüşle; LR ve RL durumları ise çift dönüşle düzeltilir. Dengeli Ağaçlar: AVL →
DüğümNodeVeri Yapıları
Bağlı liste, ağaç veya graf gibi yapılarda veriyi ve diğer düğümlere bağlantıları tutan temel birim. Graflarda düğüme köşe (vertex) de denir. Bağlı Listeler →
Düzgün kapanışGraceful shutdownGo
Sunucunun yeni bağlantı kabul etmeyi bırakıp devam eden istekleri tamamladıktan sonra kapanması. http.Server için srv.Shutdown(ctx) ile yapılır ve genellikle SIGINT veya SIGTERM sinyali yakalanınca tetiklenir. HTTP Sunucusu ve İstemcisi →

E

Eklemeli sıralamaInsertion sortAlgoritmalar
Elemanları tek tek alıp solundaki sıralı kısımda doğru yere kaydırarak yerleştiren algoritma. En kötü durumda O(n²), neredeyse sıralı girdide O(n)'dir; kararlı ve yerinde olduğu için hibrit algoritmalarda küçük parçaları sıralamakta kullanılır. Temel Sıralama Algoritmaları →
errgrouperrgroup.GroupGo
golang.org/x/sync/errgroup paketindeki, bir grup goroutine'i çalıştırıp Wait ile ilk hatayı döndüren tip. errgroup.WithContext ile oluşturulduğunda goroutine'lerden biri hata döndürünce ortak context iptal edilir. Context ve Eşzamanlılık Desenleri →
error arayüzüerror interfaceGo
Error() string metoduna sahip yerleşik arayüz. Go'da hatalar istisna (exception) olarak fırlatılmaz; genellikle son dönüş değeri olarak döndürülür ve if err != nil ile kontrol edilir. Hata Yönetimi →
errors.Is ve errors.Aserrors.Is / errors.AsGo
errors.Is(err, target), sarmalanmış hata zincirinde target'a eşit bir hata olup olmadığını kontrol eder. errors.As(err, &target) ise zincirde hedef tipe atanabilen ilk hatayı bulup target'a yazar. Hata Yönetimi →
EtiketLabelGo
Bir ifadeye verilen isim; break OuterLoop veya continue OuterLoop ile iç içe döngülerde dıştaki döngüyü hedeflemeyi sağlar. Operatörler ve Kontrol Akışı →

F

fallthroughfallthroughGo
Bir switch case'inin sonunda, bir sonraki case'in koşulunu değerlendirmeden onun gövdesine geçmeyi sağlayan anahtar kelime. Go'da case'ler varsayılan olarak birbirine düşmez. Operatörler ve Kontrol Akışı →
Fan-out / fan-inFan-out / fan-inGo
Fan-out, aynı kanaldan okuyan birden fazla goroutine ile işi dağıtmaktır. Fan-in ise birden fazla kanalın çıktısını tek bir kanalda birleştirmektir. Context ve Eşzamanlılık Desenleri →
Fenwick ağacıFenwick tree (binary indexed tree)Veri Yapıları
Önek toplamlarını ve nokta güncellemelerini O(log n)'de yapan dizi tabanlı yapı (BIT). İndeksler arasında i & -i ile bulunan en düşük bit kadar atlanarak gezinilir; segment ağacından daha az bellek ve kod gerektirir. Segment Ağacı ve Fenwick Ağacı →
fmt.Stringerfmt.StringerGo
Tek metodu String() string olan arayüz. Bu metodu uygulayan tipler fmt.Println ve %v ile yazdırılırken kendi metin gösterimlerini kullanır. Arayüzler (Interfaces) →
FuzzingFuzzingGo
Teste otomatik üretilmiş girdiler vererek hataya veya paniğe yol açan girdileri arayan test yöntemi. func FuzzX(f *testing.F) ile yazılır ve go test -fuzz=FuzzX ile çalıştırılır; Go 1.18'den beri araç zincirine yerleşiktir. Test ve Benchmark →

G

Geri izlemeBacktrackingAlgoritmalar
Çözümü adım adım kurup bir kısıt ihlal edildiğinde son seçimi geri alarak diğer seçenekleri deneyen arama tekniği (seç, keşfet, geri al). Permütasyonlar, alt kümeler ve N-Vezir gibi problemlerde kullanılır. Geri İzleme (Backtracking) →
go buildgo buildGo
Paketleri ve bağımlılıklarını derleyen komut. main paketi için tek bir statik bağlanmış çalıştırılabilir dosya üretir; GOOS ve GOARCH ile başka platformlar için çapraz derleme yapılabilir. Go'ya Giriş →
go mod tidygo mod tidyGo
Kaynak kodda import edilen paketlere bakarak eksik bağımlılıkları go.mod dosyasına ekleyen, kullanılmayanları kaldıran ve go.sum dosyasını güncelleyen komut. Paketler ve Modüller →
go rungo runGo
Programı geçici bir dizinde derleyip hemen çalıştıran komut. Kalıcı bir çalıştırılabilir dosya üretmez; bunun için go build kullanılır. Go'ya Giriş →
go testgo testGo
_test.go ile biten dosyalardaki func TestX(t *testing.T) fonksiyonlarını derleyip çalıştıran komut. t.Error hatayı kaydedip teste devam eder, t.Fatal ise testi hemen durdurur. Test ve Benchmark →
go vetgo vetGo
Derlenen ama büyük olasılıkla hatalı olan yapıları bulan statik analiz aracı. Örneğin Printf biçim fiili ile argüman uyuşmazlığını veya kilitlerin kopyalanmasını raporlar. Go'ya Giriş →
Go zamanlayıcısıGo scheduler (G-M-P)Go
Goroutine'leri (G) işletim sistemi iş parçacıkları (M) üzerinde mantıksal işlemciler (P) aracılığıyla çalıştıran çalışma zamanı bileşeni. Her P'nin yerel bir çalıştırma kuyruğu vardır; işi biten P başka kuyruklardan iş çalar (work stealing). Goroutine'ler →
go.modgo.mod fileGo
Modülün yolunu, gereken Go sürümünü (go yönergesi) ve bağımlılıklarını (require) listeleyen dosya. go get ve go mod tidy bu dosyayı günceller. Paketler ve Modüller →
go.sumgo.sum fileGo
İndirilen modül sürümlerinin kriptografik özetlerini (checksum) tutan dosya. Bağımlılıkların içeriğinin sonradan değişmediğini doğrulamak için kullanılır ve sürüm kontrolüne eklenmelidir. Paketler ve Modüller →
gofmtgofmtGo
Go kodunu tek bir standart biçime sokan araç (girinti için sekme, hizalama, boşluklar). go fmt ./... komutu paketlerdeki dosyalara gofmt uygular; bu sayede biçim tartışmaları ortadan kalkar. Go'ya Giriş →
GOMAXPROCSGOMAXPROCSGo
Aynı anda Go kodu çalıştırabilecek iş parçacığı sayısının (P sayısının) üst sınırı. Varsayılanı kullanılabilir mantıksal CPU sayısıdır ve Go 1.25'ten beri Linux'ta cgroup CPU sınırı da hesaba katılır; runtime.GOMAXPROCS veya aynı adlı ortam değişkeniyle değiştirilebilir. Goroutine'ler →
GoroutineGoroutineGo
Go çalışma zamanı tarafından yönetilen hafif eşzamanlı yürütme birimi; go f() ile başlatılır. Küçük bir stack ile başlayıp gerektiğinde büyüdüğü için işletim sistemi iş parçacıklarına göre çok daha ucuzdur. Goroutine'ler →
GölgelemeShadowingGo
İç bir kapsamda, dış kapsamdaki bir değişkenle aynı adda yeni bir değişken tanımlanması. Özellikle := ile err gibi değişkenlerin yanlışlıkla gölgelenmesi sık görülen bir hatadır. Değişkenler, Sabitler ve Tipler →
GömmeEmbeddingGo
Bir struct'a alan adı vermeden başka bir tip eklemek. Gömülen tipin alanları ve metotları dış tipe yükseltilir (promoted); Go kalıtım yerine bu kompozisyon mekanizmasını kullanır. Struct'lar ve Metotlar →
GrafGraphVeri Yapıları
Düğümlerden (V) ve bu düğümleri bağlayan kenarlardan (E) oluşan yapı. Kenarlar yönlü veya yönsüz, ağırlıklı veya ağırlıksız olabilir; ağaçlar ve bağlı listeler grafın özel hâlleridir. Graflar →

H

HaritaMapGo
Anahtarları karşılaştırılabilir (comparable) olan yerleşik hash tablosu tipi; map[string]int gibi yazılır. Gezinme sırası belirsizdir ve eşzamanlı yazma senkronizasyon olmadan güvenli değildir. Haritalar (Maps) →
Hash fonksiyonuHash functionVeri Yapıları
Bir anahtarı sabit boyutlu bir tamsayıya (hash değerine) dönüştüren fonksiyon. Aynı anahtar için her zaman aynı değeri üretmeli ve değerleri kovalara olabildiğince eşit dağıtmalıdır. Hash Tabloları →
Hash tablosuHash tableVeri Yapıları
Anahtarları bir hash fonksiyonuyla dizi konumlarına eşleyerek ekleme, silme ve aramayı ortalama O(1) sürede yapan yapı. Kötü hash dağılımında en kötü durum O(n)'e çıkabilir; Go'nun map tipi bir hash tablosudur. Hash Tabloları →
Hata sarmalamaError wrappingGo
Bir hataya bağlam ekleyip onu yeni bir hatanın içine koyma: fmt.Errorf("ayar okunamadı: %w", err). Sarmalanan hata errors.Unwrap ile açılabilir ve errors.Is ile errors.As tüm zincir boyunca arama yapar. Hata Yönetimi →
HeapHeap (binary heap)Veri Yapıları
Heap özelliğini sağlayan tam ikili ağaç (öbek): min-heap'te her ebeveyn çocuklarından küçük veya eşit, max-heap'te büyük veya eşittir. En küçük/büyük elemana O(1)'de bakılır, ekleme ve çıkarma O(log n)'dir; Go'da container/heap paketiyle kullanılır. Heap ve Öncelik Kuyruğu →
HeapifyHeapifyVeri Yapıları
Sırasız bir diziyi, son yaprak olmayan düğümden köke doğru her düğüme aşağı kaydırma (sift down) uygulayarak heap'e dönüştürme. Toplam maliyeti O(n)'dir; Go'da heap.Init bu işi yapar. Heap ve Öncelik Kuyruğu →
http.Handlerhttp.HandlerGo
ServeHTTP(w http.ResponseWriter, r *http.Request) metoduna sahip arayüz; HTTP isteğini işleyen her şeyin ortak soyutlamasıdır. http.HandlerFunc tipi, uygun imzalı sıradan bir fonksiyonu bu arayüze uyarlar. HTTP Sunucusu ve İstemcisi →

I

Inorder gezinmeInorder traversalVeri Yapıları
İkili ağaçta önce sol alt ağacı, sonra düğümün kendisini, en son sağ alt ağacı ziyaret eden derinlik öncelikli gezinme. Preorder'da düğüm önce, postorder'da en son ziyaret edilir; ikili arama ağacında inorder gezinme anahtarları sıralı verir. Ağaçlar ve İkili Ağaçlar →

İ

İkili ağaçBinary treeVeri Yapıları
Her düğümün en fazla iki çocuğu (sol ve sağ) olduğu ağaç. Go'da genellikle type Node struct { Val int; Left, Right *Node } biçiminde temsil edilir. Ağaçlar ve İkili Ağaçlar →
İkili aramaBinary searchAlgoritmalar
Sıralı bir dizide her adımda arama aralığını ortadaki elemana göre yarıya indiren O(log n) algoritma. Taşmayı önlemek için orta nokta lo + (hi-lo)/2 ile hesaplanır; Go'da slices.BinarySearch ve sort.Search hazır olarak gelir. Arama Algoritmaları →
İkili arama ağacıBinary search tree (BST)Veri Yapıları
Her düğümde sol alt ağaçtaki anahtarların düğümden küçük, sağ alt ağaçtakilerin büyük olduğu ikili ağaç. Arama, ekleme ve silme O(h) sürer; dengeli ağaçta h = O(log n), sıralı eklemelerle dejenere olmuş ağaçta ise O(n)'dir. İkili Arama Ağaçları (BST) →
init fonksiyonuinit functionGo
Paket düzeyindeki değişkenler başlatıldıktan sonra, main çalışmadan önce otomatik çağrılan parametresiz fonksiyon. Bir pakette birden fazla init olabilir ve elle çağrılamaz. Paketler ve Modüller →
internal paketiInternal packageGo
Yolunda internal dizini bulunan paket. Yalnızca internal dizininin üst dizininde kök salan kodlar tarafından import edilebilir; bu kural derleyici tarafından uygulanır. Paketler ve Modüller →
io.Readerio.ReaderGo
Read(p []byte) (n int, err error) metoduna sahip arayüz; dosya, ağ bağlantısı veya bellekteki veri gibi her türlü byte kaynağını soyutlar. Veri bittiğinde io.EOF hatası döner. Dosyalar, I/O ve JSON →
io.Writerio.WriterGo
Write(p []byte) (n int, err error) metoduna sahip arayüz; dosyalar, os.Stdout, bytes.Buffer ve HTTP yanıtları gibi byte hedeflerini soyutlar. Dosyalar, I/O ve JSON →
iotaiotaGo
Bir const bloğu içinde her sabit satırında bir artan, 0'dan başlayan sabit üreteci. Numaralandırma (enum benzeri) değerleri ve 1 << iota gibi bit bayrakları tanımlamak için kullanılır. Değişkenler, Sabitler ve Tipler →
İsimlendirilmiş dönüş değeriNamed return valueGo
func split(n int) (x, y int) gibi imzada adı verilen dönüş değerleri. Fonksiyon başında sıfır değerleriyle başlatılır; defer içinden değiştirilebilir, bu da hata sarmalamada işe yarar. Fonksiyonlar →
İşaretçiPointerGo
Bir değişkenin bellek adresini tutan değer. &x adresi alır, *p adresteki değere erişir; sıfır değeri nil'dir ve Go'da (unsafe dışında) işaretçi aritmetiği yoktur. İşaretçiler (Pointers) →
iter.PullPull iteratorGo
range ile tüketilen (push) bir iter.Seq değerini, değerleri tek tek istemeyi sağlayan next ve stop fonksiyonlarına dönüştürür. İki diziyi aynı anda adım adım gezmek gibi durumlarda kullanılır; iş bitince stop çağrılmalıdır. İteratörler (range over func) →
İteratörIteratorGo
Bir dizi değeri sırayla üreten yapı. Go 1.23'ten itibaren func(yield func(V) bool) imzalı fonksiyonlar range ile gezilebilir; standart kütüphanedeki karşılıkları iter.Seq[V] ve iter.Seq2[K, V] tipleridir. İteratörler (range over func) →

J

JeneriklerGenericsGo
Fonksiyon ve tiplerin tip parametreleri sayesinde birden fazla tip için tek seferde yazılabilmesi. Go 1.18 ile geldi; örneğin func Map[T, U any](s []T, f func(T) U) []U. Jenerikler (Generics) →

K

Kaba kuvvetBrute forceAlgoritmalar
Tüm olası adayları tek tek deneyerek çözüm arayan yaklaşım. Genellikle yavaştır ama doğruluğu kolay görülür; optimal çözümü tasarlamadan önce başlangıç noktası ve test karşılaştırması olarak işe yarar. Problem Çözme Stratejileri →
Kaçış analiziEscape analysisGo
Derleyicinin bir değerin fonksiyon döndükten sonra da yaşayıp yaşamayacağını inceleyerek onu stack'e mi heap'e mi yerleştireceğine karar vermesi. Kararlar go build -gcflags=-m ile görülebilir. İşaretçiler (Pointers) →
KanalChannelGo
Goroutine'ler arasında tipli değer iletmeyi sağlayan yapı; make(chan int) ile oluşturulur, ch <- v ile gönderilir, v := <-ch ile alınır. Tamponsuz kanalda gönderici, alıcı hazır olana kadar bekler. Kanallar (Channels) →
KapasiteCapacityGo
Bir dilimin, alttaki dizide yeniden bellek ayırmadan ulaşabileceği en büyük uzunluk; cap(s) ile okunur. append kapasiteyi aşarsa daha büyük yeni bir dizi ayrılır ve elemanlar oraya kopyalanır. Diziler ve Dilimler (Slices) →
KapsamScopeGo
Bir tanımlayıcının kaynak kodda görünür olduğu bölge. Go'da kapsam bloklarla ({ }) belirlenir: evren, paket, dosya, fonksiyon ve iç bloklar. Değişkenler, Sabitler ve Tipler →
KararlılıkStability (sorting)Algoritmalar
Bir sıralama algoritmasının eşit anahtarlı elemanların başlangıçtaki göreli sırasını koruması. Birleştirmeli ve eklemeli sıralama kararlıdır, hızlı sıralama değildir; Go'da kararlı sıralama için slices.SortStableFunc kullanılır. Temel Sıralama Algoritmaları →
KenarEdgeVeri Yapıları
Graftaki iki düğüm arasındaki bağlantı. Yönlü graflarda bir yönü, ağırlıklı graflarda maliyet veya mesafe gibi bir ağırlığı vardır; bir düğüme bağlı kenar sayısına derece denir. Graflar →
Kırmızı-siyah ağaçRed-black treeVeri Yapıları
Düğümleri kırmızı veya siyah renklendirilen kendini dengeleyen ikili arama ağacı: kırmızı düğümün çocuğu kırmızı olamaz ve bir düğümden altındaki boş yapraklara giden her yolda siyah düğüm sayısı aynıdır. Bu kurallar yüksekliği O(log n) tutar ve AVL'ye göre daha az dönüş gerektirir. Dengeli Ağaçlar: AVL →
Kısa değişken tanımıShort variable declarationGo
x := 10 biçiminde tipi değerden çıkarılan tanım. Yalnızca fonksiyon içinde kullanılabilir ve sol tarafta en az bir yeni değişken bulunmalıdır. Değişkenler, Sabitler ve Tipler →
KısıtConstraintGo
Bir tip parametresinin kabul ettiği tip kümesini tanımlayan arayüz; any, comparable veya cmp.Ordered gibi. ~int yazımı, temel (underlying) tipi int olan tüm tipleri, örneğin type Celsius int tipini de kapsar. Jenerikler (Generics) →
KilitlenmeDeadlockGo
Goroutine'lerin birbirini ya da hiç gerçekleşmeyecek bir olayı sonsuza kadar beklemesi. Tüm goroutine'ler bloke olursa çalışma zamanı programı fatal error: all goroutines are asleep - deadlock! hatasıyla sonlandırır. Kanallar (Channels) →
Komşuluk listesiAdjacency listVeri Yapıları
Her düğüm için komşularının listesinin tutulduğu graf temsili; Go'da [][]int veya map[int][]int olarak yazılabilir. O(V+E) bellek kullanır ve seyrek graflar için uygundur. Graflar →
Komşuluk matrisiAdjacency matrixVeri Yapıları
V×V boyutlu bir matriste [u][v] hücresinin u'dan v'ye kenar olup olmadığını (veya ağırlığını) gösterdiği graf temsili. Kenar kontrolü O(1), bellek O(V²)'dir; yoğun graflar için uygundur. Graflar →
KovaBucketVeri Yapıları
Hash tablosunda, hash değeri aynı konuma düşen girdilerin tutulduğu yuva. Anahtarın kovası genellikle hash(key) % m ile bulunur; burada m kova sayısıdır. Hash Tabloları →
KuyrukQueueVeri Yapıları
İlk giren ilk çıkar (FIFO) prensibiyle çalışan yapı: Enqueue sona ekler, Dequeue baştan alır. BFS gibi algoritmaların ve iş kuyruklarının temelidir. Kuyruk (Queue) ve Deque →
KümeSetVeri Yapıları
Her elemanı en fazla bir kez içeren koleksiyon. Go'da yerleşik bir küme tipi yoktur; genellikle değer olarak sıfır bayt yer kaplayan struct{} kullanılarak map[T]struct{} biçiminde uygulanır. Haritalar (Maps) →

L

LRU önbellekLRU cacheVeri Yapıları
Kapasite dolduğunda en uzun süredir kullanılmayan (least recently used) girdiyi çıkaran önbellek. Bir hash tablosu ile çift yönlü bağlı liste birleştirilerek Get ve Put işlemleri O(1)'de yapılır. Hash Tabloları →

M

makemakeGo
Dilim, harita ve kanal oluşturup başlatan yerleşik fonksiyon. Örneğin make([]int, 5, 10), make(map[string]int) ve make(chan int, 3); işaretçi değil, kullanıma hazır değerin kendisini döndürür. Diziler ve Dilimler (Slices) →
Master teoremiMaster theoremAlgoritmalar
T(n) = a·T(n/b) + f(n) biçimindeki yineleme bağıntılarını, f(n)'i n^(log_b a) ile karşılaştırarak çözen teorem. f(n) daha yavaş büyürse sonuç Θ(n^(log_b a)), aynı hızda büyürse Θ(n^(log_b a)·log n), daha hızlı büyürse (düzenlilik koşuluyla) Θ(f(n)) olur. Böl ve Fethet →
MemoizationMemoizationAlgoritmalar
Özyinelemeli bir fonksiyonun daha önce hesapladığı sonuçları bir harita veya dizide saklayıp tekrar istendiğinde yeniden hesaplamadan döndürmesi (yukarıdan aşağı DP). Saf özyinelemeli Fibonacci'yi üstel süreden O(n)'e indirir. Dinamik Programlama I: Temeller →
MetotMethodGo
Alıcı (receiver) parametresiyle belirli bir tipe bağlanan fonksiyon; func (u User) Greet() string gibi tanımlanır. Metotlar yalnızca aynı pakette tanımlanmış tiplere eklenebilir. Struct'lar ve Metotlar →
Metot kümesiMethod setGo
Bir tipin çağırabileceği ve arayüz uygulamasında sayılan metotlar. T tipinin metot kümesinde yalnızca değer alıcılı metotlar bulunur; *T ise hem değer hem işaretçi alıcılı metotları içerir. Arayüzler (Interfaces) →
MiddlewareMiddlewareGo
Bir http.Handler'ı sarmalayıp isteğin öncesinde veya sonrasında loglama, kimlik doğrulama, panik yakalama gibi ek işler yapan katman. Genellikle func(next http.Handler) http.Handler imzasıyla yazılır ve zincirlenir. HTTP Sunucusu ve İstemcisi →
ModülModuleGo
Birlikte sürümlenen paketlerin koleksiyonu. Kök dizindeki go.mod dosyasıyla tanımlanır ve go mod init example.com/proje komutuyla oluşturulur. Paketler ve Modüller →
Monoton yığınMonotonic stackVeri Yapıları
Elemanları her zaman artan veya azalan sırada tutulan yığın; yeni eleman eklenmeden önce sırayı bozanlar çıkarılır. "Bir sonraki büyük eleman" gibi problemleri toplam O(n) sürede çözer. Yığın (Stack) →
Mutexsync.MutexGo
Paylaşılan veriye aynı anda yalnızca bir goroutine'in erişmesini sağlayan karşılıklı dışlama kilidi. Lock ile alınır, Unlock ile (çoğunlukla defer mu.Unlock()) bırakılır; sıfır değeri kullanıma hazırdır ve ilk kullanımdan sonra kopyalanmamalıdır. Senkronizasyon: sync ve atomic →

N

newnewGo
Verilen tip için bellek ayırıp o değişkene işaretçi döndüren yerleşik fonksiyon; new(int) sıfır değerli bir *int verir. Go 1.26'dan itibaren new(42) gibi bir ifade de alabilir ve değişkeni o değerle başlatır. İşaretçiler (Pointers) →
nilnilGo
İşaretçi, dilim, harita, kanal, fonksiyon ve arayüz tiplerinin sıfır değeri. nil bir işaretçi üzerinden alana erişmek veya nil haritaya yazmak çalışma zamanında panik oluşturur. İşaretçiler (Pointers) →
nil haritaNil mapGo
var m map[string]int ile tanımlanıp başlatılmamış harita. Okumak sıfır değer döndürür ama yazmak panik oluşturur; kullanmadan önce make veya literal ile başlatılmalıdır. Haritalar (Maps) →

O

Optimal alt yapıOptimal substructureAlgoritmalar
Bir problemin en iyi çözümünün, alt problemlerinin en iyi çözümlerinden oluşturulabilmesi. Dinamik programlama ve açgözlü algoritmaların doğru çalışması için gereken temel özelliktir. Dinamik Programlama I: Temeller →

Ö

Öncelik kuyruğuPriority queueVeri Yapıları
Her zaman en yüksek öncelikli elemanın çıkarıldığı soyut veri tipi. Genellikle heap ile uygulanır; Dijkstra, Prim ve top-k problemlerinde temel yapıdır. Heap ve Öncelik Kuyruğu →
Örtüşen alt problemlerOverlapping subproblemsAlgoritmalar
Bir problemin çözümü sırasında aynı alt problemin defalarca ortaya çıkması. Örneğin fib(n) hesaplanırken fib(n-2) birden çok kez gerekir; bu özellik DP ile kazanç sağlanabileceğini gösterir. Dinamik Programlama I: Temeller →
ÖzyinelemeRecursionAlgoritmalar
Bir fonksiyonun problemi kendisinin daha küçük örneklerine indirgeyerek kendini çağırması. Her çağrı çağrı yığınında yeni bir çerçeve açar; Go'da goroutine stack'i büyüyebilse de sınırsız değildir ve aşıldığında program stack overflow hatasıyla çöker. Özyineleme (Recursion) →

P

PaketPackageGo
Aynı dizindeki ve aynı package bildirimini taşıyan Go dosyalarının oluşturduğu derleme birimi. Çalıştırılabilir programlar package main ve func main ile başlar; diğer paketler import ile kullanılır. Paketler ve Modüller →
panicpanicGo
Programın normal akışını durduran mekanizma; panic("...") ile ya da dizin taşması, nil işaretçi erişimi gibi çalışma zamanı hatalarıyla tetiklenir. Panik sırasında goroutine'deki ertelenmiş fonksiyonlar çalışır; yakalanmazsa program yığın iziyle sonlanır. Hata Yönetimi →
PipelinePipelineGo
Her aşamanın bir kanaldan veri alıp işledikten sonra bir sonraki aşamanın kanalına gönderdiği goroutine zinciri. Aşamaların sızıntı yapmaması için context veya bir done kanalıyla iptal edilebilir olması gerekir. Context ve Eşzamanlılık Desenleri →

R

rangerangeGo
for döngüsünde dilim, dizi, string, harita, kanal, tamsayı ve iteratör fonksiyonları üzerinde gezinmeyi sağlayan anahtar kelime. Go 1.22'den beri for i := range 10 biçimiyle tamsayı üzerinde de gezinilebilir. Operatörler ve Kontrol Akışı →
recoverrecoverGo
Panik hâlindeki bir goroutine'in kontrolü geri almasını sağlayan yerleşik fonksiyon. Yalnızca ertelenmiş bir fonksiyon içinde doğrudan çağrıldığında etkilidir ve panic'e verilen değeri döndürür; aksi hâlde nil döner. Hata Yönetimi →
RuneRuneGo
Tek bir Unicode kod noktasını temsil eden int32 takma adı. 'ş' gibi karakter literal'leri rune'dur; bir string üzerinde range ile gezinmek UTF-8 baytlarını çözerek rune'lar döndürür. String, Byte ve Rune →
RWMutexsync.RWMutexGo
Aynı anda birden çok okuyucuya (RLock) ya da tek bir yazara (Lock) izin veren kilit. Okumaların yazmalardan çok daha sık olduğu paylaşılan verilerde kullanışlıdır. Senkronizasyon: sync ve atomic →

S

Segment ağacıSegment treeVeri Yapıları
Her düğümün bir dizi aralığının toplamı, minimumu gibi bir özetini tuttuğu ikili ağaç. Aralık sorgusu ve nokta güncellemesi O(log n)'de yapılır; tembel yayılım (lazy propagation) ile aralık güncellemeleri de desteklenir. Segment Ağacı ve Fenwick Ağacı →
selectselect statementGo
Birden fazla kanal işlemini aynı anda bekleyen ifade; hazır olan case çalışır, birden fazlası hazırsa biri rastgele seçilir. default case'i varsa hiçbir işlem hazır değilken beklemeden o çalışır. Kanallar (Channels) →
SemaforSemaphoreGo
Bir kaynağa aynı anda erişebilecek iş sayısını sınırlayan mekanizma. Go'da genellikle make(chan struct{}, n) biçiminde tamponlu bir kanalla ya da golang.org/x/sync/semaphore paketiyle uygulanır. Context ve Eşzamanlılık Desenleri →
Sentinel hataSentinel errorGo
io.EOF gibi paket düzeyinde tanımlanıp dışa aktarılan ve belirli bir durumu işaret eden hata değişkeni. errors.New ile oluşturulur ve sarmalanmış olabileceği için == yerine errors.Is ile kontrol edilmelidir. Hata Yönetimi →
SerileştirmeSerialization (marshaling)Go
Bellekteki bir değeri saklanabilir veya iletilebilir bir biçime (ör. JSON) dönüştürme. Go'da json.Marshal bu işi, json.Unmarshal tersini yapar; yalnızca dışa aktarılan (büyük harfle başlayan) struct alanları işlenir. Dosyalar, I/O ve JSON →
ServeMuxhttp.ServeMuxGo
Gelen istekleri desenlere göre ilgili handler'a yönlendiren istek çoğullayıcısı (router). Go 1.22'den beri GET /items/{id} gibi yöntem ve joker içeren desenleri destekler; joker değeri r.PathValue("id") ile okunur ve çakışmada en özgül desen kazanır. HTTP Sunucusu ve İstemcisi →
Sıfır değerZero valueGo
Açıkça başlatılmayan bir değişkenin aldığı varsayılan değer: sayılar için 0, bool için false, string için ""; işaretçi, dilim, harita, kanal, fonksiyon ve arayüzler için nil. Struct'larda her alan kendi sıfır değerini alır. Değişkenler, Sabitler ve Tipler →
slices paketislices packageGo
Dilimler için jenerik yardımcılar sunan standart kütüphane paketi: slices.Sort, slices.Contains, slices.Index, slices.Reverse, slices.BinarySearch gibi. Go 1.21 ile standart kütüphaneye eklendi. Diziler ve Dilimler (Slices) →
StringStringGo
Değiştirilemez (immutable) bir byte dizisi; genellikle UTF-8 metin içerir. len(s) karakter değil byte sayısını verir; karakter sayısı için utf8.RuneCountInString(s) kullanılır. String, Byte ve Rune →
strings.Builderstrings.BuilderGo
Parça parça string oluştururken gereksiz kopyalamayı önleyen tip. WriteString ile eklenir, String() ile sonuç alınır; döngüde += ile birleştirmeye göre çok daha verimlidir. String, Byte ve Rune →
StructStructGo
İsimlendirilmiş alanlardan oluşan bileşik tip. type User struct { Name string; Age int } ile tanımlanır; tüm alanları karşılaştırılabilirse struct'lar == ile karşılaştırılabilir. Struct'lar ve Metotlar →
Struct etiketiStruct tagGo
Alan tanımından sonra yazılan ve çalışma zamanında yansıma (reflection) ile okunan string meta veri. json:"name,omitempty" etiketi encoding/json paketine alanın JSON adını ve boşsa atlanacağını söyler. Dosyalar, I/O ve JSON →
Swiss tableSwiss tableGo
Go 1.24'ten itibaren yerleşik map tipinin kullandığı hash tablosu tasarımı. Slotları küçük gruplar hâlinde tutar ve her grup için kontrol baytlarıyla hızlı eşleşme yapan açık adresleme kullanır. Hash Tabloları →
sync.Oncesync.OnceGo
Bir işlemin, kaç goroutine çağırırsa çağırsın yalnızca bir kez çalışmasını garanti eder: once.Do(f). Tembel başlatma için kullanılır; sync.OnceValue sonucu da döndüren kısayoludur. Senkronizasyon: sync ve atomic →
sync/atomicsync/atomicGo
Kilit kullanmadan bölünemez (atomik) okuma, yazma ve artırma işlemleri sunan paket. atomic.Int64 gibi tipler Load, Store, Add ve CompareAndSwap metotları sağlar. Senkronizasyon: sync ve atomic →

T

Tablo güdümlü testTable-driven testGo
Girdileri ve beklenen çıktıları bir test durumu dilimi olarak tanımlayıp döngüyle çalıştıran test deseni. Her durum genellikle t.Run(tc.name, ...) ile ayrı bir alt test olarak çalıştırılır. Test ve Benchmark →
TabulationTabulationAlgoritmalar
Bir DP tablosunu temel durumlardan başlayıp döngülerle büyük alt problemlere doğru doldurma yöntemi (aşağıdan yukarı DP). Özyineleme kullanmadığı için çağrı yığını derinliği sorunu yoktur ve alan optimizasyonuna uygundur. Dinamik Programlama I: Temeller →
Tam dilim ifadesiFull slice expressionGo
a[low:high:max] biçimindeki dilimleme; sonucun kapasitesini max-low ile sınırlar. Böylece yeni dilime yapılan append çağrısı ortak alttaki dizinin kalan kısmının üzerine yazamaz. Diziler ve Dilimler (Slices) →
Tam ikili ağaçComplete binary treeVeri Yapıları
Son seviye hariç tüm seviyeleri dolu olan ve son seviyesi soldan sağa doldurulan ikili ağaç. Boşluksuz olduğu için bir dizide saklanabilir: i indeksli düğümün çocukları 2i+1 ve 2i+2, ebeveyni (i-1)/2'dir. Heap ve Öncelik Kuyruğu →
TamponBufferGo
Veriyi işlenene kadar geçici olarak tutan bellek alanı. bufio paketi okuma ve yazmaları tamponlayarak sistem çağrılarını azaltır; bytes.Buffer ise büyüyebilen bir byte tamponudur. Dosyalar, I/O ve JSON →
Tamponlu kanalBuffered channelGo
make(chan int, 10) gibi kapasiteyle oluşturulan kanal. Tampon dolu değilse gönderme, boş değilse alma işlemi beklemeden gerçekleşir. Kanallar (Channels) →
Temel durumBase caseAlgoritmalar
Özyinelemeli bir fonksiyonun kendini çağırmadan doğrudan sonuç döndürdüğü en küçük durum; örneğin faktöriyelde n <= 1. Temel duruma ulaşılamazsa özyineleme sonsuza kadar sürer. Özyineleme (Recursion) →
Tip çıkarımıType inferenceGo
Derleyicinin jenerik bir fonksiyonun tip argümanlarını çağrıdaki değerlerden kendisinin belirlemesi. Bu sayede Max[int](3, 5) yerine kısaca Max(3, 5) yazılabilir. Jenerikler (Generics) →
Tip dönüşümüType conversionGo
Bir değeri float64(n) veya []byte(s) gibi T(x) sözdizimiyle başka bir tipe çevirme. Go sayısal tipler arasında örtük dönüşüm yapmaz; int ile int64 bile açıkça dönüştürülmelidir. Değişkenler, Sabitler ve Tipler →
Tip iddiasıType assertionGo
Bir arayüz değerinin dinamik tipini x.(T) ile çıkarma. Tip uyuşmazsa tek değerli biçim panik oluşturur; v, ok := x.(T) biçimi ise panik yerine ok == false döndürür. Arayüzler (Interfaces) →
Tip parametresiType parameterGo
Köşeli parantez içinde tanımlanan ve kullanım sırasında somut bir tiple değiştirilen yer tutucu: func Max[T cmp.Ordered](a, b T) T. Her tip parametresinin bir kısıtı vardır. Jenerikler (Generics) →
Tip switchType switchGo
switch v := x.(type) biçiminde bir arayüz değerinin dinamik tipine göre dallanma. Her case içinde v o case'in tipine sahip olur. Arayüzler (Interfaces) →
Tipsiz sabitUntyped constantGo
const big = 1 << 100 gibi henüz belirli bir tipe bağlanmamış sabit. Derleme zamanında yüksek hassasiyetle hesaplanır ve kullanıldığı bağlamın tipine dönüşür; o tipe sığmıyorsa derleme hatası verir. Değişkenler, Sabitler ve Tipler →
TrieTrie (prefix tree)Veri Yapıları
Kelimeleri karakter karakter dallanan düğümlerde tutan ağaç (önek ağacı); ortak önekler aynı yolu paylaşır. Ekleme ve arama kelime uzunluğu L için O(L)'dir; Türkçe karakterler için çocuklar map[rune]*node olarak tutulabilir. Trie (Önek Ağacı) →

U

unicode.TurkishCaseunicode.TurkishCaseGo
Türkçeye özgü i/İ ve ı/I dönüşümlerini tanımlayan özel büyük/küçük harf eşlemesi. strings.ToUpperSpecial(unicode.TurkishCase, "istanbul") ifadesi "İSTANBUL" üretir; sıradan strings.ToUpper ise "ISTANBUL" verir. String, Byte ve Rune →
Union-FindUnion-Find (disjoint set union)Veri Yapıları
Elemanları ayrık kümelere bölen ve iki işlem sunan yapı: Find bir elemanın kümesinin temsilcisini bulur, Union iki kümeyi birleştirir. Yol sıkıştırma ile boyuta veya rank'e göre birleştirme birlikte kullanıldığında işlem başına amortize maliyet pratikte sabit olan O(α(n))'dir. Ayrık Kümeler (Union-Find) →

V

Variadic fonksiyonVariadic functionGo
Son parametresi nums ...int biçiminde olup değişken sayıda argüman alan fonksiyon. Fonksiyon içinde parametre bir dilimdir; mevcut bir dilimi geçirmek için sum(values...) yazılır. Fonksiyonlar →
Virgül-ok deyimiComma ok idiomGo
İkinci bir bool dönüş değeriyle işlemin başarılı olup olmadığını öğrenme kalıbı. v, ok := m[key] anahtarın varlığını, v, ok := x.(T) tip iddiasını, v, ok := <-ch ise kanalın açık olup olmadığını kontrol eder. Haritalar (Maps) →

W

WaitGroupsync.WaitGroupGo
Bir grup goroutine'in bitmesini beklemeyi sağlayan sayaç: Add artırır, Done azaltır, Wait sayaç sıfırlanana kadar bekler. Go 1.25'te eklenen wg.Go(f) goroutine'i başlatıp sayacı kendisi yönetir. Goroutine'ler →
Worker poolWorker poolGo
Sabit sayıda goroutine'in ortak bir kanaldan iş alıp işlediği eşzamanlılık deseni. Aynı anda çalışan iş sayısını sınırlayarak kaynak kullanımını öngörülebilir kılar. Context ve Eşzamanlılık Desenleri →

Y

Yapıcı fonksiyonConstructor functionGo
Go'da özel bir yapıcı sözdizimi yoktur; bunun yerine geçerli bir değer oluşturup döndüren NewStack() gibi NewX adlı sıradan fonksiyonlar yazılır. Struct'lar ve Metotlar →
YaprakLeafVeri Yapıları
Hiç çocuğu olmayan ağaç düğümü. Bir düğümün yüksekliği ondan en uzak yaprağa giden yoldaki kenar sayısıdır. Ağaçlar ve İkili Ağaçlar →
Yarış durumuRace condition (data race)Go
Birden fazla goroutine'in aynı belleğe senkronizasyon olmadan eşzamanlı eriştiği ve en az birinin yazdığı durum; sonuç çalışma sırasına bağlı ve öngörülemez olur. go test -race veya go run -race ile yarış dedektörü etkinleştirilir. Goroutine'ler →
Yerinde sıralamaIn-place sortingAlgoritmalar
Girdi dizisinin kendisi üzerinde, sabit veya çok az (ör. O(log n)) ek bellekle çalışan sıralama. Eklemeli ve hızlı sıralama yerindedir; dizilerde birleştirmeli sıralama ise O(n) ek bellek ister. Temel Sıralama Algoritmaları →
YığınStackVeri Yapıları
Son giren ilk çıkar (LIFO) prensibiyle çalışan yapı: Push en üste ekler, Pop en üstten alır, ikisi de O(1)'dir. Go'da genellikle bir dilimin sonu yığının tepesi olarak kullanılır. Yığın (Stack) →
yield fonksiyonuyield functionGo
İteratör fonksiyonuna parametre olarak verilen ve her değeri döngü gövdesine ileten fonksiyon. false döndürürse döngü break gibi bir nedenle erken bitmiştir ve iteratör yield çağırmayı bırakmalıdır. İteratörler (range over func) →
Yineleme bağıntısıRecurrence relationAlgoritmalar
Özyinelemeli bir algoritmanın süresini daha küçük girdilerdeki süresi cinsinden ifade eden denklem. Örneğin birleştirmeli sıralama için T(n) = 2T(n/2) + O(n) yazılır ve çözümü O(n log n)'dir. Böl ve Fethet →
Yol sıkıştırmaPath compressionVeri Yapıları
Union-Find'da Find çağrısı sırasında yol üzerindeki her düğümü doğrudan köke bağlama tekniği. Sonraki sorgularda ağaçların çok sığ kalmasını sağlar. Ayrık Kümeler (Union-Find) →
Yönlü döngüsüz grafDirected acyclic graph (DAG)Veri Yapıları
Kenarları yönlü olan ve hiçbir düğümden başlayıp yine kendisine dönen yol içermeyen graf. Bir grafın topolojik sıralaması ancak DAG ise vardır; bağımlılık ve görev planlama problemleri DAG ile modellenir. Topolojik Sıralama →
Yönlü kanalDirectional channelGo
Yalnızca gönderme (chan<- int) veya yalnızca alma (<-chan int) yapılabilen kanal tipi. Fonksiyon parametrelerinde kullanılarak kanalın yanlış yönde kullanılması derleme zamanında engellenir. Kanallar (Channels) →
Yük faktörüLoad factorVeri Yapıları
Tablodaki eleman sayısının kova veya slot sayısına oranı (n / m). Belirlenen eşik aşılınca tablo büyütülüp tüm anahtarlar yeniden yerleştirilir (rehashing); böylece ortalama işlem süresi O(1) kalır. Hash Tabloları →

Z

Zaman karmaşıklığıTime complexityAlgoritmalar
Bir algoritmanın yaptığı temel işlem sayısının girdi boyutuna göre nasıl büyüdüğünü anlatan ölçü. Genellikle en kötü durum için Big-O ile ifade edilir; iç içe iki tam döngü tipik olarak O(n²) sürer. Karmaşıklık Analizi (Big-O) →