Açık kaynaklı Go Programlama Dili kibı. https://cihanozhan.medium.com/go-programlama-dili-kitab%C4%B1-81eea6997997

1. Genel Bakış
Bu bölümde, Go programlama dilinin dil tasarımına ve temel özelliklerine odaklanarak Go
dilinin programlamaya bakış açısını anlamaya çalışacağız.
Go Programlama Dili Tasarımı ve Geliştirilmesi
Go programlama dili(diğer adıyla Golang, biz bu kitapta sadece Go diyeceğiz), Google tarafından 2007 yılında
tasarlanmaya başlanmış açık kaynak kodlu bir programlama dilidir. Google bu dili, öncelikle kendi ihtiyaçlarını
gidermek için tasarlamaya başlamıştır. Bu nedenle, Go dil tasarımı ekibinin temel hedefi, güçlü bir ‘sistem
programlama dili’ oluşturmak ve dili bu amaçla geliştirmeye devam etmektir.
Go, derlenen ve statik tipli bir dildir. Go’nun ilk versiyonu Kasım 2009’da yayınlanmıştır. Go dilinin ilk
derleyicisi, ‘gc’ olarak bilinen açık kaynak kodlu bir derleyicidir. Ancak daha sonra Go dilinin yüksek
performanslı bir yapıya kavuşması nedeniyle, Go dili derleyicisi Go diliyle tekrar yazıldı ve artık bu yeni
derleyici(gccgo) kullanılmaktadır. Ancak istendiği takdirde farklı derleyiciler de kullanılabilir. Bu gibi ayarları
yapabilmek için gerekli tüm alt yapıyı Go ortamı sağlamaktadır. Bu ayarları detaylı bir şekilde Go kurulumu ve
ayarlarını yapacağımız bölümde inceleyeceğiz.
Go dilinin desteklediği popüler işletim sistemlerinden bazıları şöyledir;
 Linux
 Windows
 Mac OS X
 Solaris
 FreeBSD
Go dili farklı bazı işletim sistemlerine de destek vermektedir. Ancak gerek desteğin güncellik problemi ve bu
işletim sistemlerinin çok yaygın kullanılmaması nedeniyle onları bu listeye almadım. Bu listedekilerden farklı
bir işletim sistemi üzerinde Go uygulaması geliştirecekseniz Go’nun resmi dökümanlarına bakmanızı tavsiye
ederim.
Go dilinin desteklediği popüler mimarilerden bazıları şöyledir;
 amd64
 386
 arm
 arm64
 ppc64
İşletim sistemleri ve mimariler ile ilgili ‘minimum requirements’ bilgisine ulaşmak için sürekli güncellenen
aşağıdaki GitHub sayfasını ziyaret edebilirsiniz.
https://github.com/golang/go/wiki/MinimumRequirements
Go Maskotu
Bir programlama dili ya da teknoloji geliştirirken bunun insanlar tarafından sempatik, sevecen ve ilgi çekici
olarak algılanması önemlidir. Bunu da ilk olarak logo ya da sembol ile yapabiliriz. Google, Go programlama dili
konusunda bu işi iyi gerçekten iyi yaptı. Go’nun simgesi olan Gopher, aslında gerçek bir canlının adıdır. Go’nun
simgesi olarak kullanılan ‘Gopher’ aynı zamanda Go geliştiricilerine de verilen bir tanımdır. Yani, Go
programlama dilini öğrenip bu alanda çalışmaya başladığınızda siz de birer ‘Gopher’ olacaksınız.
Go dilinin maskotu ile ilgili detaylı bilgi için: https://blog.golang.org/gopher
cihanozhan.com

2. Neden Go?
Herhangi bir teknolojiyi öğrenmek için akla yatkın bazı nedenlere sahip olmalıyız. Bu durum tüm programlama
dilleri için de geçerlidir. A programlama dili varken neden B dilini tercih edeceğiz? Bu sorunun cevabı hem
teknik hem de kişiseldir. Öncelikle, bizim bir programlama dilinden beklentimiz nedir? Eğer biz sistem
programlama odaklı çalışmayı seviyorsak seçmemiz gereken programlama diliyle, web programlama, mobil ya
da oyun programlama için seçmemiz gereken dil farklıdır. Hatta sistem programlama ile yakın bir ilişkisi olan
gömülü sistem programlama için de kendi içerisinde bulunan farklılıklar nedeniyle programlama dili
seçimlerimiz değişecektir.
Peki biz neden Go dilini öğrenmeliyiz?
Çünkü biz hem web uygulaması geliştirmek hem de sunucu bazlı uygulamalar geliştirebilmek istiyoruz. Ve
bunları yaparken, yüksek performanslı uygulamalar geliştirmeyi, kolay öğrenmeyi, kaynak kodu derlerken bizi
dakikalarca ya da saatlerce(büyük sistemlerin derdi de büyüktür) bekletmemesini istiyoruz. Şimdi ‘Neden Go?’
sorusunu biraz daha yakından inceleyelim.
 Go programlama dili ‘Virtual Machine’ kullanmaz
Go dili Java ve C# gibi dillerde olduğu gibi bir sanal makine kullanmaz. Java dilini ele alırsak, Java’da
geliştirilen bir kod doğrudan Binary Code’a dönüşmez. Java kodu önce ByteCode’a, ondan sonra da Java Virtual
Machine tarafından makine koduna dönüştürülür. Bu nedenle VM kullanan dillerin diğer dillere göre
performansı daha düşüktür. Ancak bu VM kullanan dillerin yanlış tasarlandığını göstermez! VM kullanan
dillerin amacı ve detaylarını anlatmak bu kitabın konusu olmadığı için uzun sürecek bu konuya girmeyeceğiz.
Sadece bilmemiz gereken Go’nun VM kullanmadığı ve doğrudan Binary Code’a dönüştürüldüğüdür. Bu da bize
ciddi bir ek performans sağlar. Aynı şekilde C ve C++ dilleri de doğrudan makinenin anlayacağı Binary Code’a
dönüştürülür. Bu nedenle onlar da yüksek performansa sahiptir.
 Go dili C ve C++ gibi düşük seviyeli dillere yakın bir performans sergiler
Bunu başlığı atabilmek her programlama diline nasip olmayabilir. Çünkü programlama dünyasının tartışmasız en
performanslı dilleriyle ilgili bir kıyaslama içerisine giriyoruz. Ancak bu durum Go söz konusu olduğunda sorun
teşkil etmez. Go dili Google tarafından kendi alt yapılarında bulunan C++ ile geliştirilmiş yazılımların ve
servislerin yerini alması için geliştirildi. C++ ile geliştirilen bazı Google servislerinin(Google DNS, Google DL
vb.) karşılaştığı ve çözüm bulmakta zorlanılan C++ yazılımlarının yerinde şuan Go ile geliştirilen ve C++’a göre
daha performanslı çalışan servisler koşmaktadır.
C dili Go’dan daha performanslıdır. Ancak kesinlikle C ile kod yazmak çok sıkıntılı ve çeşitli sorunlara neden
olacak bir süreçtir. Ayrıca, C’nin amacı sistem, gömülü sistem ve donanımsal yazılımların geliştirilmesini
sağlamaktır. Yani, C dilinin amacı web ya da mobil uygulama geliştirmenizi sağlamak değildir. Ancak Go ile
web ya da mobil uygulama da geliştirebilirsiniz. Hem de C ile yakın bir performans ile…
C++ dili de yüksek performans sağlayan dillerden biridir. C++ ve Go için yapılan performans testlerine göre çok
küçük farklarla C++’ın daha performanslı olduğunu görebiliriz. Ancak Go dili ve derleyicisi üzerinde yapılan
her versiyon güncellemesinde performans farklarının kapandığını görebiliyoruz.
C, C++, Java, Python, JavaScript dilleriyle Go dili arasındaki performans çıktılarını yayınlayan aşağıdaki
bağlantıyı inceleyebilirsiniz.
https://benchmarksgame-team.pages.debian.net/benchmarksgame/faster/go.html
cihanozhan.com

3.  Go dili hem sistem programlama hem de web programlama için idealdir
Go dilinden önce bu başlığı kullanabilmek gerçekten zordu. Bu hedefle geliştirilen Java her ne kadar bir çok
altyapının ana teknolojisi olsa da, performans ve altyapısal bir çok sorun nedeniyle bunu tam olarak başarabilmiş
değildir. Aynı şekilde C# programlama dili de bu hedefi gerçekleştirmek için yola çıksa da başlangıcındaki
‘sadece Windows’da çalışma’ prensibi nedeniyle bu hedefe ulaşamadı. Ayrıca bu iki dilin altyapısında VM
kullanması nedeniyle çok yüksek performanslar göstermesinin önünde yapısal engeller vardı.
Go programlama diliyle birlikte gelen ve bu kitapta da bir kısmını görebileceğiniz built-in kod paketleriyle
Go’yu web programlama için de kullanabilirsiniz. Ayrıca geliştireceğiniz Go web uygulamasının performansı
diğer web programlama dillerinden çok daha performanslı olacaktır. Bununla birlikte, hem geliştirmesi, hem de
yönetilmesi kolay bir web uygulamasına sahip olabilirsiniz.
Bu kitabın konusu Go ile web programlama olmadığı için, bu aşamada sizi sadece bloğumdaki Go ile web
uygulama geliştirme makalelerine yönlendirebilirim.
http://www.cihanozhan.com/category/golang
Ayrıca, web uygulaması dediğimizde akıllara sadece klasik web uygulamaları gelmemelidir. Artık web
kavramıyla birlikte servis odaklı REST, Microservices, gRPC gibi yeni nesil web mimarilerini geliştirmeyi
düşünebilirsiniz. Ve Go dili bu alanlarda en dikkat çeken, bir çok ücretsiz ve açık kaynak kodlu projeye sahiptir.
Tek yapmanız gereken, geliştirmek istediğiniz web mimarisine uygun açık kaynaklı projeleri belirlemek ve
kodlamaya başlamak olacaktır.
 Go dili geriye dönük uyumluluğu destekler
