Go là gì?

Go, còn được biết đến với tên gọi Golang, là một ngôn ngữ lập trình mã nguồn mở, được thiết kế tại Google bởi Robert Griesemer, Rob Pike và Ken Thompson. Go là ngôn ngữ biên dịch (compiled language) và có hệ thống kiểu dữ liệu tĩnh (statically typed).

Khác với những ngôn ngữ yêu cầu người lập trình khai báo kiểu dữ liệu rõ ràng trong mọi trường hợp, Go hỗ trợ suy luận kiểu dữ liệu khi khai báo biến. Ví dụ, với cú pháp name := "Go", trình biên dịch tự xác định name có kiểu string.

Go có cú pháp tương đối đơn giản, chịu ảnh hưởng từ C nhưng được thiết kế với những đặc điểm riêng nhằm giúp mã nguồn dễ đọc, dễ bảo trì và thuận tiện khi phát triển các hệ thống phần mềm hiện đại.

Mục đích ra đời

Go được thiết kế nhằm giải quyết những thách thức trong quá trình phát triển phần mềm quy mô lớn, đặc biệt là việc cân bằng giữa hiệu năng, sự đơn giản của mã nguồn và khả năng xử lý đồng thời.

• Đơn giản hóa quá trình phát triển: Go có hệ thống cú pháp tương đối gọn, hạn chế một số cơ chế phức tạp và cung cấp bộ công cụ tiêu chuẩn để giúp lập trình viên viết, kiểm thử và bảo trì mã nguồn thuận tiện hơn.
• Hỗ trợ xử lý đồng thời (concurrency): Go cung cấp goroutines và channels để tổ chức các tác vụ có thể thực hiện đồng thời. Goroutine có chi phí khởi tạo và quản lý thường thấp hơn thread hệ điều hành, cho phép ứng dụng tổ chức nhiều tác vụ đồng thời mà không cần tạo một thread riêng cho mỗi tác vụ.
• Hiệu năng và tốc độ biên dịch: Go thường được biên dịch thành mã máy dành cho nền tảng mục tiêu. Điều này giúp chương trình có thể thực thi trực tiếp mà không cần một máy ảo ngôn ngữ như JVM. Go cũng chú trọng thời gian biên dịch tương đối nhanh trong quy trình phát triển.
• Thuận tiện khi triển khai: Go thường tạo ra tệp thực thi có thể triển khai cùng các thành phần phụ thuộc cần thiết. Tuy nhiên, khả năng chạy trên môi trường khác vẫn phụ thuộc vào hệ điều hành, kiến trúc CPU và các thư viện hoặc tài nguyên bên ngoài mà chương trình sử dụng.
• Dễ tổ chức và mở rộng hệ thống: Go cung cấp packages, modules, interfaces và thư viện chuẩn để giúp lập trình viên tổ chức mã nguồn thành những thành phần rõ ràng, phù hợp với các dự án từ công cụ nhỏ đến dịch vụ Backend.

Ứng dụng phổ biến của Go

1. Cloud-Native và DevOps

Go được sử dụng rộng rãi trong hệ sinh thái hạ tầng đám mây và Cloud-Native. Những dự án nổi bật như Docker và Kubernetes có các thành phần được phát triển bằng Go.

Các đặc điểm như khả năng biên dịch thành tệp thực thi, thư viện mạng và hỗ trợ concurrency khiến Go phù hợp để xây dựng công cụ quản lý hạ tầng, triển khai ứng dụng và điều phối container.

2. Phát triển Backend và Microservices

Go thường được sử dụng để xây dựng Web API, dịch vụ Backend và microservices. Ngôn ngữ này cung cấp thư viện chuẩn để xây dựng HTTP server, xử lý request và giao tiếp qua mạng.

Kết hợp với goroutines, Go cho phép tổ chức nhiều tác vụ đồng thời, phù hợp với các hệ thống cần xử lý nhiều kết nối. Hiệu năng thực tế vẫn phụ thuộc vào kiến trúc, thuật toán, cơ sở dữ liệu và cách triển khai ứng dụng.

3. Công cụ dòng lệnh (CLI Tools)

Go phù hợp để phát triển các công cụ dòng lệnh phục vụ tự động hóa, quản lý hệ thống và xử lý dữ liệu.

Khả năng biên dịch thành tệp thực thi giúp việc phân phối công cụ tương đối thuận tiện, đặc biệt khi có thể xây dựng riêng cho từng hệ điều hành và kiến trúc mục tiêu.

