Packages

Giới thiệu

• Packages(Gói) trong Go là một cách để tổ chức và tái sử dụng trong source code.
• Packages cho phép phân chia source code thành các phần nhỏ hơn, giúp dễ dàng quản lý code trong dự án
• Trong Golang, mỗi file đều thuộc một package. Tên của package là tên thư mục chứa file đó.

Sử dụng

• Để sử dụng các chức năng từ một package khác, bạn cần import package đó vào file của mình. Cú pháp:
  import "tên_package" \

  Ví dụ: Import "fmt" để sử dụng các chức năng in và định dạng trong package fmt.

  Theo quy ước, tên gói giống với phần tử cuối cùng của đường dẫn nhập. Ví dụ: gói "math/rand" bao gồm các tệp bắt đầu bằng gói câu lệnh rand.

  package main import ( "fmt" "math/rand"
  )
  func main() { fmt.Println("My lucky number is", rand.Intn(100))
  } 

• Go cung cấp nhiều packages chuẩn giúp thực hiện các công việc phổ biến như định dạng in ra đọc ghi file, network,...

• Ngoài việc sử dụng các packages chuẩn, bạn có thể tạo và sử dụng các packages do chính bạn định nghĩa bằng cách file của mình trong cùng một thư mục và đặt tên thư mục là tên của package.

• Trong các dự án lớn, việc quản lý dependency giữa các packages là rất quan trọng. Go modules là một cách để quản lý dependency và phiên bản của các packages.

Exported names

• Trong Go, một tên được export nếu nó bắt đầu bằng một chữ cái viết hoa. Ví dụ, "Hello" là một tên được export, cũng như "Pi", được export từ package "math".
• "hello" và "pi" không bắt đầu bằng một chữ cái viết hoa, vì vậy chúng không được export.
• Khi import một package, bạn chỉ có thể tham chiếu đến các tên được export của nó. Bất kỳ tên không được export(unexported) nào đều không thể truy cập từ bên ngoài package. Ví dụ:

// Trong file math.go
package math // Pi là một biến được export
const Pi = 3.14159 // pizza là một biến không được export
var hello = "Xin chào" // CalculateArea là một hàm được export
func CalculateArea(radius float64) float64 { return Pi * radius * radius
} // calculateVolume là một hàm không được export
func calculateVolume(radius float64) float64 { return (4.0 / 3.0) * Pi * radius * radius * radius
}

Functions

• Một function(hàm) có thể nhận không hoặc nhiều hơn một đối số.

// Hàm nhận 1 đối số
func greet(name string) { fmt.Println("Hello,", name)
} // Hàm không nhận đối số
func main() { greet("Alice")
}

• Functions continued: Khi hai hoặc nhiều tham số liên tiếp trong hàm có cùng một kiểu dữ liệu, bạn có thể bỏ qua kiểu dữ liệu ở tất cả trừ tham số cuối cùng.

// x int, y int có thể viêt ngắn thành x, y int
func add(a, b int) int { return a + b
} func main() { sum := add(3, 5) fmt.Println("Sum:", sum)
}

• Multiple results: Một hàm có thể trả về đồng thời nhiều kết quả

// Hàm divide trả về 2 giá trị
// 1: Kiểu float64: Kết quả a/b hoặc 0
// 2: error: một error hoặc nil
func divide(a, b float64) (float64, error) { if b == 0 { return 0, errors.New("cannot divide by zero") } return a / b, nil
} func main() { result, err := divide(10, 2) if err != nil { fmt.Println("Error:", err) return } fmt.Println("Result:", result)
}

• Named return values: Giá trị trả về của hàm trong Go có thể được đặt tên, các tên này nên được sử để mô tả ý nghĩa của giá trị trả về. Một return mà không có đối số trả về sẽ trả về các giá trị được đặt tên, điều này được gọi là "naked" return. Thường nó sẽ được sử dụng trong các hàm ngắn.

func split(sum int) (x, y int) { x = sum * 2 / 10 y = sum - x return
} func main() { fmt.Println(split(30)) // kết quả: 6 24
}

Variables

Khai báo và khởi tạo

• Khai báo variables(biến): Câu lệnh "var", có thể khai báo một hoặc nhiều biến
• Kiểu dữ liệu của biến được đặt ở cuối cùng sau tên biến Ví dụ:

var age int
var name string
var isActive bool

• Khởi tạo: Khởi tạo biến bằng cách gán giá trị cho biến sau dấu "=" Ví dụ:

var age int = 30
var name string = "Jim John"
var isActive bool = true

• Khai báo biến ngắn gọn: câu lệnh gán ngắn := có thể được sử dụng thay cho khai báo var với kiểu ẩn. Ví dụ:

age := 30
name := "Jim John"
isActive := true

Lưu ý: Cách khai báo biến này chỉ có thể dùng ở trong 1 hàm.

Các loại biến cơ bản

I - Số

Các số được chia thành ba loại con như sau:
1. Số nguyên (Integer)
Cả số nguyên có dấu và không dấu đều có sẵn trong bốn kích thước khác nhau như được hiển thị trong bảng dưới đây. Số nguyên có dấu được biểu diễn bằng int và số nguyên không dấu được biểu diễn bằng uint.
Các phép toán số học có thể thực hiện: Cộng, trừ, nhân, chia, phần dư