Bu kısa başlığın arka planında ciddi tehlikeler bulunur. Uygulamalarımızı geliştirmek için kullandığımız
programlama/script dilleri, Framework ve library’lerin yeni versiyonlarının önceki versiyonlar ile uyumu
müthiş öneme sahiptir!
Geliştirdiğimiz bir uygulamada, X adında bir Framework kullandığımızı ve onun içerisindeki CALC adında bir
metodu da projenin birçok işlemi için kullandığımızı düşünelim. X adındaki Framework yeni versiyonunda
CALC adındaki metodun zorunlu parametre sayısını üçten dörde çıkardığında sizin uygulamanızın bu
Framework’ün yeni versiyonunu kullanabilmesi için tüm CALC metot çağrımlarını ve arka plandaki
algoritmalarını değiştirmesi gerekir.
Yukarıda bahsedilen durum, programlama dillerinde de daha çok önem arzedecek şekilde geçerlidir. Eğer Go 1.0
versiyonuyla bir uygulama geliştirdiyseniz, Go 1.1 versiyonu yayınlandığında ve projenizin derleyicisini
güncelleyip, yeni gelen performans, güvenlik ve diğer yeteneklerden faydalanmak istediğinizde Go 1.1’in Go 1.0
ile gelen özelliklerin hiç birini kullanımdan kaldırmamış(deprecated) olması gerekir. Aksi halde projenizin
büyüklüğü ne olursa olsun kaynak kodunuzdaki tüm ‘deprecated’ kodları yeni dil özelliklerine göre
değiştirmeniz gerekir. İşte bu noktada Go programlama dili tasarımcıları bize geriye doğru uyumluluğu
sağladıklarını ve bundan sonra da sağlayacaklarını garanti ediyor.
Google’ın Go programlama dili tasarım ekibi, Go 1.0 ve sonrasındaki tüm dil güncellemeleri için ‘geriye doğru
uyumluluk’ sözü vermektedir. İşte verdikleri bu söz nedeniyle, dile eklenecek özellikleri bazen beta aşamasında
bir kaç yıl boyunca test ederek dile ekleme/eklememe kararını veriyorlar.
 Go dilinin kendine ait söz dizimi kuralları vardır
Bir çok farklı programlama dili kullanan geliştiricilerin bildiği üzere, her programlama dilinin kendine has bazı
kuralları ya da kuralsızlıkları vardır. Eğer dil doğru tasarlanmadıysa ortaya çıkacak bazı kural boşlukları(ya da
esneklikler) o dil ile geliştirilen uygulamaların kod gözden geçirmelerini ve farklı geliştiricilerin aynı projede
çalışabilmesi durumlarını ciddi oranda olumsuz şekilde etkiler.
Go dilinin söz dizimi kurallarını denetleyen bir aracı vardır. Bu aracın adı: gofmt
cihanozhan.com

4. Go ile geliştirdiğimiz uygulama kodlarını gofmt aracılığıyla otomatik olarak düzeltebilir ve daha okunaklı bir
şekle getirebiliriz. Ayrıca, Go derleyicisine derlenmek üzere gönderdiğimiz tüm Go kodları önce gofmt aracına
gönderilerek düzenlenir ve daha sonrasında derleyici tarafından makine koduna dönüştürülür. Ancak eğer
istersek, biz de yazılım geliştirirken bu aracı kullanabilir ve geliştirdiğimiz kodların daha ‘Go söz dizimine
uygun hale’ getirilmesini sağlayabiliriz.
 Go dili ‘Garbage Collector’ ile hafızayı kendisi yönetir
Modern programlama dillerinin çoğunda GC özelliği mevcuttur. GC, biz geliştiricilere, uygulamalarımızın
bilgisayar hafızası üzerinde kullandığı alanları ve uygulamalarımızın nesnelerinin hafızadan kaldırma işlemlerini
otomatik olarak yönetme desteği sunar. Eğer C ile bir uygulama geliştirirseniz, uygulamanızın bilgisayar
üzerindeki hafıza kullanımını programcı olarak sizin yönetmeniz ve doğru zamanda, doğru şekilde hafızayı
temizlemeniz gerekir. Ancak bu konu ciddi bir tecrübe ve hafıza yönetimi alanında uzmanlık gerektirebilir. Bu
nedenle modern programlama dilleri GC ile bu süreci programcının yönetimine bırakmadan kendisi yönetir.
Ancak isterseniz, tıpkı C# dilinde olduğu gibi Go’da da hafızaya belli ölçülerde müdahale edebileceğiniz
yöntemler mevcuttur.
Genel olarak GC mimarisine sahip olan programlama dilleri işaretçi(pointer) kullanımına izin vermez ya da C#
gibi derleyici üzerinde ‘unsafe’ programlama ayarı yapmanızı zorunlu hale getirebilir. Ancak Go programlama
dili için işaretçiler varsayılan bir özelliktir ve çok sık kullanılır. Bu durum bize Go’nun sahip olduğu GC
mimarisinin bir nebze daha esnek ve kontrollü çalıştığını gösterir.
Ayrıca bu konuyu incelemek isterseniz Go built-in paketleriyle birlikte gelen ‘unsafe’ paketine göz atabilirsiniz.
https://golang.org/pkg/unsafe
 Go dilinin derleme performansı yüksek, derleme süresi düşüktür
Geliştirilen bir proje kodunun herhangi bir bilgisayarda derleyiciye gönderilerek derleme işleminin başlaması ve
bitişi arasındaki sürenin kısa olması gerekmektedir. Çünkü derlenen dillerde kodda yapılan en ufak bir değişiklik
bile, derlendikten sonra gerçek anlamda uygulamaya dönüşebilir. Bu durum küçük çaplı projelerde ciddi bir
sorun teşkil etmeyebilir. Ancak orta ve büyük çaplı projelerin kaynak kod yoğunluğu nedeniyle bu
uygulamaların normal bilgisayarlarda derlenmesi çok uzun sürebilmektedir. Tahmin edersiniz ki, bu sorunu en
ciddi şekilde yaşayan firmalardan biri de Google’dır.
Google mühendislerinin deyimiyle; “Öğle yemeğine çıkmadan önce derlemeyi başlattığımız halde, geri
döndüğümüzde halen derlemenin devam ettiğini görebiliyoruz”. İşte bu sorun nedeniyle Google, derleme
zamanını kısaltacak bazı düzenlemeler ile Go dilini hızlı derlenebilir bir dil olarak tasarladı.
 Go basit değil, sade bir dildir
Go dili sadece 25 anahtar kelimeden oluşan sade ve güçlü bir dildir! Diğer akranlarına bakacak olursak; C dili
32, Java dili 52, C# dili 100, C++ dili 109 anahtar kelimeye sahiptir. Bunun nedeni Go dilinin tasarım
amaçlarından biri olan sadeliği korumaktır. İlerleyen bölümlerde Go dilinde olmayan özellikleri gördüğünüzde
şaşıracaksınız! Ancak hepsinin yeni bir anahtar kelime olmadan kullanıldığını görünce tekrar şaşıracaksınız!
Go dilinde genel olarak yapılabilecek işlerin tek bir yolu vardır. O yol da dil tasarımcıları tarafından en
performanslı olduğu öngörülen uygulanabilir bir algoritmaya dayanır. Ancak diğer dillerde yapılacak bir işin
birden fazla algoritmik yöntemi olabilir. Go dilinin bu şekilde sadeliği tercih etmesinin temel nedeni, büyük
yazılım geliştirme ekiplerinin ürettiği kodun birbirlerinden derinlemesine farklara sahip olmamalarını
sağlamaktır. Bu sayede bir Gopher’ın yazdığı kodu bir başka Gopher rahatlıkla okuyabilir ve kod gözden
geçirmesi yapabilir.
Bu başlıktaki konunun alt başlıklarını ilerleyen ilgili konularda detaylıca inceleyeceğiz.
cihanozhan.com

5.  Bir Go uygulaması derlendiğinde tek bir ‘binary’ dosya üretir
Herhangi bir platform için uygulama geliştirirken karşılaşılan sorunlardan biri, üretilen çalıştırılabilir dosyanın
alt ve bağlılık gösteren farklı dosyalara sahip olmasıdır. Mesela bir C# uygulaması geliştirdiğimizde, arka planda
en iyi ihtimalle onlarca .dll dosyasının üretildiğini görebilirsiniz. Ve eğer bu uygulamayı dağıtmak-paylaşmak
istediğinizde tüm bu .dll dosyalarının başarılı şekilde uygulamaya gömüldüğünden ve gönderilecek istemci
bilgisayara da başarılı şekilde yüklendiğinden emin olmanız gerekiyor ki, bazen bu çok ciddi sorunlara neden
olabiliyor. Ancak Go dilinde geliştirdiğiniz uygulama tek bir dosya olarak derlenir! Bu da uygulamanızın
dağıtılabilirliğini artırır ve işinizi ciddi anlamda kolaylaştırır.
 Go dili Cross-Platform uygulama geliştirmeyi destekler
Modern uygulamalarda işletim sistemi kavramı yavaş yavaş değerini yitirerek yerini Cloud Computing ile
sağlanan ve otomatik yönetilen hizmetlere bırakıyor. Ve herhangi bir kullanıcı müdahalesi olmadan, otomatik
olarak, işletim sistemleri istenen özellik ve uygulamalarla birlikte Cloud servis sağlayıcısı tarafından oluşturulup
kullanıma hazır hale getiriliyor. Böyle bir mimari için geliştireceğimiz uygulamaların işletim sisteminden
bağımsız şekilde çalışabiliyor olması gerekmektedir. Bir yazılım geliştirici olarak biz tek bir kod yazarak
projenin iş akışını geliştirmeye odaklanırken, kullandığımız programlama dili ve teknolojiler de altyapıdaki
işletim sistemi ve diğer unsurların en verimli şekilde çalışmasını ve uygulamanın sorunsuz şekilde
koşturulmasını sağlayabilmelidir. İşte bu noktada Go dilinin işletim sistemlerinden bağımsız(cross-platform)
olarak çalışabiliyor olması bizi bir çok sıkıntıdan kurtarmaktadır.
Go dilinin desteklediği işletim sistemlerinin genel listesini, önceki konulardan biri olan
“Go Programlama Dili Tasarımı ve Geliştirilmesi” başlığında bulabilirsiniz.
Bir Go uygulamasını farklı platformlar üzerinden dağıtmak için Go’nun CLI aracı üzerinden birkaç komut
girmek yeterlidir.
 Eşzamanlı programlamaya yeni bir bakış