4. Hệ thống mạng và xử lý đồng thời

Go có thư viện chuẩn hỗ trợ giao tiếp mạng, HTTP, TCP và nhiều tác vụ I/O. Vì vậy, ngôn ngữ này được sử dụng để phát triển proxy, hệ thống xử lý thông điệp, dịch vụ mạng và các ứng dụng cần quản lý nhiều kết nối đồng thời.

Tuy nhiên, Go không tự động bảo đảm hệ thống có độ trễ thấp hoặc khả năng chịu tải cao. Những yêu cầu này vẫn cần được giải quyết bằng thiết kế kiến trúc, quản lý tài nguyên, kiểm thử và tối ưu hóa phù hợp.

5. Công cụ bảo mật và an ninh mạng

Go cũng được sử dụng để xây dựng các công cụ phục vụ kiểm thử bảo mật, phân tích mạng, tự động hóa và giám sát hệ thống.

Khả năng biên dịch thành tệp thực thi cùng thư viện hỗ trợ mạng giúp việc phát triển và phân phối những công cụ này thuận tiện. Việc sử dụng Go trong an ninh mạng không đồng nghĩa với việc ngôn ngữ này tự bảo đảm tính bảo mật; chất lượng và độ an toàn vẫn phụ thuộc vào cách thiết kế và triển khai phần mềm.

Go Fundamentals: Những kiến thức nền tảng cần nắm vững

1. Cấu trúc chương trình Go — Package, Import và func main()

Một chương trình Go được tổ chức thành các package. Mỗi file Go thuộc về một package, được xác định bằng từ khóa package ở đầu file.

Ví dụ, chương trình đơn giản nhất có thể viết như sau:

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
}

Trong đó:

• package main: Khai báo package main. Đây là package đặc biệt dùng để xây dựng chương trình có thể thực thi trực tiếp.
• import "fmt": Nạp package fmt để sử dụng các chức năng định dạng và xuất dữ liệu, chẳng hạn fmt.Println().
• func main(): Khai báo hàm main, là điểm bắt đầu thực thi của chương trình khi chạy một executable được xây dựng từ package main.

Import nhiều package

Khi cần sử dụng nhiều package, Go cho phép khai báo theo nhóm:

package main

import (
    "fmt"
    "strings"
)

func main() {
    name := "golang"

    fmt.Println(strings.ToUpper(name))
}

Kết quả:

GOLANG

Go không cho phép giữ lại các package đã import nhưng không sử dụng trong file. Điều này giúp mã nguồn gọn gàng và hạn chế các khai báo thừa.

Ngoài ra, Go sử dụng quy ước đặt tên để kiểm soát khả năng truy cập từ package khác: tên bắt đầu bằng chữ hoa có thể được truy cập từ package bên ngoài, trong khi tên bắt đầu bằng chữ thường chỉ được truy cập trong package khai báo nó.

Ví dụ, Println có thể được sử dụng thông qua package fmt, còn một hàm tên calculate trong package khác sẽ không thể được gọi trực tiếp từ bên ngoài package đó.

2. Biến, hằng số và kiểu dữ liệu — var, const, :=

Biến và hằng số là những thành phần cơ bản dùng để lưu trữ dữ liệu trong chương trình. Go là ngôn ngữ có kiểu tĩnh, nghĩa là kiểu của mỗi biến được xác định khi biên dịch. Tuy nhiên, lập trình viên không phải lúc nào cũng cần ghi kiểu dữ liệu một cách tường minh vì Go có khả năng suy luận kiểu.

Khai báo biến với var

Từ khóa var được dùng để khai báo biến:

var name string = "Go"
var age int = 16

fmt.Println(name, age)

Go cũng cho phép bỏ qua kiểu dữ liệu khi trình biên dịch có thể suy luận từ giá trị khởi tạo:

var language = "Go"
var version = 1

Biến được khai báo nhưng chưa gán giá trị sẽ nhận giá trị mặc định (zero value) tương ứng với kiểu dữ liệu:

• Số nguyên: 0
• Số thực: 0
• Boolean: false
• Chuỗi: ""
• Con trỏ, slice, map, channel, function và interface: nil trong các trường hợp tương ứng.

Khai báo ngắn với :=

Toán tử := cho phép khai báo biến và suy luận kiểu ngay trong một câu lệnh:

