Đi khóa học

Nền tảng: gói, biến, kiểu, hằng, toán tử và đầu vào/đầu ra với gói fmt.

1. 1.1Biến và loạivar, khai báo ngắn `:=`, các kiểu cơ bản (int, float64, string, bool) và khái niệm gõ tĩnh.~10 min
2. 1.2Chuyển đổi loại và giá trị bằng 0Mọi biến đều có giá trị mặc định; chuyển đổi rõ ràng (`int(x)`, `string(b)`).~10 min
3. 1.3Hằng số và iota`const`, các hằng số chưa được gõ và mẫu `iota` để tạo các bảng liệt kê có thể đọc được.~10 min
4. 1.4Toán tửSố học, so sánh, logic và bitwise; ưu tiên và sự khác biệt so với các ngôn ngữ khác.~8 min
5. 1.5Đầu vào/đầu ra với fmt`fmt.Println`, `fmt.Printf`, định dạng động từ (`%d`, `%s`, `%v`, `%T`) và khi nào nên ưu tiên cái này hơn cái kia.~10 min

Quyết định và lặp lại: if với câu lệnh init, `for` đơn, chuyển đổi thành ngữ và xử lý lỗi rõ ràng.

1. 2.1câu lệnh if, else và init`if v := f(); v > 0 { ... }` và tại sao Go không có toán tử ba ngôi.~10 min
2. 2.2for: vòng lặp duy nhấtBa dạng của `for`: ba mệnh đề, một điều kiện (= while) và vô hạn; sử dụng `break` và `tiếp tục`.~10 min
3. 2.3cho...phạm viLặp lại các lát, bản đồ và chuỗi; giá trị trả về là một bản sao, khi bỏ qua chỉ mục hoặc giá trị bằng `_`.~10 min
4. 2.4Công tắc thành ngữKhông có sự suy giảm tiềm ẩn, các biểu thức phức tạp trong các trường hợp, chuyển đổi không có điều kiện như một chuỗi if.~10 min
5. 2.5Lỗi: mẫu `if err != nil`Lỗi là giá trị; mẫu cơ bản `if err != nil { return err }` và tại sao Go không có ngoại lệ.~12 min

Các chức năng như công dân hạng nhất: chữ ký, trả về nhiều lần, tham số biến đổi, đóng và `trì hoãn`.

1. 3.1Chữ ký và thông sốCú pháp `func name(p type) type`, truyền theo giá trị theo mặc định, các tham số cùng loại được nhóm lại với nhau.~10 min
2. 3.2Trả về nhiều lần và trả về có tênTrả về nhiều giá trị (`value, err`), mẫu trả về được đặt tên và khi nào KHÔNG sử dụng nó.~12 min
3. 3.3Hàm biến thiên`func sum(nums ...int) int`, trải một lát với `slice...`, các ví dụ từ stdlib.~10 min
4. 3.4Đóng cửa và chức năng như giá trịCác hàm ẩn danh nắm bắt các biến từ bối cảnh xung quanh; bộ chuyển đổi và các mẫu nhà máy.~12 min
5. 3.5`defer`: đảm bảo dọn dẹpTrì hoãn việc thực hiện cho đến khi quay trở lại; mẫu `defer f.Close()`, thứ tự LIFO, các vấn đề bên trong vòng lặp.~12 min

Mảng, lát cắt (cấu trúc quan trọng nhất), bản đồ, rune bên trong chuỗi và sắp xếp.

1. 4.1Mảng có độ dài cố địnhCú pháp `[N]T`, tại sao mảng thực hiếm khi được sử dụng trong Go, chuyển đổi từ mảng sang lát cắt.~8 min
2. 4.2Lát: cấu trúc thành ngữ`make`, `append`, len/cap, cắt `s[a:b]`, chia sẻ mảng cơ bản và thời điểm sao chép.~15 min
3. 4.3Bản đồ: khóa và giá trịKhai báo, truy cập bằng dấu phẩy-ok (`v, ok := m[k]`), `delete`, lặp không xác định.~12 min
4. 4.4Chuỗi, byte và runeChuỗi là byte UTF-8; `phạm vi` mang lại rune; `len()` đếm byte chứ không phải ký tự.~12 min
5. 4.5Sắp xếp với gói sắp xếp`sort.Ints`, `sort.Strings`, `sort.Slice` có chức năng so sánh, ổn định.~10 min

Các kiểu dữ liệu tổng hợp: cấu trúc, phương thức trên bộ nhận giá trị hoặc con trỏ, thành phần (không có tính kế thừa) và thẻ.

1. 5.1Định nghĩa và sử dụng cấu trúc`type Person struct { Chuỗi tên; Age int }`, khởi tạo vị trí và đặt tên, cấu trúc ẩn danh.~12 min
2. 5.2Phương thức: giá trị và bộ nhận con trỏ`func (p Person) Hello()` vs `func (p *Person) Rename(n string)`; khi nào nên sử dụng cái này hay cái kia.~14 min
3. 5.3Thành phần (nhúng)Go không có tính kế thừa: bạn soạn thảo bằng cách nhúng một loại vào trong một loại khác. Phương pháp khuyến mãi.~12 min
4. 5.4Thẻ trường và JSON`json:"name,omitempty"`, sắp xếp/không sắp xếp thứ tự bằng `encoding/json`, các lỗi thường gặp.~12 min
5. 5.5Mẫu hàm tạo `Mới...`Go không có hàm tạo: quy ước là hàm `NewT(...) *T` dùng để xác thực và trả về lỗi.~10 min

Giao diện cấu trúc (không có công cụ rõ ràng), xác nhận, chuyển đổi loại và giao diện `Stringer` và `error` tiêu chuẩn.