İşletim sistemleri ve CPU/GPU donanımlarının gelişmesiyle birlikte yazılımların çalışma performansları da arttı.
Ve ayrıca, bu donanımsal gelişmeler yazılımların ve programlama dillerinin çalışma modellerini de etkileyerek
onları kendini yenilemeye itti. Eskiden tek bir çekirdeğe sahip bilgisayar üzerinde yazılım geliştirmemiz
gerekirken, bugünlerde onlarca çekirdekli donanımsal mimariler üzerinde çalışacak yazılımlar geliştirmemiz
gerekiyor. Ancak en yenilerden sayılabilecek C# programlama dilinin çıkış tarihi 2001’dir. O tarihlerde çok
çekirdekli donanımlar kullanılmıyordu. İşte bu nedenle bu tür diller sürekli alt yapı değişikliğine gitmekle
birlikte, kullandıkları Framework’lere yeni özellikler eklemek zorunda kalıyorlar. Çünkü çok çekirdekli bir
donanım geleceği için tasarlanmadılar. Ancak Go dili, bu donanımsal gelişimin tam ortasında doğduğu için
mevcut gelişmeler ışığında tasarlandı.
Bir uygulama geliştirirken, birden fazla farklı işlemi aynı anda çalıştırıyormuşuz gibi performanslı uygulamalar
geliştirmemizi sağlayan Thread mekanizması mevcuttur. Bu konuyu bu kitabın Eşzamanlılık konusunu anlatan
bölümünde detaylıca inceleyeceğiz. Ancak burada sadece Go dilinin bu alandaki yeniliğinden bahsedeceğiz.
Örneğin, Java dilinde her Thread bilgisayar hafızasından yaklaşık olarak 1MB’lik bir alan alır. Eğer multithread
bir uygulama geliştirerek yazılımınızın daha efektif çalışmasını isterseniz, her Thread için 1MB’lık bir hafıza
ayırmanız gerektiğini bilmelisiniz. Java ile yaşanan benzer durum C# için de geçerlidir. .NET Framework
mimarisi benzer şekilde her Thread için hafızadan ciddi miktarda bellek alanı tedarik eder. Ancak Go dili bu
gereksinim için farklı bir yöntemi Go dilinin içerisinde gömülü olarak sunmaktadır. Bu özelliğin adı
Goroutine’dir.
Bu konunun detaylarını Eşzamanlılık bölümünde derinlemesine inceleyeceğiz.
cihanozhan.com

6. Go Programlama Dili Kullanıcıları
Go programlama dili başta Google’ın ihtiyaçlarını karşılamak için tasarlanmakla birlikte, zamanla gelişerek
birçok sorunu çözer hale geldi. Mesela bir programlama dilini hem sistem programlama için çok verimli
kullanıp, hem de aynı dili web programlama için yüksek performanslı ve hızlı uygulama geliştirebilir şekilde
kullanabilmek gerçekten tüm büyük yazılım altyapısı geliştiricilerinin beklentisiydi. İşte bu nedenle, yıllardır bir
çok büyük proje kendi altyapısını Go’ya geçirmektedir ya da yeni başlayan bir çok proje Go ile
geliştirilmektedir. Bu projeler içerisinde devasa Cloud Computing hizmet sağlayıcıları olduğu gibi Blockchain
gibi yeni bir akımdan da çok büyük temsilciler mevcuttur. Bu firmaların isimlerini burada listelemeyeceğim.
Ancak merak edenler aşağıdaki bağlantıdan Go dili kullanıcılarına güncel olarak ulaşabilirler.
https://github.com/golang/go/wiki/GoUsers
Bu listede bulunan ve ünlü bir Türk girişimi olan Koding’in blog yazısını okuyarak başlayabilirsiniz. Koding
ekibi, neden Node.js’den Go’ya geçtiklerini anlatmaktadır.
Go Programlama Diline Başlarken
Eğer bir ya da daha fazla programlama diliyle proje geliştirecek kadar şanslıysanız bu kısımda anlatacağım
konuyu zaten yaşamışsınızdır. Ancak yazılıma yeni başladıysanız ya da sadece tek bir programlama dili üzerine
tecrübeniz varsa bu aşamada programlamaya bakış açınızı bir benze değiştirmemiz gerekiyor. Şöyle ki; her
programlama dilinin kendine has bir amacı vardır. Programlama dilini tasarlayan kişiler karşılaştıkları belli
sorunları çözmek için planlama yaparak programlama dili tasarlama sürecine girerler. Tıpkı Google’ın yaptığı
gibi… Hatırlarsanız, Google’ın bazı programsal altyapı sorunları vardı ve bu sorunları çözmek için de Go dilini
geliştirdiler. İşte bu nedenle, yeni bir programlama dilini öğrenmeye başlarken önce o dilin hangi sorunların
yaşanması sonucunda geliştirildiğini ve amacını iyi bilmelisiniz. Aksi halde, programlama dilini öğrenirken
karşılaşacağınız durumlar sizi şaşırtabilir ve aklınıza şu soruların gelmesi olasıdır “Bu özellik neden var?”,
“Böyle basit bir özellik neden yok?”. Bu iki soru sadece durumu anlatabilmek için verilmiş örneklerdir. Bunlar
gibi onlarca ciddi soruyu kendinize sorabilirsiniz.
Mesela, çok sık sorulan sorulardan bazıları;
 Go dilinde neden Java ya da C# gibi kalıtım özelliği yok?
 Go dili neden bildiğimiz nesne yönelimli programlama paradigmasını desteklemiyor?
 Go dilinde neden diğer dillerdeki gibi erişim belirleyicileri(public, private vb.) yok?
 Go dilinde neden yapıcı metotlar yok?
 Go dilinde neden metotlara aşırı yükleme(method overloading) uygulayamıyoruz?
 Go dilinde neden jenerik yapılar gibi veri tutmayı kolaylaştıran bir model yok?
 Go dilinde neden try/catch hata yakalama mekanizması yok?
Bu sorular sadece başlangıç seviyesinde hızlı kavranabilecek farklardır. Ve bu listeyi ciddi şekilde uzatabiliriz.
İşte tüm bu bakış açılarının nedeni, kullandığınız programlama dilinin tasarlanma amacında yatıyor. Örneğin,
eğer bir C# ya da Java geliştiricisiyseniz, bu dillerin kurumsal uygulamalar geliştirmeyi hedefleyerek
tasarlandığını biliyor olmalısınız. Tecrübeli bir C# ya da Java geliştiricisi veri ve son kullanıcı odaklı bir
kurumsal yazılımı çeşitli araç ve kütüphaneler ile çok hızlı şekilde geliştirebilir. Çünkü bu dillerin çıkış noktası
kurumsal uygulama geliştirmeyi kolaylaştırmaktı. Bu nedenle bu dillerdeki özelliklere “Neden var?” sorusunu
sormadan önce bu bakış açısıyla bakmalısınız. Siz bu özellikleri kullanmayabilirsiniz ama bu özellikler farklı ve
ileri seviye bir kurumsal uygulama ihtiyacı için çok gerekli olabilir. İşte Go programlama diline de bu şekilde
bakmaya hazır olmalısınız. Çünkü eğer bir programlama dili biliyorsanız ve Go diline bu kitapla birlikte
başlayacaksanız Go’nun özellikleri sizi şaşırtabilir. Bazen hiç görmediğiniz bir programlama paradigmasını
içerdiğini görebilir, bazen de her dilde olan bir özelliğin Go’da olmadığını gördüğünüzde şaşırabilirsiniz. Merak
etmeyin! Tüm bu soruların mantıklı cevapları Go dilinde mevcuttur ve bunları yeri geldiğinde açıklayacağız.
Eğer bu tür durumlarla karşılaşırsanız Go’nun tasarlanma amacını hatırlayın; Güç, hız, performans, hızlı
geliştirme, hızlı öğrenme, büyük yazılım ekiplerinin programlama yaparken bir diğerinin kodunu okuyabilmesi…
cihanozhan.com

7. Go Dahili(Built-in) Paketleri
Her programlama dilinin kendine has bazı kriterleri olduğunu daha önceki bölümlerde sık sık dile getirmiştik. Ve
bilmemiz gereken diğer bir konu da, programlama dilinin sadece bir dilden ibaret olmadığıdır. Programlama dili
beraberinde kendi platformu ile birlikte gelir. Bu platform bazen Java ve C# dillerinde olduğu gibi ‘Virtual
Machine + Framework’ şeklinde olabileceği gibi, bazen de C dili gibi, sadece belirli temel işlemlerde
programcının işini kolaylaştıracak bazı kod dosyaları olabilir. Bu konuda Go dilinin yaklaşımı da C diline
benzerdir. Go dili beraberinde birçok kategoride en gerekli olan temel kod bloklarını paketler halinde bize sunar.
Bunlara yardımcı built-in paketler diyebiliriz ve bunları bilgisayarımıza kurmak için ek bir çaba sarf etmemize
gerek yoktur. Bilgisayarımıza Go dilini başarıyla kurduğumuzda bu paketler otomatik olarak hazır hale
getirilirler.
Bu paketlere göz atmak için; https://golang.org/pkg
Anahtar Kelimeler
Bir programlama dilinin bel kemiğini söz dizimi kuralları oluşturur. Bu söz dizimi kurallarının temelini de
anahtar kelimeler oluşturur. Go programlama dilinde sadece 25 adet anahtar kelime bulunur. Bu anahtar
kelimeler aşağıdaki gibidir;
break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var
Orjinal Go dökümanı; https://golang.org/ref/spec#Keywords
Operatörler ve Noktalamalar
Yazılım geliştirirken sık sık kullanacağımız bir diğer dil özelliği grubu ise operatör ve noktalama işaretleridir.
Bunlar genel olarak birçok programlama dilinde geçerli olan işaretlemelerdir. Ancak her dilin kendi kısıtlamaları
olabilir. Go dilinin de bu konuda bazı farklılıkları mevcuttur. Bu farklılıkları ilgili konular geldiğinde
açıklayacağız.
+ & += &= && == != ( )
- | -= |= || < <= [ ]
* ^ *= ^= <- > >= { }
/ << /= <<= ++ = := , ;
% >> %= >>= -- ! ... . :
&^ &^=
Orjinal Go dökümanı; https://golang.org/ref/spec#Operators_and_punctuation
Kaynak Kod Hakkında
…
Kaynak Kod ve UTF-8
Go programlama dilinin dosya uzantısı .go’dur. Go kaynak dosyaları içerisinde UTF-8 Unicode standartları
uygulanmaktadır. Bunun anlamı, Japonca ve Çince gibi tüm farklı karakterleri kullanabiliriz.
cihanozhan.com

