Git - Hızlı Kılavuz

Go, sistem programlaması düşünülerek tasarlanmış genel amaçlı bir dildir. Başlangıçta Google'da 2007 yılında Robert Griesemer, Rob Pike ve Ken Thompson tarafından geliştirildi. Güçlü ve statik olarak türlenmiştir, çöp toplama için dahili destek sağlar ve eşzamanlı programlamayı destekler.

Programlar, bağımlılıkların verimli yönetimi için paketler kullanılarak oluşturulur. Go programlama uygulamaları, yürütülebilir ikili dosyalar oluşturmak için geleneksel bir derleme ve bağlantı modeli kullanır. Go programlama dili Kasım 2009'da duyuruldu ve Google'ın bazı üretim sistemlerinde kullanılıyor.

Go Programlamanın Özellikleri

Go programlamanın en önemli özellikleri aşağıda listelenmiştir -

• Dinamik dillere benzer kalıpları benimseyen çevre desteği. Örneğin, tür çıkarımı (x: = 0, int türünde bir x değişkeninin geçerli bildirimi)

• Derleme süresi hızlıdır.

• Dahili eşzamanlılık desteği: hafif süreçler (git rutinleri aracılığıyla), kanallar, seçim ifadesi.

• Go programları basit, özlü ve güvenlidir.

• Arabirimler ve Tür yerleştirme desteği.

• Dış bağımlılıklar olmadan statik olarak bağlı yerel ikili dosyaların üretimi.

Kasıtlı Olarak Hariç Tutulan Özellikler

Dili basit ve öz tutmak için, diğer benzer dillerde yaygın olarak bulunan aşağıdaki özellikler Go'da dahil edilmemiştir -

• Tür devralma desteği

• Yöntem veya operatör aşırı yükleme desteği

• Paketler arasında döngüsel bağımlılıklar için destek

• İşaretçi aritmetiği desteği

• İddialar için destek

• Genel programlama desteği

Programlara Git

Bir Go programının uzunluğu 3 satırdan milyonlarca satıra kadar değişebilir ve ".go" uzantılı bir veya daha fazla metin dosyasına yazılmalıdır. Örneğin, merhaba.go.

Go programınızı bir dosyaya yazmak için "vi", "vim" veya başka herhangi bir metin düzenleyicisini kullanabilirsiniz.

Yerel Ortam Kurulumu

Hala ortamınızı Go programlama dili için kurmaya istekliyseniz, bilgisayarınızda bulunan aşağıdaki iki yazılıma ihtiyacınız vardır -

• Bir metin editörü
• Derleyiciye git

Metin düzeltici

Programlarınızı yazmak için bir metin düzenleyiciye ihtiyacınız olacak. Metin düzenleyici örnekleri arasında Windows Not Defteri, İşletim Sistemi Düzenleme komutu, Kısa, Epsilon, EMACS ve vim veya vi bulunur.

Metin editörlerinin adı ve sürümü farklı işletim sistemlerine göre değişebilir. Örneğin, Windows'ta Not Defteri, Linux veya UNIX'in yanı sıra Windows'ta da vim veya vi kullanılır.

Metin düzenleyiciyle oluşturduğunuz dosyalara source files. Program kaynak kodunu içerirler. Go programlarının kaynak dosyaları genellikle şu uzantıyla adlandırılır".go".

Programlamanıza başlamadan önce, bir metin düzenleyiciniz olduğundan ve bir bilgisayar programı yazmak, onu bir dosyaya kaydetmek, derlemek ve son olarak çalıştırmak için yeterli deneyime sahip olduğunuzdan emin olun.

Go Derleyici

Kaynak dosyada yazılan kaynak kodu, programınız için okunabilir kaynaktır. Derlenmesi ve makine diline çevrilmesi gerekir, böylece CPU'nuz programı verilen talimatlara göre gerçekten çalıştırabilir. Go programlama dili derleyicisi, kaynak kodunu son çalıştırılabilir programında derler.

Go dağıtımı, FreeBSD (sürüm 8 ve üstü), Linux, Mac OS X (Snow Leopard ve üstü) ve 32 bit (386) ve 64 bit (amd64) x86 işlemci mimarilerine sahip Windows işletim sistemleri için kurulabilir bir ikili dosya olarak gelir.

Aşağıdaki bölüm Go ikili dağıtımının çeşitli işletim sistemlerine nasıl kurulacağını açıklamaktadır.

Go Archive'ı indirin

Go Downloads'dan Go yüklenebilir arşiv dosyasının en son sürümünü indirin . Bu öğreticide aşağıdaki sürüm kullanılmıştır: go1.4.windows-amd64.msi .

C: \> go klasörüne kopyalanır.

işletim sistemi	Arşiv adı
pencereler	go1.4.windows-amd64.msi
Linux	go1.4.linux-amd64.tar.gz
Mac	go1.4.darwin-amd64-osx10.8.pkg
FreeBSD	go1.4.freebsd-amd64.tar.gz

UNIX / Linux / Mac OS X ve FreeBSD üzerine kurulum

İndirme arşivini / usr / local klasörüne çıkartın ve / usr / local / go içinde bir Go ağacı oluşturun. Örneğin -

tar -C / usr / local -xzf go1.4.linux-amd64.tar.gz

PATH ortam değişkenine / usr / local / go / bin ekleyin.

işletim sistemi	Çıktı
Linux	dışa aktarma PATH = $ PATH: / usr / local / go / bin
Mac	dışa aktarma PATH = $ PATH: / usr / local / go / bin
FreeBSD	dışa aktarma PATH = $ PATH: / usr / local / go / bin

Windows üzerine kurulum

MSI dosyasını kullanın ve Go araçlarını yüklemek için istemleri izleyin. Varsayılan olarak, yükleyici c: \ Go'daki Go dağıtımını kullanır. Yükleyici, Pencerenin PATH ortam değişkeninde c: \ Go \ bin dizinini ayarlamalıdır. Değişikliğin etkili olması için tüm açık komut istemlerini yeniden başlatın.

Kurulumu Doğrulama

İçinde test.go adlı bir go dosyası oluşturun C:\>Go_WorkSpace.

Dosya: test.go

package main

import "fmt"

func main() {
   fmt.Println("Hello, World!")
}

Şimdi sonucu görmek için test.go çalıştırın -

C:\Go_WorkSpace>go run test.go

Çıktı

Hello, World!

Go programlama dilinin temel yapı taşlarını incelemeden önce, sonraki bölümlerde referans olarak alabilmemiz için ilk olarak Go programlarının yalın minimum yapısını tartışalım.

Merhaba Dünya Örneği

Bir Go programı temelde aşağıdaki bölümlerden oluşur -

• Paket Beyanı
• Paketleri İçe Aktar
• Functions
• Variables
• İfadeler ve İfadeler
• Comments

"Merhaba Dünya" kelimesini basacak basit bir koda bakalım -

package main

import "fmt"

func main() {
   /* This is my first sample program. */
   fmt.Println("Hello, World!")
}

Yukarıdaki programın çeşitli bölümlerine bir göz atalım -

• Main program paketinin ilk satırı, bu programın içinde yer alması gereken paket adını tanımlar. Go programları paketler halinde çalıştığı için zorunlu bir ifadedir. Ana paket, programı çalıştırmak için başlangıç ​​noktasıdır. Her paketin kendisiyle ilişkilendirilmiş bir yolu ve adı vardır.

• Sonraki satır import "fmt", Go derleyicisine fmt paketinde bulunan dosyaları dahil etmesini söyleyen bir önişlemci komutudur.

• Sonraki satır func main (), programın yürütülmesinin başladığı ana işlevdir.

• Sonraki satır /*...*/ derleyici tarafından yok sayılır ve programa yorum eklemek için oradadır. Yorumlar, Java veya C ++ açıklamalarına benzer // kullanılarak da temsil edilir.

• Bir sonraki satır fmt.Println (...), Go'da bulunan ve "Merhaba, Dünya!" Mesajına neden olan başka bir işlevdir. ekranda görüntülenecek. Burada fmt paketi, mesajı ekranda görüntülemek için kullanılan Println yöntemini dışa aktarmıştır.

• Println yönteminin büyük harf P'sine dikkat edin. Go dilinde, bir isim büyük harfle başlıyorsa dışa aktarılır. Dışa aktarılan, işlev veya değişken / sabitin ilgili paketin ithalatçısı tarafından erişilebilir olduğu anlamına gelir.

Bir Go Programı Yürütme

Kaynak kodunu bir dosyaya nasıl kaydedeceğimizi, derleyeceğimizi ve son olarak programı nasıl çalıştıracağımızı tartışalım. Lütfen aşağıda verilen adımları izleyin -

• Bir metin düzenleyici açın ve yukarıda belirtilen kodu ekleyin.

• Dosyayı hello.go olarak kaydedin

• Komut istemini açın.

• Dosyayı kaydettiğiniz dizine gidin.

• Go run hello.go yazın ve kodunuzu çalıştırmak için enter tuşuna basın.

• Kodunuzda hata yoksa "Merhaba Dünya!" ekranda basılmıştır.

$ go run hello.go
Hello, World!

Go derleyicisinin yolunuzda olduğundan ve onu hello.go kaynak dosyasını içeren dizinde çalıştırdığınızdan emin olun.

Önceki bölümde bir Go programının temel yapısını tartıştık. Artık Go programlama dilinin diğer temel yapı taşlarını anlamak kolay olacak.

Go Jetonları