1. 6.1Giao diện: xác định hành viGiao diện là một tập hợp các phương thức; bất cứ ai thực hiện chúng đều tự động đáp ứng nó (gõ vịt tĩnh).~12 min
2. 6.2Xác nhận kiểu`v, ok := i.(*MyT)`, dạng dấu phẩy-ok để tránh hoảng loạn, khi nào nên ưu tiên một xác nhận hơn là chuyển đổi loại.~10 min
3. 6.3Công tắc loại`switch v := x.(type) { case int: ... }` để gửi đi loại thời gian chạy.~10 min
4. 6.4Giao diện StringerViệc triển khai `String() string` sẽ thay đổi cách `fmt.Println` thể hiện loại của bạn.~10 min
5. 6.5Giao diện lỗi`error` chỉ là `Error() string`; tạo lỗi tùy chỉnh, `errors.Is`, `errors.As`, `fmt.Errorf("%w", err)`.~14 min

Mô hình tương tranh của Go: goroutine nhẹ, kênh giao tiếp, `select`, đồng bộ hóa và ngữ cảnh.

1. 7.1Goroutines: song song nhẹ`go f()`, chi phí của một goroutine, tại sao main thoát mà không phải chờ và cách đồng bộ hóa.~12 min
2. 7.2Kênh: giao tiếp đánh máy`ch := make(chan int)`, `ch <- v`, `v := <-ch`, kênh được đệm và không có bộ đệm, đóng.~15 min
3. 7.3`select`: ghép kênhĐợi kênh sẵn sàng đầu tiên, trường hợp `mặc định` để tránh bị chặn, mẫu thời gian chờ với `time.After`.~12 min
4. 7.4`sync.Mutex` và `sync.WaitGroup`Khi các kênh không đủ: bảo vệ trạng thái chia sẻ bằng Mutex, đợi N goroutine bằng WaitGroup.~14 min
5. 7.5`context.Context`: hủy bỏ và thời hạnTruyền bá tính năng hủy trên các goroutines, `context.WithTimeout`, `ctx.Done()`, mẫu tham số đầu tiên.~14 min

Các gói bạn sẽ sử dụng hàng ngày: fmt, strings, strconv, io, os, time, Encoding/json.

1. 8.1`fmt` nâng cao`Sprintf`, `Fprintf`, các động từ `%+v` và `%#v`, định dạng chiều rộng và độ chính xác, các cờ `-` và `0`.~10 min
2. 8.2`chuỗi` và `strconv``strings.Contains/Split/Tham gia/TrimSpace`, `strconv.Itoa/Atoi/ParseInt/FormatFloat`.~12 min
3. 8.3`io` và `os`: tập tin và luồng`os.Open/Create/ReadFile/WriteFile`, giao diện `io.Reader/Writer`, mẫu `defer f.Close()`.~14 min
4. 8.4Gói `thời gian``time.Now()`, thời lượng, phân tích cú pháp với bố cục tham chiếu `2006-01-02 15:04:05`, bộ tính giờ và mã đánh dấu.~12 min
5. 8.5`mã hóa/json``json.Marshal/Unmarshal`, thẻ struct, `json.Decoding/Encode` cho các luồng, lỗi phân tích cú pháp.~14 min

Công cụ `go test`, kiểm tra dựa trên bảng, điểm chuẩn, quản lý phụ thuộc với `go mod` và thẻ xây dựng.

1. 9.1Gói `thử nghiệm`Các tệp `*_test.go`, các hàm `TestXxx(t *testing.T)`, `t.Error` vs `t.Fatal`, `go test ./...`.~12 min
2. 9.2Kiểm tra dựa trên bảngMẫu thành ngữ: một lát cấu trúc ẩn danh có đầu vào và đầu ra dự kiến, `t.Run(name, ...)` dành cho các thử nghiệm phụ.~14 min
3. 9.3Điểm chuẩn và hồ sơCác hàm `BenchmarkXxx(b *testing.B)`, `for i := 0; tôi < b.N; vòng lặp i++`, `go test -bench=.`.~12 min
4. 9.4Đi mô-đun`go mod init`, `go get`, phiên bản nhập ngữ nghĩa, tệp khóa `go.sum`, `go mod gọn gàng`.~12 min
5. 9.5Xây dựng các ràng buộc và thẻLệnh `//go:build ...` dành cho các bản dựng đa nền tảng, tách mã kiểm tra/tích hợp, các ví dụ trong thế giới thực.~10 min

Đặt tên, xử lý lỗi nâng cao, khái quát (Go 1.18+) và hai dự án nhỏ: CLI và máy chủ HTTP.

1. 10.1Quy ước và phong cách đặt tênPascalCase dành cho xuất khẩu, CamelCase dành cho người dân địa phương, tên viết tắt trong phạm vi ngắn, `gofmt` là không thể thương lượng.~10 min
2. 10.2Xử lý lỗi thành ngữLỗi trọng điểm (`io.EOF`), lỗi tùy chỉnh với `Unwrap`, gói bằng `%w`, khi nào nên sử dụng `panic`.~14 min
3. 10.3Thuốc gốc (Đi 1.18+)Nhập tham số `func Map[T, U Any](s []T, f func(T) U) []U`, các ràng buộc (`có thể so sánh`, tùy chỉnh), sự đánh đổi.~15 min
4. 10.4Dự án nhỏ: CLI có cờGói `flag`, các lệnh và lệnh phụ, mã thoát, `log` vs `fmt` cho đầu ra.~18 min
5. 10.5Dự án nhỏ: máy chủ HTTP`net/http`, trình xử lý và bộ định tuyến tối thiểu, phần mềm trung gian làm công cụ trang trí, tắt máy duyên dáng theo ngữ cảnh.~18 min