8. Opsiyonel Noktalı Virgül
Go dili dosyalarında satır sonunda noktalı virgül kullanımı opsiyoneldir. Kod yazarken CTRL+S ile
kaydettiğinizde, VSCode gibi Go editörleri varsayılan olarak noktalı virgülleri siler. Bu karakterler Go dili için
gerekli değildir. Go derleyicisi için noktalı virgül sadece tek satırda çoklu ifade kullanılması gerektiğinde
gereklidir.
Yorum Satırları
Go dili C++ tarzı yorum satırlarını takip eder.
Tekli Açıklama Satırı;
// Bu açıklama yöntemi tek satır için uygulanır
Çoklu Açıklama Satırı;
/*
Bu alan
çok satırlı
açıklama içerir
*/
Çalışma Ortamı ve Hazırlıkları
Bu kitap içeriği hazırlanırken çalışma ortamı olarak Windows kullanılmıştır. Ancak Go kurulumunu Linux ya da
MacOSX gibi diğer yaygın işletim sistemleri üzerinde de rahatlıkla yapabilirsiniz. Bunun için, Go dili resmi
dökümanlarından kurulum başlığını takip edebilirsiniz.
https://golang.org/doc/install
Bilgisayara Go Programlama Dili Ortamı Kurulumu
Windows işletim sistemi üzerine Go kurulumu yapmak gayet basittir. Aşağıdaki bağlantıyı açarak Windows için
gerekli seçenekleri görebilirsiniz.
https://golang.org/doc/install#windows
İsterseniz bu açılan sayfadan ‘MSI installer’ başlığı altında bulunan ‘MSI file’ bağlantısına tıklayarak Go
kurulum dosyalarının bulunduğu sayfaya gidebilir ya da doğrudan aşağıdaki bağlantıyı açarak Go kurulum
dosyalarının yayınlandığı sayfaya ulaşabilirsiniz.
https://golang.org/dl
Biz Windows’a göre kurulum adımlarını takip ettiğimiz için açılan sayfada ‘Microsoft Windows’ alanındaki
.msi dosyasını indireceğiz. Go kurulumunu indirdikten sonra normal bir Windows programı kurar gibi kurulum
adımlarını geçebilirsiniz. Bu aşamalarda herhangi bir ayar değiştirmeniz gerekmiyor.
cihanozhan.com

9. Terminal Kullanımı
Go kurulumunu yaptıktan sonra bu işlemi başarıyla yaptığımızı anlayabilmek için Go terminalini kullanabiliriz.
Bu aşamada sadece Go dili versiyonunu öğrenmek için basit bir komut kullanacağız. İlerleyen bölümlerde bu
terminali farklı amaçlarla kullanacağız.
Terminal-1.PNG
Çalışma Ortamı Organizasyonu
Go dili kurulumunu tamamladıktan sonra bilgisayarımızı Go geliştirmeye hazır hale getirmek için birkaç ayar
yapmalıyız. Bu ayarları takip ederek en sondaki test sürecine kadar tamamladığınızda kitaptaki örnekleri
uygulayabilir hale geleceğiz.
Aşağıdaki yolu izleyerek ortam değişkenlerini ayarlayacağımız ekranı açın.
Denetim Masası > Sistem ve Güvenlik > Sistem > Gelişmiş sistem ayarları
COG-1.PNG
 Ortam değişkenlerine bulunan “Path” alanındaki verinin sonuna ekleyin; “C:Gobin”
 C dizinine giderek çalışma alanı klasörünüzü oluşturun; “C:ProjectsGo”
 Ortam değişkenlerine “GOPATH” ayarını ekleyin
o Sistem değişkenleri > Yeni…
o Değişken adı “GOPATH” ve değişken değeri olarak “C:ProjectsGo” ekleyin.
 Ortam değişkenlerini kaydedin ve ilgili panelleri kapatın
 Windows komut satırı aracını açın;
o Komut; echo %GOPATH%
o Sonuç olarak ekranda “C:ProjectsGo” görülmelidir.
 Komut satırında test uygulamasını çalıştırın;
o Komut; go get github.com/golang/example/hello
o Komut; %GOPATH%/bin/hello
o Sonuç olarak ekranda “Hello, Go examples!” görülmelidir.
Bu aşamaya kadar başarıyla geldiyseniz bilgisayarınızdaki Go kurulumu başarıyla çalışıyor demektir. Eğer
beklenen sonuçları alamadıysanız ayarları tekrar gözden geçirin ve bilgisayarınızda herhangi bir Windows
komut satırı aracının açık olmadığından emin olduktan sonra tekrar bir komut satırı açıp testleri baştan alarak
deneyin.
İlk Go Uygulaması : Merhaba Mars!
Bilgisayarımıza Go programlama dili ortamını kurduk ve gerekli ayarları yaparak testleri gerçekleştirdik. Artık
ilk uygulamamızı yaparak onun üzerinde incelemelerde bulunabiliriz.
İlk uygulamamızı basit bir ekrana mesaj yazdırma uygulaması olarak planladık. Burada genel yöntem “Merhaba
Dünya” olsa da, artık insanlık olarak Mars’a doğru yol almış olmanın verdiği heyecan ile uygulamamızı
“Merhaba Mars” olarak geliştireceğiz!
Örnek;
package main
func main() {
println("Merhaba Mars!")
}
cihanozhan.com

10. İlk kez Go kodu ile ilgilenenler için bu kod üzerinde biraz açıklama yapabiliriz. Öncelikle, ilk satırdaki kodumuz
“package …” bizim her Go uygulaması ve dosyası için belirtmek zorunda olduğumuz bir paket tanımlama
alanıdır. Bir paketin adının “main” olması ise, derleyiciden o paketin çalıştırılabilir bir uygulama olarak
yorumlanmasını istediğimizi gösterir. Ancak, her uygulamanın da bir başlangıç noktası olmalıdır ki, Go
derleyicisi bu uygulamanın hangi metot ile başlatılacağını bilsin… Bu nedenle, kodumuzun çalıştırılacağı bir de
“main()” isimli metot tanımladık. Bu metot bizim uygulamamızın ilk çalışmaya başlayacağı yer olacaktır.
Ardından, çalıştırmak istediğimiz kodu main() isimli başlangıç metodumuzun içerisine yazıyoruz. Burada
belirttiğimiz println() isimli metot çağrımı ise, Go kurulumu ile birlikte gelen built-in yapılardan biridir. Bu
metodu, kendisine parametre olarak verdiğimiz değeri, konsol üzerinden ekranda göstermek için kullanıyoruz.
Uygulamanın çıktısı aşağıdaki gibi olacaktır;
Merhaba Mars!
Bu aşamada, kod içerisinde küçük bir düzenleme yaparak ilk uygulama örneğimizi tamamlayalım. Dikkat
ederseniz, kod içerisinde herhangi bir dosyayı projeye dahil etmeden println() metodunu kullanabildik. Bu
kullanıma izin vermek Go dilinin geliştiricilere sunduğu ufak yardımlardan biridir. Ancak istersek, bu metodun
arka planında kullanılan Go built-in paketlerinden biri olan fmt paketini açık bir şekilde projeye dahil ederek
kullanabiliriz.
Bu işlemi aşağıdaki gibi uygulayabiliriz;
package main
import "fmt"
func main() {
fmt.Println("Merhaba Mars!")
}
Eğer daha önce hiç Go diliyle uğraşmadıysanız bu aşamada anlamadığınız konular için biraz daha sabırlı olun!
Her konuyu ayrı ayrı ele alarak detaylıca inceleyeceğiz.
Yazılım Geliştirme Editörleri
Bir programlama dilinin kalitesini belirleyen en önemli konulardan birisi uygulama geliştirme editörleridir.
Konuya teknik olarak bakacak olursak, herhangi bir programlama diliyle yazılım geliştirebilmek için basit bir
NotePad uygulaması yeterlidir. İçerisinde kodlar bulunan .go uzantısına sahip bir dosyayı Go derleyicisine
derlenmek üzere göndermek yeterlidir. Ancak programlama dilleri tek başına derleyicilerden oluşmaz. Bir
programlama dili kendi platformu ve geliştirme kültürüyle birlikte oluşturulur ve hayatını devam ettirir. Go açık
kaynak kodlu bir programlama dili olduğu için, yazılım sektöründe aktif olarak kullanılan açık kaynak kodlu ve
ücretsiz IDE’ler ile entegrasyonu başarılı şekilde çalışmaktadır.
Not : IDE (Integrated Development Environment)
Biz bu kitapta, Microsoft tarafından geliştirilen Visual Studio Code editörünü kullanacağız. Visual Studio
Code editörü, kısaca VSCode olarak isimlendirilmektedir. VSCode editörü Microsoft tarafından geliştirilmiş
olsa da, şu an aktif olarak 600’ün üzerinde yazılım geliştirici tarafından kod desteği sağlanmaktadır. Bu editörü
kullanmaya başladığınızda göreceksiniz ki, VSCode editörü hem rahat bir kullanıma sahip, hem de çok sık
güncellemeler alarak gün geçtikte güç kazanmaktadır.
Visual Studio Code editörü ile ilgili bağlantılar;
 VSCode’un resmi web sayfası: https://code.visualstudio.com
 VSCode eklentileri: https://marketplace.visualstudio.com/vscode
 VSCode kaynak kodlarını görmek için: https://github.com/Microsoft/vscode
 VSCode için geliştirilen Go eklentisi: https://github.com/Microsoft/vscode-go
Go programlama dilini kullanarak yazılım geliştirebileceğiniz diğer kod editör alternatifleri;
cihanozhan.com

11.  Online Go IDE: https://play.golang.org
 Vim için Go eklentisi: https://github.com/fatih/vim-go
 SublimeText 3 için Go eklentisi: https://github.com/DisposaBoy/GoSublime
 IntelliJ için Go eklentisi: https://github.com/go-lang-plugin-org/go-lang-idea-plugin
 LiteIDE (Go için geliştirilen bir IDE): https://github.com/visualfc/liteide
 Atom için Go eklentisi: https://atom.io/packages/go-plus
