Golang Döküm Örnekleri

Golang Dokum Ornekleri



Bir değerin veri türünü bir türden diğerine değiştirme işlemi, tür dönüştürme, bazen tür dönüştürme olarak bilinir. Tip dökümü, açık tip dönüştürmeleri kullanılarak Go'da gerçekleştirilir. Go, güçlü yazmayı destekler. Bu nedenle, türler arasında dönüştürme yaparken amacımızı açıkça belirtmeliyiz. Bu, yazım güvenliğini artırır ve yazım hatası olasılığını azaltır. Bu yazıda, Go'da farklı türlerle oyuncu seçimi yapmayı keşfedeceğiz.

Örnek 1: Golang Temel Tip Döküm

Go'daki doğrudan ve temel atama örneğiyle başlayalım çünkü değişkenin türünü herhangi bir yerde değiştirmek için tip belirlemeye ihtiyacımız var.

paket ana
içe aktarmak (
'fmt'
)
işlev ana () {
öyleydi X int = 31
Ve := şamandıra64 ( X )
fmt . Yazdır ( Ve )
}

Burada “x” isimli “int” tipi bir değişkeni bildirip 31 değeri atayarak ana fonksiyonla başlıyoruz. Daha sonra “:=” kısayol atama operatörü kullanılarak “y” değişkeni bildiriliyor. “x”in “float64”e dönüştürülmesi sonucu sağ taraftaki ifadeden “y”nin tipi otomatik olarak belirlenir. Böylece bu programda “x” değeri “float64”e çevrilir ve “y” atanır.







Go'daki temel dökümden alınan sonuçlar aşağıdaki gibi görüntülenir:





Örnek 2: Golang Örtülü Tip Döküm

Farklı türler arasında örtük tür atamaya izin verilmez. Go, güçlü yazmayı zorunlu kılar; bu, bir türün değerini doğrudan atayamayacağımız veya açık dönüştürme olmadan başka bir tür olarak kullanamayacağımız anlamına gelir. Aşağıda, Go tarafından istisna oluşturan örtülü dökümü gerçekleştirmeye çalışıyoruz:





paket ana
içe aktarmak 'fmt'
işlev ana () {
öyleydi tamsayı int = 9 . 08
fmt . Yazdır ( 'Tam sayı %g' , tamsayı )
}

İşte main() fonksiyonu ile başlayan ve “integer” tipinde bir “integer” değişkeninin bildirildiği kod. “Tamsayı” değişkenine atanan değer, kayan noktalı bir sayı olan 9.08'dir. Doğrudan bir tamsayı değişkenine kayan noktalı bir değer atamaya çalıştığımız için, bu bir tür uyuşmazlığı hatasıyla sonuçlanır. Daha sonra “fmt” paketinden “printf” fonksiyonunu kullanarak “integer” değişkeninin değerini “%g” biçim belirleyicisini kullanarak yazdırıyoruz.

Beklendiği gibi, Golang'da örtük tip dökümü kabul edilemez. Önceki örtük tip dökümü aşağıdaki hatayı üretir:



Örnek 3: Golang Explicit Type Casting

Açık tür dönüştürme, bir amacı açıkça belirtirken değerleri uyumlu türler arasında güvenli bir şekilde dönüştürmemizi sağlar. Tip dönüşümünün farkında olmamızı sağlar ve yanlışlıkla tip hatalarını önlemeye yardımcı olur. Aşağıdaki açık dökümü göz önünde bulundurun:

paket ana
içe aktarmak 'fmt'

işlev ana () {
öyleydi yüzenVal şamandıra32 = 6 . 75
öyleydi intVal int = int ( yüzenVal )
fmt . Yazdır ( 'Kayan Değer %g \N ' , yüzenVal )
fmt . Yazdır ( 'Tamsayı Değeri %d' , intVal )
}

Burada “float32” türünde bir “floatVal” değişkeni oluşturulur ve “6.75” değeri atanır. Daha sonra “int” tipinde bir “intVal” değişkeni tanımlanır. FloatVal değerini intVal'a atamak için tip dönüştürme kullanılır. FloatVal'ı bir tamsayı değerine dönüştürmek için, giriş olarak floatVal ile 'int' işlevi kullanılır. Bundan sonra, “fmt.Printf(“Float Value is %g\n”, floatVal)”, kayan noktalı değerleri yazdırmak için uygun olan %g biçim belirleyicisini kullanarak floatVal değerini yazdırır. “fmt.Printf(“Integer Value is %d”, intVal)” kod satırı intVal değerini yazdırırken, tamsayı değerlerinin yazdırılmasına uygun olan %d format belirticisini kullanır.

Aşağıdaki çıktı, dökümden sonra hem floatVal hem de intVal için değerler üretir:

Örnek 4: Ortalamayı Almak İçin Golang Tipi Döküm

Ardından, verilen değerlerden ortalama sayıyı elde etmek için döküm yapıyoruz. Aşağıda sağlanan kaynak kodunu inceleyelim:

paket ana
içe aktarmak 'fmt'
işlev ana () {
öyleydi Toplam int = 900
öyleydi Numaram int = yirmi
öyleydi ortalama şamandıra32
ortalama = şamandıra32 ( Toplam ) / şamandıra32 ( Numaram )
fmt . Yazdır ( 'Ortalama = %f \N ' , ortalama )
}

