Trong ngôn ngữ lập trình Go, kiểu dữ liệu tham chiếu đến một hệ thống sâu rộng được sử dụng để khai báo biến hoặc hàm của các kiểu khác nhau. Kiểu của biến giúp xác định nó chiếm dụng bao nhiêu khoảng trống trong lưu trữ và làm thế nào các kiểu bit lưu trữ được biên dịch.
Sau đây là những kiểu dữ liệu cơ bản có sẵn trong Go
bool
Kiểu bool miêu tả một Boolean và là true hoặc false.
package main
import "fmt"
func main() {
a := true
b := false
fmt.Println("a:", a, "b:", b)
c := a && b
fmt.Println("c:", c)
d := a || b
fmt.Println("d:", d)
}
Trong ví dụ bên trên a được gán giá trị true, và b được gán giá trị false.
c được gán giá trị của a && b. Toán tử && chỉ trả về true khi cả a và b đều trả về true. Nên trong trường hợp này c là false
Toán tử || trả về true nếu a hoặc b là true. Trong trường hợp này d được gán là true bởi vì a là true
Kết quả
a: true b: false c: false d: true
Kiểu dữ liệu số
Chúng là các kiểu số học và đại diện cho các kiểu số nguyên interger, và giá trị kiểu floating trong suốt chương trình.
Kiểu số nguyên không dấu
| Kiểu | Miêu tả |
| uint8 | Miêu tả 8 bit số nguyên không dấu(0 đến 255) |
| uint16 | Miêu tả 16 bit số nguyên không dấu (0 đến 65535) |
| uint32 | Miêu tả 32 bit số nguyên không dấu (0 đến 4294967295) |
| uint64 | Miêu tả 64 bit số nguyên không dấu (0 đến 18446744073709551615) |
| uint | Miêu tả 32 hoặc 64 bit số nguyên không dấu (0 đến 4294967295 trong hệ thống 32 bit và 0 đến 18446744073709551615 trong hệ thống 64 bit) |
Kiểu số nguyên có dấu
| Kiểu | Miêu tả |
| int8 | Miêu tả 8 bit số nguyên có dấu(-128 đến 127) |
| int16 | Miêu tả 16 bit số nguyên có dấu (-32768 đến 32767) |
| int32 | Miêu tả 32 bit số nguyên có dấu (-2147483648 đến 2147483647) |
| int64 | Miêu tả 64 bit số nguyên có dấu (-9223372036854775808 đến 9223372036854775807) |
| int | Miêu tả 32 hoặc 64 bit số nguyên có dấu (-2147483648 đến 2147483647 trong hệ thống 32 bit và -9223372036854775808 đến 9223372036854775807 trong hệ thống 64 bit) |
package main
import "fmt"
func main() {
var a int = 89
b := 95
fmt.Println("value of a is", a, "and b is", b)
}
Kết quả
value of a is 89 and b is 95
Trong ví dụ trên thì a kiểu int. Kiểu của b được suy ra từ giá trị mà nó được gán 95. Như đã trình bày ở trên kiểu int là 32 bit trong hệ thống 32 bit và là 64 trong hệ thống 64 bit. Hãy cùng kiểm tra điều này.
Kiểu của một biến được in ra sử dụng chỉ định định dạng %T trong phương thức Printf. Go có một unsafe package và có hàm Sizeof trả về byte theo kích thước của biến được truyền cho nó. unsafe package nên được sử dụng cẩn thận bởi vì code sử dụng nó có thể có vấn đề về tính linh động, nhưng với mục đích cho bài viết này chúng ta sẽ sử dụng nó
Chương trình sau đưa ra kiểu và kích thước của cả 2 biến a và b. %T chỉ định định dạng để in ra kiểu và %d để in ra kích thước
package main
import (
"fmt"
"unsafe"
)
func main() {
var a int = 89
b := 95
fmt.Println("value of a is", a, "and b is", b)
fmt.Printf("type of a is %T, size of a is %d", a, unsafe.Sizeof(a)) //kiểu và kích thước của a
fmt.Printf("\ntype of b is %T, size of b is %d", b, unsafe.Sizeof(b)) //kiểu và kích thước của b
}
Kết quả
value of a is 89 and b is 95 type of a is int, size of a is 4 type of b is int, size of b is 4
Chúng ta có thể suy luận từ kết quả bên trên là a và b kiểu int, chúng có kích thước 32 bit (4 byte). Kết quả trên sẽ thay đổi nếu bạn chạy trong hệ thống 64 bit, a và b sẽ chiếm 64 bit (8 byte).
Kiểu Floating
| Kiểu | Miêu tả |
| float32 | 32 bit số dấu phẩy động |
| float64 | 64 bit số dấu phẩy động |
| complex64 | Số phức có phần thực và phần ảo float32 |
| complex128 | Số phức có phần thực và phần ảo float64 |
Hãy cùng xem ví dụ sau đây về kiểu Integer và Floating
package main
import (
"fmt"
)
func main() {
a, b := 5.67, 8.97
fmt.Printf("type of a %T b %T\n", a, b)
sum := a + b
diff := a - b
fmt.Println("sum", sum, "diff", diff)
no1, no2 := 56, 89
fmt.Println("sum", no1+no2, "diff", no1-no2)
}
Kiểu của a và b được suy ra từ các giá trị mà nó được gán. Trong trường hợp này a và b kiểu float64 (float64 là kiểu mặc định trong Floating). Chúng ta cộng a và b, sau đó gán cho biến sum. Chúng ta lấy a trừ b rồi gán cho biến diff. Sau đó sum và diff được in ra. Tính toán được làm tương tự với no1 và no2.
Kết quả
type of a float64 b float64 sum 14.64 diff -3.3000000000000007 sum 145 diff -33
Tiếp theo chúng ta sẽ cùng xem một ví dụ để hiểu rõ hơn về kiểu complex
package main
import (
"fmt"
)
func main() {
c1 := complex(5, 7)
c2 := 8 + 27i
cadd := c1 + c2
fmt.Println("sum:", cadd)
cmul := c1 * c2
fmt.Println("product:", cmul)
}
c1 và c2 là 2 số complex. c1 có 5 là phần thực và 7 là phần ảo. c2 có 8 là phần thực 27 là phần ảo. c1 và c2 được cộng vào nhau và gán cho cadd, c1 nhân với c2 và gán cho cmul.
Kết quả
sum: (13+34i) product: (-149+191i)
Kiểu số khác
Byte là cách gọi khác của uint8.
Rune là cách gọi khác của int32.
Kiểu string
String là một tập hợp các byte trong Golang. Không sao nếu định nghĩa này không có ý nghĩa gì. Chúng ta có thể coi một chuỗi là tập hợp các ký tự.
Hãy cùng xem ví dụ sau
package main
import (
"fmt"
)
func main() {
first := "Naveen"
last := "Ramanathan"
name := first +" "+ last
fmt.Println("My name is",name)
}
fist được gạn một chuỗi là “Naveen”. last cũng được gán một chuỗi là “Ramanathan”. Chúng ta có thể nối các string bằng cách sử dụng toán tử +. name được gán giá trị là kết quả của việc nối fist với khoảng trống và với last.
Kết quả
My name is Naveen Ramanathan
Chuyển đổi kiểu
Go rất nghiêm ngặt về kiểu rõ ràng. Không có chuyển đổi kiểu tự động. Hãy cùng xem ví dụ sau để hiểu rõ hơn
package main
import (
"fmt"
)
func main() {
i := 55 //int
j := 67.8 //float64
sum := i + j //int + float64 không cho phép
fmt.Println(sum)
}
Đoạn code trên là hợp lệ trong ngôn ngữ C. Nhưng trong trường hợp của Go, nó sẽ không chạy. i kiểu int và j kiểu float64. Nếu chúng ta thử cộng 2 số với kiểu khác nhau thì điều này là không được cho phép. Khi chạy thử chương trình trên thì kết quả lỗi nhận được như sau
main.go:10: invalid operation: i + j (mismatched types int and float64)
Để sửa lỗi, thì cả i và j nên cùng kiểu với nhau. Hãy chuyển đổi j thành int. T(v) là cú pháp chuyển đổi a giá trị v thành kiểu T
package main
import (
"fmt"
)
func main() {
i := 55 //int
j := 67.8 //float64
sum := i + int(j) //j được chuyển đổi thành int
fmt.Println(sum)
}
Kết quả giá trị 122 sẽ được in ra
Trường hợp tương tự, chuyển đổi kiểu rõ ràng được yêu cầu để gán một biến khác kiểu cho một biến khác.
package main
import (
"fmt"
)
func main() {
i := 10
var j float64 = float64(i) //Câu lệnh không chạy nếu không có chuyển đổi rõ ràng
fmt.Println("j", j)
}
Ở hàng thứ 9, i được chuyển đổi sang kiểu float64 và gán cho j. Khi bạn thử gán giá trị i cho j mà không chuyển đổi kiểu, trình biên dịch sẽ đưa ra một lỗi.
