Golang cơ bản: Kiểu dữ liệu và Toán tử (1/3)

Nếu bạn mới bắt đầu học Go, bạn đến đúng nơi rồi đấy.

Chán những ngôn ngữ lập trình chậm chạp, rườm rà khó học và khó sử dụng? Bạn đến đúng nơi... AGAIN!

Go là một ngôn ngữ lập trình hiện đại và nhẹ nhàng đang làm mưa làm gió trong thế giới phát triển phần mềm. Nó nhanh chóng, hiệu quả và dễ học, làm cho nó trở thành lựa chọn tuyệt vời cho các nhà phát triển ở mọi cấp độ.

Đủ từ rồi, Bắt đầu thôi nào.

Kiểu dữ liệu

Giống như bất kỳ ngôn ngữ lập trình nào khác, chúng ta đầu tiên bắt đầu với các loại dữ liệu.

Kiểu số

Các loại này bao gồm các kiểu số nguyên (ví dụ: int, int8, int16, int32, int64) và các kiểu số thực (ví dụ: float32, float64).

int

Kiểu int là kiểu số nguyên mặc định trong Go. Đây là kiểu số nguyên có dấu có kích thước ít nhất là 32 bit hoặc 64 bit, tùy thuộc vào kiến trúc cơ bản của máy mà mã chạy trên đó.

// int
a := 10
b := -5
c := a + b // 5

“Bạn có thể giải thích thêm về kích thước của kiểu int không?”

Trên máy tính có kiến trúc 32 bit, kiểu int có kích thước là 32 bit (4 byte), trong khi trên máy tính có kiến trúc 64 bit, kiểu int có kích thước là 64 bit (8 byte).

int8, int16, int32, int64

Nếu bạn cần chỉ định kích thước cố định cho một kiểu số nguyên, bạn có thể sử dụng một trong các kiểu số nguyên có kích thước cố định được cung cấp bởi Go: int8, int16, int32 hoặc int64.

// Kiểu int8 là kiểu số nguyên có dấu 8 bit. Nó có thể chứa giá trị từ -128 đến 127.
d := int8(127)
e := int8(-128)
f := d + e // -1

// Kiểu int16 là kiểu số nguyên có dấu 16 bit. Nó có thể chứa giá trị từ -32768 đến 32767.
g := int16(32767)
h := int16(-32768)
i := g + h // -1

// Kiểu int32 là kiểu số nguyên có dấu 32 bit. Nó có thể chứa giá trị từ -2147483648 đến 2147483647.
j := int32(2147483647)
k := int32(-2147483648)
l := j + k // -1

// Kiểu int64 là kiểu số nguyên có dấu 64 bit. Nó có thể chứa giá trị từ -9223372036854775808 đến 9223372036854775807.
m := int64(9223372036854775807)
n := int64(-9223372036854775808)
o := m + n // -1

Những loại này được định nghĩa có kích thước cố định bất kể kiến trúc cơ bản, do đó bạn có thể sử dụng chúng để lưu trữ số nguyên với kích thước cụ thể nếu cần thiết.

float32, float64

Các kiểu dữ liệu float32 và float64 đại diện cho số dấu phẩy động đơn và đôi chính xác tương ứng. Những kiểu dữ liệu này được sử dụng để biểu diễn các số thực, tức là các số có phần thập phân.

// Kiểu dữ liệu float32 là kiểu dấu phẩy động 32-bit.
p := float32(3.14159)
q := float32(2.71828)
r := p * q // r là 8.5397405

// Kiểu dữ liệu float64 là kiểu dấu phẩy động 64-bit. Nó được sử dụng để biểu diễn các giá trị có độ chính xác thập phân cao hơn.
s := float64(3.14159)
t := float64(2.71828)
u := s * t // u là 8.539728707423581

float32 hay float64 nên sử dụng loại nào?

