Temel Söz Dizimi

Go'nun temel söz dizimi oldukça basit ve anlaşılırdır, en basit örnekten başlayalım.

package main

import "fmt"

func main() {
   fmt.Println("Merhaba Dünya!")
}

• package anahtar kelimesi, mevcut go dosyasının hangi pakete ait olduğunu belirtir. Giriş dosyası main paketi olarak tanımlanmalıdır ve giriş fonksiyonu main fonksiyonudur. Özel paket ve fonksiyon isimlendirirken bunlarla çakışmamaya özen gösterin.

• import içe aktarma anahtar kelimesidir ve ardından içe aktarılan paket adı gelir.

• func fonksiyon tanımlama anahtar kelimesidir ve bir fonksiyon tanımlamak için kullanılır.

• fmt.Println("Merhaba Dünya!") bir ifadedir ve fmt paketindeki Println fonksiyonunu çağırarak çıktı yapar.

Yukarıdaki temel bir söz dizimi tanıtımıdır, şimdi kavramları daha detaylı inceleyelim.

Paket

Go'da programlar paketleri birbirine bağlayarak oluşturulur. Go'da içe aktarmanın en temel birimi .go dosyası değil, bir pakettir. Paket aslında bir klasördür (İngilizce: package) ve paket içindeki tüm değişkenler, sabitler ve tanımlanan tüm tipler paylaşılır. Paket isimlendirme stili küçük harflerle olmalı ve mümkün olduğunca kısa tutulmalıdır.

Görünürlük

Daha önce belirtildiği gibi, paket içindeki tüm değişkenler, sabitler ve tanımlanan tüm tipler paylaşılır, ancak paket dışı için bu geçerli değildir. Bazen belirli bir tipe başkalarının erişmesini istemezsiniz, bu nedenle görünürlüğü kontrol etmeniz gerekir. Diğer OOP dillerinde Public, Private gibi anahtar kelimeler görmüş olabilirsiniz, ancak Go dilinde bunlar yoktur. Görünürlüğü kontrol etme yöntemi oldukça basittir, kurallar şöyledir:

• Büyük harfle başlayan isimler genel (public) tip/değişken/sabittir
• Küçük harf veya alt çizgi ile başlayan isimler özel (private) tip/değişken/sabittir

Örneğin aşağıdaki örnekte, MyName sabiti genelken, mySalary sabiti özeldir.

package example

// Genel
const MyName = "jack"

// Özel
const mySalary = 20_000

Bu görünürlük kuralı Go dilinin her yerinde geçerlidir.

İçe Aktarma

Bir paketi içe aktararak o paketteki tipleri/metodları/fonksiyonları/değişkenleri kullanabilirsiniz. İçe aktarma söz dizimi import anahtar kelimesi ve ardından paket adıdır.

package main

import "example"

Birden fazla paketi içe aktarırken şu şekilde yazabilirsiniz:

package main

import "example"
import "example1"

Veya parantez içine alarak da yazabilirsiniz, aşağıdaki yöntem pratikte daha yaygın kullanılır.

package main

import (
  "example"
  "example1"
)

Paket adları tekrar ederse veya paket adları karmaşıksa, onlara takma ad verebilirsiniz:

package main

import (
  e "example"
  e1 "example1"
)

Takma ad alt çizgi _ olduğunda, bu anonim içe aktarmadır. Anonim içe aktarılan paket kullanılamaz. Bu genellikle paket altındaki init fonksiyonlarını yüklemek için yapılır, ancak paketteki tipleri kullanmanız gerekmez. Yaygın bir örnek veritabanı sürücülerini kaydetmektir, ancak sürücüyü manuel olarak kullanmanız gerekmez.

package main

import (
  e "example"
  _ "mysql-driver-go"
)

İçe aktardıktan sonra, paketteki türlere erişmek istediğinizde PaketAdı.Tanıtıcı şeklinde erişebilirsiniz. Örneğin aşağıdaki örnekte, özel bir tipe erişmeye çalışırsanız, derleyici size erişilemeyeceğini söyleyecektir.

package main

import (
  "example"
   "fmt"
)

func main() {
    fmt.Println(example.MyName)
}

Özel bir içe aktarma yöntemi de paketteki tüm tipleri geçerli paket kapsamına içe aktarmaktır. Bu yöntemle içe aktarılan tipler artık erişim için . operatörüne ihtiyaç duymaz, ancak aynı ada sahip tipler varsa derleme başarısız olur.

package main

import (
  . "example"
)

WARNING

Go'da döngüsel içe aktarma yapılamaz, doğrudan veya dolaylı olsun. Örneğin A paketi B paketini içe aktarır, B paketi de A paketini içe aktarır, bu doğrudan döngüsel içe aktarmadır. A paketi C paketini içe aktarır, C paketi B paketini içe aktarır, B paketi de A paketini içe aktarır, bu dolaylı döngüsel içe aktarmadır. Döngüsel içe aktarma varsa derleme başarısız olur.