name := "Go"
age := 20
isLearning := true

Cách khai báo này thường được sử dụng bên trong hàm. Không thể dùng := để khai báo biến ở phạm vi package.

Hằng số với const

Hằng số được khai báo bằng const và không thể được gán lại sau khi khai báo:

const Pi = 3.14159
const AppName = "Go Fundamentals"

Hằng số trong Go được giới hạn ở những giá trị có thể xác định tại thời điểm biên dịch, chẳng hạn số, chuỗi, boolean và các biểu thức hằng hợp lệ.

Các kiểu dữ liệu cơ bản

Nhóm	Kiểu dữ liệu thường gặp	Mục đích
Số nguyên	int, int32, int64, uint	Lưu số nguyên
Số thực	float32, float64	Lưu số có phần thập phân
Boolean	bool	Biểu diễn true hoặc false
Chuỗi	string	Lưu dữ liệu văn bản
Ký tự Unicode	rune	Biểu diễn một giá trị mã Unicode
Byte	byte	Bí danh của uint8, thường dùng khi xử lý dữ liệu dạng byte

Một điểm cần lưu ý là Go không tự động chuyển đổi giữa các kiểu số khác nhau:

var a int = 10
var b float64 = 2.5

result := float64(a) + b
fmt.Println(result)

Trong ví dụ này, a được chuyển sang float64 một cách tường minh trước khi thực hiện phép cộng.

Việc hiểu rõ kiểu dữ liệu giúp tránh lỗi khi tính toán, xử lý dữ liệu đầu vào và trao đổi dữ liệu giữa các thành phần của ứng dụng.

3. Toán tử và cấu trúc điều khiển — if, switch, for

Toán tử cho phép thực hiện các phép tính và so sánh, trong khi cấu trúc điều khiển quyết định thứ tự thực thi của chương trình.

Các nhóm toán tử

• Số học: +, -, *, /, %
• So sánh: ==, !=, <, >, <=, >=
• Logic: &&, ||, !
• Gán: =, +=, -=, *=

Ví dụ:

age := 20

if age >= 18 && age < 60 {
    fmt.Println("Working age")
}

Cấu trúc if

if thực hiện một khối lệnh khi điều kiện đúng. Go không yêu cầu dấu ngoặc đơn quanh điều kiện và dấu ngoặc nhọn là bắt buộc.

score := 85

if score >= 90 {
    fmt.Println("Excellent")
} else if score >= 70 {
    fmt.Println("Good")
} else {
    fmt.Println("Keep practicing")
}

Go cũng hỗ trợ câu lệnh khởi tạo trong if:

if score := 85; score >= 80 {
    fmt.Println("Passed")
}

Biến score trong ví dụ này chỉ tồn tại trong phạm vi của câu lệnh if và các nhánh liên quan.

Cấu trúc switch

switch phù hợp khi cần lựa chọn giữa nhiều trường hợp:

day := 2

switch day {
case 1:
    fmt.Println("Monday")
case 2:
    fmt.Println("Tuesday")
case 3:
    fmt.Println("Wednesday")
default:
    fmt.Println("Another day")
}

Khác với một số ngôn ngữ, switch thông thường trong Go không tự động chạy tiếp sang case kế tiếp. Nếu muốn chạy tiếp, cần sử dụng fallthrough một cách tường minh.

Go còn hỗ trợ switch không có biểu thức, cho phép viết các điều kiện tương tự chuỗi if-else:

score := 85

switch {
case score >= 90:
    fmt.Println("Excellent")
case score >= 70:
    fmt.Println("Good")
default:
    fmt.Println("Needs improvement")
}

Cấu trúc lặp for

Go chỉ có một từ khóa vòng lặp là for, nhưng có thể sử dụng theo nhiều cách.

Vòng lặp với biến đếm:

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

Vòng lặp theo điều kiện:

count := 0

for count < 3 {
    fmt.Println(count)
    count++
}

Vòng lặp vô hạn:

for {
    // Thực hiện công việc lặp lại
    break
}

Trong thực tế, break được dùng để thoát khỏi vòng lặp, còn continue bỏ qua phần còn lại của lượt lặp hiện tại và chuyển sang lượt tiếp theo.

Ngoài ra, range giúp duyệt qua các phần tử của array, slice, map, chuỗi và một số kiểu dữ liệu khác:

numbers := []int{10, 20, 30}

for index, value := range numbers {
    fmt.Println(index, value)
}

Nắm vững các cấu trúc điều khiển là điều kiện cần để xây dựng thuật toán, xử lý dữ liệu và triển khai logic nghiệp vụ.

4. Hàm trong Go — Tham số và giá trị trả về

Hàm (function) là khối mã thực hiện một nhiệm vụ cụ thể. Việc chia chương trình thành các hàm giúp tái sử dụng logic, giảm lặp code và làm cho chương trình dễ kiểm thử hơn.

Khai báo hàm

Một hàm được khai báo bằng từ khóa func:

func add(a int, b int) int {
    return a + b
}

Trong đó:

• add là tên hàm.
• a và b là các tham số có kiểu int.
• int sau danh sách tham số là kiểu dữ liệu trả về.
• return trả kết quả của phép cộng về nơi gọi hàm.

Khi nhiều tham số liên tiếp có cùng kiểu, có thể viết gọn:

func multiply(a, b int) int {
    return a * b
}

Hàm không trả về giá trị

Một hàm không cần trả về kết quả có thể bỏ qua kiểu trả về:

func greet(name string) {
    fmt.Println("Hello,", name)
}

Hàm trả về nhiều giá trị

Một đặc điểm đáng chú ý của Go là hàm có thể trả về nhiều giá trị:

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("cannot divide by zero")
    }

    return a / b, nil
}

Khi gọi hàm, chương trình có thể nhận cả kết quả và lỗi:

result, err := divide(10, 2)

if err != nil {
    fmt.Println("Error:", err)
    return
}

fmt.Println(result)

Cách thiết kế này được sử dụng phổ biến trong Go, đặc biệt khi một thao tác có thể thất bại. Thay vì buộc chương trình phải dựa vào ngoại lệ để xử lý các lỗi thông thường, hàm thường trả về một giá trị error để bên gọi chủ động kiểm tra.

Go cũng hỗ trợ named return values, cho phép đặt tên cho các giá trị trả về. Tuy nhiên, nên sử dụng tính năng này khi tên giúp làm rõ ý nghĩa kết quả, tránh khiến hàm trở nên khó đọc.

5. Các kiểu dữ liệu tổng hợp — Array, Slice, Map và Struct

Ngoài các kiểu dữ liệu cơ bản, Go cung cấp nhiều kiểu dữ liệu để tổ chức và biểu diễn các tập hợp thông tin.

Array

Array là một dãy phần tử có cùng kiểu dữ liệu và có độ dài cố định. Độ dài là một phần của kiểu dữ liệu.

var numbers [3]int = [3]int{10, 20, 30}

fmt.Println(numbers[0])

Array phù hợp khi số lượng phần tử được xác định trước. Khi gán một array cho biến khác, toàn bộ giá trị của array được sao chép.

Slice

Slice là một cấu trúc linh hoạt hơn, thường được dùng để làm việc với các dãy phần tử có thể thay đổi độ dài.

numbers := []int{10, 20, 30}

numbers = append(numbers, 40)

fmt.Println(numbers)

Kết quả:

[10 20 30 40]

Slice được xây dựng trên một array nền và chứa thông tin về độ dài, sức chứa cùng tham chiếu đến vùng dữ liệu đó. Vì vậy, hai slice có thể cùng chia sẻ dữ liệu nền; việc sửa đổi phần tử qua một slice có thể ảnh hưởng đến slice khác.

Khi cần tạo một slice có độ dài hoặc sức chứa cụ thể, có thể sử dụng make:

numbers := make([]int, 3, 5)

Trong ví dụ này, slice có độ dài ban đầu là 3 và sức chứa là 5.

Map

Map lưu trữ dữ liệu theo cặp khóa–giá trị (key-value). Kiểu của khóa và giá trị được xác định khi khai báo.

scores := map[string]int{
    "An":  90,
    "Binh": 85,
}

scores["Chi"] = 95

fmt.Println(scores["An"])

Có thể kiểm tra một khóa có tồn tại hay không bằng cách nhận thêm giá trị boolean:

score, ok := scores["An"]

if ok {
    fmt.Println(score)
}

Map phù hợp với các tình huống cần tra cứu theo khóa, chẳng hạn ánh xạ tên người dùng sang thông tin, đếm tần suất xuất hiện hoặc lưu cấu hình.