float32 là kiểu dữ liệu đại diện cho số dấu phẩy động đơn. Đây là những số có phần thập phân, chẳng hạn như 3.14 hoặc 2.71828. Các số dấu phẩy động đơn được lưu trữ trong 4 byte (32 bit) của bộ nhớ và có thể biểu diễn một loạt các giá trị với độ chính xác tốt (khoảng 6-9 chữ số có ý nghĩa). Chúng thường nhanh hơn khi làm việc với các giá trị float64, nhưng có thể không chính xác bằng.

Ngoài ra, các kiểu float32 và float64 có các quy tắc cụ thể để xử lý các giá trị đặc biệt như vô cùng dương và âm và không phải là một số (NaN).

Kiểu Logic (Boolean)

Kiểu boolean đại diện cho giá trị đúng (true) hoặc sai (false).

a := true 
b := false 

if a { 
  fmt.Println("a là đúng") 
} else { 
  fmt.Println("a là sai") 
}

// a là đúng

Boolean thường được sử dụng trong các câu lệnh điều khiển như if và switch để thực hiện quyết định trong mã của bạn dựa trên tính đúng hay sai của một điều kiện.

Ví dụ, bạn có thể sử dụng boolean để kiểm tra xem trời có mưa hay không trước khi quyết định mang theo ô khi ra ngoài.

Kiểu chuỗi (String)

Chuỗi là một chuỗi các ký tự.

a := "hello"
b := "world"
c := a + " " + b // "hello world"

fmt.Println(a)        // "hello"
fmt.Println(b)        // "world"
fmt.Println(c)        // "hello world"
fmt.Println(len(a))   // 5 ('hello' is 5 characters)
fmt.Println(a[0])     // "h" (the first character of 'hello')
fmt.Println(a[1:3])   // "el"

Trong ví dụ này, chúng ta định nghĩa hai chuỗi a và b, và sau đó nối chúng với nhau bằng toán tử +. Chúng ta cũng sử dụng hàm len để lấy độ dài của chuỗi a và toán tử [] để truy cập vào từng ký tự riêng lẻ trong chuỗi a.

Chuỗi trong Go là bất biến (immutable), có nghĩa là sau khi bạn tạo một chuỗi, bạn không thể thay đổi các ký tự trong chuỗi đó. Tuy nhiên, bạn có thể tạo ra một chuỗi mới là phiên bản đã chỉnh sửa của chuỗi hiện có thông qua việc sử dụng thư viện "strings".

e := strings.ToUpper(a) // "HELLO"
f := strings.Repeat(a, 3) // "hellohellohello"

Mảng (Array)

Trong Go, một mảng là một bộ sưu tập có kích thước cố định của các giá trị cùng kiểu. Mỗi giá trị trong mảng được gọi là một phần tử, và mỗi phần tử có chỉ số riêng, đó là vị trí của nó trong mảng. Bạn có thể truy cập vào một phần tử cụ thể trong mảng bằng cách sử dụng chỉ số của nó trong dấu ngoặc vuông, như sau:

var a [3]int // a is an array of 3 int
a[0] = 1     // set the first element of a to 1
a[1] = 2     // second element is 2
a[2] = 3     // third element is 3

fmt.Println(a[0]) // 1
fmt.Println(a[1]) // 2
fmt.Println(a[2]) // 3
fmt.Println(len(a)) // 3 (a is an array of 3 int)

// short declaration syntax to create and initialize an array
b := [3]int{1, 2, 3}

Kích thước của mảng (số lượng phần tử mà nó có thể chứa) là một phần của kiểu của nó, do đó bạn không thể thay đổi kích thước của một mảng sau khi bạn đã tạo nó. Bạn có thể sử dụng hàm len để lấy độ dài của một mảng tại thời điểm chạy.

Slice (Mảng cắt)

Khác với mảng có kích thước cố định, slice (mảng cắt) là một mảng động có thể mở rộng hoặc co lại theo nhu cầu.

Slice là một giải pháp linh hoạt và hiệu quả hơn so với mảng khi bạn cần lưu trữ và xử lý một số lượng biến đổi của các giá trị cùng loại.