Dahili Paket

Go'da约定 olarak, internal adlı bir paket dahili pakettir. Dış paketler dahili paketteki hiçbir içeriğe erişemez, aksi takdirde derleme başarısız olur. Aşağıda bir örnek verilmiştir.

/home/user/go/
    src/
        crash/
            bang/              (go code in package bang)
                b.go
        foo/                   (go code in package foo)
            f.go
            bar/               (go code in package bar)
                x.go
            internal/
                baz/           (go code in package baz)
                    z.go
            quux/              (go code in package main)
                y.go

Dosya yapısından görülebileceği gibi, crash paketi baz paketindeki türlere erişemez.

Yorumlar

Go tek satırlık ve çok satırlık yorumları destekler. Yorumlar ve içerik arasında bir boşluk bırakılması önerilir, örneğin:

// Bu main paketi
package main

// fmt paketi içe aktarıldı
import "fmt"

/*
*
Bu başlangıç fonksiyonu main fonksiyonudur
*/
func main() {
  // Bu bir ifadedir
  fmt.Println("Merhaba Dünya!")
}

Tanıtıcılar

Tanıtıcı bir isimdir, paket isimlendirmesi, fonksiyon isimlendirmesi, değişken isimlendirmesi vb. için kullanılır. İsimlendirme kuralları şöyledir:

• Sadece harfler, rakamlar ve alt çizgilerden oluşabilir
• Sadece harf ve alt çizgi ile başlayabilir
• Büyük/küçük harf duyarlıdır
• Mevcut hiçbir tanıtıcı ile aynı olamaz, yani paket içinde benzersiz olmalıdır
• Go'nun yerleşik anahtar kelimeleriyle çakışamaz

Aşağıda tüm yerleşik anahtar kelimeler listelenmiştir, daha fazla detay için Referans El Kitabı - Tanıtıcılar adresini ziyaret edebilirsiniz.

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

Operatörler

Aşağıda Go dilinde desteklenen operatörlerin öncelik sıralaması verilmiştir, daha fazla detay için Referans El Kitabı - Operatörler adresini ziyaret edebilirsiniz.

Precedence    Operator
    5             *  /  %  <<  >>  &  &^
    4             +  -  |  ^
    3             ==  !=  <  <=  >  >=
    2             &&
    1             ||

Dikkat edilmesi gereken bir nokta, Go dilinde ~ ters operatörü olarak kullanılmaz, bunun yerine ^ sembolü yeniden kullanılır. İki sayı ^ kullanıldığında, örneğin a^b, bu XOR operatörüdür. Sadece bir sayı için kullanıldığında, örneğin ^a, bu ters operatördür. Go ayrıca geliştirilmiş atama operatörlerini de destekler, aşağıdaki gibi.

a += 1
a /= 2
a &^= 2

TIP

Go dilinde artırım ve azaltma operatörleri yoktur, bunlar statement düzeyine indirgenmiştir ve sadece operandtan sonra yer alabilir, bu yüzden i++ ve ++i gibi soruları düşünmenize gerek yoktur.

a++ // Doğru
++a // Yanlış
a-- // Doğru

Bir diğer nokta da, artık geri dönüş değerleri yoktur, bu nedenle a = b++ gibi ifadeler yanlıştır.

Değişmezler (Literals)

Değişmezler, bilgisayar bilimi terminolojisine göre kaynak kodunda sabit bir değeri ifade etmek için kullanılan sembollerdir, literal değer olarak da adlandırılır. Her iki isim de aynı anlama gelir, ne yazdıysanız değer odur, değer "kelimenin tam anlamıyla" değerdir.

Tamsayı Değişmezleri

Okunabilirlik için alt çizgi _ kullanarak sayıları bölmeye izin verilir, ancak sadece ön işaret sembolünden sonra ve rakamlar arasında kullanıma izin verilir.

24 // 24
024 // 24
2_4 // 24
0_2_4 // 24
10_000 // 10k
100_000 // 100k
0O24 // 20
0b00 // 0
0x00 // 0
0x0_0 // 0

Ondalık Sayı Değişmezleri

Farklı ön ekler kullanarak farklı tabanlarda ondalık sayıları ifade edebilirsiniz.

0.
72.40
072.40       // == 72.40
2.71828
1.e+0
6.67428e-11
1E6
.25
.12345E+5
1_5.         // == 15.0
0.15e+0_2    // == 15.0

0x1p-2       // == 0.25
0x2.p10      // == 2048.0
0x1.Fp+0     // == 1.9375
0X.8p-0      // == 0.5
0X_1FFFP-16  // == 0.1249847412109375
0x15e-2      // == 0x15e - 2 (tamsayı çıkarma)

Karmaşık Sayı Değişmezleri

0i
0123i         // == 123i
0o123i        // == 0o123 * 1i == 83i
0xabci        // == 0xabc * 1i == 2748i
0.i
2.71828i
1.e+0i
6.67428e-11i
1E6i
.25i
.12345E+5i
0x1p-2i       // == 0x1p-2 * 1i == 0.25i