Không nên dựa vào thứ tự duyệt của map vì thứ tự các phần tử không được đảm bảo.

Struct

Struct cho phép nhóm nhiều trường dữ liệu có thể thuộc các kiểu khác nhau vào một kiểu dữ liệu duy nhất.

type User struct {
    ID    int
    Name  string
    Email string
}

func main() {
    user := User{
        ID:    1,
        Name:  "An",
        Email: "[email protected]",
    }

    fmt.Println(user.Name)
}

Trong ví dụ trên, User biểu diễn một người dùng với ba trường dữ liệu.

Struct thường được sử dụng để mô hình hóa các đối tượng trong ứng dụng, chẳng hạn người dùng, sản phẩm, đơn hàng hoặc thông tin cấu hình. Khi kết hợp với methods, struct có thể đi kèm các hành vi liên quan đến dữ liệu của nó.

6. Con trỏ, Methods và Interfaces — Dữ liệu và hành vi

Ba khái niệm này giúp tổ chức chương trình Go theo hướng rõ ràng hơn, đồng thời hỗ trợ kiểm soát việc thay đổi dữ liệu và xây dựng các thành phần có thể thay thế cho nhau.

Con trỏ (Pointer)

Con trỏ lưu địa chỉ của một giá trị trong bộ nhớ. Toán tử & lấy địa chỉ của biến, còn toán tử * được dùng để truy cập giá trị tại địa chỉ đó trong các biểu thức con trỏ.

x := 10
p := &x

fmt.Println(*p) // 10

*p = 20
fmt.Println(x) // 20

Trong ví dụ này, p trỏ đến x. Khi thay đổi giá trị thông qua *p, giá trị của x cũng thay đổi.

Con trỏ thường được sử dụng khi cần thay đổi dữ liệu thông qua hàm hoặc method, hoặc khi muốn tránh sao chép các cấu trúc dữ liệu lớn. Go có con trỏ nhưng không cho phép thực hiện phép toán số học trên con trỏ theo cách thông thường như C/C++.

Methods

Method là một hàm được khai báo với receiver, tức giá trị nhận method đó. Receiver thường là một giá trị hoặc con trỏ đến một giá trị thuộc kiểu được định nghĩa trong cùng package.

type User struct {
    Name string
}

func (u User) Greet() string {
    return "Hello, " + u.Name
}

Có thể gọi method như sau:

user := User{Name: "An"}

fmt.Println(user.Greet())

Khi sử dụng value receiver, method nhận một bản sao của giá trị receiver. Nếu cần thay đổi dữ liệu gốc, pointer receiver thường phù hợp hơn:

func (u *User) Rename(name string) {
    u.Name = name
}

Go không sử dụng hệ thống class inheritance như nhiều ngôn ngữ hướng đối tượng khác. Thay vào đó, chương trình thường kết hợp struct, methods và interfaces để tổ chức dữ liệu và hành vi.

Interfaces

Interface mô tả một tập hợp các method mà một kiểu dữ liệu cần có để thỏa mãn interface đó. Go sử dụng cơ chế thỏa mãn interface ngầm định: kiểu dữ liệu không cần khai báo rõ ràng rằng nó đang triển khai một interface.

type Speaker interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string {
    return "Woof!"
}

func introduce(s Speaker) {
    fmt.Println(s.Speak())
}

Vì Dog có method Speak() string, nó thỏa mãn interface Speaker và có thể được truyền vào hàm introduce.

Interface giúp giảm sự phụ thuộc giữa các thành phần. Ví dụ, một service có thể làm việc với interface lưu trữ dữ liệu thay vì phụ thuộc trực tiếp vào một cơ sở dữ liệu cụ thể. Nhờ đó, việc thay đổi cách triển khai hoặc viết kiểm thử thường dễ dàng hơn.

Tuy nhiên, không nên tạo interface cho mọi kiểu dữ liệu một cách máy móc. Interface hữu ích nhất khi nó thể hiện một hành vi mà thành phần gọi thực sự cần.

7. Packages, Modules và xử lý lỗi

Khi chương trình lớn dần, việc đặt toàn bộ mã nguồn trong một file sẽ khiến việc bảo trì, kiểm thử và tái sử dụng trở nên khó khăn. Go sử dụng package và module để tổ chức mã nguồn, đồng thời có cơ chế xử lý lỗi theo hướng tường minh.

Package

