[Golang] Phần 4 – Go Variables

Biến (Variables) trong lập trình là một định danh hoặc tên được sử dụng để đặt tên cho một vùng bộ nhớ trong máy tính, nơi giá trị có thể được lưu trữ, đọc và sửa đổi. Biến chứa dữ liệu và có thể thay đổi giá trị trong quá trình thực thi của chương trình.

Trong Go và nhiều ngôn ngữ lập trình khác, mỗi biến có kiểu dữ liệu xác định, giúp xác định loại dữ liệu mà biến có thể chứa (ví dụ: số nguyên, số thực, chuỗi, boolean (true/false), v.v.).

Các biến cũng có thể được khai báo với hoặc không có giá trị khởi tạo ban đầu.

• Biến là gì?
  • Biến là các “container” được sử dụng để lưu trữ giá trị dữ liệu.
• Các loại bến trong Go.
  • int: Lưu trữ số nguyên (ví dụ: 123, -123).
  • float32: Lưu trữ số thực có dấu thập phân (ví dụ: 19.99, -19.99).
  • string: Lưu trữ chuỗi (ví dụ: “Hello World”). Chuỗi được bao quanh bởi dấu ngoặc kép.
  • bool: Lưu trữ giá trị với hai trạng thái: true hoặc false.

Khai báo (tạo) biến.

Có hai cách để khai báo biến trong Go:

Sử dụng var.

var variablename type = value

Sử dụng :=.

variablename := value

Bạn có thể chỉ định kiểu dữ liệu, giá trị hoặc chỉ định cả hai. Kiểu dữ liệu cũng có thể được phát hiện từ giá trị (compiler tự động quyết định kiểu dựa trên giá trị).

Lưu ý: Không thể khai báo một biến bằng dấu := mà không gán giá trị cho nó.

Khai báo biến với giá trị khởi tạo trong Go.

Nếu giá trị của biến là đã biết từ đầu, bạn có thể khai báo biến và gán giá trị cho nó trong cùng một dòng code.

Dưới đây là một ví dụ:

package main
import "fmt"

func main() {
  var student1 string = "John" // kiểu dữ liệu là string
  var student2 = "Jane"        // kiểu dữ liệu tự động phát hiện từ giá trị truyền vào
  x := 2                       // kiểu dữ liệu tự động phát hiện từ giá trị truyền vào

  fmt.Println(student1)
  fmt.Println(student2)
  fmt.Println(x)
}

Trong ví dụ này:

• student1 được khai báo với kiểu dữ liệu là string và được gán giá trị là “John”.
• student2 được khai báo mà không cần xác định kiểu dữ liệu, compiler tự động phát hiện kiểu dữ liệu từ giá trị “Jane”.
• x được khai báo và gán giá trị 2, kiểu dữ liệu của x cũng được phát hiện từ giá trị.

Sử dụng dấu := và kiểu dữ liệu được phát hiện từ giá trị của biến giúp làm cho code ngắn gọn hơn, giảm bớt sự lặp lại trong code.

Khai báo biến mà không có giá trị khởi tạo trong Go.

Nếu bạn khai báo một biến mà không gán giá trị khởi tạo, giá trị của nó sẽ được đặt thành giá trị mặc định của kiểu dữ liệu của biến đó.

Dưới đây là một ví dụ:

package main
import "fmt"

func main() {
  var a string
  var b int
  var c bool

  fmt.Println(a) // a được in ra là chuỗi rỗng ""
  fmt.Println(b) // b được in ra là số nguyên 0
  fmt.Println(c) // c được in ra là giá trị boolean false
}

Trong ví dụ này:

• Biến a là một chuỗi (string) và giá trị mặc định của nó là chuỗi rỗng "".
• Biến b là một số nguyên (int) và giá trị mặc định của nó là 0.
• Biến c là một giá trị boolean (bool) và giá trị mặc định của nó là false.

Việc này giúp tránh các giá trị nguyên bản không mong muốn khi bạn sử dụng biến mà không có giá trị được gán một cách rõ ràng.

Bạn có thể gán giá trị cho một biến sau khi nó đã được khai báo.

Điều này hữu ích trong những trường hợp mà giá trị không được biết ngay từ đầu.

package main
import "fmt"

func main() {
  var student1 string
  student1 = "John"
  fmt.Println(student1)
}

Trong ví dụ này:

• student1 được khai báo với kiểu dữ liệu là string nhưng không được gán giá trị ngay lập tức.
• Sau đó, giá trị “John” được gán cho student1.
• Cuối cùng, giá trị của student1 được in ra màn hình và sẽ là “John”.

Cách này cho phép bạn tạo ra biến mà giá trị của nó có thể thay đổi trong quá trình thực thi của chương trình.

Đối với cú pháp := trong Go, bạn phải gán giá trị cho biến ngay sau khi nó được khai báo. Cú pháp := giúp việc khai báo biến ngắn gọn hơn và bắt buộc bạn phải gán giá trị lúc khai báo biến, nếu bạn không gán giá trị, code sẽ không hợp lệ.

package main
import "fmt"

func main() {
  // Không thể sử dụng := mà không gán giá trị
  // var x := 10 // Lỗi: non-declaration statement outside function body
  // fmt.Println(x)
  
  // Để sử dụng :=, bạn phải gán giá trị ngay khi khai báo
  y := 20
  fmt.Println(y)
}

Trong ví dụ này, y được khai báo và gán giá trị là 20 cùng một lúc bằng cách sử dụng :=. Việc sử dụng := giúp làm cho code ngắn gọn và đảm bảo rằng biến được khởi tạo và có giá trị ngay từ đầu.

Sự khác biệt giữa var và := trong Go.