Go Döküman ve Tur Sayfaları
Go dili, hem resmi hem de topluluk tarafından hazırlanan dökümanlar ile geliştiricilere detaylı
eğitim materyalleri sunmaktadır.
Go Programlama Dili Resmi Dökümanları
Yeni teknolojilerin kullanıcılar tarafından hızlı öğrenilmesi ve tercih edilebilir olmasını sağlayan temel
özelliklerden biri döküman zenginliği, uygulama örnekleri, eğitim materyalleri ve çalışmayı kolaylaştıracak
araçlardır. Go dili bu konuda işini doğru yapıyor!
Go dili, dökümanlarına resmi web sitesi üzerinden ulaşabilirsiniz; https://golang.org/doc
Bu döküman sayfasında, Go’nun built-in paketleri için hazırlanan dökümanlara, Go hafıza yönetimi
dökümanlarına, etkili Go kodu geliştirme dökümanlarına, Go komut satırı aracı ve diğer araçlara ait
dökümanlara kadar tüm resmi dökümanlara ulaşabilirsiniz. Ayrıca Go’nun resmi bloğundaki makalelere de
buradan ulaşabilirsiniz.
Eğer Go komut satırı üzerinden belirli Go nesnelerine ait dökümanlara ulaşmak isterseniz;
godoc fmt Println
GoTour-1.PNG
Go Programlama Dili Tur Sayfaları
Go gibi açık kaynak kodlu programlama dilleri açık kaynak toplulukları ve bireysel şahıslar tarafından
desteklenirler. Bu sayede, bu teknolojiler yaygınlaşır ve resmi dökümanlarından daha fazla topluluk dökümanına
sahip olurlar. Hem de bir çok farklı dilde…
Go için topluluklar tarafından hazırlanan pratik ve hızlı başlangıç yapmayı sağlayan sitelerden ikisini ilginize
sunacağım.
Go Tur Sayfaları
Türkçe: https://go-tour-turkish.appspot.com
İngilizce: https://tour.golang.org
Bu sitelerden herhangi birini baştan sona incelerseniz, Go dili için en temel seviyede bilgiyi hızlı bir şekilde elde
etmiş olursunuz. Kitabın bu aşamasında, bu kısa turu gözden geçirmenizi öneririm. Bu kaynaklar, kitap ile
birlikte gireceğimiz yoğun odaklanma öncesinde size genel bir bakış açısı kazandırmış olacaktır.
Go dili online tur uygulamasını kişisel bilgisayarınızda çalıştırabilirsiniz. Bunun için Go
ortamını kurduktan sonra, terminal üzerinden aşağıdaki komutu çalıştırmanız yeterlidir.
cmd> go tool tour
cihanozhan.com

12. Go Aracı ve Komutları
Go programlama dili, uygulamanın derleyici ve Go altyapısı ilgili olan süreçleri yönetmek, Go kodu üzerindeki
gerekli işlemleri yapmak, döküman işlemleri ve dilin diğer çevre teknolojileriyle ilgili işlemleri
gerçekleştirebilmek için birçok araçla birlikte gelmektedir.
Bu araçlardan en önemlisi ve en çok kullanacağımız ise “go” aracıdır. Bu araç ile birlikte gelen birçok ek
parametre ise, uygulama geliştirirken bizim en büyük yardımcımız olacaktır.
Go aracı komutları:
 build paketleri ve bağımlılıkları derler
 clean nesne dosyalarını siler
 doc paket ya da sembol için dökümantasyon gösterir
 env Go ortam bilgisini basar
 fmt Go kaynak dosyalarındaki kodların kurallara uygun düzenlenmesini sağlar
 get paketleri ve bağımlılıkları indirir ve kurar
 install paketleri ve bağımlılıkları derler ve kurar
 run Go programını derler ve çalıştırır
 test test paketleri için kullanılır
 version Go versiyonunu gösterir
Go aracını en temel haliyle çalıştırmak ve sonuç olarak gelen listeyi incelemek için Windows komut satırı
aracınıza “go” yazarak çalıştırmanız yeterlidir.
GoToolAndCommands-1.PNG
Go Paketlerini Kullanmak
Son yıllarda geliştirilen modern programlama dili ve platformlarında yeni ve internetin özüne uygun bir bakış
açısı mevcut. Bunlardan birisi de paket yöneticisi kavramıdır! Eğer Node.js ile ya da gelişmiş diğer JavaScript
platform ve kütüphaneleriyle programlama tecrübeniz varsa, paket yöneticisi kavramına aşina olmalısınız. Go
programlama dili de bu tür modern Framework ve platformların kullandığı yaklaşımı doğrudan dilin içerisine
gömerek, paketleme konusunda bir yeniliğe imza attı diyebiliriz.
Go ile yazılım geliştirirken, her .go dosyasını bir paket olarak planlarız. Ve bu paketleri de iç içe gruplayarak
programlama açısından hoş bir mimari elde edebiliriz. Bu yöntem kolay, sade ve de kodlama maliyeti ucuz bir
yoldur. Ancak kendi paketlerimizi oluşturma konusunu paketlere özel hazırladığımız bölüme bırakıyoruz. Bu
başlık altında sadece online açık kaynak depolarında bulunan Go kütüphanelerini projemize nasıl
ekleyeceğimize ve bu süreci nasıl yöneteceğimize odaklanacağız.
Go Paketlerini İndirmek
Go uygulamaları iki yönlü paket kullanımına sahiptir. Bunlardan ilki, tüm programlama dillerinde olduğu gibi
kendi geliştirdiğimiz kodları paketler halinde depolayarak Go kod dosyalarına dahil etmek, diğer yöntem ise
programlama dili olarak Go’ya özgü olan online kod depolarından indirerek bilgisayarın yerel diskine
depolayarak kullanmak.
Bir Go kod dosyasına online kod depolarından kod indirmek için go get komutu kullanılır.
Kod indirme örneğini kullanmak için Visual Studio Code gibi bir editöre ihtiyacımız yok. Bu işlemi
Windows(ya da diğer işletim sistemleri) terminaliyle gerçekleştirebiliriz.
cihanozhan.com

13.  Windows komut satırı uygulamasını açın
 go get test komutunu yazın: go get github.com/golang/example/hello
Bu işlemle birlikte, Go dilinin GitHub hesabındaki örnek uygulama olan hello’nun kaynak kodlarını
bilgisayarımızın yerel diskine indirmiş olduk. Programımızı çalıştırdığımızda ya da derlediğimizde, Go
derleyicisi hello uygulamasını kendi bilgisayarımızdaki disk üzerinden okuyarak çalıştıracaktır. Yani artık
GitHub ile herhangi bir bağı olmayan bir hello örneğinin kopyasına sahibiz! Bizim yaptığımız ayarlara göre
hello uygulamasının kopyası aşağıdaki dosya yolunda olacaktır.
C:ProjectsGosrcgithub.comgolangexamplehello
Dikkat ederseniz, go get komutu sadece uzak depodaki dosyaları kopyalamadı, ayrıyeten uzak depodaki domain
ve klasör yapısını da yerel diskimizde birebir klasörleri oluşturarak hazırladı.
Aklınıza bir soru gelmiş olabilir. Peki, eğer GitHub üzerindeki hello örneği üzerinde herhangi bir güncelleme
yapılarak yeni özellikler eklenirse bizim yerel diskimizde bulunan hello uygulaması eski sürüm olmayacak mı?
Evet, öyle olacak! Bu nedenle, projemizde kullandığımız Go kütüphanelerinin güncel versiyonları çıktığında ve
bu güncellemelere ihtiyacımız varsa kendi projemizdeki Go kütüphanelerini de güncellemeliyiz. Ama nasıl?
Bu güncelleme işlemi için aynı komut yapısına sadece küçük bir ekleme yapacağız.
go get ile kütüphane güncelleme komutu:
go get -u github.com/golang/example/hello
Dikkat ederseniz, aynı koda sadece basit bir -u komut eklemesi yaptık! Bu komut her çalıştırıldığında yerel
diskteki hello kütüphanesinin versiyonu ile GitHub üzerindeki hello kütüphanesinin versiyonunu karşılaştırır ve
eğer güncel bir özellik varsa kütüphaneyi günceller, aksi halde yerel diskte bulunan kütüphaneyi kullanmaya
devam eder.
Peki, sadece GitHub üzerinden mi kod depoları çekip kullanabiliriz? Hayır!
GitHub’ın yanında, Bitbucket, Launchpad ve IBM DevOps Services gibi versiyon kontrol sistemlerini de
kullanabilirsiniz. Diğer yandan farklı ve daha az bilinen versiyon kontrol sistemleri ya da kendi sistemlerinizi de
kullanabilirsiniz. Ancak bu durumda bazı protokol ayarlarını kontrol etmeniz gerekebilir.
Daha detaylı bilgi için aşağıdaki Go dökümanlarına göz atabilirsiniz:
https://golang.org/cmd/go/#hdr-Import_path_syntax
Go Paketlerini Kurmak
Kendi ürettiğimiz paketleri ya da go get ile yerel diske indirdiğimiz paketleri kullanmak ya da hata kontrolüne
tabi tutmak için bu paketleri go build ile derlemeliyiz. Derlenen bir Go paketi kullanılmaya hazırdır.
go build komutu çalıştırıldığında hedefteki her paketi derler. Bu paketlerden kütüphane olanlar ayrılır ve sadece
derleme hatalarına karşı kontrol edilirler. Ve derleyici, bu paketlerden name olarak isimlendirilen paketlere denk
geldiğinde, bu paketin bir uygulama olarak çalıştırılmasının istendiğini anlar ve linker’ı çağırır. Linker da bu
istek doğrultusunda, mevcut klasör içerisinde çalıştırılabilir bir dosya üretir.
go build ile Go dosyası yürütme yöntemleri:
Yöntem 1:
cmd> cd herhangiBirDosyaYolu
cmd> go build github.com/golang/example/hello
cihanozhan.com