Bir Go programı çeşitli belirteçlerden oluşur. Bir belirteç, bir anahtar sözcük, bir tanımlayıcı, bir sabit, bir dize değişmezi veya bir semboldür. Örneğin, aşağıdaki Go ifadesi altı simgeden oluşur -

fmt.Println("Hello, World!")

Bireysel belirteçler -

fmt
.
Println
(
   "Hello, World!"
)

Satır Ayırıcı

Bir Go programında, satır ayırıcı anahtar bir ifade sonlandırıcıdır. Yani, tek tek ifadelerin ";" gibi özel bir ayırıcıya ihtiyacı yoktur. C de. Go derleyicisi dahili olarak ";" bir mantıksal varlığın sonunu belirtmek için ifade sonlandırıcı olarak.

Örneğin, aşağıdaki ifadelere bir göz atın -

fmt.Println("Hello, World!")
fmt.Println("I am in Go Programming World!")

Yorumlar

Yorumlar, Go programınızdaki yardımcı metinler gibidir ve derleyici tarafından yok sayılır. / * İle başlarlar ve aşağıda gösterildiği gibi * / karakterleriyle biterler -

/* my first program in Go */

Yorumların içinde açıklamalara sahip olamazsınız ve bunlar bir dize veya karakter sabit değerleri içinde yer almazlar.

Tanımlayıcılar

Bir Go tanımlayıcısı, bir değişkeni, işlevi veya diğer herhangi bir kullanıcı tanımlı öğeyi tanımlamak için kullanılan bir addır. Tanımlayıcı, A'dan Z'ye veya a'dan z'ye veya alt çizgi _ ile başlar ve ardından sıfır veya daha fazla harf, alt çizgi ve rakam (0-9) gelir.

tanımlayıcı = harf {harf | unicode_digit}.

Go, tanımlayıcılar içinde @, $ ve% gibi noktalama karakterlerine izin vermez. Git bircase-sensitiveProgramlama dili. Dolayısıyla, İnsan gücü ve insan gücü , Go'da iki farklı tanımlayıcıdır. İşte kabul edilebilir tanımlayıcılara bazı örnekler -

mahesh      kumar   abc   move_name   a_123
myname50   _temp    j      a23b9      retVal

Anahtar kelimeler

Aşağıdaki liste, Go'daki ayrılmış sözcükleri gösterir. Bu ayrılmış sözcükler, sabit ya da değişken ya da başka herhangi bir tanımlayıcı isim olarak kullanılamaz.

kırmak	varsayılan	işlev	arayüz	seç
durum	ertelemek	Git	harita	Struct
chan	Başka	Git	paket	Değiştirmek
sabit	suya düşmek	Eğer	Aralık	Tür
devam et	için	ithalat	dönüş	Var

Go'da boşluk

Boşluk, Boşlukları, sekmeleri, yeni satır karakterlerini ve yorumları tanımlamak için Git'te kullanılan terimdir. Yalnızca beyaz boşluk içeren, muhtemelen açıklama içeren bir satır boş satır olarak bilinir ve bir Go derleyicisi bunu tamamen yok sayar.

Beyaz boşluklar bir ifadenin bir bölümünü diğerinden ayırır ve derleyicinin bir ifadedeki int gibi bir öğenin nerede bittiğini ve bir sonraki öğenin nerede başladığını belirlemesini sağlar. Bu nedenle, aşağıdaki ifadede -

var age int;

Derleyicinin bunları ayırt edebilmesi için int ve age arasında en az bir boşluk karakteri (genellikle boşluk) olmalıdır. Öte yandan, aşağıdaki açıklamada -

fruit = apples + oranges;   // get the total fruit

Meyve ve = arasında veya = ile elma arasında boşluk karakteri gerekmez, ancak okunabilirlik amacıyla dilerseniz bazılarını dahil etmekte özgürsünüz.

Go programlama dilinde, veri türleri, farklı türlerdeki değişkenleri veya işlevleri bildirmek için kullanılan kapsamlı bir sistemi ifade eder. Bir değişkenin tipi, depoda ne kadar yer kapladığını ve depolanan bit deseninin nasıl yorumlandığını belirler.

Go'daki türler şu şekilde sınıflandırılabilir -

Sr.No.	Türler ve Açıklama
1	Boolean types Boole türleridir ve önceden tanımlanmış iki sabitten oluşur: (a) doğru (b) yanlış
2	Numeric types Yine aritmetik türlerdir ve program boyunca a) tam sayı türlerini veya b) kayan nokta değerlerini temsil ederler.
3	String types Bir dize türü, dize değerleri kümesini temsil eder. Değeri bir bayt dizisidir. Dizeler, bir kez oluşturulduktan sonra değişmez türlerdir, bir dizenin içeriğini değiştirmek mümkün değildir. Önceden beyan edilen dize türü dizedir.
4	Derived types Bunlar arasında (a) İşaretçi türleri, (b) Dizi türleri, (c) Yapı türleri, (d) Birleştirme türleri ve (e) İşlev türleri f) Dilim türleri g) Arabirim türleri h) Harita türleri i) Kanal Türleri

Dizi türleri ve yapı türleri toplu olarak şu şekilde anılır: aggregate types. Bir işlevin türü, aynı parametre ve sonuç türlerine sahip tüm işlevlerin kümesini belirtir. Aşağıdaki bölümde temel türleri tartışacağız, diğer türler ise sonraki bölümlerde ele alınacaktır.

Tamsayı Türleri

Önceden tanımlanmış mimariden bağımsız tam sayı türleri şunlardır:

Sr.No.	Türler ve Açıklama
1	uint8 İşaretsiz 8 bitlik tam sayılar (0-255)
2	uint16 İşaretsiz 16 bit tam sayılar (0 - 65535)
3	uint32 İmzasız 32 bit tam sayılar (0 - 4294967295)
4	uint64 İmzasız 64 bit tam sayılar (0 - 18446744073709551615)
5	int8 İmzalı 8 bit tam sayılar (-128 ila 127)
6	int16 İmzalı 16 bit tam sayılar (-32768 - 32767)
7	int32 İmzalı 32 bit tam sayılar (-2147483648 - 2147483647)
8	int64 İmzalı 64 bit tam sayılar (-9223372036854775808 - 9223372036854775807)

Yüzer Tipler

Önceden tanımlanmış mimariden bağımsız kayan tipler şunlardır:

Sr.No.	Türler ve Açıklama
1	float32 IEEE-754 32 bit kayan noktalı sayılar
2	float64 IEEE-754 64 bit kayan noktalı sayılar
3	complex64 Float32 gerçek ve sanal parçalı karmaşık sayılar
4	complex128 Float64 gerçek ve hayali parçalı karmaşık sayılar

Bir n-bit tamsayının değeri n bittir ve ikinin tamamlayıcı aritmetik işlemleri kullanılarak temsil edilir.

Diğer Sayısal Türler

Ayrıca uygulamaya özel boyutlara sahip bir dizi sayısal tür vardır -

Sr.No.	Türler ve Açıklama
1	byte uint8 ile aynı
2	rune int32 ile aynı
3	uint 32 veya 64 bit
4	int uint ile aynı boyutta
5	uintptr işaretçi değerinin yorumlanmamış bitlerini saklamak için işaretsiz bir tamsayı

Değişken, programların işleyebileceği bir depolama alanına verilen addan başka bir şey değildir. Go'daki her değişkenin, değişkenin belleğinin boyutunu ve düzenini, bu bellekte saklanabilecek değerler aralığını ve değişkene uygulanabilecek işlemler kümesini belirleyen belirli bir türü vardır.

Bir değişkenin adı harflerden, rakamlardan ve alt çizgi karakterinden oluşabilir. Bir harf veya alt çizgiyle başlamalıdır. Go büyük / küçük harfe duyarlı olduğu için büyük ve küçük harfler birbirinden farklıdır. Önceki bölümde açıklanan temel türlere bağlı olarak, aşağıdaki temel değişken türleri olacaktır -

Sr.No	Tip ve Açıklama
1	byte Genellikle tek bir sekizli (bir bayt). Bu bir bayt türüdür.
2	int Makine için en doğal tam sayı boyutu.
3	float32 Tek duyarlıklı kayan nokta değeri.

Go programlama dili, sonraki bölümlerde tartışacağımız Numaralandırma, İşaretçi, Dizi, Yapı ve Birlik gibi çeşitli diğer değişken türlerini de tanımlamaya izin verir. Bu bölümde sadece temel değişken türlerine odaklanacağız.

Go'da Değişken Tanım

Değişken tanımı, derleyiciye değişken için nerede ve ne kadar depolama alanı yaratacağını söyler. Bir değişken tanımı, bir veri türünü belirtir ve bu türden bir veya daha fazla değişkenin aşağıdaki gibi bir listesini içerir -

var variable_list optional_data_type;

Buraya, optional_data_type byte, int, float32, complex64, boolean veya herhangi bir kullanıcı tanımlı nesne vb. dahil olmak üzere geçerli bir Go veri türüdür ve variable_listvirgülle ayrılmış bir veya daha fazla tanımlayıcı adından oluşabilir. Bazı geçerli beyanlar burada gösterilmektedir -

var  i, j, k int;
var  c, ch byte;
var  f, salary float32;
d =  42;

İfade “var i, j, k;”i, j ve k değişkenlerini bildirir ve tanımlar; bu, derleyiciye int türünde i, j ve k adlı değişkenler oluşturma talimatı verir.

