Golang int sang string, string sang int và ép kiểu

Go không bao giờ tự ngầm chuyển đổi kiểu. Bạn chuyển giữa các kiểu tương thích bằng T(v), và giữa số với văn bản bằng package strconv. Hai kiểu chuyển đổi được tìm nhiều nhất:

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") định dạng một int thành văn bản thập phân. strconv.Atoi ("ASCII to integer") phân tích văn bản thành một int và trả về lỗi khi văn bản không phải số hợp lệ. Luôn kiểm tra lỗi đó.

Chuyển đổi bằng T(v)

Cú pháp chuyển đổi của Go trông như một lời gọi hàm mang tên kiểu đích. Nó dùng được trong ba trường hợp:

1. giữa các kiểu số (int, int64, float64, uint8, ...),
2. giữa string và []byte hoặc []rune,
3. giữa các kiểu có chung kiểu nền (Celsius và 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)
}

Đọc kỹ kết quả:

• int(3.9) là 3 và int(-3.9) là -3. Chuyển đổi cắt bỏ phần thập phân về phía 0; nó không làm tròn. Hãy dùng math.Round, math.Floor hoặc math.Ceil trước để chọn cách xử lý. math.Round làm tròn số .5 ra xa số 0, nên -3.5 thành -4.
• uint8(300) là 44, vì chỉ 8 bit thấp được giữ lại (300 trừ 256), và int8(200) là -56 cũng vì lý do đó. Không có lỗi, không có panic.
• Celsius và float64 có chung kiểu nền, nên chuyển qua lại thoải mái, nhưng phải viết tường minh.

Các giá trị được đặt trong biến là có chủ ý. Với hằng số, cùng những phép chuyển đổi đó sẽ không biên dịch được.

Hằng số được kiểm tra, biến thì không

Chuyển một hằng số không vừa với kiểu đích là lỗi biên dịch. Chuyển một biến có cùng giá trị thì lặng lẽ bị tràn vòng:

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

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

Chuyển một hằng số không nguyên sang kiểu số nguyên cũng bị từ chối, trong khi cùng giá trị đó nằm trong biến thì bị cắt phần thập phân:

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

Nếu giá trị số thực nằm ngoài phạm vi của kiểu số nguyên đích (ví dụ int64(1e20)), kết quả phụ thuộc vào cài đặt: chẳng hạn amd64 và arm64 cho ra kết quả khác nhau. Hãy kiểm tra phạm vi trước khi chuyển đổi những giá trị không đáng tin.

Chuyển số sang chuỗi

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 nhận một byte định dạng ('f' cho dạng thập phân cố định, 'e' cho dạng số mũ, 'g' cho dạng nào ngắn hơn), một độ chính xác (-1 nghĩa là "ít chữ số nhất mà vẫn khôi phục chính xác được"), và kích thước bit của số thực gốc (64 hoặc 32).

strconv nhanh hơn fmt.Sprint, vì fmt.Sprint đóng gói giá trị vào một interface và đi qua đường định dạng tổng quát của fmt. Trong một vòng lặp chạy nhiều, khác biệt này thấy rõ; với những lần chuyển đổi thỉnh thoảng, chọn cách nào dễ đọc hơn là được.

Chuyển chuỗi sang số

ParseInt luôn trả về int64. Đối số bitSize (0, 8, 16, 32, 64) quy định phạm vi nó chấp nhận, nên kết quả chắc chắn vừa khi bạn chuyển xuống kiểu nhỏ hơn. base bằng 0 nghĩa là "suy ra từ tiền tố", nên 0x1f, 0o17, 0b101 và 1_000 đều phân tích được.

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

Những điều đầu ra cho thấy:

• " 42" thất bại. Atoi chỉ chấp nhận dấu tùy chọn và chữ số, không gì khác. Đầu vào từ bufio thường kết thúc bằng \n, nên hãy cắt nó đi.
• "4.2" không hợp lệ với Atoi. Dùng ParseFloat cho số thập phân.
• Khi gặp lỗi vượt phạm vi, ParseInt trả về giá trị lớn nhất còn vừa (127 với int8) kèm theo lỗi. Đừng dùng giá trị đó khi lỗi khác nil.
• Các lỗi là giá trị *strconv.NumError bọc strconv.ErrSyntax hoặc strconv.ErrRange, nên errors.Is phân biệt được chúng.

ParseBool chấp nhận 1, t, T, TRUE, true, True và các dạng false tương ứng. "yes" và "on" là lỗi.

Cái bẫy string(65)

Chuyển một số nguyên sang string không tạo ra chữ số. Nó tạo ra ký tự có code point Unicode đó:

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

Trình biên dịch chấp nhận, nhưng go vet sẽ báo:

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

Nếu bạn thật sự muốn lấy ký tự, hãy nói rõ bằng rune: string(rune(n)). Nếu bạn muốn con số dưới dạng văn bản, dùng strconv.Itoa(n). Chuyển một rune hoặc byte sang string thì hoàn toàn bình thường và rất hay gặp:

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
}

Chuỗi, byte và rune

string, []byte và []rune chuyển qua lại với nhau bằng T(v). Mỗi lần chuyển đổi đều sao chép dữ liệu, vì chuỗi là bất biến còn slice thì không:

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
}

Chuyển sang []rune khi bạn cần truy cập hoặc sửa theo từng ký tự; chuyển sang []byte cho I/O, băm và chỉnh sửa ở mức byte. Trang rune và byte trình bày chi tiết về UTF-8.

Chuyển đổi kiểu và type assertion

Chuyển đổi kiểu biến một giá trị từ kiểu cụ thể này sang kiểu cụ thể khác. Lấy giá trị cụ thể ra khỏi một interface (any, error, io.Reader) là một thao tác khác, gọi là 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

Assert trước, rồi mới chuyển đổi. Dạng comma-ok n, ok := v.(int) tránh được panic khi kiểu không đúng.

Tra cứu nhanh

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