a := make([]int, 3) // a is a slice of 3 integers
a[0] = 1            // first element is 1
a[1] = 2            // second element is 2
a[2] = 3            // third element is 3

// we can append more int to a, after this line, a is: [1, 2, 3, 4]
a = append(a, 4) 

fmt.Println(a[3]) // 4, fourth element is 4
fmt.Println(len(a)) // 4, a have 4 ints

// short declaration syntax to create and initialize a slice
b := []int{1, 2, 3}

Còn nhiều điều để nói về mảng cắt, nhưng nó không nằm trong phạm vi của bài học này.

Struct (Cấu trúc)

Struct hữu ích khi bạn cần biểu diễn các cấu trúc dữ liệu phức tạp có nhiều thuộc tính hoặc thuộc tính.

Trong Go, struct là một kiểu dữ liệu tùy chỉnh có thể chứa một kết hợp của các kiểu trường khác nhau:

type Person struct {
    Name string
    Age int
    Address string
}

// create a person struct instance is simple
p := Person{
  Name: "Jane Smith", 
  Age: 25, 
  Address: "456 Maple Ave."
}

fmt.Println(p.Name) // "John Smith"

// struct also has its own method (or action)
func (p *Person) Greet() string {
    return "Hello, my name is " + p.Name
}

fmt.Println(p.Greet()) // "Hello, my name is John Smith"

Pointers (Con trỏ)

Con trỏ hữu ích khi bạn muốn chuyển địa chỉ bộ nhớ của một giá trị cho một hàm hoặc khi bạn muốn sửa đổi giá trị của một biến một cách gián tiếp.

Nếu bạn mới làm quen với khái niệm con trỏ, có thể sẽ khó tưởng tượng, trong Go, một con trỏ là một biến lưu trữ địa chỉ bộ nhớ của một giá trị.

Hãy xem ví dụ bên dưới rồi đọc giải thích của mình nhé.

a := 1
b := &a // b is point to a's memory

fmt.Println(a) // 1
fmt.Println(*b) // 1, the * operator point to the value that memory holding

*b = 2 // set the value of a through the pointer b

fmt.Println(a) // 2
fmt.Println(*b) // 2

Trong ví dụ này, chúng ta khai báo một biến số nguyên a và gán giá trị là 1. Sau đó, chúng ta tạo một con trỏ b trỏ tới a bằng toán tử &.

Toán tử * được sử dụng để giải tham chiếu con trỏ b và truy cập giá trị của a. Sau đó, chúng ta sử dụng toán tử * để thiết lập giá trị của a thành 2 thông qua con trỏ b.

Function

function là một khối mã thực hiện một nhiệm vụ cụ thể và có thể được gọi từ các phần khác của chương trình.

Chức năng có thể được coi như giá trị và có thể được gán cho các biến hoặc được truyền như tham số cho các chức năng khác. Điều này được gọi là "first-class function" trong Go.

func Add(x int, y int) int {
    return x + y
}

func Multiply(x, y int) int {
    return x * y
}

// `operation` now work like an `Add` function
operation := Add 
fmt.Println(operation(1, 2)) // 3

// `operation` now work like an `Multiply` function
operation = Multiply
fmt.Println(operation(3, 4)) // 12

// what type of operation?
fmt.Println(reflect.TypeOf(operation)) // func(int, int) int

Như bạn có thể thấy, type của operation là func(int, int) int, điều này gọi là chữ ký (signature) của hàm (function).

Biến và hằng số (Constants)

Variables

Trong Go, biến và hằng số được sử dụng để lưu trữ và thao tác các giá trị trong chương trình.

Biến được sử dụng để lưu trữ các giá trị có thể thay đổi trong quá trình thực thi của chương trình. Để tạo một biến trong Go, bạn sử dụng từ khóa var, tiếp theo là tên biến và kiểu giá trị mà nó sẽ lưu trữ. Dưới đây là một ví dụ:

var x int

Code này tạo một biến x có kiểu int, có thể lưu trữ các giá trị số nguyên. Bạn cũng có thể chỉ định giá trị khởi tạo ban đầu cho biến khi bạn khai báo nó:

var x int = 5

Go cũng cung cấp cú pháp ngắn hơn để khai báo và khởi tạo biến, gọi là "khai báo biến ngắn gọn." Bạn có thể sử dụng cú pháp này bằng cách thay thế từ khóa var bằng toán tử :=:

x := 5

Constants

Hằng số được sử dụng để lưu trữ các giá trị không thể thay đổi trong quá trình thực thi của chương trình. Để tạo một hằng số, bạn sử dụng từ khóa const, tiếp theo là tên hằng số và kiểu giá trị mà nó sẽ lưu trữ. Dưới đây là một ví dụ:

const pi float64 = 3.14

Code này tạo một hằng số pi có kiểu float64, có thể lưu trữ các giá trị thập phân. Tương tự như biến, bạn cũng có thể chỉ định giá trị khởi tạo ban đầu cho hằng số khi bạn khai báo nó.

Việc sử dụng hằng số khi bạn cần lưu trữ các giá trị không thay đổi, nó giúp làm cho code của bạn dễ dàng dự đoán và dễ hiểu hơn. Sử dụng hằng số cũng giúp bạn tránh những lỗi lập trình phổ biến và cải thiện code performance.

Toán tử và biểu thức

Như bạn có thể biết, toán tử là những ký tự đặc biệt thực hiện các phép toán cụ thể trên một hoặc nhiều giá trị (toán hạng) và tạo ra một kết quả.

Toán tử số học

Go hỗ trợ các toán tử số học sau:

• +: Toán tử cộng. Cộng hai toán hạng và tạo ra tổng.
• -: Toán tử trừ. Trừ toán hạng thứ hai từ toán hạng đầu tiên và tạo ra hiệu.
• *: Toán tử nhân. Nhân hai toán hạng và tạo ra tích.
• /: Toán tử chia. Chia toán hạng đầu tiên cho toán hạng thứ hai và tạo ra thương.
• %: Toán tử chia lấy phần dư. Chia toán hạng đầu tiên cho toán hạng thứ hai và tạo ra phần dư.

Dưới đây là một số ví dụ về cách sử dụng những toán tử này trong Go:

x := 10
y := 3

// Addition
z := x + y // 13
// Subtraction
z = x - y // 7
// Multiplication
z = x * y // 30
// Division
z = x / y // 3
// Modulus
z = x % y // 1

Toán tử nhân và chia có độ ưu tiên cao hơn so với toán tử cộng và trừ, vì vậy chúng được thực hiện trước các phép toán này.

Bạn có thể sử dụng dấu ngoặc đơn để ghi đè độ ưu tiên mặc định và chỉ định thứ tự thực hiện các phép toán.

Toán tử so sánh

Các toán tử so sánh so sánh hai giá trị và trả về một giá trị boolean chỉ ra liệu phép so sánh đó đúng hay sai.

• ==: Toán tử bằng. Trả về true nếu hai toán hạng bằng nhau, ngược lại trả về false.
• !=: Toán tử khác. Trả về true nếu hai toán hạng không bằng nhau, ngược lại trả về false.
• >: Toán tử lớn hơn. Trả về true nếu toán hạng đầu tiên lớn hơn toán hạng thứ hai, ngược lại trả về false.
• <: Toán tử nhỏ hơn. Trả về true nếu toán hạng đầu tiên nhỏ hơn toán hạng thứ hai, ngược lại trả về false.
• >=: Toán tử lớn hơn hoặc bằng. Trả về true nếu toán hạng đầu tiên lớn hơn hoặc bằng toán hạng thứ hai, ngược lại trả về false.
• <=: Toán tử nhỏ hơn hoặc bằng. Trả về true nếu toán hạng đầu tiên nhỏ hơn hoặc bằng toán hạng thứ hai, ngược lại trả về false.