Karakter Değişmezleri

Karakter değişmezleri tek tırnak içine alınmalıdır ''. Go'daki karakterler tamamen utf8 uyumludur.

'a'
'ä'
'你'
'\t'
'\000'
'\007'
'\377'
'\x07'
'\xff'
'\u12e4'
'\U00101234'

Kaçış Karakterleri

Go'da kullanılabilir kaçış karakterleri:

\a   U+0007 Zil sembolü
\b   U+0008 Geri alma sembolü
\f   U+000C Sayfa çevirme sembolü
\n   U+000A Yeni satır sembolü
\r   U+000D Satır başı sembolü
\t   U+0009 Yatay sekme sembolü
\v   U+000B Dikey sekme sembolü
\\   U+005C Ters eğik çizgi kaçış
\'   U+0027 Tek tırnak kaçış (bu kaçış sadece karakter içinde geçerlidir)
\"   U+0022 Çift tırnak kaçış (bu kaçış sadece string içinde geçerlidir)

String Değişmezleri

String değişmezleri çift tırnak "" veya ters tırnak ` ile çevrilmelidir (ters tırnak string'lerde kaçışa izin verilmez).

`abc`                // "abc"
`\n
\n`                  // "\\n\n\\n"
"\n"
"\""                 // `"`
"Hello, world!\n"
"Bugün hava güzel"
"日本語"
"\u65e5本\U00008a9e"
"\xff\u00FF"

Fonksiyonlar

Go'da fonksiyon tanımlama func anahtar kelimesi ile yapılır, çoğu dile benzer.

func main() {
  println(1)
}

Ancak Go'daki fonksiyonların iki farklı noktası vardır, ilki parametre türünün sonda olmasıdır, aşağıdaki gibi:

func Hello(name string) {
  fmt.Println(name)
}

İkinci farklı nokta çoklu dönüş değerleridir ve isimli olabilirler:

func Pos() () (x, y float64) {
    ...
}

Stil

Kodlama stili konusunda Go herkesi aynı stile uymaya zorlar. Go resmi bir formatlama aracı gofmt sağlar, komut satırı üzerinden kullanılabilir. Bu formatlama aracının geçirilebilecek formatlama parametresi yoktur, sadece iki parametre formatlama sürecini çıktılar, bu yüzden özelleştirmeyi tamamen desteklemez. Bu, bu araçla formatlanan tüm kodların aynı kod stiline sahip olacağı anlamına gelir, bu da bakım yapanların bilişsel yükünü büyük ölçüde azaltır. Bu nedenle bu alanda kişisellik aramak akıllıca bir seçim değildir.

Aşağıda bazı kurallar basitçe listelenecektir, kod yazarken bunlara dikkat edebilirsiniz.

Fonksiyon Süslü Parantez Yeni Satırı

Fonksiyondan sonra süslü parantezin yeni satıra geçip geçmemesi gerektiği konusunda neredeyse her programcının kendi的理由 vardır. Go'da hiçbir süslü parantez yeni satıra geçmemelidir.

// Doğru örnek
func main() {
  fmt.Println("Merhaba Dünya!")
}

Eğer gerçekten aşağıdaki gibi yaparsanız:

// Yanlış örnek
func main()
{
  fmt.Println("Merhaba Dünya!")
}

Bu tür kodlar derlenemez bile, bu yüzden Go tüm programcıları fonksiyondan sonraki parantezin yeni satıra geçmemeye zorlar.

Kod Girintisi

Go varsayılan olarak Tab yani sekme karakteri ile girinti yapar, sadece bazı özel durumlarda boşluk kullanılır.

Kod Aralıkları

Go'da çoğu aralık anlamlıdır, bir açıdan bu da derleyicinin kodunuzu nasıl gördüğünü temsil eder. Örneğin aşağıdaki matematiksel işlem:

2*9 + 1/3*2

Bilindiği gibi, çarpmanın önceliği toplamadan daha yüksektir. Formatlandıktan sonra, * sembolü arasındaki aralık daha kompakt görünür, bu da öncelikle işlem yapılacağını gösterir, + sembolü yakınındaki aralık ise daha büyüktür, bu da daha sonra işlem yapılacağını gösterir.

Süslü Parantezlerin Atlanması

Diğer dillerde if ve for ifadeleri genellikle kısaltılabilir, aşağıdaki gibi:

for (int i=0; i < 10; i++) printf("%d", i)

Ancak Go'da bu mümkün değildir, sadece bir satır yazabilirsiniz ama süslü parantez eklemelisiniz:

for i := 0; i < 10; i++ {fmt.Println(i)}

Üçlü İfade

Go'da üçlü ifade yoktur, bu nedenle aşağıdaki kod derlenemez:

var c = a > b ? a : b

Bu makale ile Go'nun söz dizimi hakkında初步 bir anlayış kazanabilirsiniz, sonraki içeriklerde daha detaylı açıklanacaktır.