strconv

Tài liệu chính thức: strconv package - strconv - Go Packages

Gói strconv thực hiện chuyển đổi giữa chuỗi và các kiểu dữ liệu cơ bản

Nhập

import (
  "strconv"
)

Dưới đây sẽ trình bày cách sử dụng thông qua các ví dụ.

Chuyển chuỗi sang số nguyên

func Atoi(s string) (int, error)

• s - Chuỗi cần chuyển đổi

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

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

Chuyển số nguyên sang chuỗi

func Itoa(i int) string

• i - Số nguyên cần chuyển đổi

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

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

Chuyển chuỗi sang boolean

func ParseBool(str string) (bool, error)

• s - Chuỗi cần chuyển đổi

Các chuỗi có thể chuyển đổi như sau

"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

Chuyển boolean sang chuỗi

func FormatBool(b bool) string

• b - 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

Chuyển sang chuỗi Go

Cả hai đều chuyển chuỗi thành chuỗi Go có dấu ngoặc kép, điểm khác biệt là cái sau sẽ escape ký tự không phải ASCII thông qua \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

Chuyển chuỗi sang số dấu phẩy động

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

• s - Chuỗi cần chuyển đổi
• bitSize - Số 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

Chuyển số dấu phẩy động sang chuỗi

Khi chuyển đổi số dấu phẩy động, chính thức đưa ra một số định dạng để xuất ra các kiểu dáng khác nhau.

// 'b' (-ddddp±ddd, số mũ nhị phân),
// 'e' (-d.dddde±dd, số mũ thập phân chữ thường e),
// 'E' (-d.ddddE±dd, số mũ thập phân chữ hoa E),
// 'f' (-ddd.dddd, không có số mũ), // Không có yêu cầu đặc biệt thường dùng cái này
// 'g' (dùng định dạng 'e' cho số mũ lớn, dùng định dạng 'f' cho số mũ nhỏ),
// 'G' (dùng định dạng 'E' cho số mũ lớn, dùng định dạng 'f' cho số mũ nhỏ),
// 'x' (-0xd.ddddp±ddd, phân số thập lục phân và số mũ nhị phân),
// 'X' (-0Xd.ddddP±ddd, phân số thập lục phân và số mũ nhị phân).

Hàm chuyển đổi

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

• f - Số dấu phẩy động cần chuyển đổi
• fmt - Kiểu định dạng
• prec - Độ chính xác, ngoại trừ trường hợp g/G là số chữ số có nghĩa tối đa, các trường hợp khác đều là số chữ số sau dấu phẩy động
• bitSize - Số bit

Tất nhiên thông thường đều dùng f để chuyển đổi định dạng số thập phân là nhiều nhất.

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

Chuyển chuỗi sang số phức

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

• s - Chuỗi cần chuyển đổi
• bitSize - Số 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

Chuyển số phức sang chuỗi

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

c - Số phức

fmt - Kiểu định dạng, tham khảo kiểu định dạng số dấu phẩy động

prec - Tham khảo độ chính xác số dấu phẩy động

bitsize - Số 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

Nối thêm dữ liệu vào chuỗi

Trong các ngôn ngữ khác như Java, kết quả của "1"+1 là "11", Java sẽ tự động hoàn thành chuyển đổi kiểu, còn trong Go thao tác như vậy không được phép vì kiểu dữ liệu của cả hai khác nhau. Vì vậy cần sử dụng hàm Append trong strconv, các tham số cụ thể giống với hàm chuyển đổi dữ liệu tương ứng ở trên.

func TestAppend(t *testing.T) {
   bytes := []byte("Ở đây có một số dữ liệu:")
   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
Ở đây có một số dữ liệu:101.22false
--- PASS: TestAppend (0.00s)
PASS