14. Yukarıdaki yöntem ile hızlı bir şekilde komut satırı üzerinden build işlemini başlatabiliriz. Ancak burada
unutmamanız gereken bir nokta var! Komut satırı üzerinde komut çalıştırdığınız dosya yolu ne ise build
sonucunda çalıştırılabilir dosyanızın oluşturulacağı yol da odur.
Örneğin, aşağıdaki örnek komut çalıştırıldığında hello.exe isimli çalıştırılabilir dosya C:WINDOWSsystem32
klasörü altında oluşturulacaktır.
Yöntem 2:
cmd> cd %GOPATH%/src/github.com/golang/example/hello
cmd> go build
Bu yöntemde ise online olarak GitHub’dan dosyayı çekerek build yapmak yerine, kendi yerel diskimizde
bulunan hello kaynak kodunu hedefleyerek bir build işlemi başlattık. Bu komut çalıştırıldığında hello.exe
dosyası cd … ile belirtilen hello isimli Go kaynak kodu ile aynı klasör içerisinde üretilir.
Yöntem 3:
cmd> cd %GOPATH%
cmd> go build ./src/github.com/golang/example/hello
Bu yöntem ile de go build işlemini başlatabiliriz. Bu yöntemle oluşturulacak hello.exe dosyası C:ProjectsGo
klasörü altında yer alacaktır. Çünkü sistem ayarlarımızdaki GOPATH ortam değişkeninde bu dosya yolu yer
alır.
go install komutu da go build ile benzer bir işlem yürütür. En önemli fark, her paket ve derleme için derlenmiş
kodu kaydetmesidir. Derlenen dosyalar %GOPATH%/pkg altına, çalıştırılabilir dosyalar ise %GOPATH%/bin
klasörü altına kaydedilir.
Bu aşamada önemli bir performans meselesine değinmek gerekiyor. Yukarıdaki ilgili dosyaları ilgili yerlere
kaydetme işleminden sonra go build ve go install komutları bu saklanmış dosyaları tekrar çalıştırmıyor. Bu
nedenle bu komutların bir sonraki çalıştırılma süresi daha hızlı olmaktadır. Önceki bölümlerde Go’nun derleme
süresini ciddi oranda azalttığından bahsetmiştik. Bu açıkladığımız performans konusu da bu gelişimin bir alt
sebebidir.
Derleme konusu Go dilinin cross-platform olabilme yeteneğiyle doğrudan ilişkilidir. go install komutu GOOS
ve GOARCH ortam değişkenlerinin değerlerini içerir. Bu ortam değişkenleri uygulama çalışırken ya da
derlenirken uygulamanın üzerinde bulunduğu mimarinin ve işletim sisteminin bilgisini verir. go install komutu
da bu iki bilgiye göre işletim sisteminin ne olduğunu bilir ve derleme sonucunda üretilecek derlenmiş komutları
bu işletim sistemine göre üretir. Örneğin, golang.org/x/net/html paketini go install komutu ile çalıştırdığımızda
derlenme ve kurulum dosyaları %GOPATH%/pkg/darwin_amd64 şeklindeki bir dosya yoluna kaydedilir.
Uygulama içerisinde, Go’nun built-in paketlerinden runtime paketini kullanarak GOOS ve GOARCH
değerlerine ulaşabilir ve bu değerlere göre uygulamamızın mimari ve işletim sistemini bilmesini sağlayabiliriz.
Bu değerleri öğrendikten sonra, uygulamamız içerisinde Windows, Linux ya da MacOSX işletim sistemlerine
göre özel geliştirdiğimiz kodları çalıştırma yöntemini uygulayabiliriz.
Bazen işletim sistemi yeteneklerini son limitlerine kadar kullanmak gerekebilir. Bu durumda düşük seviyeli
kodlar yazılması gerekebilir. Örneğin, Windows gibi kapalı bir sistem üzerinde yapabileceğiniz işlemler ile
Linux gibi açık ve low-level işlemlerle programlanabilen bir mimaride farklı davranışlar ve performans gösteren
yazılımlar geliştirebiliriz. Aynı şekilde Windows’un da WinAPI’lerini kullanarak özel işlemler yapılabilir. Bu
durumda yukarıda bahsettiğimiz modeli kullanarak işletim sistemine özgü yazdığımız Go kodlarını
çalıştırabiliriz.
Örneğin:
 encryption_linux.go
 encryption_windows.go
cihanozhan.com

15.  encryption_amd64.s
Bu iki dosyanın hedeflediği işletim sistemi ve mimarileri farklı tasarlayabiliriz. Go uygulaması içerisinde tek
yapmamız gereken işletim sistemi ve mimariyi belirleyerek ilgili Go kod dosyasının çalıştırılmasını sağlamak
olacaktır.
Go derleyicisine “bu Go dosyasını sadece linux’da çalıştır“ gibi bir hedefleme yapabilir miyiz?
Bu soruya cevabımız: Evet! Go dili bu konuyu da çok ince bir şekilde çözmüştür.
Örneğin, eğer bir Go dosyası içerisinde paket tanımlama alanından önce aşağıdaki açıklama satırlarını yazarsak,
bu Go dosyası go build komutu ile çağrıldığında, sadece linux darwin işletim sistemleri için çalıştırılacaktır.
Not : ‘Linux Darwin’ hedeflemesi Linux ve MacOSX işletim sistemlerini hedeflediğimizi gösterir.
// +build linux darwin
Hatta eğer istersek, bazı Go dosyalarının hiç derlenmemesini de sağlayabiliriz. Bunun için de aşağıdaki açıklama
satırını öncekiyle aynı şekilde paket tanımlamasından önce bildirmeliyiz.
// +build ignore
Eğer build işlemleri konusunda daha fazla bilgi edinmek isterseniz aşağıdaki bağlantı üzerinden Go resmi
dökümanlarına göz atabilirsiniz.
https://golang.org/pkg/go/build/#hdr-Build_Constraints
İçe Aktarma
Go dosyalarına harici bir kaynaktan indirdiğimiz(GitHub gibi…), Go ile birlikte gelen built-in ya da kendi
geliştirdiğimiz yerel diskteki Go paketlerini dahil etmemiz gerekecek. Bu işleme kısaca içe aktarma diyoruz.
Temel olarak bu işlemi iki yöntemle uygulayabiliriz.
Eğer tek bir paketi içe aktarmak istersek;
import "math/rand"
Eğer birden fazla paketi içe aktarmak istersek;
import (
"math/rand"
"database/sql"
)
İçe Aktarım Bildirimleri
Go dosyasına içe aktarma yöntemiyle dahil ettiğimiz paketleri belirli bir düzen içerisinde tutmamız
gerekmektedir. Bu aşamada Go ile birlikte gelen gofmt aracı bizim yerimize bu işi sık sık yapmaktadır. Örneğin,
Visual Studio Code ile yazılım geliştirirken kodları her kaydettiğimizde(CTRL + S) gofmt aracı eğer kodlarda
bir hata yoksa otomatik olarak bu kodları Go standartlarına uygun şekilde düzenler. Aynı şekilde import
bildirimlerini de…
Bir diğer konu, bazen tek bir dosya içerisinde kullanacağımız dosyaların birbiriyle aynı isme sahip olması ya da
uzun ve anlamsız isimlere sahip olması durumu söz konusu olabilir. Bu tür durumlarda import alanında
yapacağımız küçük bir düzenleme ile paketlere yeni bir takma isim(alias name) verebiliriz.
Örneğin aşağıdaki gibi bir kullanım doğrudur:
cihanozhan.com

16. import (
cry "crypto/rand"
)
func main() {
cry.Reader() // İşlem anlamlı değil, sadece bir örnektir!
}
Boşluk( _ ) İçe Aktarım
Bir Go dosyasına import ile eklenen paketlerin Go kodları içerisinde herhangi bir nesne ve isimle referansı
yoksa bu dosyayı derlemeye çalıştığımızda Go derleyicisi “unused import” hatasını fırlatacaktır. Bunun nedeni,
Go dilinin kullanılmayan nesnelerin tanımlanmasına izin vermemesidir. Ancak, bazı durumlarda paketin
derlenme aşamasında uygulamaya dahil edilmesi ve paket içeriğinin runtime’da kullanılması söz konusu olabilir.
Bu durumda paketi dahil etmiş olmalıyız ancak herhangi bir isim referansını kullanmamıza gerek yoktur. Bu tür
durumlarda hem Go’nun kurallarına uygun hem de kullanılmayan nesne ve paketlerin tanımlanmasını
engelleyebilecek bir yöntem olarak alt çizgi( _ ) ile paket ve nesne tanımlama yöntemi Go diline eklendi.
En basit haliyle örneklemek gerekirse:
import _ "database/sql"
Yukarıda dahil edilen paketin nesnesine kod içerisinde ulaşamayız, çünkü bu paketi isimsiz olarak sadece
uygulamanın hafızasında kullanılabilir olması için ekledik!
Bu durumda, aşağıdaki kod bloğundaki sonuçlar tamamen geçerlidir:
package main
import (
"database/mysql"
_ "github.com/lib/pq" // Postgres desteği aktif
_ "github.com/go-sql-driver/mysql" // MySQL desteği aktif
)
db, err = sql.Open("postgres", dbName) // Başarılı
db, err = sql.Open("mysql", dbName) // Başarılı
db, err = sql.Open("sqlite3", dbName) // Çalışma anında 'unknown driver "sqlite3"'
hatası
Yukarıdaki örnekte görüldüğü üzere, Go dosyamıza PostgreSQL desteği kazandırarak çalışabilmek için pq
kütüphanesini, MySQL için de go-sql-driver/mysql paketini dahil ettik! Ancak bu paketlerin nesne
referanslarına programlama aşamasında değil, program çalışırken(runtime) uygulama arka planında
uygulamamızın ihtiyacı olacaktı. Bu nedenle, hem Go söz dizimi hatasını yaşamamak, hem de bu özellikleri
kullanabilmek için alt çizgi( _ ) kullandık.
Paketler ve İsimlendirme
Geliştirilen yazılımların yönetilebilir, sürdürülebilir ve clean code kurallarına uygun olabilmesi için temel
konulardan birisi isimlendirme kurallarıdır. Bu bölümde Go dilinin paket isimlendirme yaklaşımını
inceleyeceğiz.
Go dilinde bulunan built-in paketler Go’nun yaklaşımını ortaya koymaktadır. Tüm Go paketleri paketin amacına
uygun ve anlamı bozulmayacak şekilde isimlendirilir.
Örneğin:
cihanozhan.com

