Bạn khai báo biến như thế nào và các kiểu cơ bản của Go là gì?

Question

Accepted Answer

Go là ngôn ngữ định kiểu tĩnh với nhiều cách khai báo biến. Cách phổ biến nhất là **khai báo ngắn** `:=`, cách này suy luận kiểu. Các kiểu cơ bản của Go bao gồm số, chuỗi, boolean và nhiều hơn nữa.

## Khai báo biến

```go
var x int = 42        // dạng đầy đủ: kiểu và giá trị tường minh
var y = 42            // kiểu được suy luận → int
var z int             // khai báo, mang giá trị ZERO (z = 0)

name := "Ann"         // khai báo ngắn (:=) — suy luận kiểu, CHỈ bên trong hàm
count := 10

var a, b = 1, "two"   // nhiều biến cùng lúc
const Pi = 3.14159     // hằng số (tại thời điểm biên dịch)
```

`:=` là cách dùng đúng kiểu (idiomatic) bên trong hàm — ngắn gọn với suy luận kiểu. `var` được dùng ở cấp package và khi bạn muốn một kiểu tường minh hoặc chỉ cần giá trị zero.

## Các kiểu cơ bản

```go
// số nguyên
int, int8, int16, int32, int64     // có dấu (int phụ thuộc nền tảng, thường 64-bit)
uint, uint8, ..., uint64           // không dấu
byte                                // bí danh cho uint8
rune                                // bí danh cho int32 — một Unicode code point

// dấu phẩy động
float32, float64                    // float64 là mặc định cho số thập phân

// khác
string                              // văn bản UTF-8 bất biến (immutable)
bool                               // true / false
complex64, complex128              // số phức
```

## Giá trị zero — không có biến "chưa khởi tạo"

```go
var i int       // 0
var f float64   // 0.0
var s string    // "" (rỗng)
var b bool      // false
var p *int      // nil
```

Một tính năng quan trọng của Go: mỗi biến được khai báo đều tự động nhận một **giá trị zero** hợp lý — không có giá trị undefined/rác. Điều này khiến code an toàn hơn và nghĩa là bạn thường có thể bỏ qua việc khởi tạo tường minh.

## Chuyển đổi kiểu là tường minh

```go
var i int = 42
var f float64 = float64(i)   // PHẢI chuyển đổi tường minh — không ép kiểu ngầm
var u uint = uint(f)
// i + f  → ❌ lỗi biên dịch: kiểu không khớp
```

Go yêu cầu chuyển đổi kiểu **tường minh** — nó không bao giờ trộn lẫn các kiểu một cách ngầm định, ngăn chặn một lớp các lỗi tinh vi.

## Tại sao điều này quan trọng

Hiểu cách khai báo biến và các kiểu của Go là nền tảng để viết bất kỳ đoạn Go nào.

Khai báo ngắn `:=` với suy luận kiểu giúp code ngắn gọn, trong khi `var` và hằng số phục vụ vai trò của chúng. **Đảm bảo giá trị zero** (mỗi biến được khởi tạo an toàn) là một tính năng đặc trưng, quan trọng của Go, loại bỏ các lỗi biến-chưa-khởi-tạo và định hình các pattern idiomatic (ví dụ, một struct mang giá trị zero thường vẫn dùng được).

Và việc Go nhấn mạnh **chuyển đổi kiểu tường minh** (không ép kiểu ngầm) là một lựa chọn an toàn có chủ đích, ngăn chặn các loại lỗi số thầm lặng mà các ngôn ngữ khác cho phép.

Biết các kiểu cơ bản (đặc biệt là `rune` cho Unicode, `byte`, và việc `int`/`float64` là mặc định) là kiến thức hàng ngày thiết yếu.