Golang Int'ten String'e, String'den Int'e ve Tip Dönüşümü

Go tipleri asla örtük olarak dönüştürmez. Uyumlu tipler arasında T(v) ile, sayılar ile metin arasında ise strconv paketiyle dönüşüm yaparsınız. En çok aranan iki dönüşüm:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// int to string
	n := 42
	s := strconv.Itoa(n)
	fmt.Println(s, len(s))

	// string to int
	parsed, err := strconv.Atoi("1234")
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println(parsed + 1)
}

strconv.Itoa ("integer to ASCII") bir int'i ondalık metin olarak biçimlendirir. strconv.Atoi ("ASCII to integer") metni bir int'e ayrıştırır ve metin geçerli bir sayı değilse hata döndürür. Bu hatayı her zaman kontrol edin.

T(v) Dönüşümü

Go'nun dönüşüm söz dizimi, hedef tipin adını taşıyan bir fonksiyon çağrısına benzer. Üç durumda çalışır:

1. sayısal tipler arasında (int, int64, float64, uint8, ...),
2. string ile []byte ya da []rune arasında,
3. aynı temel tipi paylaşan tipler arasında (Celsius ve float64).

package main

import (
	"fmt"
	"math"
)

type Celsius float64

func main() {
	count := 7
	total := 2.5

	// numeric conversions
	avg := total / float64(count)
	fmt.Printf("%.3f\n", avg)

	// float to int truncates toward zero
	up, down := 3.9, -3.9
	fmt.Println(int(up), int(down))
	fmt.Println(int(math.Round(up)), int(math.Round(-3.5)))

	// narrowing an integer keeps the low bits
	big, mid := 300, 200
	fmt.Println(uint8(big), int8(mid))

	// named type to underlying type and back
	t := Celsius(21.5)
	f := float64(t)
	fmt.Println(t, f)
}

Sonuçları dikkatle okuyun:

• int(3.9) sonucu 3, int(-3.9) sonucu -3'tür. Dönüşüm sıfıra doğru keser; yuvarlamaz. Davranışı seçmek için önce math.Round, math.Floor ya da math.Ceil kullanın. math.Round yarımları sıfırdan uzağa yuvarlar, yani -3.5, -4 olur.
• uint8(300) sonucu 44'tür, çünkü yalnızca alt 8 bit kalır (300 eksi 256); int8(200) de aynı nedenle -56'dır. Hata yok, panic yok.
• Celsius ve float64 aynı temel tipi paylaşır, bu yüzden serbestçe dönüşürler, ama yalnızca açıkça.

Değerler bilerek değişkenlerde tutuluyor. Sabitlerle aynı dönüşümler derlenmez.

Sabitler Kontrol Edilir, Değişkenler Edilmez

Sığmayan bir sabiti dönüştürmek derleme hatasıdır. Aynı değere sahip bir değişkeni dönüştürmek ise sessizce başa sarar:

fmt.Println(uint8(300)) // compile error
x := 300
fmt.Println(uint8(x)) // 44

./main.go:6:20: constant 300 overflows uint8

Tam sayı olmayan bir sabiti tam sayı tipine dönüştürmek de reddedilir; aynı değer bir değişkendeyse kesilir:

./main.go:7:18: cannot convert -3.9 (untyped float constant) to type int

Float değeri hedef tam sayı tipinin aralığı dışındaysa (örneğin int64(1e20)) sonuç uygulamaya bağlıdır: örneğin amd64 ve arm64 farklı cevaplar verir. Güvenilmeyen değerleri dönüştürmeden önce aralığı kontrol edin.

Sayıları String'e Dönüştürmek

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var id int64 = 9007199254740993
	fmt.Println(strconv.FormatInt(id, 10))
	fmt.Println(strconv.FormatInt(255, 2), strconv.FormatInt(255, 16))

	f := 1234.5678
	fmt.Println(strconv.FormatFloat(f, 'f', 2, 64))  // fixed, 2 decimals
	fmt.Println(strconv.FormatFloat(f, 'e', 3, 64))  // scientific
	fmt.Println(strconv.FormatFloat(f, 'f', -1, 64)) // shortest exact form
	fmt.Println(strconv.FormatFloat(0.1, 'f', -1, 64))

	fmt.Println(fmt.Sprintf("%.1f%%", 45.67))
	fmt.Println("item-" + strconv.Itoa(7))
}

FormatFloat bir format baytı (sabit için 'f', üslü gösterim için 'e', hangisi kısaysa onun için 'g'), bir hassasiyet (-1, "tam olarak geri dönüşebilen en az basamak" demektir) ve orijinal float'ın bit boyutunu (64 ya da 32) alır.

strconv, değeri bir interface'e kutulayıp fmt'nin genel biçimlendirme yolundan geçen fmt.Sprint'ten daha hızlıdır. Sık çalışan bir döngüde bu fark görünür; ara sıra yapılan dönüşümler için hangisi daha okunaklıysa onu seçin.

String'leri Sayılara Dönüştürmek