Hãy xem ví dụ dưới đây:

x := 10
y := 3

// Equal to
z := x == y // false

// Not equal to
z = x != y // true

// Greater than
z = x > y // true

// Less than
z = x < y // false

// Greater than or equal to
z = x >= y // true

// Less than or equal to
z = x <= y // false

Các toán tử so sánh chỉ hoạt động với các giá trị cùng loại. Nếu so sánh các giá trị khác loại sẽ dẫn đến lỗi biên dịch.

Toán tử logic

Các toán tử logic thực hiện logic boolean và trả về một giá trị boolean.

• &&: Toán tử VÀ logic. Trả về true nếu cả hai toán hạng đều đúng, false nếu không.
• ||: Toán tử HOẶC logic. Trả về true nếu một trong hai toán hạng đúng, false nếu cả hai đều sai.
• !: Toán tử KHÔNG logic. Trả về true nếu toán hạng là sai, false nếu toán hạng là đúng.

x := true
y := false

// Logical AND
z := x && y // z = false

// Logical OR
z = x || y // z = true

// Logical NOT
z = !x // z = false

Cần lưu ý rằng toán tử VÀ và HOẶC logic có độ ưu tiên thấp hơn so với các toán tử so sánh, vì vậy chúng sẽ được thực hiện sau các phép so sánh.

Toán tử gán

Bạn có thể đoán kết quả của toán tử gán dựa trên toán tử số học tương ứng.

• =: Toán tử gán đơn giản. Gán giá trị của toán hạng bên phải cho toán hạng bên trái.
• +=, -=, /=, *=, %=: Toán tử gán. Tính giá trị của toán hạng bên phải và gán kết quả cho toán hạng bên trái.

x := 10
y := 3

// Simple assignment
x = y // 3

// Addition assignment
x += y // 6, x = x + y

// Subtraction assignment
x -= y // 3, x = x - y

// Multiplication assignment
x *= y // 9, x = x * y

// Division assignment
x /= y // 3, x = x / y

// Modulus assignment
x %= y // x = 0, x = x % y

Toán tử bitwise

Các toán tử bitwise trong Go giống như các công cụ trong toolbox của chúng ta - cho phép bạn làm việc với các bit riêng lẻ trong một giá trị để xây dựng các cấu trúc phức tạp hơn.

Tương tự như cách bạn có thể sử dụng tua vít, búa và cưa để xây dựng một kệ sách, bạn có thể sử dụng các toán tử bitwise để thao tác các bit trong một giá trị như thiết lập hoặc xóa các bit cụ thể, hoặc kiểm tra xem một bit cụ thể có được thiết lập không.

• &: Toán tử AND bitwise. Toán tử này so sánh từng bit của toán hạng đầu tiên với bit tương ứng của toán hạng thứ hai, và nếu cả hai bit đều là 1, bit kết quả tương ứng sẽ được thiết lập là 1. Ngược lại, bit kết quả sẽ được thiết lập là 0.
• |: Toán tử OR bitwise. Toán tử này so sánh từng bit của toán hạng đầu tiên với bit tương ứng của toán hạng thứ hai, và nếu một trong hai bit là 1, bit kết quả tương ứng sẽ được thiết lập là 1. Ngược lại, bit kết quả sẽ được thiết lập là 0.
• ^: Toán tử XOR bitwise. Toán tử này so sánh từng bit của toán hạng đầu tiên với bit tương ứng của toán hạng thứ hai, và nếu hai bit khác nhau, bit kết quả tương

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

x := 10 // 1010 in binary
y := 3  // 0011 in binary

z := x & y // 2, 0010 in binary
z = x | y // 11, 1011 in binary
z = x ^ y // 9, 1001 in binary

Kết

Bài viết được dịch từ: https://medium.com/@func25/a-comprehensive-golang-guide-for-beginners-go-fundamentals-p1-2b4109ce2a7c