Değişkenler bildirimlerinde başlatılabilir (bir başlangıç ​​değeri atanabilir). Değişkenin türü, kendisine iletilen değere göre derleyici tarafından otomatik olarak değerlendirilir. Başlatıcı, bir eşittir işaretinden ve ardından aşağıdaki gibi sabit bir ifadeden oluşur:

variable_name = value;

Örneğin,

d = 3, f = 5;    // declaration of d and f. Here d and f are int

Başlatıcı olmadan tanımlama için: statik depolama süresi olan değişkenler örtük olarak nil ile başlatılır (tüm baytlar 0 değerine sahiptir); diğer tüm değişkenlerin başlangıç ​​değeri, veri türlerinin sıfır değeridir.

Go'da Statik Tip Beyanı

Statik bir tür değişkeni bildirimi, derleyiciye, verilen tür ve adla kullanılabilen bir değişken olduğuna dair güvence sağlar, böylece derleyici, değişkenin tüm ayrıntılarını gerektirmeden daha fazla derlemeye devam edebilir. Değişken bildiriminin anlamı yalnızca derleme sırasında vardır, derleyici programın bağlanması sırasında gerçek değişken bildirimine ihtiyaç duyar.

Misal

Değişkenin bir türle bildirildiği ve ana işlev içinde başlatıldığı aşağıdaki örneği deneyin -

package main

import "fmt"