Ví dụ:

 // Using 8-bit unsigned int var a uint8 = 225 fmt.Println(a, a-3) // Using 16-bit signed int var b int16 = 32767 fmt.Println(b+2, b-2) fmt.Println("Example of arithmetic operations:") var x int16 = 170 var y int16 = 83 //Addition fmt.Printf(" addition : %d + %d = %d\n ", x, y, x+y) //Subtraction fmt.Printf("subtraction : %d - %d = %d\n", x, y, x-y) //Multiplication fmt.Printf(" multiplication : %d * %d = %d\n", x, y, x*y) //Division fmt.Printf(" division : %d / %d = %d\n", x, y, x/y) //Modulus fmt.Printf(" remainder : %d %% %d = %d\n", x, y, x%y)

Output:

225 222
-32767 32765
Example of arithmetic operations: addition : 170 + 83 = 253 subtraction : 170 - 83 = 87 multiplication : 170 * 83 = 14110 division : 170 / 83 = 2 remainder : 170 % 83 = 4

2. Số thực (Float)
Số thực được chia thành 2 loại như bảng dưới. Các phép toán số học có thể thực hiện: Cộng, trừ, nhân, chia.

Ví dụ:

 a := 20.45 b := 34.89 c := b-a // Display the result fmt.Printf("Result is: %f", c) // Display the type of c variable fmt.Printf("\nThe type of c is : %T", c) 

Output:

Result is: 14.440000
The type of c is : float64

3. Số phức (Complex)
Số phức (Complex Numbers): Các số phức được chia thành hai phần như được hiển thị trong bảng dưới đây. float32 và float64 cũng là một phần của các số phức này. Hàm tích hợp sẵn tạo ra một số phức từ phần ảo và phần thực của nó và hàm ảo và thực tích hợp sẵn trích xuất các phần đó.

Ví dụ:

 var a complex128 = complex(6, 2) var b complex64 = complex(9, 2) fmt.Println(a) fmt.Println(b) // Display the type fmt.Printf("The type of a is %T and "+ "the type of b is %T", a, b)

Output:

(6+2i)
(9+2i)
The type of a is complex128 and the type of b is complex64

II - Booleans

Kiểu dữ liệu boolean đại diện cho chỉ một bit thông tin có thể là true hoặc false. Các giá trị của kiểu boolean không được chuyển đổi một cách ngầm định hoặc rõ ràng sang bất kỳ kiểu dữ liệu nào khác.
Ví dụ:

 // variables str1 := "GolangEssentials" str2:= "golangEssentials" str3:= "golangessentials" result1:= str1 == str2 result2:= str1 == str3 // Display the result fmt.Println( result1) fmt.Println( result2) // Display the type of // result1 and result2 fmt.Printf("The type of result1 is %T and "+ "the type of result2 is %T", result1, result2)

Output:

false
false
The type of result1 is bool and the type of result2 is bool

II - Strings

Kiểu dữ liệu chuỗi (string) đại diện cho một chuỗi các điểm mã Unicode. Hay nói cách khác, ta có thể nói rằng một chuỗi là một chuỗi các byte không thể thay đổi, có nghĩa là một khi một chuỗi đã được tạo ra thì bạn không thể thay đổi chuỗi đó. Một chuỗi có thể chứa dữ liệu tùy ý, bao gồm cả byte có giá trị không trong dạng có thể đọc được cho con người. Các chuỗi có thể được ghép lại bằng toán tử cộng (+).
Ví dụ:

 // str variable which stores strings str := "GolangEssentials" // Display the length of the string fmt.Printf("Length of the string is:%d",len(str)) // Display the string fmt.Printf("\nString is: %s", str) // Display the type of str variable fmt.Printf("\nType of str is: %T", str)

Output:

Length of the string is:16
String is: GolangEssentials
Type of str is: string

Một số lưu ý

• Default value: Các biến được khai báo mà không có giá trị khởi tạo rõ ràng sẽ được gán giá trị default: 0 đối với kiểu số, false đối với kiểu bolean và ""(the empty string) với chuỗi

 var i int var f float64 var b bool var s string fmt.Printf("%v %v %v %q\n", i, f, b, s)

Output:

0 0 false ""

• Ép kiểu: Trong Go, các kiểu dữ liệu có thể chuyển đổi bằng cách sử dụng toán tử type(value) \

 a := 5 //int b := 3.4 //float64 sumFloat := float64(a) + b fmt.Println(sumFloat) // Output = 8.4 sumInt := a + int(b) fmt.Println(sumInt) // Output = 8

• Hằng số(constants): Hằng số được khai báo giống như biến, nhưng sử dụng từ khóa const. Hằng số có thể là ký tự, chuỗi, boolean, hoặc giá trị số. Không thể khai báo hằng số bằng cú pháp :=. package main

import "fmt"

const Pi = 3.14

func main() { const World = "Jim John" fmt.Println("Hello", World) fmt.Println("Happy", Pi, "Day")

const Truth = true
fmt.Println("Go rules?", Truth)

}

Kết bài

Trong bài thứ 2 này mình đã giới thiệu với các bạn những khái niệm cơ bản cũng như quan trọng nhất về package, hàm và biến. Còn rất nhiều loại biến thú vị nữa mà mình sẽ tiếp tục giới thiệu ở những bài viết sau 😄 Nếu có thắc mắc hoặc phát hiện bài viết có thiếu sót gì, hãy comment cho mình biết để mình kịp thời chỉnh sửa cũng như cùng thảo luận về thắc mắc đó nhé 😉 Hi vọng những kiến thức này sẽ giúp ích được các bạn trong hành trình chinh phục Golang. Hẹn gặp lại ở những bài viết tiếp theo trong series Golang Essentials: Nền Tảng và Kiến Thức Cơ Bản. See ya!

Tham khảo: https://www.geeksforgeeks.org/data-types-in-go/