Kiểu dữ liệu Golang: int, float64, string, bool, byte, rune

Các kiểu cơ bản của Go là số, boolean và chuỗi. Mỗi biến có đúng một kiểu dữ liệu (data type), cố định lúc biên dịch, và Go không bao giờ tự chuyển đổi giữa các kiểu cho bạn. %T in ra kiểu của bất kỳ giá trị nào:

package main

import "fmt"

func main() {
	count := 42
	price := 19.99
	name := "gopher"
	ok := true
	initial := 'G'
	raw := byte('G')
	z := 3 + 4i

	fmt.Printf("%-8v %T\n", count, count)
	fmt.Printf("%-8v %T\n", price, price)
	fmt.Printf("%-8v %T\n", name, name)
	fmt.Printf("%-8v %T\n", ok, ok)
	fmt.Printf("%-8v %T\n", initial, initial)
	fmt.Printf("%-8v %T\n", raw, raw)
	fmt.Printf("%v %T\n", z, z)
}

Để ý 'G' được in ra là 71 với kiểu int32: một ký tự trong dấu nháy đơn là một rune, tức là một con số (code point Unicode). rune là bí danh của int32 (cùng một kiểu với tên thứ hai), nên %T báo int32. Tương tự, byte báo uint8.

Số nguyên

Mặc định hãy dùng int. len() trả về int, chỉ số slice là int, và bộ đếm vòng lặp là int. Trên mọi nền tảng 64 bit, int là 64 bit. Chỉ dùng các kiểu có kích thước cố định khi kích thước là một phần của giao ước: int32 trong định dạng tệp nhị phân, uint8 cho byte thô, int64 cho Unix timestamp tính bằng nano giây.

Tránh dùng kiểu không dấu cho các đại lượng "không thể âm", như số đếm. Trừ quá số 0 sẽ quay vòng thành một số rất lớn thay vì tạo ra một số âm mà bạn bắt được.

Giới hạn và tràn số

Package math có một hằng số cho mỗi giới hạn. Lúc chạy, phép tính số nguyên bị tràn sẽ âm thầm quay vòng:

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxInt:  ", math.MaxInt)
	fmt.Println("MaxInt32:", math.MaxInt32)
	fmt.Println("MaxUint8:", math.MaxUint8)

	var small int8 = 127
	small++
	fmt.Println("127 + 1 as int8:", small)

	var u uint = 0
	u--
	fmt.Println("0 - 1 as uint:", u)

	var n int32 = math.MaxInt32
	fmt.Println("MaxInt32 * 2:", n*2)
}

Không panic, không lỗi: 127 + 1 thành -128. Chỉ các biểu thức hằng được kiểm tra lúc biên dịch (var b int8 = 128 không biên dịch được). Nếu dữ liệu của bạn có thể bị tràn, hãy kiểm tra trước phép tính hoặc dùng math/big.

Literal số nguyên

million := 1_000_000   // underscores for readability (Go 1.13+)
mask := 0xFF           // hexadecimal
perm := 0o755          // octal (also the older form 0755)
flags := 0b1010        // binary

Số thực

Một literal có dấu thập phân hoặc số mũ (2.5, 1e6) mặc định là float64, và package math nhận và trả về float64. Hãy dùng nó, trừ khi bộ nhớ của một mảng lớn là vấn đề.

Số thực được lưu ở dạng nhị phân, nên phần lớn phân số thập phân chỉ là giá trị xấp xỉ:

package main

import (
	"fmt"
	"math"
)

func main() {
	a := 0.1
	b := 0.2
	fmt.Println(a+b, a+b == 0.3)

	// compare with a tolerance instead
	fmt.Println(math.Abs((a+b)-0.3) < 1e-9)

	// integer division vs float division
	fmt.Println(7/2, 7.0/2, float64(7)/2)

	// special values
	zero := 0.0
	fmt.Println(1/zero, -1/zero, math.NaN())
}

Từ đó có hai quy tắc. Không bao giờ so sánh số thực bằng == sau khi tính toán. Và không bao giờ lưu tiền bằng số thực: hãy dùng số nguyên tính theo xu, hoặc một thư viện số thập phân.

Chia một số thực cho 0 cho ra +Inf, -Inf hoặc NaN thay vì gây panic. Chia một số nguyên cho 0 gây panic lúc chạy (runtime error: integer divide by zero), và số chia là hằng số 0 thì là lỗi biên dịch.

Boolean

bool chứa true hoặc false, và giá trị zero của nó là false. Go không coi số, chuỗi rỗng hay nil là boolean. if count {} là lỗi biên dịch; hãy viết if count > 0 {}. Các toán tử là &&, || và !, và && với || có tính đoản mạch.

Chuỗi

Một string là một dãy byte bất biến, thường là văn bản UTF-8. len(s) đếm byte, không phải ký tự:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "héllo"
	fmt.Println(len(s))                    // bytes
	fmt.Println(utf8.RuneCountInString(s)) // characters
	fmt.Println(s[0], string(s[0]))        // indexing gives a byte

	multiline := `raw string:
backslashes \n stay as written`
	fmt.Println(multiline)
}

é chiếm hai byte trong UTF-8, nên len báo 6 cho năm ký tự. Chuỗi trong dấu nháy kép xử lý các ký tự thoát như \n; chuỗi thô trong dấu backquote thì không, và có thể trải dài nhiều dòng. Trang về chuỗi trình bày package strings, còn trang rune và byte nói sâu về UTF-8.

byte và rune

Đây là bí danh, không phải kiểu mới: byte và uint8 dùng thay cho nhau được mà không cần chuyển kiểu. Cái tên cho biết con số đó mang ý nghĩa gì.

Số phức

Go có sẵn các kiểu số phức, complex64 và complex128, cùng real, imag và package math/cmplx:

package main

import (
	"fmt"
	"math/cmplx"
)

func main() {
	c := complex(3, 4) // complex128
	fmt.Println(c, real(c), imag(c))
	fmt.Println(cmplx.Abs(c))
	fmt.Println(cmplx.Sqrt(-1))
}

Ít chương trình cần đến chúng, nhưng xử lý tín hiệu và một số code tính toán số thì có.

Kiểu tổng hợp và kiểu tham chiếu

Các kiểu cơ bản kết hợp thành kiểu tổng hợp. Mỗi kiểu có trang riêng:

any là bí danh của interface{} (từ Go 1.18) và chứa được giá trị thuộc bất kỳ kiểu nào.

Kiểu có tên

Bạn có thể định nghĩa một kiểu mới từ một kiểu có sẵn. Nó có cùng cách biểu diễn nhưng là một kiểu riêng biệt, và có thể có phương thức:

type Celsius float64
type UserID int64

var t Celsius = 21.5
var f float64 = t // compile error: cannot use t (variable of float64 type Celsius) as float64 value in variable declaration

Sự chặt chẽ đó chính là mục đích: không thể vô tình truyền một UserID vào chỗ cần OrderID. Hãy chuyển kiểu tường minh khi bạn thực sự muốn: float64(t). Xem trang chuyển đổi kiểu để biết các quy tắc và các hàm strconv để chuyển qua lại giữa số và chuỗi.

Giá trị zero

Mọi kiểu đều có giá trị zero, là thứ một biến chứa trước khi bạn gán gì cho nó: 0 cho số, false cho bool, "" cho chuỗi, và nil cho con trỏ, slice, map, channel, hàm và interface. Trong Go không có biến chưa khởi tạo.