func main() {
   var x float64
   x = 20.0
   fmt.Println(x)
   fmt.Printf("x is of type %T\n", x)
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

20
x is of type float64

Go'da Dinamik Tür Bildirimi / Tür Çıkarımı

Dinamik tür değişken bildirimi, derleyicinin değişkenin türünü kendisine iletilen değere göre yorumlamasını gerektirir. Derleyici, gerekli bir gereksinim olarak statik olarak türe sahip bir değişken gerektirmez.

Misal

Değişkenlerin herhangi bir tür olmadan bildirildiği aşağıdaki örneği deneyin. Dikkat edin, tür çıkarımı durumunda, değişkeni başlattıky ile: = operatör, oysa x = işleci kullanılarak başlatılır.

package main

import "fmt"

func main() {
   var x float64 = 20.0

   y := 42 
   fmt.Println(x)
   fmt.Println(y)
   fmt.Printf("x is of type %T\n", x)
   fmt.Printf("y is of type %T\n", y)	
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

20
42
x is of type float64
y is of type int

Go'da Karışık Değişken Bildirimi

Farklı türlerdeki değişkenler, tür çıkarımı kullanılarak tek seferde bildirilebilir.

Misal

package main

import "fmt"

func main() {
   var a, b, c = 3, 4, "foo"  
	
   fmt.Println(a)
   fmt.Println(b)
   fmt.Println(c)
   fmt.Printf("a is of type %T\n", a)
   fmt.Printf("b is of type %T\n", b)
   fmt.Printf("c is of type %T\n", c)
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

3
4
foo
a is of type int
b is of type int
c is of type string

Go'daki ldeğerler ve değerler

Go'da iki tür ifade vardır -

• lvalue- Bir bellek konumuna başvuran ifadeler "lvalue" ifadesi olarak adlandırılır. Bir değer, bir ödevin sol veya sağ tarafı olarak görünebilir.

• rvalue- rvalue terimi, bellekteki bazı adreslerde depolanan bir veri değerini ifade eder. Bir rvalue, kendisine atanmış bir değere sahip olamayan bir ifadedir; bu, bir atamanın sağ tarafında değil sol tarafında bir r değerinin görünebileceği anlamına gelir.

Değişkenler ldeğerlerdir ve bu nedenle bir atamanın sol tarafında görünebilir. Sayısal değişmez değerler r değerleridir ve bu nedenle atanamaz ve sol tarafta görünmeyebilir.

Aşağıdaki ifade geçerlidir -

x = 20.0

Aşağıdaki ifade geçerli değildir. Derleme zamanı hatası oluşturacaktır -

10 = 20

Sabitler, programın yürütülmesi sırasında değiştiremeyeceği sabit değerleri ifade eder. Bu sabit değerler ayrıcaliterals.

Sabitler, bir tamsayı sabiti, kayan sabit, bir karakter sabiti veya bir dize değişmezi gibi temel veri türlerinden herhangi biri olabilir . Ayrıca numaralandırma sabitleri de vardır.

Sabitler, değerlerinin tanımlarından sonra değiştirilememesi dışında, normal değişkenler gibi ele alınır.

Tamsayı Değişmezleri

Tamsayı değişmez değeri, ondalık, sekizlik veya onaltılık sabit olabilir. Bir önek, tabanı veya tabanı belirtir: Onaltılık için 0x veya 0X, sekizlik için 0 ve ondalık için hiçbir şey.

Bir tamsayı değişmezi ayrıca, sırasıyla işaretsiz ve uzun için U ve L'nin bir kombinasyonu olan bir son eke sahip olabilir. Son ek, büyük veya küçük harf olabilir ve herhangi bir sırada olabilir.

İşte tamsayı değişmez değerlerine bazı örnekler -

212         /* Legal */
215u        /* Legal */
0xFeeL      /* Legal */
078         /* Illegal: 8 is not an octal digit */
032UU       /* Illegal: cannot repeat a suffix */

Aşağıda, çeşitli Tamsayı değişmez değerlerinin diğer örnekleri verilmiştir -

85         /* decimal */
0213       /* octal */
0x4b       /* hexadecimal */
30         /* int */
30u        /* unsigned int */
30l        /* long */
30ul       /* unsigned long */

Kayan nokta değişmezleri

Bir kayan noktalı değişmez değerin bir tamsayı bölümü, bir ondalık noktası, bir kesirli bölümü ve bir üs bölümü vardır. Kayan noktalı değişmez değerleri ondalık veya üstel biçimde temsil edebilirsiniz.

Ondalık biçimi kullanarak temsil ederken, ondalık noktayı, üssü veya her ikisini de eklemelisiniz ve üstel biçimi kullanarak temsil ederken, tamsayı bölümünü, kesirli bölümü veya her ikisini birden eklemelisiniz. İmzalı üs, e veya E ile tanıtılır.

İşte kayan noktalı değişmez değerlere bazı örnekler -

3.14159       /* Legal */
314159E-5L    /* Legal */
510E          /* Illegal: incomplete exponent */
210f          /* Illegal: no decimal or exponent */
.e55          /* Illegal: missing integer or fraction */

Kaçış dizisi

Bazı karakterlerin önünde ters eğik çizgi varsa, bunların Go'da özel bir anlamı olacaktır. Bunlar, satırsonu (\ n), sekme (\ t), geri tuşu vb. Temsil etmek için kullanılan Kaçış Sırası kodları olarak bilinir. Burada, bu tür kaçış dizisi kodlarının bir listesi vardır -

Kaçış dizisi	Anlam
\\	\ karakteri
\ '	karakter
\ "	"karakteri
\?	? karakter
\ a	Uyarı veya zil
\ b	Geri tuşu
\ f	Form besleme
\ n	Yeni hat
\ r	Satırbaşı
\ t	Yatay sekme
\ v	Dikey sekme
\ ooo	Bir ila üç basamaklı sekizlik sayı
\ xhh. . .	Bir veya daha fazla basamağın onaltılık sayısı

Aşağıdaki örnek, nasıl kullanılacağını gösterir. \t bir programda -

package main

import "fmt"

func main() {
   fmt.Printf("Hello\tWorld!")
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Hello World!

Go'da Dize Değişmezleri

Dize değişmezleri veya sabitleri çift tırnak "" içine alınır. Bir dize, karakter değişmezlerine benzer karakterler içerir: düz karakterler, kaçış dizileri ve evrensel karakterler.

Dize değişmezlerini kullanarak ve boşlukları kullanarak uzun bir satırı birden çok satıra bölebilirsiniz.

İşte dize değişmezlerine bazı örnekler. Üç formun tümü aynı dizelerdir.

"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"

const Kelimeler

Kullanabilirsiniz const aşağıdaki gibi belirli bir türe sahip sabitleri bildirmek için önek -

const variable type = value;

Aşağıdaki örnek, nasıl kullanılacağını gösterir. const anahtar kelime -

package main

import "fmt"

func main() {
   const LENGTH int = 10
   const WIDTH int = 5   
   var area int

   area = LENGTH * WIDTH
   fmt.Printf("value of area : %d", area)   
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

value of area : 50

CAPITALS'ta sabitleri tanımlamanın iyi bir programlama uygulaması olduğuna dikkat edin.

Operatör, derleyiciye belirli matematiksel veya mantıksal işlemleri gerçekleştirmesini söyleyen bir semboldür. Go dili yerleşik operatörler açısından zengindir ve aşağıdaki operatör türlerini sağlar -

• Aritmetik operatörler
• İlişkisel Operatörler
• Mantıksal operatörler
• Bitsel Operatörler
• Atama Operatörleri
• Çeşitli Operatörler

Bu eğitimde aritmetik, ilişkisel, mantıksal, bitsel, atama ve diğer operatörleri tek tek açıklanmaktadır.

Aritmetik operatörler

Aşağıdaki tablo, Go dili tarafından desteklenen tüm aritmetik operatörleri göstermektedir. Değişken varsayA 10 ve değişken tutar B 20 tutar sonra -

Örnekleri Göster

Şebeke	Açıklama	Misal
+	İki işlenen ekler	A + B 30 verir
-	İlk işlenenden ikinci işleneni çıkarır	A - B -10 verir
*	Her iki işleneni de çarpar	A * B, 200 verir
/	Payı paydaya böler.	B / A 2 verir
%	Modül operatörü; bir tamsayı bölmesinden sonra kalanı verir.	B% A, 0 verir
++	Arttırma operatörü. Tamsayı değerini bir artırır.	A ++, 11 verir
-	Azaltma operatörü. Tamsayı değerini bir azaltır.	A-- 9 verir

İlişkisel Operatörler

Aşağıdaki tablo, Go dili tarafından desteklenen tüm ilişkisel operatörleri listeler. Değişken varsayA 10 ve değişken tutar B 20 tutar, sonra -

Örnekleri Göster

Şebeke	Açıklama	Misal
==	İki işlenenin değerlerinin eşit olup olmadığını kontrol eder; evet ise, durum gerçek olur.	(A == B) doğru değil.
! =	İki işlenenin değerlerinin eşit olup olmadığını kontrol eder; değerler eşit değilse, koşul doğru olur.	(A != B) is true.
>	It checks if the value of left operand is greater than the value of right operand; if yes, the condition becomes true.	(A > B) is not true.
<	It checks if the value of left operand is less than the value of the right operand; if yes, the condition becomes true.	(A < B) is true.
>=	It checks if the value of the left operand is greater than or equal to the value of the right operand; if yes, the condition becomes true.	(A >= B) is not true.
<=	It checks if the value of left operand is less than or equal to the value of right operand; if yes, the condition becomes true.	(A <= B) is true.

Logical Operators

The following table lists all the logical operators supported by Go language. Assume variable A holds 1 and variable B holds 0, then −

Show Examples

Operator	Description	Example
&&	Called Logical AND operator. If both the operands are non-zero, then condition becomes true.	(A && B) is false.
||	Called Logical OR Operator. If any of the two operands is non-zero, then condition becomes true.	(A || B) is true.
!	Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false.	!(A && B) is true.

The following table shows all the logical operators supported by Go language. Assume variable A holds true and variable B holds false, then −

Operator	Description	Example
&&	Called Logical AND operator. If both the operands are false, then the condition becomes false.	(A && B) is false.
||	Called Logical OR Operator. If any of the two operands is true, then the condition becomes true.	(A || B) is true.
!	Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true, then Logical NOT operator will make it false.	!(A && B) is true.

Bitwise Operators

Bitwise operators work on bits and perform bit-by-bit operation. The truth tables for &, |, and ^ are as follows −

p	q	p & q	p | q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Assume A = 60; and B = 13. In binary format, they will be as follows −

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

The Bitwise operators supported by C language are listed in the following table. Assume variable A holds 60 and variable B holds 13, then −

Show Examples

Operator	Description	Example
&	Binary AND Operator copies a bit to the result if it exists in both operands.	(A & B) will give 12, which is 0000 1100
|	Binary OR Operator copies a bit if it exists in either operand.	(A | B) will give 61, which is 0011 1101
^	Binary XOR Operator copies the bit if it is set in one operand but not both.	(A ^ B) will give 49, which is 0011 0001
<<	Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand.	A << 2 will give 240 which is 1111 0000
>>	Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand.	A >> 2 will give 15 which is 0000 1111

Assignment Operators

The following table lists all the assignment operators supported by Go language −

Show Examples

Operator	Description	Example
=	Simple assignment operator, Assigns values from right side operands to left side operand	C = A + B will assign value of A + B into C
+=	Add AND assignment operator, It adds right operand to the left operand and assign the result to left operand	C += A is equivalent to C = C + A
-=	Subtract AND assignment operator, It subtracts right operand from the left operand and assign the result to left operand	C -= A is equivalent to C = C - A
*=	Multiply AND assignment operator, It multiplies right operand with the left operand and assign the result to left operand	C *= A is equivalent to C = C * A
/=	Divide AND assignment operator, It divides left operand with the right operand and assign the result to left operand	C /= A is equivalent to C = C / A
%=	Modulus AND assignment operator, It takes modulus using two operands and assign the result to left operand	C %= A is equivalent to C = C % A
<<=	Left shift AND assignment operator	C <<= 2 is same as C = C << 2
>>=	Right shift AND assignment operator	C >>= 2 is same as C = C >> 2
&=	Bitwise AND assignment operator	C &= 2 is same as C = C & 2
^=	bitwise exclusive OR and assignment operator	C ^= 2 is same as C = C ^ 2
|=	bitwise inclusive OR and assignment operator	C |= 2 is same as C = C | 2

Miscellaneous Operators

There are a few other important operators supported by Go Language including sizeof and ?:.

Show Examples

Operator	Description	Example
&	Returns the address of a variable.	&a; provides actual address of the variable.
*	Pointer to a variable.	*a; provides pointer to a variable.

Operators Precedence in Go

Operator precedence determines the grouping of terms in an expression. This affects how an expression is evaluated. Certain operators have higher precedence than others; for example, the multiplication operator has higher precedence than the addition operator.

For example x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher precedence than +, so it first gets multiplied with 3*2 and then adds into 7.

Here, operators with the highest precedence appear at the top of the table, those with the lowest appear at the bottom. Within an expression, higher precedence operators will be evaluated first.

Show Examples

Category	Operator	Associativity
Postfix	() [] -> . ++ - -	Left to right
Unary	+ - ! ~ ++ - - (type)* & sizeof	Right to left
Multiplicative	* / %	Left to right
Additive	+ -	Left to right
Shift	<< >>	Left to right
Relational	< <= > >=	Left to right
Equality	== !=	Left to right
Bitwise AND	&	Left to right
Bitwise XOR	^	Left to right
Bitwise OR	|	Left to right
Logical AND	&&	Left to right
Logical OR	||	Left to right
Assignment	= += -= *= /= %=>>= <<= &= ^= |=	Right to left
Comma	,	Left to right

Decision making structures require that the programmer specify one or more conditions to be evaluated or tested by the program, along with a statement or statements to be executed if the condition is determined to be true, and optionally, other statements to be executed if the condition is determined to be false.

Following is the general form of a typical decision making structure found in most of the programming languages −

Go programming language provides the following types of decision making statements. Click the following links to check their detail.

Sr.No	Statement & Description
1	if statement An if statement consists of a boolean expression followed by one or more statements.
2	if...else statement An if statement can be followed by an optional else statement, which executes when the boolean expression is false.
3	nested if statements You can use one if or else if statement inside another if or else if statement(s).
4	switch statement A switch statement allows a variable to be tested for equality against a list of values.
5	select statement A select statement is similar to switch statement with difference that case statements refers to channel communications.

There may be a situation, when you need to execute a block of code several number of times. In general, statements are executed sequentially: The first statement in a function is executed first, followed by the second, and so on.

Programming languages provide various control structures that allow for more complicated execution paths.

A loop statement allows us to execute a statement or group of statements multiple times and following is the general form of a loop statement in most of the programming languages −

Go programming language provides the following types of loop to handle looping requirements.

Sr.No	Loop Type & Description
1	for loop It executes a sequence of statements multiple times and abbreviates the code that manages the loop variable.
2	nested loops These are one or multiple loops inside any for loop.

Loop Control Statements

Loop control statements change an execution from its normal sequence. When an execution leaves its scope, all automatic objects that were created in that scope are destroyed.

Go supports the following control statements −

Sr.No	Control Statement & Description
1	break statement It terminates a for loop or switch statement and transfers execution to the statement immediately following the for loop or switch.
2	continue statement It causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating.
3	goto statement It transfers control to the labeled statement.

The Infinite Loop

A loop becomes an infinite loop if its condition never becomes false. The for loop is traditionally used for this purpose. Since none of the three expressions that form the for loop are required, you can make an endless loop by leaving the conditional expression empty or by passing true to it.

package main

import "fmt"

func main() {
   for true  {
       fmt.Printf("This loop will run forever.\n");
   }
}

When the conditional expression is absent, it is assumed to be true. You may have an initialization and increment expression, but C programmers more commonly use the for(;;) construct to signify an infinite loop.

Note − You can terminate an infinite loop by pressing Ctrl + C keys.

A function is a group of statements that together perform a task. Every Go program has at least one function, which is main(). You can divide your code into separate functions. How you divide your code among different functions is up to you, but logically, the division should be such that each function performs a specific task.

A function declaration tells the compiler about a function name, return type, and parameters. A function definition provides the actual body of the function.

The Go standard library provides numerous built-in functions that your program can call. For example, the function len() takes arguments of various types and returns the length of the type. If a string is passed to it, the function returns the length of the string in bytes. If an array is passed to it, the function returns the length of the array.

Functions are also known as method, sub-routine, or procedure.

Defining a Function

The general form of a function definition in Go programming language is as follows −

func function_name( [parameter list] ) [return_types]
{
   body of the function
}

A function definition in Go programming language consists of a function header and a function body. Here are all the parts of a function −

• Func − It starts the declaration of a function.

• Function Name − It is the actual name of the function. The function name and the parameter list together constitute the function signature.

• Parameters − A parameter is like a placeholder. When a function is invoked, you pass a value to the parameter. This value is referred to as actual parameter or argument. The parameter list refers to the type, order, and number of the parameters of a function. Parameters are optional; that is, a function may contain no parameters.

• Return Type − A function may return a list of values. The return_types is the list of data types of the values the function returns. Some functions perform the desired operations without returning a value. In this case, the return_type is the not required.

• Function Body − It contains a collection of statements that define what the function does.

Example

The following source code shows a function called max(). This function takes two parameters num1 and num2 and returns the maximum between the two −

/* function returning the max between two numbers */
func max(num1, num2 int) int {
   /* local variable declaration */
   result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

Calling a Function

While creating a Go function, you give a definition of what the function has to do. To use a function, you will have to call that function to perform the defined task.

When a program calls a function, the program control is transferred to the called function. A called function performs a defined task and when its return statement is executed or when its function-ending closing brace is reached, it returns the program control back to the main program.

To call a function, you simply need to pass the required parameters along with its function name. If the function returns a value, then you can store the returned value. For example −

package main

import "fmt"

func main() {
   /* local variable definition */
   var a int = 100
   var b int = 200
   var ret int

   /* calling a function to get max value */
   ret = max(a, b)

   fmt.Printf( "Max value is : %d\n", ret )
}

/* function returning the max between two numbers */
func max(num1, num2 int) int {
   /* local variable declaration */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

We have kept the max() function along with the main() function and compiled the source code. While running the final executable, it would produce the following result −

Max value is : 200

Returning multiple values from Function

A Go function can return multiple values. For example −

package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}
func main() {
   a, b := swap("Mahesh", "Kumar")
   fmt.Println(a, b)
}

When the above code is compiled and executed, it produces the following result −

Kumar Mahesh

Function Arguments

If a function is to use arguments, it must declare variables that accept the values of the arguments. These variables are called the formal parameters of the function.

The formal parameters behave like other local variables inside the function and are created upon entry into the function and destroyed upon exit.

While calling a function, there are two ways that arguments can be passed to a function −

Sr.No	Call Type & Description
1	Call by value This method copies the actual value of an argument into the formal parameter of the function. In this case, changes made to the parameter inside the function have no effect on the argument.
2	Call by reference This method copies the address of an argument into the formal parameter. Inside the function, the address is used to access the actual argument used in the call. This means that changes made to the parameter affect the argument.

By default, Go uses call by value to pass arguments. In general, it means the code within a function cannot alter the arguments used to call the function. The above program, while calling the max() function, used the same method.

Function Usage

A function can be used in the following ways:

Sr.No	Function Usage & Description
1	Function as Value Functions can be created on the fly and can be used as values.
2	Function Closures Functions closures are anonymous functions and can be used in dynamic programming.
3	Method Methods are special functions with a receiver.

A scope in any programming is a region of the program where a defined variable can exist and beyond that the variable cannot be accessed. There are three places where variables can be declared in Go programming language −

• Inside a function or a block (local variables)

• Outside of all functions (global variables)

• In the definition of function parameters (formal parameters)

Let us find out what are local and global variables and what are formal parameters.

Local Variables

Variables that are declared inside a function or a block are called local variables. They can be used only by statements that are inside that function or block of code. Local variables are not known to functions outside their own. The following example uses local variables. Here all the variables a, b, and c are local to the main() function.

package main

import "fmt"

func main() {
   /* local variable declaration */
   var a, b, c int 

   /* actual initialization */
   a = 10
   b = 20
   c = a + b

   fmt.Printf ("value of a = %d, b = %d and c = %d\n", a, b, c)
}

When the above code is compiled and executed, it produces the following result −

value of a = 10, b = 20 and c = 30

Global Değişkenler

Global değişkenler, bir fonksiyonun dışında, genellikle programın üstünde tanımlanır. Global değişkenler, programın ömrü boyunca değerlerini korurlar ve program için tanımlanan herhangi bir fonksiyonun içinden erişilebilirler.

Global bir değişkene herhangi bir işlevle erişilebilir. Yani, global bir değişken, bildiriminden sonra program boyunca kullanılabilir. Aşağıdaki örnek hem global hem de yerel değişkenleri kullanır -

package main

import "fmt"
 
/* global variable declaration */
var g int
 
func main() {
   /* local variable declaration */
   var a, b int

   /* actual initialization */
   a = 10
   b = 20
   g = a + b

   fmt.Printf("value of a = %d, b = %d and g = %d\n", a, b, g)
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

value of a = 10, b = 20 and g = 30

Bir program yerel ve global değişkenler için aynı isme sahip olabilir, ancak bir fonksiyonun içindeki yerel değişkenin değeri tercih edilir. Örneğin -

package main

import "fmt"
 
/* global variable declaration */
var g int = 20
 
func main() {
   /* local variable declaration */
   var g int = 10
 
   fmt.Printf ("value of g = %d\n",  g)
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

value of g = 10

Biçimsel Parametreler

Biçimsel parametreler, bu işlevde yerel değişkenler olarak ele alınır ve genel değişkenlere göre tercih edilir. Örneğin -

package main

import "fmt"
 
/* global variable declaration */
var a int = 20;
 
func main() {
   /* local variable declaration in main function */
   var a int = 10
   var b int = 20
   var c int = 0

   fmt.Printf("value of a in main() = %d\n",  a);
   c = sum( a, b);
   fmt.Printf("value of c in main() = %d\n",  c);
}
/* function to add two integers */
func sum(a, b int) int {
   fmt.Printf("value of a in sum() = %d\n",  a);
   fmt.Printf("value of b in sum() = %d\n",  b);

   return a + b;
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

value of a in main() = 10
value of a in sum() = 10
value of b in sum() = 20
value of c in main() = 30

Yerel ve Global Değişkenleri Başlatma

Yerel ve global değişkenler, 0 olan varsayılan değerlerine başlatılır; işaretçiler sıfır olarak başlatılırken.

Veri tipi	İlk Varsayılan Değer
int	0
float32	0
Işaretçi	sıfır

Go programlamasında yaygın olarak kullanılan dizeler, salt okunur bir bayt dilimidir. Go programlama dilinde dizelerslices. Go platformu, dizeleri işlemek için çeşitli kitaplıklar sağlar.

• unicode
• regexp
• strings

Dizeler Oluşturma

Bir dizge oluşturmanın en doğrudan yolu yazmaktır -

var greeting = "Hello world!"

Kodunuzda bir dize değişmezi ile karşılaştığında, derleyici bu durumda "Merhaba dünya!" Değerine sahip bir dize nesnesi oluşturur.

Dize değişmezi, runes adı verilen geçerli bir UTF-8 dizisini içerir. Bir String keyfi baytları tutar.

package main

import "fmt"

func main() {
   var greeting =  "Hello world!"
   
   fmt.Printf("normal string: ")
   fmt.Printf("%s", greeting)
   fmt.Printf("\n")
   fmt.Printf("hex bytes: ")
   
   for i := 0; i < len(greeting); i++ {
       fmt.Printf("%x ", greeting[i])
   }
   fmt.Printf("\n")
   
   const sampleText = "\xbd\xb2\x3d\xbc\x20\xe2\x8c\x98" 
   /*q flag escapes unprintable characters, with + flag it escapses non-ascii 
   characters as well to make output unambigous  
   */
   fmt.Printf("quoted string: ")
   fmt.Printf("%+q", sampleText)
   fmt.Printf("\n")  
}

Bu, aşağıdaki sonucu verecektir -

normal string: Hello world!
hex bytes: 48 65 6c 6c 6f 20 77 6f 72 6c 64 21 
quoted string: "\xbd\xb2=\xbc \u2318"

Note - Dize değişmezdir, bu nedenle bir kez oluşturulduktan sonra değişmez dize değiştirilemez.

IP uzunluğu

len (str) yöntemi, dizge değişmezinde bulunan bayt sayısını döndürür.

package main

import "fmt"

func main() {
   var greeting =  "Hello world!"
   
   fmt.Printf("String Length is: ")
   fmt.Println(len(greeting))  
}

Bu, aşağıdaki sonucu verecektir -

String Length is : 12

Dizeleri Birleştirme

Dizeler paketi bir yöntem içerir join birden çok dizeyi birleştirmek için -

strings.Join(sample, " ")

Join, tek bir dize oluşturmak için bir dizinin öğelerini birleştirir. İkinci parametre ise dizinin elemanı arasına yerleştirilen ayırıcıdır.

Şu örneğe bakalım -

package main

import ("fmt" "math" )"fmt" "strings")

func main() {
   greetings :=  []string{"Hello","world!"}   
   fmt.Println(strings.Join(greetings, " "))
}

Bu, aşağıdaki sonucu verecektir -

Hello world!

Go programlama dili, the array, aynı türden öğelerin sabit boyutlu sıralı bir koleksiyonunu depolayabilir. Bir dizi, bir veri koleksiyonunu depolamak için kullanılır, ancak bir diziyi aynı türden bir değişkenler koleksiyonu olarak düşünmek genellikle daha kullanışlıdır.

Sayı0, sayı1, ... ve sayı99 gibi tek tek değişkenleri bildirmek yerine, sayılar gibi bir dizi değişkeni bildirir ve temsil etmek için sayılar [0], sayılar [1] ve ..., sayılar [99] kullanırsınız bireysel değişkenler. Bir dizideki belirli bir öğeye bir dizinle erişilir.

Tüm diziler bitişik bellek konumlarından oluşur. En düşük adres ilk öğeye ve en yüksek adres son öğeye karşılık gelir.

Dizileri Bildirme

Go'da bir dizi bildirmek için, bir programcı aşağıdaki gibi öğelerin türünü ve bir dizi için gereken öğe sayısını belirtir:

var variable_name [SIZE] variable_type

Buna tek boyutlu dizi denir . arraySize sıfırdan büyük bir tamsayı sabiti olmalı ve typeherhangi bir geçerli Go veri türü olabilir. Örneğin, 10 öğeli bir dizi bildirmek içinbalance float32 türünde, bu ifadeyi kullanın -

var balance [10] float32

Buraya, balance 10'a kadar kayan sayı tutabilen değişken bir dizidir.

Dizileri Başlatma

Go'da diziyi tek tek veya aşağıdaki gibi tek bir ifade kullanarak başlatabilirsiniz -

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

Küme parantezleri {} arasındaki değerlerin sayısı, köşeli parantezler [] arasındaki dizi için belirttiğimiz öğelerin sayısından büyük olamaz.

Dizinin boyutunu atlarsanız, başlatmayı tutacak kadar büyük bir dizi oluşturulur. Bu nedenle, yazarsanız -

var balance = []float32{1000.0, 2.0, 3.4, 7.0, 50.0}

Önceki örnekte yaptığınız gibi tam olarak aynı diziyi yaratacaksınız. Aşağıda, dizinin tek bir öğesini atamak için bir örnek verilmiştir -

balance[4] = 50.0

Yukarıdaki ifade , dizideki ^5. eleman numarasını 50.0 değeriyle atar . Tüm diziler, aynı zamanda temel indeks olarak da adlandırılan ilk elemanlarının indeksi olarak 0'a sahiptir ve bir dizinin son indeksi, dizinin toplam boyutu eksi 1 olacaktır.

Dizi Öğelerine Erişim

Dizi adını indeksleyerek bir elemana erişilir. Bu, elemanın dizini dizinin isminden sonra köşeli parantez içine yerleştirilerek yapılır. Örneğin -

float32 salary = balance[9]

Yukarıdaki açıklamada 10, şu alacak ^inci diziden eleman ve maaş değişkene değer atamak. Aşağıda, yukarıda bahsedilen üç kavramın tamamını kullanacak bir örnek verilmiştir. bildirim, atama ve dizilere erişim -

package main

import "fmt"

func main() {
   var n [10]int /* n is an array of 10 integers */
   var i,j int

   /* initialize elements of array n to 0 */         
   for i = 0; i < 10; i++ {
      n[i] = i + 100 /* set element at location i to i + 100 */
   }
   /* output each array element's value */
   for j = 0; j < 10; j++ {
      fmt.Printf("Element[%d] = %d\n", j, n[j] )
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109

Dizileri Ayrıntılı Olarak Git

Bir Go programcısı için açık olması gereken dizi ile ilgili önemli kavramlar vardır -

Sr.No	Konsept ve Açıklama
1	Çok boyutlu diziler Go, çok boyutlu dizileri destekler. Çok boyutlu bir dizinin en basit şekli iki boyutlu dizidir.
2	Dizileri işlevlere geçirme Dizinin adını indeks olmadan belirterek işleve bir diziye bir işaretçi iletebilirsiniz.

Go'daki işaretçileri öğrenmesi kolay ve eğlencelidir. Bazı Go programlama görevleri işaretçilerle daha kolay gerçekleştirilir ve referansla arama gibi diğer görevler işaretçiler kullanılmadan gerçekleştirilemez. Bu nedenle, mükemmel bir Go programcısı olmak için işaretçileri öğrenmek gerekli hale gelir.

Bildiğiniz gibi, her değişken bir bellek konumudur ve her bellek konumunun, bellekteki bir adresi belirten ve işareti (&) operatörü kullanılarak erişilebilen tanımlanmış adresi vardır. Tanımlanan değişkenlerin adresini yazdıracak aşağıdaki örneği düşünün -

package main

import "fmt"

func main() {
   var a int = 10   
   fmt.Printf("Address of a variable: %x\n", &a  )
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Address of a variable: 10328000

Böylece hafıza adresinin ne olduğunu ve ona nasıl erişileceğini anladınız. Şimdi işaretçilerin ne olduğunu görelim.

İşaretçiler Nelerdir?

Bir pointerdeğeri başka bir değişkenin adresi, yani bellek yerinin doğrudan adresi olan bir değişkendir. Herhangi bir değişken veya sabit gibi, herhangi bir değişken adresini saklamak için kullanmadan önce bir işaretçi bildirmelisiniz. Bir işaretçi değişken bildiriminin genel şekli -

var var_name *var-type

Buraya, typeişaretçinin temel türüdür; geçerli bir C veri türü olmalı vevar-nameişaretçi değişkeninin adıdır. İşaretçi bildirmek için kullandığınız yıldız işareti *, çarpma için kullandığınız yıldız işaretiyle aynıdır. Bununla birlikte, bu ifadede yıldız işareti, bir değişkeni işaretçi olarak belirlemek için kullanılmaktadır. Aşağıda geçerli işaretçi bildirimi verilmiştir -

var ip *int        /* pointer to an integer */
var fp *float32    /* pointer to a float */

Tüm işaretçilerin değerinin gerçek veri türü, ister tam sayı, ister kayan değer olsun, isterse başka türlü olsun, aynıdır, bir bellek adresini temsil eden uzun bir onaltılık sayı. Farklı veri türlerinin işaretçileri arasındaki tek fark, işaretçinin işaret ettiği değişken veya sabitin veri türüdür.

İşaretçiler Nasıl Kullanılır?

İşaretçilerle sık sık gerçekleştirdiğimiz birkaç önemli işlem vardır: (a) işaretçi değişkenlerini tanımlarız, (b) bir değişkenin adresini bir işaretçiye atarız ve (c) işaretçi değişkeninde depolanan adresteki değere erişiriz .

Tüm bu işlemler, işlenen tarafından belirtilen adreste bulunan değişkenin değerini döndüren tekli operatör * kullanılarak gerçekleştirilir. Aşağıdaki örnek, bu işlemlerin nasıl gerçekleştirileceğini gösterir -

package main

import "fmt"

func main() {
   var a int = 20   /* actual variable declaration */
   var ip *int      /* pointer variable declaration */

   ip = &a  /* store address of a in pointer variable*/

   fmt.Printf("Address of a variable: %x\n", &a  )

   /* address stored in pointer variable */
   fmt.Printf("Address stored in ip variable: %x\n", ip )

   /* access the value using the pointer */
   fmt.Printf("Value of *ip variable: %d\n", *ip )
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Address of var variable: 10328000
Address stored in ip variable: 10328000
Value of *ip variable: 20

Go'da Nil İşaretçileri

Go derleyicisi, atanacak tam adresinizin olmaması durumunda bir işaret değişkenine bir Nil değeri atar. Bu, değişken bildirimi sırasında yapılır. Sıfır atanan bir göstericiyenil Işaretçi.

Sıfır gösterici, birkaç standart kitaplıkta tanımlanan sıfır değerine sahip bir sabittir. Aşağıdaki programı düşünün -

package main

import "fmt"

func main() {
   var  ptr *int

   fmt.Printf("The value of ptr is : %x\n", ptr  )
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

The value of ptr is 0

Çoğu işletim sisteminde, programların 0 adresindeki belleğe erişmesine izin verilmez, çünkü bu bellek işletim sistemi tarafından ayrılmıştır. Bununla birlikte, hafıza adresi 0'ın özel bir anlamı vardır; işaretçinin erişilebilir bir bellek konumuna işaret etmesinin amaçlanmadığını belirtir. Ancak geleneksel olarak, bir gösterici sıfır (sıfır) değerini içeriyorsa, hiçbir şeyi göstermediği varsayılır.

Bir sıfır işaretçisi olup olmadığını kontrol etmek için aşağıdaki gibi bir if ifadesi kullanabilirsiniz -

if(ptr != nil)     /* succeeds if p is not nil */
if(ptr == nil)    /* succeeds if p is null */

İşaretçilere Ayrıntılı Git

İşaretçilerin birçok ama kolay konsepti vardır ve Go programlaması için çok önemlidirler. Aşağıdaki işaretçi kavramları bir Go programcısı için açık olmalıdır:

Sr.No	Konsept ve Açıklama
1	Go - İşaretçiler dizisi Bir dizi işaretçi tutacak diziler tanımlayabilirsiniz.
2	Git - İşaretçiye işaretçi Git, bir işaretçinin üzerinde bir işaretçiye sahip olmanızı sağlar.
3	Go'da işaretçileri işlevlere aktarma Bir bağımsız değişkeni başvuru veya adrese göre iletmek, iletilen bağımsız değişkenin çağrılan işlev tarafından çağrılan işlevde değiştirilmesini sağlar.

Go dizileri, aynı türden birkaç veri öğesini tutabilen değişkenleri tanımlamanıza izin verir. Structure Go programlamada bulunan ve farklı türlerdeki veri öğelerini birleştirmenize olanak tanıyan kullanıcı tanımlı başka bir veri türüdür.

Yapılar bir kaydı temsil etmek için kullanılır. Bir kütüphanedeki kitapları takip etmek istediğinizi varsayalım. Her kitabın aşağıdaki özniteliklerini izlemek isteyebilirsiniz -

• Title
• Author
• Subject
• Kitap kimliği

Böyle bir senaryoda yapılar oldukça kullanışlıdır.

Bir Yapının Tanımlanması

Bir yapı tanımlamak için kullanmalısınız type ve structifadeler. Struct deyimi, programınız için birden çok üye içeren yeni bir veri türünü tanımlar. Type deyimi, bizim durumumuzda struct olan türle bir adı bağlar. Struct ifadesinin biçimi aşağıdaki gibidir -

type struct_variable_type struct {
   member definition;
   member definition;
   ...
   member definition;
}

Bir yapı türü tanımlandıktan sonra, aşağıdaki sözdizimi kullanılarak bu türdeki değişkenleri bildirmek için kullanılabilir.

variable_name := structure_variable_type {value1, value2...valuen}

Yapı Üyelerine Erişim

Bir yapının herhangi bir üyesine erişmek için, member access operator (.).Üye erişim operatörü, yapı değişkeni adı ile erişmek istediğimiz yapı üyesi arasında bir dönem olarak kodlanır. Kullanırdınstructyapı tipindeki değişkenleri tanımlamak için anahtar kelime. Aşağıdaki örnek bir yapının nasıl kullanılacağını açıklamaktadır -

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}
func main() {
   var Book1 Books    /* Declare Book1 of type Book */
   var Book2 Books    /* Declare Book2 of type Book */
 
   /* book 1 specification */
   Book1.title = "Go Programming"
   Book1.author = "Mahesh Kumar"
   Book1.subject = "Go Programming Tutorial"
   Book1.book_id = 6495407

   /* book 2 specification */
   Book2.title = "Telecom Billing"
   Book2.author = "Zara Ali"
   Book2.subject = "Telecom Billing Tutorial"
   Book2.book_id = 6495700
 
   /* print Book1 info */
   fmt.Printf( "Book 1 title : %s\n", Book1.title)
   fmt.Printf( "Book 1 author : %s\n", Book1.author)
   fmt.Printf( "Book 1 subject : %s\n", Book1.subject)
   fmt.Printf( "Book 1 book_id : %d\n", Book1.book_id)

   /* print Book2 info */
   fmt.Printf( "Book 2 title : %s\n", Book2.title)
   fmt.Printf( "Book 2 author : %s\n", Book2.author)
   fmt.Printf( "Book 2 subject : %s\n", Book2.subject)
   fmt.Printf( "Book 2 book_id : %d\n", Book2.book_id)
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Book 1 title      : Go Programming
Book 1 author     : Mahesh Kumar
Book 1 subject    : Go Programming Tutorial
Book 1 book_id    : 6495407
Book 2 title      : Telecom Billing
Book 2 author     : Zara Ali
Book 2 subject    : Telecom Billing Tutorial
Book 2 book_id    : 6495700

Fonksiyon Bağımsız Değişkenleri Olarak Yapılar

Bir yapıyı, başka bir değişken veya işaretçi ilettiğinizde çok benzer bir şekilde işlev bağımsız değişkeni olarak iletebilirsiniz. Yapı değişkenlerine yukarıdaki örnekte yaptığınız gibi erişirsiniz -

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}
func main() {
   var Book1 Books    /* Declare Book1 of type Book */
   var Book2 Books    /* Declare Book2 of type Book */
 
   /* book 1 specification */
   Book1.title = "Go Programming"
   Book1.author = "Mahesh Kumar"
   Book1.subject = "Go Programming Tutorial"
   Book1.book_id = 6495407

   /* book 2 specification */
   Book2.title = "Telecom Billing"
   Book2.author = "Zara Ali"
   Book2.subject = "Telecom Billing Tutorial"
   Book2.book_id = 6495700
 
   /* print Book1 info */
   printBook(Book1)

   /* print Book2 info */
   printBook(Book2)
}
func printBook( book Books ) {
   fmt.Printf( "Book title : %s\n", book.title);
   fmt.Printf( "Book author : %s\n", book.author);
   fmt.Printf( "Book subject : %s\n", book.subject);
   fmt.Printf( "Book book_id : %d\n", book.book_id);
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Book title     : Go Programming
Book author    : Mahesh Kumar
Book subject   : Go Programming Tutorial
Book book_id   : 6495407
Book title     : Telecom Billing
Book author    : Zara Ali
Book subject   : Telecom Billing Tutorial
Book book_id   : 6495700

Yapılara İşaretçiler

İşaretçileri, başka herhangi bir değişkene işaretçi tanımladığınız gibi, aşağıdaki gibi tanımlayabilirsiniz -

var struct_pointer *Books

Şimdi, bir yapı değişkeninin adresini yukarıda tanımlanan işaretçi değişkeninde saklayabilirsiniz. Bir yapı değişkeninin adresini bulmak için, & operatörünü yapının adının önüne aşağıdaki gibi yerleştirin -

struct_pointer = &Book1;

Bir yapının üyelerine, o yapının göstericisini kullanarak erişmek için "." aşağıdaki gibi operatör -

struct_pointer.title;

Yapı işaretçisini kullanarak yukarıdaki örneği yeniden yazalım -

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}
func main() {
   var Book1 Books   /* Declare Book1 of type Book */
   var Book2 Books   /* Declare Book2 of type Book */
 
   /* book 1 specification */
   Book1.title = "Go Programming"
   Book1.author = "Mahesh Kumar"
   Book1.subject = "Go Programming Tutorial"
   Book1.book_id = 6495407

   /* book 2 specification */
   Book2.title = "Telecom Billing"
   Book2.author = "Zara Ali"
   Book2.subject = "Telecom Billing Tutorial"
   Book2.book_id = 6495700
 
   /* print Book1 info */
   printBook(&Book1)

   /* print Book2 info */
   printBook(&Book2)
}
func printBook( book *Books ) {
   fmt.Printf( "Book title : %s\n", book.title);
   fmt.Printf( "Book author : %s\n", book.author);
   fmt.Printf( "Book subject : %s\n", book.subject);
   fmt.Printf( "Book book_id : %d\n", book.book_id);
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Book title     : Go Programming
Book author    : Mahesh Kumar
Book subject   : Go Programming Tutorial
Book book_id   : 6495407
Book title     : Telecom Billing
Book author    : Zara Ali
Book subject   : Telecom Billing Tutorial
Book book_id   : 6495700

Go Slice, Go Array üzerinde bir soyutlamadır. Diziye Git, aynı türden birkaç veri öğesini tutabilen değişkenler tanımlamanıza izin verir, ancak boyutunu dinamik olarak artırmak veya kendi alt dizisini almak için herhangi bir dahili yöntem sağlamaz. Dilimler bu sınırlamanın üstesinden gelir. Array'de gerekli olan birçok yardımcı işlevi sağlar ve Go programlamasında yaygın olarak kullanılır.

Bir dilim tanımlama

Bir dilimi tanımlamak için, boyutunu belirtmeden onu bir dizi olarak bildirebilirsiniz. Alternatif olarak kullanabilirsinizmake dilim oluşturma işlevi.

var numbers []int /* a slice of unspecified size */
/* numbers == []int{0,0,0,0,0}*/
numbers = make([]int,5,5) /* a slice of length 5 and capacity 5*/

len () ve cap () işlevleri

Bir dilim, dizi üzerinde bir soyutlamadır. Aslında dizileri temel yapı olarak kullanır. len() işlev, dilimde bulunan öğeleri döndürür cap()işlev, dilimin kapasitesini döndürür (yani, kaç öğenin barındırılabileceğini). Aşağıdaki örnek dilim kullanımını açıklamaktadır -

package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)
   printSlice(numbers)
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

len = 3 cap = 5 slice = [0 0 0]

Nil dilim

Bir dilim giriş olmadan bildirilirse, o zaman varsayılan olarak sıfır olarak başlatılır. Uzunluğu ve kapasitesi sıfırdır. Örneğin -

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   if(numbers == nil){
      fmt.Printf("slice is nil")
   }
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

len = 0 cap = 0 slice = []
slice is nil

Alt dilimleme

Dilim, alt sınırını ve üst sınırını kullanarak alt dilimini almak için belirtilmesine izin verir.[lower-bound:upper-bound]. Örneğin -

package main

import "fmt"

func main() {
   /* create a slice */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)
   
   /* print the original slice */
   fmt.Println("numbers ==", numbers)
   
   /* print the sub slice starting from index 1(included) to index 4(excluded)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])
   
   /* missing lower bound implies 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])
   
   /* missing upper bound implies len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])
   
   numbers1 := make([]int,0,5)
   printSlice(numbers1)
   
   /* print the sub slice starting from index 0(included) to index 2(excluded) */
   number2 := numbers[:2]
   printSlice(number2)
   
   /* print the sub slice starting from index 2(included) to index 5(excluded) */
   number3 := numbers[2:5]
   printSlice(number3)
   
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

len = 9 cap = 9 slice = [0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
numbers[1:4] == [1 2 3]
numbers[:3] == [0 1 2]
numbers[4:] == [4 5 6 7 8]
len = 0 cap = 5 slice = []
len = 2 cap = 9  slice = [0 1]
len = 3 cap = 7 slice = [2 3 4]

append () ve copy () İşlevleri

Bir dilimin kapasitesi, append()işlevi. Kullanmacopy()işlevi, bir kaynak dilimin içeriği bir hedef dilime kopyalanır. Örneğin -

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   /* append allows nil slice */
   numbers = append(numbers, 0)
   printSlice(numbers)
   
   /* add one element to slice*/
   numbers = append(numbers, 1)
   printSlice(numbers)
   
   /* add more than one element at a time*/
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)
   
   /* create a slice numbers1 with double the capacity of earlier slice*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)
   
   /* copy content of numbers to numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

len = 0 cap = 0 slice = []
len = 1 cap = 2 slice = [0]
len = 2 cap = 2 slice = [0 1]
len = 5 cap = 8 slice = [0 1 2 3 4]
len = 5 cap = 16 slice = [0 1 2 3 4]

range anahtar kelime kullanılır forBir dizi, dilim, kanal veya haritanın öğeleri üzerinde yineleme yapmak için döngü. Dizi ve dilimlerle öğenin dizinini tamsayı olarak döndürür. Haritalarla, sonraki anahtar / değer çiftinin anahtarını döndürür. Aralık, bir veya iki değer döndürür. Bir aralık ifadesinin solunda yalnızca bir değer kullanılırsa, aşağıdaki tablodaki 1. değerdir.

Aralık ifadesi	1. Değer	2. Değer (İsteğe Bağlı)
A [n] E dizisi veya dilim	dizin i int	a [i] E
Dize s dize türü	dizin i int	rune int
harita m haritası [K] V	anahtar k K	değer m [k] V
kanal c chan E	e E öğesi	Yok

Misal

Aşağıdaki paragraf, aralığın nasıl kullanılacağını gösterir -

package main

import "fmt"

func main() {
   /* create a slice */
   numbers := []int{0,1,2,3,4,5,6,7,8} 
   
   /* print the numbers */
   for i:= range numbers {
      fmt.Println("Slice item",i,"is",numbers[i])
   }
   
   /* create a map*/
   countryCapitalMap := map[string] string {"France":"Paris","Italy":"Rome","Japan":"Tokyo"}
   
   /* print map using keys*/
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
   
   /* print map using key-value*/
   for country,capital := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",capital)
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Slice item 0 is 0
Slice item 1 is 1
Slice item 2 is 2
Slice item 3 is 3
Slice item 4 is 4
Slice item 5 is 5
Slice item 6 is 6
Slice item 7 is 7
Slice item 8 is 8
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo

Go, benzersiz anahtarları değerlerle eşleyen harita adlı başka bir önemli veri türü sağlar. Anahtar, daha sonraki bir tarihte bir değeri almak için kullandığınız bir nesnedir. Bir anahtar ve değer verildiğinde, değeri bir Harita nesnesinde saklayabilirsiniz. Değer kaydedildikten sonra, anahtarını kullanarak değeri geri alabilirsiniz.

Bir Harita Tanımlama

Kullanmalısın make harita oluşturma işlevi.

/* declare a variable, by default map will be nil*/
var map_variable map[key_data_type]value_data_type

/* define the map as nil map can not be assigned any value*/
map_variable = make(map[key_data_type]value_data_type)

Misal

Aşağıdaki örnek, bir haritanın nasıl oluşturulacağını ve kullanılacağını göstermektedir -

package main

import "fmt"

func main() {
   var countryCapitalMap map[string]string
   /* create a map*/
   countryCapitalMap = make(map[string]string)
   
   /* insert key-value pairs in the map*/
   countryCapitalMap["France"] = "Paris"
   countryCapitalMap["Italy"] = "Rome"
   countryCapitalMap["Japan"] = "Tokyo"
   countryCapitalMap["India"] = "New Delhi"
   
   /* print map using keys*/
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
   
   /* test if entry is present in the map or not*/
   capital, ok := countryCapitalMap["United States"]
   
   /* if ok is true, entry is present otherwise entry is absent*/
   if(ok){
      fmt.Println("Capital of United States is", capital)  
   } else {
      fmt.Println("Capital of United States is not present") 
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Capital of India is New Delhi
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of United States is not present

delete () İşlevi

delete () işlevi, bir haritadan bir girişi silmek için kullanılır. Haritaya ve silinecek ilgili anahtarı gerektirir. Örneğin -

package main

import "fmt"

func main() {   
   /* create a map*/
   countryCapitalMap := map[string] string {"France":"Paris","Italy":"Rome","Japan":"Tokyo","India":"New Delhi"}
   
   fmt.Println("Original map")   
   
   /* print map */
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
   
   /* delete an entry */
   delete(countryCapitalMap,"France");
   fmt.Println("Entry for France is deleted")  
   
   fmt.Println("Updated map")   
   
   /* print map */
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Original Map
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of India is New Delhi
Entry for France is deleted
Updated Map
Capital of India is New Delhi
Capital of Italy is Rome
Capital of Japan is Tokyo

Özyineleme, öğeleri kendine benzer bir şekilde tekrar etme işlemidir. Aynı kavram programlama dilleri için de geçerlidir. Bir program aynı işlevin içindeki bir işlevi çağırmaya izin veriyorsa, buna özyinelemeli işlev çağrısı denir. Aşağıdaki örneğe bir göz atın -

func recursion() {
   recursion() /* function calls itself */
}
func main() {
   recursion()
}

Go programlama dili özyinelemeyi destekler. Yani bir fonksiyonun kendisini çağırmasına izin verir. Ancak özyinelemeyi kullanırken, programcıların işlevden bir çıkış koşulu tanımlamada dikkatli olmaları gerekir, aksi takdirde sonsuz bir döngü haline gelecektir.

Go'da Özyineleme Örnekleri

Özyinelemeli fonksiyonlar, bir sayının faktöriyelini hesaplamak, bir Fibonacci serisi oluşturmak gibi birçok matematik problemini çözmek için çok kullanışlıdır.

Örnek 1: Go'da Özyineleme Kullanarak Faktöriyel Hesaplama

Aşağıdaki örnek, özyinelemeli bir işlev kullanarak belirli bir sayının faktöriyelini hesaplar -

package main

import "fmt"

func factorial(i int)int {
   if(i <= 1) {
      return 1
   }
   return i * factorial(i - 1)
}
func main() { 
   var i int = 15
   fmt.Printf("Factorial of %d is %d", i, factorial(i))
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Factorial of 15 is 1307674368000

Örnek 2: Go'da Özyineleme Kullanan Fibonacci Serisi

Aşağıdaki örnek, özyinelemeli bir işlev kullanılarak belirli bir sayının Fibonacci serisinin nasıl oluşturulacağını gösterir -

package main

import "fmt"

func fibonaci(i int) (ret int) {
   if i == 0 {
      return 0
   }
   if i == 1 {
      return 1
   }
   return fibonaci(i-1) + fibonaci(i-2)
}
func main() {
   var i int
   for i = 0; i < 10; i++ {
      fmt.Printf("%d ", fibonaci(i))
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

0 1 1 2 3 5 8 13 21 34

Tür atama, bir değişkeni bir veri türünden başka bir veri türüne dönüştürmenin bir yoludur. Örneğin, uzun bir değeri basit bir tamsayı olarak saklamak istiyorsanız, cast long to int yazabilirsiniz. Değerleri bir türden diğerine dönüştürmek içincast operator. Sözdizimi aşağıdaki gibidir -

type_name(expression)

Misal

Cast operatörünün, bir tamsayı değişkeninin diğerine bölünmesinin bir kayan sayı işlemi olarak yapılmasına neden olduğu aşağıdaki örneği düşünün.

package main

import "fmt"

func main() {
   var sum int = 17
   var count int = 5
   var mean float32
   
   mean = float32(sum)/float32(count)
   fmt.Printf("Value of mean : %f\n",mean)
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Value of mean : 3.400000

Go programlama adı verilen başka bir veri türü sağlar interfacesBu, bir dizi yöntem imzasını temsil eder. Struct veri türü bu arabirimleri arabirimlerin yöntem imzası için yöntem tanımlarına sahip olacak şekilde uygular.

Sözdizimi

/* define an interface */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

/* define a struct */
type struct_name struct {
   /* variables */
}

/* implement interface methods*/
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* method implementation */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /* method implementation */
}

Misal

package main

import (
   "fmt" 
   "math" 
)

/* define an interface */
type Shape interface {
   area() float64
}

/* define a circle */
type Circle struct {
   x,y,radius float64
}

/* define a rectangle */
type Rectangle struct {
   width, height float64
}

/* define a method for circle (implementation of Shape.area())*/
func(circle Circle) area() float64 {
   return math.Pi * circle.radius * circle.radius
}

/* define a method for rectangle (implementation of Shape.area())*/
func(rect Rectangle) area() float64 {
   return rect.width * rect.height
}

/* define a method for shape */
func getArea(shape Shape) float64 {
   return shape.area()
}

func main() {
   circle := Circle{x:0,y:0,radius:5}
   rectangle := Rectangle {width:10, height:5}
   
   fmt.Printf("Circle area: %f\n",getArea(circle))
   fmt.Printf("Rectangle area: %f\n",getArea(rectangle))
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Circle area: 78.539816
Rectangle area: 50.000000

Go programlama, aşağıdaki bildirimin dahili hata arabirim türü ile oldukça basit bir hata işleme çerçevesi sağlar -

type error interface {
   Error() string
}

Fonksiyonlar normalde son dönüş değeri olarak hatayı döndürür. Kullanımerrors.New aşağıdaki gibi temel bir hata mesajı oluşturmak için -

func Sqrt(value float64)(float64, error) {
   if(value < 0){
      return 0, errors.New("Math: negative number passed to Sqrt")
   }
   return math.Sqrt(value), nil
}

Dönüş değerini ve hata mesajını kullanın.

result, err:= Sqrt(-1)

if err != nil {
   fmt.Println(err)
}

Misal

package main

import "errors"
import "fmt"
import "math"

func Sqrt(value float64)(float64, error) {
   if(value < 0){
      return 0, errors.New("Math: negative number passed to Sqrt")
   }
   return math.Sqrt(value), nil
}
func main() {
   result, err:= Sqrt(-1)

   if err != nil {
      fmt.Println(err)
   } else {
      fmt.Println(result)
   }
   
   result, err = Sqrt(9)

   if err != nil {
      fmt.Println(err)
   } else {
      fmt.Println(result)
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Math: negative number passed to Sqrt
3