ParseInt her zaman bir int64 döndürür. bitSize argümanı (0, 8, 16, 32, 64) kabul ettiği aralığı belirler, bu yüzden sonucu küçük bir tipe dönüştürdüğünüzde sığması garantidir. base 0 "önekten çıkar" demektir, bu yüzden 0x1f, 0o17, 0b101 ve 1_000'in hepsi ayrıştırılır.

package main

import (
	"errors"
	"fmt"
	"strconv"
	"strings"
)

func main() {
	inputs := []string{"42", " 42", "4.2", "abc", "99999999999999999999"}
	for _, in := range inputs {
		n, err := strconv.Atoi(in)
		fmt.Printf("%-24q -> %d, %v\n", in, n, err)
	}

	// trim first when the input may have spaces or a newline
	n, err := strconv.Atoi(strings.TrimSpace(" 42\n"))
	fmt.Println(n, err)

	// ParseInt with a size limit
	v, err := strconv.ParseInt("300", 10, 8)
	fmt.Println(v, err)

	// base 0 reads the prefix
	h, _ := strconv.ParseInt("0xff", 0, 64)
	fmt.Println(h)

	// inspect the error kind
	_, err = strconv.Atoi("12a")
	if errors.Is(err, strconv.ErrSyntax) {
		fmt.Println("not a number")
	}
	_, err = strconv.ParseInt("300", 10, 8)
	if errors.Is(err, strconv.ErrRange) {
		fmt.Println("too big for int8")
	}

	price, err := strconv.ParseFloat("19.99", 64)
	fmt.Println(price*2, err)

	ok, err := strconv.ParseBool("true")
	fmt.Println(ok, err)
}

Çıktının gösterdikleri:

• " 42" başarısız olur. Atoi isteğe bağlı bir işaret ve rakamlar kabul eder, başka hiçbir şey değil. bufio'dan gelen girdi genellikle \n ile biter, bu yüzden kırpın.
• "4.2", Atoi için geçersizdir. Ondalıklı sayılar için ParseFloat kullanın.
• Aralık dışı bir hatada ParseInt, hatayla birlikte sığan en büyük değeri döndürür (int8 için 127). Hata nil değilse değeri kullanmayın.
• Hatalar, strconv.ErrSyntax ya da strconv.ErrRange'i sarmalayan *strconv.NumError değerleridir, bu yüzden errors.Is onları ayırt edebilir.

ParseBool; 1, t, T, TRUE, true, True ve bunlara karşılık gelen false biçimlerini kabul eder. "yes" ve "on" hatadır.

string(65) Tuzağı

Bir tam sayıyı string'e dönüştürmek rakamlar üretmez. O Unicode kod noktasına sahip karakteri üretir:

n := 65
s := string(n) // "A", not "65"

Derleyici bunu kabul eder, ama go vet raporlar:

./main.go:10:7: conversion from int to string yields a string of one rune, not a string of digits

Gerçekten karakteri istiyorsanız bunu bir rune ile belirtin: string(rune(n)). Sayıyı metin olarak istiyorsanız strconv.Itoa(n) kullanın. Bir rune ya da byte'ı string'e dönüştürmek ise sorunsuz ve yaygındır:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	n := 65
	fmt.Println(strconv.Itoa(n)) // "65"
	fmt.Println(string(rune(n))) // "A"

	letter := 'é'
	fmt.Println(string(letter))

	word := "go"
	fmt.Println(string(word[0])) // a byte converted to a one-character string
}

String'ler, Byte'lar ve Rune'lar

string, []byte ve []rune birbirine T(v) ile dönüşür. String'ler değiştirilemez, slice'lar değiştirilebilir olduğu için her dönüşüm veriyi kopyalar:

package main

import "fmt"

func main() {
	s := "héllo"

	b := []byte(s) // UTF-8 bytes
	r := []rune(s) // Unicode code points

	fmt.Println(len(b), b)
	fmt.Println(len(r), r)

	r[1] = 'e'
	fmt.Println(string(r))

	b[0] = 'H'
	fmt.Println(string(b), s) // s is unchanged
}

Karaktere göre indekslemeniz ya da değişiklik yapmanız gerekiyorsa []rune'a, G/Ç, hash'leme ve bayt seviyesinde düzenlemeler için []byte'a dönüştürün. Runes and bytes sayfası UTF-8'i ayrıntılı anlatıyor.

Dönüşüm ve Type Assertion

Dönüşüm bir değeri bir somut tipten diğerine çevirir. Bir interface'ten (any, error, io.Reader) somut değeri çıkarmak ise farklı bir işlemdir, type assertion:

var v any = 42

n := v.(int)       // type assertion: v holds an int, give it to me
f := float64(n)    // conversion: int to float64
// f := float64(v) // compile error: cannot convert v (variable of interface type any)
//                  // to type float64: need type assertion

Önce assertion, sonra dönüşüm. Virgül-ok biçimi n, ok := v.(int), tip yanlış olduğunda panic'i önler.

Hızlı Başvuru

n, err := strconv.Atoi("42")
if err != nil {
	// not a valid integer
}