• Giới hạn sử dụng.
  • var: Có thể sử dụng cả bên trong và bên ngoài các functions.
  • :=: Chỉ có thể sử dụng bên trong các functions.
• Khai báo và gán giá trị.
  • var: Cho phép bạn khai báo một biến và gán giá trị cho nó sau đó. Có thể thực hiện khai báo và gán giá trị ở các dòng code khác nhau.
  • :=: Yêu cầu bạn khai báo và gán giá trị trong cùng một dòng code.

Dưới đây là một ví dụ để bạn thấy sự khác biệt:

package main
import "fmt"

// Khai báo globalVar sử dụng như biến toàn cục, có thể sử dụng bất cứ nơi nào trong dự án
var globalVar int

func main() {
  // Sử dụng var để khai báo và gán giá trị sau đó
  var a int
  a = 1

  // Sử dụng var để khai báo và gán giá trị ngay từ đầu
  var b int = 2

  // Sử dụng := để khai báo và gán giá trị ngay từ đầu
  c := 3

  fmt.Println(a)
  fmt.Println(b)
  fmt.Println(c)
}

Như bạn đã thấy, việc sử dụng := ngoài hàm (function) trong Go sẽ gây lỗi vì cú pháp này chỉ được phép sử dụng bên trong hàm.

Trong chương trình dưới đây, chúng ta khai báo a := 1 ngoài hàm main thì lỗi sẽ xuất hiện tại dòng a := 1 vì nó nằm bên ngoài hàm main vì Go không cho phép cú pháp khai báo biến := ở mức độ toàn cục.

package main
import ("fmt")

a := 1

func main() {
  fmt.Println(a)
}

Kết quả.

./prog.go:5:1: syntax error: non-declaration statement outside function body

Để khắc phục lỗi, bạn có thể sử dụng var để khai báo biến tại mức độ toàn cục:

package main

import "fmt"

var a = 1

func main() {
  fmt.Println(a)
}

Trong ví dụ này, a được khai báo tại mức độ toàn cục với giá trị khởi tạo là 1. Sau đó, hàm main có thể sử dụng a mà không gặp phải lỗi.

Khai báo nhiều biến trong cùng một dòng code.

Bạn có thể khai báo nhiều biến trong cùng một dòng code.

package main
import "fmt"

func main() {
  var a, b, c, d int = 1, 3, 5, 7

  fmt.Println(a)
  fmt.Println(b)
  fmt.Println(c)
  fmt.Println(d)
}

• Ở đây, a, b, c, và d là các biến kiểu số nguyên (int) và giá trị khởi tạo được gán sau mỗi biến.

Khai báo nhiều biến với các kiểu khác nhau.

package main
import "fmt"

func main() {
  var a, b = 6, "Hello"
  c, d := 7, "World!"

  fmt.Println(a)
  fmt.Println(b)
  fmt.Println(c)
  fmt.Println(d)
}

• Ở đây, a và b có kiểu là int và string, còn c và d được khai báo và gán giá trị ngay từ đầu, compiler tự phát hiện kiểu dữ liệu của chúng từ giá trị.

Lưu ý, nếu bạn khai báo biến có sử dụng type, bạn chỉ có thể khai báo một kiểu biến trên mỗi dòng code. Tuy nhiên, nếu không chỉ định kiểu biến thì bạn có thể khai báo nhiều biến với các kiểu khác nhau trong cùng một dòng code.

Nhóm nhiều khai báo biến cùng kiểu vào một khối.

Bạn có thể nhóm nhiều khai báo biến cùng kiểu vào một khối để làm cho code dễ đọc hơn.

Dưới đây là một ví dụ:

package main
import "fmt"

func main() {
   var (
     a int
     b int = 1
     c string = "hello"
   )

  fmt.Println(a)
  fmt.Println(b)
  fmt.Println(c)
}

Trong ví dụ này:

• a, b, và c đều được khai báo trong cùng một khối (var (...)).
• Biến a không có giá trị khởi tạo, nên giá trị mặc định của kiểu dữ liệu sẽ được sử dụng.
• Biến b được khai báo và gán giá trị là 1.
• Biến c được khai báo và gán giá trị là chuỗi “hello”.

Một số quy tắc đặt tên biến.

Một biến có thể có tên ngắn (như x và y) hoặc có tên mô tả hơn (như age, price, carname, v.v.).

• Quy tắc đặt tên biến trong Go:
  • Tên biến phải bắt đầu bằng một chữ cái hoặc ký tự gạch dưới (_).
  • Tên biến không thể bắt đầu bằng một chữ số.
  • Tên biến chỉ có thể chứa các ký tự chữ cái, số và gạch dưới (a-z, A-Z, 0-9, và _).
  • Tên biến phân biệt chữ hoa chữ thường (age, Age, và AGE là ba biến khác nhau).
  • Không có giới hạn độ dài cho tên biến.
  • Tên biến không thể chứa dấu cách.
  • Tên biến không được trùng với tên biến đặc biệt nào của Go.
• Đối với các biến có tên gồm nhiều từ, có một số kỹ thuật để làm cho chúng dễ đọc hơn:
  • Camel Case: Mỗi từ, ngoại trừ từ đầu tiên, bắt đầu bằng một chữ cái viết thường, các từ sau cùng bắt đầu bằng chữ cái viết hoa (ví dụ: myVariableName).
  • Pascal Case: Mỗi từ bắt đầu bằng một chữ cái viết hoa (ví dụ: MyVariableName).
  • Snake Case: Mỗi từ được phân tách bằng một ký tự gạch dưới (ví dụ: my_variable_name).

Việc tuân thủ các quy tắc đặt tên giúp làm cho mã nguồn của bạn trở nên dễ đọc và dễ hiểu hơn.