Package là đơn vị tổ chức mã nguồn ở cấp độ code. Các file Go trong cùng một thư mục thường thuộc cùng một package, ngoại trừ một số trường hợp đặc biệt liên quan đến kiểm thử.

Ví dụ, một ứng dụng có thể tổ chức thành các package như:

• handler: tiếp nhận và xử lý HTTP request.
• service: thực hiện logic nghiệp vụ.
• repository: làm việc với cơ sở dữ liệu.
• model: định nghĩa các kiểu dữ liệu dùng chung.

Đây chỉ là một cách tổ chức phổ biến, không phải cấu trúc bắt buộc của mọi dự án Go.

Module

Module là đơn vị quản lý phiên bản và các dependency của một dự án Go. Một module thường được xác định bằng file go.mod, chứa đường dẫn module và thông tin về phiên bản Go cùng các phụ thuộc liên quan.

Có thể khởi tạo module bằng lệnh:

go mod init example.com/myapp

Sau khi khởi tạo, các package thuộc module có thể được import bằng đường dẫn module kết hợp với đường dẫn package tương ứng.

Một số lệnh thường dùng:

go run .
go build .
go test ./...
go mod tidy

• go run .: biên dịch và chạy chương trình trong package hiện tại.
• go build .: xây dựng chương trình hoặc package.
• go test ./...: chạy các bài kiểm thử trong các package thuộc cây thư mục hiện tại.
• go mod tidy: cập nhật các khai báo dependency dựa trên mã nguồn và các bài kiểm thử.

Xử lý lỗi trong Go

Go thường biểu diễn lỗi thông qua giá trị thuộc kiểu error. Các hàm thực hiện thao tác có thể thất bại thường trả về kết quả cùng lỗi để bên gọi kiểm tra.

file, err := os.Open("data.txt")

if err != nil {
    fmt.Println("Cannot open file:", err)
    return
}

defer file.Close()

Trong ví dụ này, chương trình kiểm tra err ngay sau khi gọi os.Open. Nếu có lỗi, chương trình xử lý lỗi thay vì tiếp tục sử dụng một file không mở thành công.

defer trì hoãn việc thực thi một lời gọi hàm cho đến khi hàm hiện tại kết thúc. Nó thường được dùng để giải phóng tài nguyên như đóng file hoặc đóng kết nối.

Go cũng cung cấp errors.New, fmt.Errorf, errors.Is và errors.As để tạo, bổ sung ngữ cảnh và kiểm tra lỗi. Với những lỗi cần truyền ngược qua nhiều tầng của ứng dụng, việc bổ sung ngữ cảnh giúp xác định lỗi phát sinh từ thao tác nào.

Ví dụ:

if err != nil {
    return fmt.Errorf("load user: %w", err)
}

Trong ví dụ trên, %w cho phép bọc lỗi gốc để các tầng gọi phía trên vẫn có thể kiểm tra lỗi bằng những công cụ như errors.Is hoặc errors.As.

Go vẫn có panic và recover, nhưng chúng không thay thế cách xử lý lỗi thông thường bằng error. Trong phần lớn logic nghiệp vụ, lỗi nên được trả về và xử lý một cách tường minh.

Kết luận

Go Fundamentals cung cấp nền tảng để hiểu cách một chương trình Go được tổ chức, cách dữ liệu được lưu trữ và xử lý, cũng như cách các thành phần phối hợp với nhau. Từ cấu trúc chương trình, biến và kiểu dữ liệu, cấu trúc điều khiển, hàm cho đến slice, map, struct, con trỏ, methods, interfaces, packages, modules và xử lý lỗi — mỗi kiến thức đều đóng vai trò trong quá trình phát triển phần mềm.

Tuy nhiên, nắm được cú pháp mới chỉ là bước đầu. Điều quan trọng hơn là có thể tự viết chương trình, lựa chọn cấu trúc dữ liệu phù hợp, chia nhỏ bài toán thành các hàm, tổ chức mã nguồn hợp lý và xử lý những tình huống phát sinh.

Mục tiêu cuối cùng không phải là ghi nhớ mọi cú pháp của Go, mà là có đủ nền tảng để đọc hiểu, tự triển khai, kiểm thử và từng bước xây dựng một ứng dụng hoàn chỉnh.

Nguồn tham khảo

• Giới thiệu ngôn ngữ lập trình GoLang

• Golang là gì? Tại sao nên học Golang 2024?