17. bytes, flag, fmt, http, io, json, os, sync
Yukarıda listelediğimiz isimlere ilk baktığımızda bile onların hangi amaç için geliştirildiğini anlayabiliyoruz. Ve
fmt paketinde görüldüğü gibi, mümkün oldukça kısaltma yapılmaya çalışılmış. Bir Gopher olarak, Go ile yazılım
geliştirirken bizler de bu yolu takip edebiliriz.
Örnek bir senaryo üzerinden ilerlemek gerekirse:
Eğer bir video işleme ve dönüştürme yazılımı geliştiriyorsak, video işlemlerinden sorumlu paketin adını video
olarak belirlemek doğru olmayabilir. Çünkü, bu isim tam olarak bu paketin ne için geliştirildiğini temsil
edemiyor. Bu durumda, VideoConverter gibi bir paket ismi belirlemek de tercih edilebilir. Ancak
VideoConverter ismi de Go built-in paketlerinin yaklaşımına uygun şekilde kısaltılabilir.
Örneğin, Go built-in paketlerinden strconv isimli paketin isimlendirmesini örnek alabiliriz. Bu durumda,
oluşturacağımız paketin adını videoconv ya da vidconv gibi daha kısa ve anlamı bozulmayacak şekilde
belirleyerek kullanabiliriz. Ancak, eğer bu paket sadece video dönüştürme işlemleri için değil de, aynı zamanda
videodan resim alma, kesme-birleştirme ve daha birçok dönüştürme işlemi haricindeki süreçleri de içeriyorsa, bu
durumda, paketimizin adını daha kapsayıcı hale getirmeliyiz. Örneğin bu durumda paketimizin adı vidtool
olabilir.
İsim kısaltmaları uygularken mantıklı ve anlam bozukluğuna müsade etmemeliyiz. Örneğin, sıcaklık ölçme ve
hesaplamayla ilgili bir paket hazırlıyorsak, buna en uygun isim temperature olabilir. Peki bunu nasıl
kısaltabiliriz? temp isimlendirmesi burada kullanılabilir mi? Eğer temp adını kullanırsak, bilişim sektöründe çok
sık kullanılan temporary teriminin kısaltması temp olarak algılanabilir. Eğer bu paket sıcaklık işlemleriyle ilgili
kapsayıcı ve geniş bir içeriğe sahip ise, temperature kullanılabilir. Ancak, eğer sıcaklık dönüşümleriyle ilgili bir
hesaplama paketinden ibaret ise, onu sadece tempconv şeklinde isimlendirmeyi tercih edebiliriz.
Paketleri Sorgulamak
Go dilinin yapısı gereği dışarıdan yerel diske indirilen Go paketleri ek birr gereksinimi de beraberinde getiriyor.
Örneğin, bazı durumlarda geliştirdiğimiz yazılım içerisinden ya da komut satırı terminali üzerinden basit bir
sorgu ile herhangi bir paketin yerel diskte olup olmadığını kontrol etmemiz gerekebilir. Bu tür bir istek için go
list komutu ile paketleri sorgulayabiliriz.
cmd> go list github.com/lib/pq
Bilgisayarımın yerel diskinde pq kütüphanesi bulunmadığı için aşağıdaki sonucu aldım.
PaketleriSorgulamak-1.PNG
Şimdi bu paketi yerel diskimize indirerek tekrar aynı listeleme sorgusunu çalıştıralım.
cmd> go get github.com/lib/pq
cmd> go list github.com/lib/pq
PaketleriSorgulamak-2.PNG
Yerel diskimizde bulunan tüm paketlerin listesini de go list ile elde edebiliriz.
cmd> go list …
ya da belirli bir git versiyon kontrol sistemindeki alt dal dediğimiz paketlerin listesi de alabiliriz.
cmd> go list github.com/cihanozhan/…
Yukarıdaki sorguda önemli olan kısım URL’in sonundaki üç nokta yan yana(...) kullanımıdır. Bu sorgu ile
birlikte GH/cihanozhan altındaki depolardan sistemimize yüklediklerimizin hepsi ekrana basılır.
cihanozhan.com

18. Komut Satırı Argümanları
Modern uygulamalarda sık sık görmeye ve kullanmaya başladığımız bir uygulama konsepti olarak CLI
uygulamalarını gösterebiliriz. Temel olarak terminal bazlı uygulamalar yeni bir kopsept olmasa da, paket
yönetim araçları, Cloud Computing platformları için hazırlanan terminal bazlı CLI yönetim arayüzleri, network
yönetim araçları ve daha birçok amaçla kullanılan CLI uygulama konseptinin temelini aslında çok basit bir
şekilde komut satırı argümanları oluşturur.
Komut satırı argümanları, konsolun siyah ekranı haricinde herhangi bir GUI’ye sahip olmadan, sadece belirli
standartlarla belirlenen komutların uygulamaya gönderilebildiği, hızlı yönetim araçları geliştirebilmek için
kullanılan yardımcı programlama özellikleridir.
Bu bölümde, Go ile komut satırı argümanlarını nasıl kullanabileceğimizi inceleyeceğiz.
Go dilinde built-in olarak bulunan os paketi bize Args adında bir slice sunuyor. Bu nesne ile birlikte,
uygulamamıza parametre olarak gönderilen argümanları uygulama içerisinden elde ederek kullanabiliriz.
Örnek:
package main
import (
"fmt"
"os"
)
func main() {
var x, seperator string
for i := 1; i < len(os.Args); i++ {
x += seperator + os.Args[i]
seperator = "n"
}
fmt.Println(x)
}
Uygulamayı parametreler ile birlikte çalıştırıyoruz:
cmd>go run main.go Go Programlama Dili Cihan Özhan
Uygulamanın çıktısı aşağıdaki gibi olacaktır:
Go
Programlama
Dili
Cihan
Özhan
Yukarıdaki mini uygulamada, sadece dışarıdan gönderilen parametreleri os.Args nesnesi üzerinden elde ederek,
bir döngüye dahil ettik ve parça parça ekrana bastık.
os.Args nesnesi bir string slice’dır. Bu demek oluyor ki, os.Args ile elde edilen verileri bir slice’ı parçalar gibi
parçalara ayırarak işleyebiliriz.
Not : Slice konusunu ileride detaylı olarak işleyeceğiz. Şuan için slice’ın tüm programlama dillerindeki dizilerle
neredeyse aynı yapıya sahip olduğunu bilmeniz yeterli olacaktır. Slice ile neler yapılabileceğini henüz
incelemediğimiz için, bu örneği basit tutmaya çalıştık.
cihanozhan.com

19. Değişkenler, Veri Tipleri ve Operatörler
Programlama dillerinin gerçek anlamda temelini oluşturan özelliklerden bir kaçını bölüm altında inceleyeceğiz.
Bu özellikleri eksiksiz olarak her uygulamada kullanırız. Bu nedenle, her ne kadar basit bir konu gibi görünse de,
bir programlama dilinin değişkenler, türler ve operatörler konularını çok iyi kavramalı ve bu konulardaki dile
özgü kuralları iyi bilmek gerekmektedir.
Değişkenler
Değişkenler, programlama dilleri için bilgisayar hafızasında veri tutmak için kullanılan nesnelerdir.
Programlama dillerindeki değişken kavramını insan beyni ve hafızası üzerinden açıklayabiliriz. Herhangi basit
bir matematiksel işlemi ele alalım.
Soru: 3+3 matematiksel işleminin sonucu kaçtır?
Bu soruyu nasıl hesapladınız? Muhtemelen hesaplamak için düşünmediniz bile! Ancak beyniniz bunun için
birçok işlemi koordineli bir şekilde yaptı. Eğer bu hesaplama modelini anlamaya çalışırsak süreç şöyle işliyor:
 Sorunun ilk değerini(3) hafızanızın bir hücresinde tuttunuz.
 Soru içerisindeki toplama(+) işaretini hafızanızın bir başka hücresinde tuttunuz.
 Sorunun ikinci değerini(3) hafızanızın bir başka hücresinde tuttunuz.
 Beyniniz ‘+’ işaretinin ne anlama geldiğini(operatör) temel matematik bilgisiyle yorumlayarak bunun
iki değeri toplamak anlamına geldiği sonucuna vardı.
 Beyniniz hafızanızda tutulan bu üç ayrı değerin olduğu hücrelerin adreslerini nöronlar(pointer)
vasıtasıyla bildiği için, beynin hesaplama yapan bölgesi otomatik olarak onları topladı.
 Sonuç: 6
Bilgisayar işlemcileri de, buna benzer bir çalışma mekanizmasını modellemek üzere tasarlanmıştır. Bu iki farklı
‘3’ değerlerini bilgisayar hafızasının farklı bölgelerinde tutarız ve onların hafızadaki adreslerine
işaretçiler(pointer) yardımıyla ulaşabiliriz. Bu işaretçileri de, programatik olarak yönetebilmek için, kendi
isimlendirdiğimiz programatik nesnelere bağlarız. İşte bu programatik nesnelere de değişken diyoruz. Biz
değişkenler tanımlarız ve bu değişkenler üzerinden hafızadaki adreslere ulaşarak veri yazıp okuyabiliriz. Bu
değişkenler de hafıza adreslerine ulaşmak için işaretçileri(pointer) kullanır. Ayrıca, derleyici mimarisinde tanımlı
olan operatörler(bu örnekte ‘+’ işareti bir operatördür) yardımıyla da bu değerler üzerinde herhangi bir işlemi
gerçekleştirebiliriz.
Go dilinde en temel haliyle değişken tanımlamak:
var message string
Go dilinde değişkenler var anahtar kelimesi ile tanımlanır. Farklı yöntemler mevcut olsa da şu an için sadece bu
yöntem üzerinde duracağız. message adını verdiğimiz değişkenin “Bu değişkende hangi türden veri tutulacak?”
sorusunun cevabı olarak da, metinsel veri tutacağımız için Go içerisinde metinsel veri tutmayı sağlayan veri tipi
olan string veri tipini belirttik. Artık message isimli değişken üzerinde veri tutabilir, onu değiştirebilir ve ekrana
basabiliriz.
Değişkene değer atamak:
message = "Merhaba Mars!"
Değişkenin değerini ekrana basmak:
fmt.Println(message)
Temel haliyle değişken tanımlama, değer atama ve ekrana basma işlemleri bu kadar basit!
cihanozhan.com