Burada, başlangıçta üç değişken bildiriyoruz. 'Toplam', 900 değeriyle başlatılan bir tamsayı değişkendir. 'MyNumber', 20 değeriyle başlatılan bir tamsayı değişkendir. Hesaplanan ortalama daha sonra float32 'ortalama' değişkeninde depolanır. Daha sonra hesaplamayı gerçekleştirmek için ortalama formül verilir. Bölmenin kayan noktalı bölme olarak yapılmasını sağlamak için “toplam” ve “Sayım” değerleri tür dönüştürme kullanılarak float32'ye dönüştürülür. Hesaplanan ortalama “ortalama” değişkenine atanır. Son olarak, 'printf' işlevinde kullanılan '%f\n' biçim dizesi, bir kayan değerin ardından bir yeni satır karakterinin yazdırılması gerektiğini belirtir.

Ortalama olarak elde edilen değer, önceki kodda tip dökümü ima edildikten sonra getirilir:

Örnek 5: Golang Int ve String Type Casting

Ek olarak Go, Int ve String türleri arasında aktarım da sunar. Bunu strconv paketinin işlevini kullanarak başarabiliriz.

paket ana
içe aktarmak (
'fmt'
'strconv'
)
işlev ana () {
öyleydi str sicim = '1999'
içinde , _ := strconv . römork ( S )
fmt . Yazdır ( içinde )
öyleydi tamsayı int = 1999
toStr := strconv . boğuldu ( tamsayı )

fmt . Yazdır ( toStr )
}

İşte iki değişkenin bildirimi ile başlayan kod. “str”, “1999” değeri ile başlatılan bir dizi değişkenidir ve “integer”, “1999” değeri ile başlatılan bir tamsayı değişkenidir. Bundan sonra, “str” dizgesini bir tamsayı değerine dönüştürmek için “strconv.Atoi()” işlevi kullanılır. Döndürülen 'v' değeri, dönüştürülmüş tamsayıyı temsil eder ve boş '_' tanımlayıcısı, Atoi() tarafından döndürülen herhangi bir olası hatayı yok saymak için kullanılır.

Ardından, tamsayıyı bir dize değerine dönüştürmek için strconv.Itoa() işlevi kullanılır. Döndürülen değer olan 'toStr', dönüştürülen dizgiyi temsil eder.

Çıktı, '1999' dizisinden bir tamsayıya ve '1999'un orijinal değerini üreten bir diziye dönüşümü gösterir:

Örnek 6: String ve Byte Arasında Golang Tipi Döküm

Ayrıca Go'da döküm, string ve byte tiplerinde de yapılabilmektedir. Aşağıdaki kodlar, dizeler ve bayt dilimleri arasındaki dönüşümü gösterir:

paket ana
içe aktarmak (
'fmt'
)
işlev ana () {
öyleydi gizem sicim = 'Selam'
öyleydi b1 [] bayt = [] bayt ( myStr )
fmt . Yazdır ( b1 )
toString := sicim ( b1 )
fmt . Yazdır ( toString )
}

Burada değişkenler önce belirli değerlerle ilklendirilen “myStr” ve “b1” olarak tanımlanır. Ardından, []byte(myStr) ifadesi, tür dönüştürmeyi kullanarak 'myStr' dizesini bir bayt dilimine dönüştürür. Ortaya çıkan bayt dilimini “b1” değişkenine atar. Bundan sonra, “string(b1)” ifadesi, tip dönüştürmeyi kullanarak b1 bayt dilimini tekrar bir dizgeye dönüştürür. Ortaya çıkan diziyi “toString” değişkenine atar.

Çıktı, 'Hey Orada' dizesi ile buna karşılık gelen bayt dilimi gösterimi arasındaki dönüşümü aşağıdaki şekilde gösterir:

Örnek 7: Karekök Almak İçin Golang Tipi Döküm

Şimdi, karekök sonuçlarını bulmak için Go'da döküm yapıyoruz. Kod aşağıdaki gibi yerleştirilir:

paket ana
içe aktarmak (
'fmt'
'matematik'
)
işlev ana () {
öyleydi N int = 177
öyleydi KareN şamandıra64
KareN = matematik . metrekare ( şamandıra64 ( N ))
fmt . Yazdır ( '%d'nin karekökü %.2f'dir \N ' , N , KareN )
}

Burada “n” değişkeni int olarak bildirilir ve “144” değerini atar. “SqrtN” değişkeni bir float64 olarak bildirilir ve “n”nin hesaplanan karekökünü saklar. Ardından, 'n'nin karekökünü hesaplamak için math.Sqrt() işlevi devreye alınır. math.Sqrt() bir float64 bağımsız değişkeni beklediğinden ve 'n' değeri, float64(n) kullanılarak float64'e dönüştürülür. Bundan sonra, bir tamsayı değeri (%d) ve bir kayan nokta değeri (%.2f) belirten “printf” işlevinde “%d'nin karekökü %.2f\n” biçimindeki dizeyi çağırır. “%.2f” içindeki “.2” kesinlik tanımlayıcısı, karekökün iki ondalık basamakla yazdırılmasını sağlar.

Verilen değerin karekökünü gösteren aşağıdaki çıktı alınır:

Çözüm

Go'daki döküm, tümü yürütülebilir olan farklı örneklerle tartışılır. Go'da, güçlü yazmayı zorunlu kılan ve kod netliğini ve güvenilirliğini artıran tip belirlemenin açık olduğunu unutmayın.