Int to String, String to Int, dan Konversi Tipe di Golang

Go tidak pernah mengonversi tipe secara implisit. Kamu mengonversi antartipe yang kompatibel dengan T(v), dan antara angka dan teks dengan package strconv. Dua konversi yang paling sering dicari:

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") memformat int sebagai teks desimal. strconv.Atoi ("ASCII to integer") melakukan parse pada teks menjadi int dan mengembalikan error kalau teksnya bukan angka yang valid. Selalu periksa error itu.

Konversi T(v)

Sintaks konversi Go terlihat seperti pemanggilan fungsi yang dinamai sesuai tipe tujuan. Konversi ini bekerja dalam tiga situasi:

1. antartipe angka (int, int64, float64, uint8, ...),
2. antara string dan []byte atau []rune,
3. antartipe yang punya underlying type yang sama (Celsius dan 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)
}

Baca hasilnya dengan teliti:

• int(3.9) bernilai 3 dan int(-3.9) bernilai -3. Konversi memotong ke arah nol; konversi tidak membulatkan. Pakai math.Round, math.Floor, atau math.Ceil lebih dulu untuk memilih perilakunya. math.Round membulatkan setengah menjauhi nol, jadi -3.5 menjadi -4.
• uint8(300) bernilai 44, karena hanya 8 bit terbawah yang tersisa (300 dikurangi 256), dan int8(200) bernilai -56 karena alasan yang sama. Tidak ada error, tidak ada panic.
• Celsius dan float64 punya underlying type yang sama, jadi keduanya bisa dikonversi dengan bebas, tetapi hanya secara eksplisit.

Nilai-nilainya sengaja disimpan di variabel. Dengan konstanta, konversi yang sama tidak bisa dikompilasi.

Konstanta diperiksa, variabel tidak

Mengonversi konstanta yang tidak muat adalah error kompilasi. Mengonversi variabel dengan nilai yang sama akan wrap tanpa peringatan:

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

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

Mengonversi konstanta bukan bilangan bulat ke tipe integer juga ditolak, sementara nilai yang sama di dalam variabel akan dipotong:

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

Kalau nilai float berada di luar jangkauan tipe integer tujuan (misalnya int64(1e20)), hasilnya bergantung pada implementasi: amd64 dan arm64, misalnya, memberi jawaban yang berbeda. Periksa jangkauannya sebelum mengonversi nilai yang tidak tepercaya.

Mengonversi angka ke string

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 menerima byte format ('f' untuk fixed, 'e' untuk eksponen, 'g' untuk mana pun yang lebih pendek), presisi (-1 berarti "digit paling sedikit yang tetap kembali ke nilai yang persis sama"), dan ukuran bit float aslinya (64 atau 32).

strconv lebih cepat daripada fmt.Sprint, yang membungkus nilainya dalam interface dan melewati jalur format umum milik fmt. Di perulangan yang sangat sering dijalankan, perbedaan itu terasa; untuk konversi yang sesekali, pilih mana yang lebih enak dibaca.

Mengonversi string ke angka

ParseInt selalu mengembalikan int64. Argumen bitSize (0, 8, 16, 32, 64) menentukan jangkauan yang diterima, jadi hasilnya dijamin muat saat kamu mengonversinya ke tipe yang lebih kecil. base 0 berarti "tebak dari prefix-nya", jadi 0x1f, 0o17, 0b101, dan 1_000 semuanya bisa dibaca.

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)
}

Hal yang ditunjukkan output-nya:

• " 42" gagal. Atoi menerima tanda opsional dan digit, tidak lebih. Input dari bufio biasanya diakhiri \n, jadi pangkas dulu.
• "4.2" tidak valid untuk Atoi. Pakai ParseFloat untuk bilangan desimal.
• Pada error di luar jangkauan, ParseInt mengembalikan nilai terbesar yang muat (127 untuk int8) bersama error-nya. Jangan pakai nilainya kalau error-nya bukan nil.
• Error-nya berupa nilai *strconv.NumError yang membungkus strconv.ErrSyntax atau strconv.ErrRange, jadi errors.Is bisa membedakannya.

ParseBool menerima 1, t, T, TRUE, true, True, dan bentuk false yang sepadan. "yes" dan "on" menghasilkan error.

Jebakan string(65)

Mengonversi integer ke string tidak menghasilkan digit. Hasilnya adalah karakter dengan code point Unicode tersebut:

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

Compiler menerimanya, tetapi go vet melaporkannya:

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

Kalau kamu memang menginginkan karakternya, tulis dengan jelas memakai rune: string(rune(n)). Kalau kamu ingin angkanya sebagai teks, pakai strconv.Itoa(n). Mengonversi rune atau byte ke string tidak masalah dan umum dilakukan:

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, byte, dan rune

string, []byte, dan []rune bisa saling dikonversi dengan T(v). Setiap konversi menyalin datanya, karena string bersifat immutable sedangkan slice tidak:

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
}

Konversikan ke []rune kalau kamu perlu mengakses indeks atau mengubah isi per karakter; konversikan ke []byte untuk I/O, hashing, dan perubahan di level byte. Halaman rune dan byte membahas UTF-8 secara detail.

Konversi vs type assertion

Konversi mengubah nilai dari satu tipe konkret ke tipe konkret lain. Mengambil nilai konkret dari sebuah interface (any, error, io.Reader) adalah operasi yang berbeda, yaitu 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

Lakukan assertion lebih dulu, baru konversi. Bentuk comma-ok n, ok := v.(int) mencegah panic kalau tipenya salah.

Referensi singkat

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