20. Değişkeni tanımlarken değer ataması yapabilir miydik? Evet!
Buna Go dilinde ‘var initialize’ diyoruz.
var message = "Hello World!"
Yukarıdaki message değişkenini aşağıdaki ‘Type Inference’ yöntemiyle veri tipi belirtmeden de yapabilirdik. Ve
herhangi bir Go örneğinde ya da açık kaynaklı projede göreceğiniz en sık tanımlama yöntemi genel olarak bu
olacaktır.
var message = "Cihan Özhan"
Ancak eğer bir üst kısımdaki ‘Type Inference’ yöntemini uygularsanız, başlangıç değerlerini vermeniz
gerekiyor. Aksi halde, Go derleyicisi bu değişkenin hangi veri tipinde veri tutması gerektiğini
çıkarımlayamayacaktır. Ve Go dilinde buna izin verilmez!
Aynı zamanda tek bir değişken tanımlama işleminde birden fazla değişken tanımlayıp bunların ilk değerlerini de
aynı satırda almalarını sağlayabiliriz.
var a, b, c = 1, 2, 3
Ayrıca tek bir satırda, birbirinden farklı veri tiplerine sahip değişkenler de tanımlayabiliriz.
var a, b, c, d = 1, false, 3, "Hello Mars!"
Go dilinde değişken tanımlamanın birçok farklı ve kolay yollardır vardır. Bunlardan biri de kısa değişken
tanımlamaktır. Kısa değişken tanımlarken var tanımı ya da veri tipi belirtmeye gerek yoktur.
u := 42
v, n := "foo", true
Kısa değişken tanımlarken sık sık karşılaşılan hatalardan biri eşittir( = ) kullanmaktır. Halbuki, kısa değişken
tanımlarken eşittir değil, iki nokta üst üste+eşittir(:=) bitişik şekilde kullanılır. Ve bu kullanımda var anahtar
kelimesi ya da veri tipi tanımlaması yapılmaz.
Kısa değişken tanımlamaya farklı örnekler de verebiliriz:
a := 10
b := "golang"
c := 4.17
d := true
e := "Merhaba"
f := `Golang nasıl ama?`
g := 'M'
fmt.Printf("%v n", a)
fmt.Printf("%v n", b)
fmt.Printf("%v n", c)
fmt.Printf("%v n", d)
fmt.Printf("%v n", e)
fmt.Printf("%v n", f)
fmt.Printf("%v n", g)
Not : Kısa değişkenler uygulamanın global scope’unda tanımlanamaz. Kısa değişkenler sadece
metotlar/fonksiyonlar içerisinde tanımlanıp kullanılabilirler.
Uygulamanın hangi kısmına ‘global scope’ denir?
cihanozhan.com

21. Go dilinde metot/fonksiyonların dışı global scope ya da package scope olarak tanımlanır. Bu metot/fonksiyon
main() de olabilir, diğer herhangi bir metot/fonksiyon da olabilir.
Aşağıdaki örneği inceleyelim:
// sayi değişkeni 'global scope' içerisinde tanımlanmıştır.
var sayi = 7 // geçerli!
// xyz : global scope’da kısa değişken tanımlaması yapılamaz!
xyz := 9 // geçersiz!
func main() {
var message = "Merhaba!" // Burası global scope değildir!
fmt.Println(sayi)
}
Global scope içerisinde de tek satırda birden fazla değişken tanımlaması yapabiliriz:
var b, c string = "global/package scope b", "global/package scope c"
Yukarıdaki çoklu değişken tanımlama örneğini daha düzenli şekilde de tanımlayabiliriz:
var (
str1 = "Cihan"
str2 = "Özhan"
)
Tür Çıkarımı
Go programlama dili programlamayı kolaylaştırmak için bazı özellikler sunuyor. Önceki konuda anlattığımız
üzere, örneğin değişkenleri var ve veri tipi bildirimi yapmadan kısa tanımlama yöntemiyle kullanabiliriz. Bu bize
programlamada esnek ve hızlı davranabilmemizi sağlar. Ancak bu durumda derleyicinin işi biraz daha karmaşık
hale gelmektedir. Çünkü, biz veri tipi bildirimi yapmadığımızda, derleyici bizim değişkene atadığımız değer
üzerinden değişkenin veri tipini anlayıp arka planda onu kullanması gerekir. Bu işleme de, genel olarak
programlama dünyasında ‘type inference’, yani tür çıkarımı diyoruz.
Örnek:
var firstName string
middleName := firstName
fmt.Printf("middleName veri tipi: %Tn", middleName)
price := 4.5
fmt.Printf("price veri tipi: %Tn", price)
age := 30
fmt.Printf("age veri tipi: %T", age)
Örnek sonucu:
Yukarıdaki örneklerde görüldüğü üzere, ilk değişkenimizin adı firstName ve bu değişkene bir string veri tipi
ataması yaptık! Sonrasında ise, middleName adında farklı ve veri tipi olmayan bir değişken tanımladık. Ancak,
middleName veri tipine string veri tipine sahip olan firstName’in değerini atadığımızda, middleName’in de
cihanozhan.com

22. firstName’in veri tipine sahip olduğunu görebiliyoruz. Sonrasında ise, kısa tanımlama yöntemiyle price adında
farklı bir değişken daha tanımladık. Bu tanımlamada herhangi bir veri tipi belirtmediğimiz halde price
değişkenine atadığımız 4.5 değeri programatik olarak bir float değer olduğu için, Go derleyicisi tarafından
otomatik olarak float olarak çıkarımlandı! Aynı şekilde, kısa olarak tanımladığımız age değişkenine de 30
değerini verdiğimiz için, Go derleyicisi bu değişkenin bir integer veri tipine sahip olması gerektiğini çıkarımladı.
Veri Tipleri
Veri tipleri, programlama dillerinde veri tutucular olarak çalışırlar. Hangi tipte veri depolamak istiyorsak, o tipe
uygun bir veri tipi kullanırız.
Go dilindeki veri tiplerinin listesi:
bool
string
int int8 int16 int32 int64
uint uint8 uint16 int32 uint64 uintptr
byte // uint8'in alias'ı
rune // int32'in alias'ı
float32 float64
complex64 complex128
Şimdi Go dilindeki veri tiplerini ve kullanımlarını inceleyelim.
Boolean Türleri
Boolean veri tipi sadece iki tür veri alabilir: true ya da false
Genellikle programlama dillerinde, Boolean tipi kısaltılarak bool adıyla kullanılır.
Örneğin, bir işlem sonucunun başarılı olup olmadığını tutmak için bool veri tipi kullanılabilir.
Örnek:
func main() {
val1 := true
val2 := false
fmt.Println("val1:", val1, "val2:", val2)
val3 := val1 && val2
fmt.Println("val3:", val3)
val4 := val1 || val2
fmt.Println("val4:", val4)
}
Örneğin çıktısı:
val1: true val2: false
val3: false
val4: true
Not : Bu veri tiplerini zaten örnekler içerisinde bolca kullanacağız. Bu nedenle, burada sadece temel
kullanımlarını inceliyoruz.
Tamsayı Veri Tipleri
Bu veri tiplerini tamsayı verilerini tutmak için kullanırız. Go ve diğer programlama dillerinde genel olarak
tamsayı veri tipleri ikiye ayrılırlar.
Tamsayı veri tipi türleri:
cihanozhan.com

23.  İşaretli Tamsayı Türleri
 İşaretsiz Tamsayı Türleri
Bu ayrımın temel nedeni, tamsayı veri tiplerinin kapasitesini düzenlemektir. İşaretli(signed) veri tipleri negatif(-)
değer alabilirken, işaretsiz(unsigned) veri tipleri ise sadece pozitif(+) değer alabilirler.
İşaretli Tamsayı Türleri
Eğer bir tamsayı veri tipi işaretli ise, tamsayı kapasitesinin yarısı negatif(-), diğer yarısı ise pozitif(+) değer için
ayrılır.
int8
8 bitlik integer kapasitesini temsil eder
Boyutu : 8 bit
Aralığı : -128 ile 127 arası
int16
16 bitlik integer kapasitesini temsil eder
Boyutu : 16 bit
Aralığı : -32768 ile 32767 arası
int32
32 bitlik integer kapasitesini temsil eder
Boyutu : 32 bit
Aralığı : -2147483648 ile 2147483647 arası
int64
64 bitlik integer kapasitesini temsil eder
Boyutu : 64 bit
Aralığı : -9223372036854775808 ile 9223372036854775807 arası
int
Bu veri tipinin kapasitesi, üzerinde çalıştığı platforma göre değişir.
Özel bir kapasite seçimi gerekmedikçe uygulamalarınızda int kullanmalısınız.
Boyutu : 32 bit sistemlerde 32 bit, 64 bitlik sistemlerde 64 bit
Aralığı :
32 bitlik sistemler için: -2147483648 ile 2147483647
64 bitlik sistemler için: -9223372036854775808 ile 9223372036854775807
Örnek:
var x int = 90
y := 91
fmt.Println("x'in değeri:", x, " ve y'nin değeri:", y)
Örneğin çıktısı:
x’in değeri:90 ve y’nin değeri:91
İşaretsiz Tamsayı Türleri
Eğer bir tamsayının veri tipi işaretsiz ise, tamsayı kapasitesinde herhangi bir bölünme yaşanmaz. Ve bu tamsayı
veri tipi türünde tüm kapasitesi pozitif(+) veri kullanımı olarak kullanılır.
uint8
8 bitlik integer kapasitesini temsil eder
Boyutu : 8 bit
Aralığı : 0 ile 127 arası
cihanozhan.com

24. uint16
16 bitlik integer kapasitesini temsil eder
Boyutu : 16 bit
Aralığı : 0 ile 65535 arası
uint32
32 bitlik integer kapasitesini temsil eder
Boyutu : 32 bit
Aralığı : 0 ile 4294967295 arası
uint64
64 bitlik integer kapasitesini temsil eder
Boyutu : 64 bit
Aralığı : 0 ile 18446744073709551615 arası
uint
Bu veri tipinin kapasitesi, üzerinde çalıştığı platforma göre değişir.
Özel bir kapasite seçimi gerekmedikçe uygulamalarınızda uint kullanmalısınız.
Boyutu : 32 bit sistemlerde 32 bit, 64 bitlik sistemlerde 64 bit
Aralığı :
32 bitlik sistemler için: 0 ile 4294967295
64 bitlik sistemler için: 0 ile 18446744073709551615
Kayan Nokta Veri Tipi : Float
Bu veri türü tipleri ondalıklı verileri tutmak için kullanılır. Genel olarak Floating ya da Float olarak
isimlendirilirler.
Go dilinde float32 ve float64 olmak üzere iki farklı float veri tipi vardır.
Örnek:
x, y := 8.92, 2.47
fmt.Printf("x ve y'nin tipleri: %T / %Tn", x, y)
sum := x + y
diff := x - y
fmt.Println("topla", sum, "çıkar", diff)
Float-1.PNG
Diğer Sayısal Veri Tipleri
byte : uint8 veri tipinin bir alias’ıdır. Yani byte geri planda bir uint8 olarak algılanır.
rune : int32 veri tipinin bir alias’ıdır. Yani rune geri planda bir int32 olarak tanımlanır.
[]rune Dönüşümü (Doc)
cihanozhan.com