Go Operatörleri

1 Golang Operatorlarının Genel Bakışı

Go dilinde, operatörler program kodu işlemlerini gerçekleştirmek için kullanılır; bu işlemler arasında aritmetik operasyonlar, ilişkisel karşılaştırmalar, mantıksal operasyonlar ve daha fazlası bulunmaktadır. Farklı operatörler farklı işlevselliklere ve kullanım senaryolarına karşılık gelir. Bu operatörleri anlamak ve ustalaşmak etkili programlamanın temelidir.

2 Aritmetik Operatörler

Go dilinde bir dizi aritmetik operatör bulunmaktadır:

• Toplama (+): Toplama operasyonu
• Çıkarma (-): Çıkarma operasyonu
• Çarpma (*): Çarpma operasyonu
• Bölme (/): Bölme operasyonu
• Kalan (%): Mod işlemi

Örnekler:

package main

import "fmt"

func main() {
    // Toplama operasyonu
    toplam := 10 + 5
    fmt.Println("10 + 5 =", toplam) // Çıktı 15

    // Çıkarma operasyonu
    fark := 10 - 5
    fmt.Println("10 - 5 =", fark) // Çıktı 5

    // Çarpma operasyonu
    carpim := 10 * 5
    fmt.Println("10 * 5 =", carpim) // Çıktı 50

    // Bölme operasyonu
    bolum := 10 / 5
    fmt.Println("10 / 5 =", bolum) // Çıktı 2

    // Mod işlemi
    kalan := 10 % 5
    fmt.Println("10 % 5 =", kalan) // Çıktı 0
}

3 Mantıksal Operatörler

Go dilindeki mantıksal operatörler, birden fazla koşulu birleştirmek için kullanılır (genellikle boolean değerler için kullanılır). Bu operatörler AND (&&), OR (||) ve NOT (!) olmak üzere üç tür içerir.

3.1 AND (&&)

Tüm koşullar doğru olduğunda "AND" operasyonunun sonucu doğru olur.

Örnekler:

package main

import "fmt"

func main() {
    fmt.Println(true && true)   // Çıktı doğru
    fmt.Println(true && false)  // Çıktı yanlış
    fmt.Println(false && false) // Çıktı yanlış
    // Sonuç, her iki koşul da doğru olduğunda sadece doğrudur
}

3.2 OR (||)

En az bir koşul doğru olduğunda "OR" operasyonunun sonucu doğru olur.

Örnekler:

package main

import "fmt"

func main() {
    fmt.Println(true || true)   // Çıktı doğru
    fmt.Println(true || false)  // Çıktı doğru
    fmt.Println(false || false) // Çıktı yanlış
    // Bir koşulun en az biri doğru ise sonuç doğrudur
}

3.3 NOT (!)

Bir koşulun boolean değerini tersine çevirmek için kullanılır.

Örnekler:

package main

import "fmt"

func main() {
    fmt.Println(!true)  // Çıktı yanlış
    fmt.Println(!false) // Çıktı doğru
    // Boolean değeri tersine çevirir
}

4 Karşılaştırma Operatörleri

Go dilindeki karşılaştırma operatörleri, iki değişkeni veya değeri karşılaştırmak için kullanılır:

• Eşit (=)
• Eşit değil (!=)
• Büyük (>)
• Küçük (<)
• Büyük veya eşit (>=)
• Küçük veya eşit (<=)

Karşılaştırma operasyonlarının sonucu bir boolean değerdir: true veya false.

5 Bit Düzeyinde Operatörler

Go'da, bit düzeyinde operatörler verilerin ikili bitlerini doğrudan manipüle etmemize olanak tanır:

• Bitwise AND (&)
• Bitwise OR (|)
• Bitwise XOR (^)
• Bitwise sola kaydırma (<<)
• Bitwise sağa kaydırma (>>)

Bit düzeyinde operatörler genellikle düşük seviyeli programlamada, doğrudan donanım operasyonlarında, şifreleme ve diğer senaryolarda kullanılır.

6 Atama Operatörleri

Atama operatörleri, değişkenlere değer atamak için kullanılır. Go dilinde atama operatörlerinin birden fazla formu bulunmaktadır:

• Basit atama (=)
• Toplama atama (+=)
• Çıkarma atama (-=)
• Çarpma atama (*=)
• Bölme atama (/=)
• Modül atama (%=)

Bu operatörler kodu daha kısa hale getirir. Örneğin, x += 1 ifadesi x = x + 1 ile eşdeğerdir.

7 Özel Operatörler

7.1 Artırma (++) ve Azaltma (--) Operatörleri

Artırma operatörü (++) ve azaltma operatörü (--), sırasıyla bir değişkenin değerine 1 eklemek ve 1 çıkarmak için kullanılır. Bunlar Go dilinde doğrudan değişken üzerinde (bir ifade üzerinde değil) çalışabilen tek operatörlerdir.

package main

import "fmt"

func main() {
    x := 1
    x++
    fmt.Println("x++ =", x) // 2 olarak çıktı verir

    y := 10
    y--
    fmt.Println("y-- =", y) // 9 olarak çıktı verir
}

Go dilinde, x++ veya x-- bir ifadenin bir parçası olamaz. Örneğin, z := x++ bu şekilde bir ifadeye izin verilmez.

7.2 Tür Dönüşümü

Go dilinin tipi statiktir, yani bir değişken bir kere tanımlandığında, tipi değiştirilemez. Bu nedenle bazen bir değişkenin bir türden diğer bir türe dönüştürülmesi gerekebilir. Go dilinde otomatik tür dönüşümü bulunmamaktadır; açık tür dönüşümü gerekmektedir.

Örnek:

package main

import (
	"fmt"
)

func main() {
	var i int = 42
	fmt.Println(float64(i)) // int'i float64'e dönüştür

	var f float64 = 3.14
	fmt.Println(int(f)) // float64'ü int'e dönüştür, ondalık kısmı atılacaktır
}

Tür dönüşümü yaparken, verinin dönüşüm sürecinde güvenli olduğundan emin olmak önemlidir, örneğin, bir kayan nokta sayısını bir tamsayıya dönüştürürken hassasiyetin kaybedilme olasılığı gibi.