strconv

Dokumentasi resmi: strconv package - strconv - Go Packages

Package strconv mengimplementasikan konversi ke dan dari representasi string tipe data dasar.

Impor

import (
  "strconv"
)

Di bawah ini akan ditampilkan cara penggunaannya dalam bentuk contoh.

String ke Integer

func Atoi(s string) (int, error)

• s - String yang akan dikonversi

func TestAoti(t *testing.T) {
  ints, err := strconv.Atoi("456789")
  fmt.Println(ints, err)
}

=== RUN   TestAoti
456789 <nil>
--- PASS: TestAoti (0.00s)
PASS

Integer ke String

func Itoa(i int) string

• i - Angka integer yang akan dikonversi

func TestIota(t *testing.T) {
   str := strconv.Itoa(114)
   fmt.Println(str)
}

=== RUN   TestIota
114
--- PASS: TestIota (0.00s)
PASS

String ke Boolean

func ParseBool(str string) (bool, error)

• s - String yang akan dikonversi

String yang dapat dikonversi adalah sebagai berikut

"1", "t", "T", "true", "TRUE", "True" // true
"0", "f", "F", "false", "FALSE", "False" // false

func TestAtob(t *testing.T) {
   parseBool, err := strconv.ParseBool("1")
   fmt.Println(parseBool, err)

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

   b2, err := strconv.ParseBool("FALSE")
   fmt.Println(b2, err)
}

=== RUN   TestAotb
true <nil>
true <nil>
false <nil>
--- PASS: TestAotb (0.00s)
PASS

Boolean ke String

func FormatBool(b bool) string

• b - Nilai boolean

func TestBota(t *testing.T) {
   fmt.Println(strconv.FormatBool(true))
   fmt.Println(strconv.FormatBool(false))
}

=== RUN   TestBota
true
false
--- PASS: TestBota (0.00s)
PASS

Konversi ke String Go

Keduanya akan mengonversi string menjadi string Go yang diberi tanda kutip, perbedaannya adalah yang terakhir akan meng-escape karakter non-ASCII melalui \u.

func TestQuote(t *testing.T) {
  fmt.Println(strconv.Quote("hello 世界"))
  fmt.Println(strconv.QuoteToASCII("hello 世界"))
}

=== RUN   TestQuote
"hello 世界"
"hello \u4e16\u754c"
--- PASS: TestQuote (0.00s)
PASS

String ke Floating Point

func ParseFloat(s string, bitSize int) (float64, error)

• s - String yang akan dikonversi
• bitSize - Ukuran bit

func TestParseFloat(t *testing.T) {
   float, err := strconv.ParseFloat("1.145114", 64)
   fmt.Println(float, err)

   float, err = strconv.ParseFloat("2.3333333333333333333", 64)
   fmt.Println(float, err)
}

=== RUN   TestFloat
1.145114 <nil>
2.3333333333333335 <nil>
--- PASS: TestFloat (0.00s)
PASS

Floating Point ke String

Saat mengonversi floating point ke string,官方 memberikan beberapa format metode untuk output gaya yang berbeda.

// 'b' (-ddddp±ddd, eksponen biner),
// 'e' (-d.dddde±dd, eksponen desimal e kecil),
// 'E' (-d.ddddE±dd, eksponen desimal E besar),
// 'f' (-ddd.dddd, tanpa eksponen), // Umumnya menggunakan ini jika tidak ada kebutuhan khusus
// 'g' (Menggunakan format 'e' untuk eksponen besar, format 'f' untuk eksponen kecil),
// 'G' (Menggunakan format 'E' untuk eksponen besar, format 'f' untuk eksponen kecil),
// 'x' (-0xd.ddddp±ddd, fraksi heksadesimal dan eksponen biner),
// 'X' (-0Xd.ddddP±ddd, fraksi heksadesimal dan eksponen biner).

Fungsi konversi

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

• f - Mengacu pada floating point yang akan dikonversi
• fmt - Mengacu pada tipe format
• prec - Mengacu pada presisi, kecuali untuk kasus g/G yang menunjukkan digit signifikan maksimum, kasus lainnya menunjukkan berapa digit desimal yang dipertahankan,
• bitSize - Mengacu pada ukuran bit

Tentu saja, dalam kebanyakan kasus, langsung menggunakan f untuk mengonversi format desimal kecil adalah yang paling umum.

func TestFormatFloat(t *testing.T) {
   f := 1315643.14159261234567891011
   fmt.Println(strconv.FormatFloat(f, 'f', 6, 64))
   fmt.Println(strconv.FormatFloat(f, 'b', 6, 64))
   fmt.Println(strconv.FormatFloat(f, 'e', 6, 64))
   fmt.Println(strconv.FormatFloat(f, 'x', 6, 64))
   fmt.Println(strconv.FormatFloat(f, 'g', 6, 64))
   fmt.Println(strconv.FormatFloat(1.111, 'g', 6, 64))
}

=== RUN   TestFormatFloat
1315643.141593
5650644266346967p-32
1.315643e+06
0x1.4133b2p+20
1.31564e+06
1.111
--- PASS: TestFormatFloat (0.00s)
PASS

String ke Kompleks

func ParseComplex(s string, bitSize int) (complex128, error)

• s - String yang akan dikonversi
• bitSize - Ukuran bit

func TestParseComplex(t *testing.T) {
   fmt.Println(strconv.ParseComplex("1+2i", 128))
   fmt.Println(strconv.ParseComplex("1+2j", 128))
}

=== RUN   TestParseComplex
(1+2i) <nil>
(0+0i) strconv.ParseComplex: parsing "1+2j": invalid syntax
--- PASS: TestParseComplex (0.00s)
PASS

Kompleks ke String

func FormatComplex(c complex128, fmt byte, prec, bitSize int) string

c - Bilangan kompleks

fmt - Tipe format, lihat tipe format floating point

prec - Lihat presisi floating point

bitSize - Ukuran bit

func TestFormatComplex(t *testing.T) {
   fmt.Println(strconv.FormatComplex(complex(1.1, 12), 'f', 2, 128))
   fmt.Println(strconv.FormatComplex(complex(5.6, 2.8), 'b', 2, 128))
   fmt.Println(strconv.FormatComplex(complex(18.88999, 89.7), 'g', 2, 128))
}

=== RUN   TestFormatComplex
(1.10+12.00i)
(6305039478318694p-50+6305039478318694p-51i)
(19+90i)
--- PASS: TestFormatComplex (0.00s)
PASS

Menambahkan Data ke String

Di bahasa lain seperti Java, hasil dari "1"+1 adalah "11", Java akan secara otomatis menyelesaikan konversi tipe, sedangkan di Go operasi seperti ini tidak diizinkan karena kedua tipe data berbeda. Jadi perlu menggunakan fungsi Append di bawah strconv, parameter spesifiknya konsisten dengan fungsi konversi data di atas.

func TestAppend(t *testing.T) {
   bytes := []byte("Ada beberapa data di sini:")
   bytes = strconv.AppendInt(bytes, 10, 10)
   bytes = strconv.AppendFloat(bytes, 1.2222, 'f', 2, 64)
   bytes = strconv.AppendBool(bytes, false)
   fmt.Println(string(bytes))
}

=== RUN   TestAppend
Ada beberapa data di sini:101.22false
--- PASS: TestAppend (0.00s)
PASS