func main() {
fmt.Println(7 / 2)
fmt.Println(-7 / 2)
}Đáp án: C
In 3 rồi -3. Hai số nguyên chia nhau là chia nguyên; Go cắt phần thập phân HƯỚNG VỀ 0 (truncate toward zero), nên 7/2 = 3 và -7/2 = -3 — khác Python vốn làm tròn xuống (-4). Muốn kết quả float phải cho ít nhất một toán hạng là float. (FREE)
Nguồn tham khảo
implements như trong JavaĐáp án: B
Trong Go, một kiểu thoả mãn interface một cách ngầm định: chỉ cần nó định nghĩa đủ tất cả method mà interface yêu cầu, không có từ khoá implements hay khai báo liên kết. Trình biên dịch kiểm tra ở compile time. Nhờ vậy interface có thể được định nghĩa ở phía consumer, tách rời khỏi kiểu cụ thể.
error và khi nào dùng panic/recover?panic thay cho error vì gọn hơnerror cho lỗi dự kiến trong luồng bình thườngerror chỉ dùng cho lỗi mạng, mọi lỗi khác phải panicrecover có thể gọi ở bất kỳ đâu để bỏ qua mọi lỗi runtimeĐáp án: B
Go coi lỗi là giá trị: hàm trả error ở vị trí cuối và caller kiểm tra if err != nil. Dùng error cho mọi thất bại dự kiến (I/O, parse, validate). Chỉ panic khi gặp bug hoặc bất biến bị phá vỡ không thể tiếp tục; recover đặt trong defer để chặn panic tại ranh giới, tránh sập cả tiến trình.
Đáp án: A
Array [N]T có độ dài N là một phần của kiểu, được copy theo giá trị khi gán/truyền hàm. Slice là struct nhẹ gồm con trỏ tới backing array, len và cap; nó là "cửa sổ" động tham chiếu, co giãn qua append và chia sẻ dữ liệu với slice khác cùng backing array. Trong thực tế Go dùng slice gần như mọi lúc.
var s string
var n int
var p *intundefined cho tới khi được gáns là chuỗi rỗng "", n là 0, p là nil — mỗi kiểu có zero value xác địnhĐáp án: B
Mọi biến Go khai báo không khởi tạo đều nhận zero value của kiểu: s = "", n = 0, p = nil. Quy tắc chung: số → 0, string → chuỗi rỗng, bool → false, pointer/slice/map/channel/interface → nil, struct → zero value của từng field. Không có undefined hay giá trị rác như C.
Nguồn tham khảo
x := 10 khác var x = 10 ở điểm nào?:= chỉ dùng được bên trong function:= không có kiểu cố định, đổi kiểu được như JavaScript:= tạo hằng số không đổi được, còn var tạo biến thường:= là phép gán giá trị cho biến đã tồn tại, var mới là khai báo biến mớiĐáp án: A
x := 10 (short declaration) vừa khai báo vừa gán, kiểu được suy ra từ vế phải, và CHỈ dùng được bên trong function. var x = 10 làm điều tương tự nhưng dùng được cả ở package level. Trong hàm, := là cách viết phổ biến nhất; var dùng khi khai báo ở cấp package hoặc khi muốn biến nhận zero value (var x int).
go.modpublic / private đặt trước khai báo như Java, C#fmt.Println), viết thường là unexportedĐáp án: C
Chữ cái đầu của tên quyết định: viết HOA là exported — package khác import và dùng được (fmt.Println, http.Get); viết thường là unexported — chỉ dùng trong nội bộ package. Go không có từ khóa public/private. Quy tắc áp dụng cho mọi identifier: hàm, biến, hằng, type, và cả từng field trong struct.
Nguồn tham khảo
nums := []int{1, 2, 3}
for _, v := range nums {
v *= 10
}
fmt.Println(nums)[10 2 3] — chỉ phần tử đầu tiên bị thay đổi[1 2 3] — v là bản copy của từng phần tử, sửa v không ảnh hưởng slicev được gán nhưng kết quả không được sử dụng[10 20 30] — v tham chiếu trực tiếp tới phần tử trong sliceĐáp án: B
In ra [1 2 3]. range copy GIÁ TRỊ của từng phần tử vào biến loop v — sửa v là sửa bản copy, slice gốc không đổi. Muốn thay đổi phần tử thật, gán qua index: for i := range nums { nums[i] *= 10 }. Quy tắc này áp dụng cho cả struct trong slice: sửa field của v cũng vô tác dụng.
func main() {
m := map[string]int{"a": 1}
v, ok := m["b"]
fmt.Println(v, ok)
}Đáp án: C
In 0 false. Tra khoá không tồn tại trên map không panic: dạng comma-ok v, ok := m["b"] trả về zero value của kiểu value (int → 0) và ok == false. Nếu bỏ ok, chỉ nhận 0 — không phân biệt được "khoá vắng" với "khoá có giá trị 0". (FREE)
sync.WaitGroup nào sau đây là đúng khi khởi chạy nhiều goroutine?wg.Add(1) ở dòng đầu tiên BÊN TRONG mỗi goroutine, ngay trước phần việc chínhwg.Add(1) TRƯỚC câu lệnh go, mỗi goroutine defer wg.Done(), và goroutine chờ gọi wg.Wait()wg.Done() nhiều lần hơn Add cũng không sao, bộ đếm sẽ dừng ở 0Add; wg.Wait() tự đếm số goroutine đang chạy trong chương trìnhĐáp án: B
Mẫu đúng: wg.Add(1) TRƯỚC câu lệnh go, bên trong goroutine defer wg.Done(), và bên chờ gọi wg.Wait(). Gọi Add bên trong goroutine là race kinh điển — Wait có thể thấy bộ đếm 0 và trả về trước khi goroutine kịp chạy. Done vượt quá Add gây panic bộ đếm âm.
rune trong Go là bí danh của kiểu nào?uint8, giống hệt kiểu byte của Gouint16 theo chuẩn mã hoá UTF-16string có độ dài đúng một ký tựint32Đáp án: D
int32. Một rune biểu diễn một code point Unicode, cần tới 21 bit nên phải dùng kiểu 32 bit. Còn byte là bí danh của uint8. Hai kiểu này tồn tại để nói rõ ý định khi làm việc với chuỗi.
Nguồn tham khảo
len(s) và cap(s) của một slice khác nhau thế nào?Đáp án: A
len là số phần tử slice đang chứa. cap là số phần tử mà mảng nền có thể chứa tính từ vị trí bắt đầu của slice. Khi append vượt quá sức chứa, runtime cấp một mảng mới lớn hơn và copy dữ liệu sang — lúc đó slice cũ và mới không còn dùng chung mảng nền.
Nguồn tham khảo
any (hay interface{}) trong Go nghĩa là gì?Đáp án: D
Là interface không khai báo phương thức nào. Vì mọi kiểu đều thoả mãn điều kiện rỗng đó, biến kiểu này chứa được giá trị bất kỳ. Đổi lại không gọi được phương thức nào lên nó cho tới khi xác định kiểu cụ thể bằng type assertion hoặc type switch.
Nguồn tham khảo
error trả về bằng cách gán vào dấu gạch dưới có vấn đề gì?Đáp án: D
Thao tác có thể đã thất bại nhưng chương trình vẫn chạy tiếp như không có gì. Các giá trị trả về khác lúc đó thường ở trạng thái zero hoặc không đầy đủ, nên mã phía sau xử lý dữ liệu sai và lỗi thật lộ ra ở nơi khác, xa nguyên nhân.
Nguồn tham khảo
go.sum khác go.mod ở chỗ nào?go.sum chỉ dùng khi build bản phát hành, không dùng lúc phát triểngo.sum liệt kê module trực tiếp còn go.mod liệt kê module gián tiếpgo.sum do người viết còn go.mod do công cụ sinh tự độnggo.sum lưu mã băm để xác minh nội dung module tải vềĐáp án: D
go.mod khai báo module và các phụ thuộc cùng phiên bản. go.sum lưu mã băm mật mã của từng phiên bản đã tải, để xác minh nội dung không bị thay đổi. Cả hai đều phải commit vào repository.
Nguồn tham khảo
errors.New("x") và fmt.Errorf("x") khác nhau ở điểm nào?fmt.Errorf chậm hơn đáng kể nên chỉ dùng khi thật cần thiếtfmt.Errorf cho phép chèn giá trị và bọc lỗi khác vào thông điệperrors.New tạo lỗi có dấu vết stack còn fmt.Errorf thì khôngerrors.New chỉ dùng được ở phạm vi package hiện tạiĐáp án: B
errors.New tạo lỗi từ một chuỗi cố định. fmt.Errorf nhận chuỗi định dạng nên chèn được giá trị vào thông điệp, và quan trọng hơn là dùng được động từ %w để bọc một lỗi khác — giữ lỗi gốc cho errors.Is và errors.As kiểm tra sau này.
Nguồn tham khảo
main.go ở thư mục gốc dự ánmain và có hàm main() không tham sốĐáp án: C
Hai điều kiện cùng lúc: package phải tên là main, và phải có hàm func main() không nhận tham số, không trả về gì. Thiếu một trong hai thì lệnh build chỉ tạo ra thư viện chứ không tạo tệp thực thi.
Nguồn tham khảo
defer trong một hàm chạy theo thứ tự nào?Đáp án: D
Ngược lại với thứ tự khai báo — lệnh khai báo sau cùng chạy trước. Các lệnh hoãn được xếp vào một ngăn xếp, và thứ tự này phù hợp với việc giải phóng tài nguyên theo chiều ngược với lúc mở.
Nguồn tham khảo
switch trong Go khác switch của C và Java ở điểm nào?breakĐáp án: C
Không tự rơi xuống nhánh tiếp theo nên không cần lệnh thoát ở cuối mỗi nhánh. Muốn rơi xuống thì phải khai báo tường minh — thiết kế này loại bỏ hẳn nhóm lỗi quên viết lệnh thoát.
Nguồn tham khảo
map chưa được khởi tạo bằng make cho kết quả gì?Đáp án: A
Đọc trả về giá trị mặc định của kiểu, còn ghi thì panic. Map chưa khởi tạo mang giá trị nil, và ngôn ngữ cho phép đọc từ nó như một map rỗng nhưng không có chỗ để ghi vào.
Nguồn tham khảo
func main() {
for i := 0; i < 3; i++ {
defer fmt.Println(i)
}
}Đáp án: D
In 2 1 0. defer chạy theo LIFO; đối số i được đánh giá NGAY lúc gặp defer nên ba lời gọi lưu sẵn 0, 1, 2, rồi in ngược khi main return. (FREE)
func main() {
var m map[string]int
m["a"] = 1
fmt.Println(m)
}Đáp án: C
Panic: assignment to entry in nil map. var m map[string]int chỉ tạo map nil; đọc map nil trả zero value an toàn, nhưng GHI thì panic. Phải make(map[string]int) hoặc dùng literal trước khi gán. (FREE)
Nguồn tham khảo
const (
A = iota
B
C
_
E
)
func main() {
fmt.Println(A, B, C, E)
}Đáp án: C
In 0 1 2 4. iota bắt đầu từ 0 và tăng 1 mỗi dòng trong khối const, kể cả dòng _. Các dòng B, C, E kế thừa ngầm biểu thức = iota. Dòng _ "nuốt" giá trị 3, nên E = 4. (FREE)
Nguồn tham khảo
func main() {
s := "héllo"
fmt.Println(len(s), utf8.RuneCountInString(s))
}Đáp án: C
In 6 5. String trong Go là chuỗi byte UTF-8; len(s) đếm BYTE. Chữ "é" chiếm 2 byte nên chuỗi dài 6 byte nhưng chỉ 5 rune (ký tự). Muốn đếm ký tự, dùng utf8.RuneCountInString hoặc range. (FREE)
type Point struct {
X, Y int
}
func main() {
a := Point{1, 2}
b := Point{1, 2}
fmt.Println(a == b)
}Đáp án: C
In true. Struct mà mọi field đều comparable (ở đây toàn int) thì so sánh được bằng ==, đối chiếu từng field theo giá trị. a và b cùng {1, 2} nên bằng nhau — không cần reflect.DeepEqual cho trường hợp này. (FREE)
Đáp án: A
Goroutine là luồng nhẹ do Go runtime quản lý, không phải OS thread. Scheduler M:N của Go ghép nhiều goroutine lên một số ít OS thread. Stack goroutine khởi đầu chỉ khoảng 2KB và tự co giãn, còn OS thread tốn hàng trăm KB tới vài MB, nên tạo hàng nghìn goroutine là chuyện bình thường.
Nguồn tham khảo
close()Đáp án: D
Unbuffered channel (make(chan T)) đồng bộ: mỗi lần gửi chặn cho tới khi có bên nhận, tạo điểm bắt tay giữa hai goroutine. Buffered channel (make(chan T, n)) có sức chứa n: gửi chỉ chặn khi buffer đầy, nhận chỉ chặn khi buffer rỗng, giúp tách nhịp giữa producer và consumer.
Nguồn tham khảo
select trong Go dùng để làm gì?switch thông thườngĐáp án: C
select cho một goroutine chờ đồng thời nhiều thao tác channel và chạy case đầu tiên sẵn sàng. Nếu nhiều case cùng sẵn sàng, Go chọn ngẫu nhiên để tránh starvation. Có default thì select không chặn (non-blocking). Đây là công cụ cốt lõi cho timeout, hủy (cancel) và fan-in/fan-out.
Nguồn tham khảo
context.Context trong Go chủ yếu dùng để làm gì?Đáp án: A
context.Context truyền tín hiệu hủy (cancel), deadline/timeout và một ít giá trị phạm vi request qua chuỗi lời gọi và các goroutine. Hàm nhận ctx lắng nghe ctx.Done() để dừng sớm khi request bị huỷ hoặc hết hạn. Quy ước: truyền ctx làm tham số đầu tiên, đừng lưu trong struct, đừng dùng làm kho tham số.
sync.WaitGroup và sync.Mutex khác nhau về mục đích như thế nào?WaitGroup bảo vệ biến chia sẻ, Mutex để chờ goroutine kết thúcWaitGroup thay thế được Mutex trong mọi trường hợpWaitGroup để chờ một nhóm goroutine hoàn thànhĐáp án: D
sync.WaitGroup đồng bộ hoá điểm kết thúc: Add(n) trước khi khởi chạy, mỗi goroutine defer wg.Done(), và wg.Wait() chặn tới khi bộ đếm về 0 — dùng để chờ cả nhóm goroutine xong. sync.Mutex là khoá loại trừ tương hỗ: Lock/Unlock bao quanh vùng critical để mỗi lúc chỉ một goroutine chạm state chia sẻ. Hai mục đích khác nhau, thường dùng cùng nhau.
Nguồn tham khảo
func main() {
ch := make(chan int, 2)
ch <- 1
ch <- 2
fmt.Println(<-ch, <-ch)
}Đáp án: B
In 1 2. Channel buffer 2 cho phép gửi hai giá trị mà không cần bên nhận sẵn sàng — gửi chỉ chặn khi buffer ĐẦY. Buffer là hàng đợi FIFO nên nhận ra đúng thứ tự gửi. Nếu đổi thành make(chan int) (không buffer), dòng ch <- 1 chặn vĩnh viễn trong goroutine duy nhất → deadlock. (FREE)
Nguồn tham khảo
func main() {
src := []int{1, 2, 3}
dst := make([]int, 2)
n := copy(dst, src)
fmt.Println(n, dst)
}Đáp án: B
In 2 [1 2]. copy(dst, src) chép min(len(dst), len(src)) phần tử và trả về số phần tử đã chép — ở đây min(2, 3) = 2. copy KHÔNG tự nới rộng dst; bẫy kinh điển là dst := make([]int, 0, n) (len 0) khiến copy chép 0 phần tử dù cap thừa chỗ. (FREE)
*MyErr nil, nhưng caller kiểm tra err != nil lại nhận true. Vì sao?func doWork() error {
var e *MyErr // nil pointer
// ... no error happened
return e
}
err := doWork()
fmt.Println(err != nil) // true!return e tạo interface có type *MyErr và value nilerr != nil so sánh địa chỉ của biến err, mà biến luôn có địa chỉ khác nilerror là interface đặc biệt không bao giờ bằng nil sau khi được gán qua returnĐáp án: A
Giá trị interface là cặp (type, value) và chỉ bằng nil khi CẢ HAI đều nil. return e với e là *MyErr nil tạo interface (type=*MyErr, value=nil) — type khác nil nên err != nil là true. Đây là bẫy "typed nil". Cách tránh: hàm trả error hãy return nil tường minh, đừng return biến con trỏ error nil.
strings.Builder khi nối chuỗi trong vòng lặp?Đáp án: B
Vì chuỗi Go là bất biến, nên s += x cấp phát chuỗi mới và copy toàn bộ nội dung cũ mỗi lần. Nối n lần cho chi phí bậc hai. strings.Builder ghi vào một bộ đệm byte tăng trưởng theo cấp số nhân rồi trả về chuỗi một lần, nên tổng chi phí tuyến tính.
Nguồn tham khảo
v, ok := i.(MyType) khác v := i.(MyType) ở điểm nào?Đáp án: C
Dạng hai giá trị an toàn: nếu kiểu không khớp thì v nhận zero value và ok là false, chương trình chạy tiếp. Dạng một giá trị panic ngay khi kiểu không khớp. Trong mã production gần như luôn dùng dạng hai giá trị.
Nguồn tham khảo
iota trong khối const của Go dùng để làm gì?Đáp án: D
Sinh dãy số nguyên tăng dần: nó nhận giá trị 0 ở dòng đầu tiên của khối const và tăng thêm một sau mỗi dòng. Đây là cách Go khai báo enum mà không phải đánh số thủ công, nên chèn thêm giá trị vào giữa cũng không phải sửa các dòng sau.
Nguồn tham khảo
src?dst := src rồi thao tác trên dst như một slice riêngdst := new([]T) rồi gán từng phần tử của slice gốc vàodst := make([]T, len(src)); copy(dst, src)dst := src[:] để tạo một lát cắt mới từ toàn bộ slice gốcĐáp án: C
make một slice mới đúng độ dài rồi gọi copy. Cả phép gán lẫn cắt lát đều chỉ sao chép cấu trúc mô tả (con trỏ, độ dài, sức chứa) chứ không sao chép dữ liệu, nên hai slice vẫn dùng chung mảng nền và sửa cái này thì cái kia thấy.
Nguồn tham khảo
map thông thường sẽ gây ra điều gì?Đáp án: D
Chương trình panic với thông báo về việc ghi map đồng thời. Đây là hành vi có chủ đích: runtime có cơ chế phát hiện riêng cho map và chủ động dừng, vì hỏng cấu trúc bên trong map sẽ gây lỗi khó lần hơn nhiều so với một lần panic rõ ràng.
Nguồn tham khảo
range cho thứ tự thế nào?Đáp án: A
Ngẫu nhiên, và hai lần duyệt liên tiếp có thể cho hai thứ tự khác nhau. Go cố ý ngẫu nhiên hoá điểm bắt đầu chứ không phải chỉ đơn giản là không bảo đảm — mục đích là làm lộ ngay những đoạn mã vô tình phụ thuộc vào thứ tự.
Nguồn tham khảo
Đáp án: D
Các trường và phương thức của struct được nhúng được thăng cấp lên struct ngoài, nên truy cập trực tiếp outer.Field thay vì outer.Inner.Field. Đây là composition chứ không phải kế thừa: không có đa hình, và phương thức trùng tên ở struct ngoài chỉ che đi chứ không ghi đè.
Nguồn tham khảo
T có phương thức với pointer receiver. Giá trị kiểu T (không phải *T) có thoả mãn interface chứa phương thức đó không?*T mới thoả mãnĐáp án: B
Không. Tập phương thức của T chỉ gồm các phương thức có value receiver. Tập phương thức của *T gồm cả hai loại. Vì vậy chỉ *T thoả mãn interface đó, và gán một giá trị T vào biến interface sẽ báo lỗi biên dịch.
Nguồn tham khảo
errors.Is và errors.As khác nhau ở mục đích nào?Đáp án: D
errors.Is(err, target) hỏi trong chuỗi lỗi có cái nào bằng đúng giá trị target không — dùng với các lỗi sentinel. errors.As(err, &target) tìm lỗi đầu tiên khớp kiểu rồi gán vào biến, để đọc được các trường riêng của kiểu lỗi đó.
Nguồn tham khảo
Đáp án: B
Trả về ngay zero value của kiểu phần tử mà không bị chặn — và trả về mãi như vậy. Dùng dạng hai giá trị v, ok := <-ch để phân biệt: ok là false nghĩa là channel đã đóng và hết dữ liệu tồn đọng.
Nguồn tham khảo
sync.Once bảo đảm điều gì?Đáp án: B
Hàm được truyền vào chỉ thực thi đúng một lần trong suốt vòng đời chương trình, dù có bao nhiêu goroutine cùng gọi. Quan trọng hơn, các goroutine gọi sau sẽ chờ cho tới khi lần chạy đầu hoàn tất, nên không ai quan sát được trạng thái khởi tạo dở dang.
Nguồn tham khảo
Đáp án: C
Khởi chạy N goroutine, tất cả cùng range trên một channel công việc chung. Mỗi giá trị gửi vào channel chỉ được đúng một goroutine nhận, nên việc phân phối là tự động và tự cân bằng — worker nào rảnh thì nhận việc tiếp theo.
Nguồn tham khảo
defer cancel() sau khi tạo context bằng context.WithTimeout?Đáp án: B
Để giải phóng tài nguyên. Context con được đăng ký vào context cha và một timer được tạo; nếu công việc xong sớm mà không gọi huỷ, cả hai vẫn nằm lại cho tới khi hết thời gian chờ. Với hàm được gọi nhiều lần, đây là rò rỉ thật sự.
Nguồn tham khảo
GOMAXPROCS điều khiển điều gì?Đáp án: A
Số OS thread tối đa được phép thực thi mã Go cùng lúc — tức mức song song thật. Nó không giới hạn số goroutine, vốn có thể lên tới hàng triệu. Từ Go 1.5, giá trị mặc định bằng số lõi CPU mà runtime nhìn thấy.
Nguồn tham khảo
GOGC điều chỉnh điều gì?Đáp án: D
Tỉ lệ tăng trưởng heap kích hoạt đợt thu gom kế tiếp. Mặc định là 100, nghĩa là chạy lại khi heap đạt gấp đôi kích thước còn sống sau lần thu gom trước. Đặt cao hơn thì thu gom thưa hơn nhưng tốn RAM hơn; đặt thấp hơn thì ngược lại.
Nguồn tham khảo
Đáp án: A
Mọi ca dùng chung một đoạn logic kiểm tra, nên thêm ca mới chỉ là thêm một dòng dữ liệu. Kết hợp với t.Run để mỗi ca thành một bài con có tên riêng, báo cáo chỉ rõ ca nào hỏng và các ca còn lại vẫn chạy tiếp.
Nguồn tham khảo
for i := 0; i < b.N; i++ có ý nghĩa gì?Đáp án: D
Bộ chạy benchmark tự quyết định giá trị này: nó bắt đầu với số vòng nhỏ, đo, rồi tăng dần cho tới khi tổng thời gian đủ dài (mặc định khoảng một giây) để kết quả ổn định. Kết quả báo cáo là thời gian trung bình cho một vòng.
Nguồn tham khảo
http.Client mặc định của Go có thời gian chờ (timeout) bao lâu?Đáp án: A
Không có thời gian chờ nào. http.DefaultClient để trường timeout ở zero value, nghĩa là chờ vô hạn. Nếu máy chủ đích ngừng phản hồi mà không đóng kết nối, goroutine gọi sẽ treo mãi — và trong một dịch vụ, điều này tích tụ thành cạn tài nguyên.
Nguồn tham khảo
defer resp.Body.Close() sau mỗi HTTP request?Đáp án: A
Để trả kết nối TCP về pool cho lần sau dùng lại. Không đóng thì kết nối bị giữ vĩnh viễn, và sau đủ nhiều request thì tiến trình cạn file descriptor. Nên gọi ngay sau khi kiểm tra lỗi, trước khi đọc body.
Nguồn tham khảo
time.Ticker cần được xử lý thế nào khi không dùng nữa?Stop(), nếu không bộ đếm vẫn chạy và rò rỉ tài nguyênĐáp án: B
Gọi Stop(), thường bằng lệnh hoãn ngay sau khi tạo. Bộ đếm được runtime giữ và tiếp tục gửi tín hiệu theo chu kỳ dù không còn ai đọc, nên bỏ qua bước này là rò rỉ tài nguyên tích luỹ theo thời gian.
Nguồn tham khảo
Đáp án: A
Go 1.18. Chúng cho phép viết một hàm hoặc kiểu dùng chung cho nhiều kiểu dữ liệu mà vẫn được kiểm tra lúc biên dịch. Trước đó chỉ có hai lựa chọn: chép mã cho từng kiểu, hoặc dùng interface{} rồi type assertion và mất an toàn kiểu.
Nguồn tham khảo
Đáp án: A
Cả chương trình sập. Panic lan lên hết ngăn xếp của goroutine đó, và khi tới đỉnh mà chưa được recover thì runtime kết thúc toàn bộ tiến trình. Go không cô lập lỗi theo goroutine.
Nguồn tham khảo
errgroup.Group thêm gì so với sync.WaitGroup?Đáp án: A
Nó thu lỗi và huỷ nhóm. Wait() trả về lỗi đầu tiên gặp phải thay vì không trả gì, và bản tạo kèm context sẽ huỷ context đó ngay khi có goroutine đầu tiên lỗi — nhờ đó các goroutine còn lại dừng sớm thay vì tiếp tục công việc đã trở nên vô ích.
Nguồn tham khảo
os.Exit(1) có chạy các lệnh defer đang chờ không?Đáp án: B
Không. Nó kết thúc tiến trình ngay lập tức, bỏ qua toàn bộ lệnh hoãn đang chờ. Hệ quả là tệp chưa được đóng, bộ đệm chưa được ghi xuống, và các bước dọn dẹp khác không diễn ra.
Nguồn tham khảo
:= bên trong khối if với biến trùng tên biến ngoài gây ra điều gì?Đáp án: C
Nó tạo một biến mới che biến ngoài trong phạm vi khối đó. Mọi phép gán bên trong tác động lên biến mới, còn biến ngoài giữ nguyên giá trị cũ sau khi ra khỏi khối. Đây là nguồn của lỗi trông như phép gán không có tác dụng.
Nguồn tham khảo
Đáp án: B
Tham số nên khai báo kiểu interface để bên gọi truyền vào bất kỳ hiện thực nào — dễ thay thế khi kiểm thử. Giá trị trả về nên là kiểu cụ thể để bên gọi dùng được đầy đủ phương thức và tự quyết định có cần trừu tượng hoá hay không.
Nguồn tham khảo
Đáp án: B
Thêm hậu tố phiên bản vào cuối đường dẫn: example.com/lib/v2. Vì đường dẫn khác nhau, Go coi hai phiên bản lớn là hai module hoàn toàn riêng biệt — nhờ đó một bản build chứa được cả v1 lẫn v2 khi các phụ thuộc yêu cầu khác nhau.
Nguồn tham khảo
go vet khác gofmt ở mục đích nào?Đáp án: D
gofmt chuẩn hoá định dạng — thụt lề, khoảng trắng, thứ tự import — và không quan tâm ngữ nghĩa. go vet phân tích ngữ nghĩa để tìm các mẫu mã biên dịch được nhưng gần như chắc chắn là lỗi, ví dụ chuỗi định dạng không khớp tham số.
Nguồn tham khảo
b := a[1:3] rồi b[0] = 99. Slice a có bị ảnh hưởng không?Đáp án: D
Có. Phép cắt không sao chép dữ liệu mà tạo một khung nhìn mới lên cùng mảng nền, nên sửa qua slice này thì slice kia thấy được. Muốn độc lập thì phải sao chép tường minh.
Nguồn tham khảo
data[:10] làm kết quả. Vấn đề gì?Đáp án: C
Cả mảng nền 100MB không được giải phóng. Slice con vẫn tham chiếu tới nó, nên bộ thu gom rác không thu hồi được phần còn lại dù chương trình chỉ dùng mười byte đầu.
Nguồn tham khảo
time.After trong một select nằm trong vòng lặp vô hạn gây vấn đề gì?Đáp án: A
Mỗi vòng lặp tạo một timer mới và timer chỉ được thu hồi sau khi hết hạn. Với vòng lặp chạy nhanh và thời gian chờ dài, số timer chờ trong bộ nhớ tích luỹ rất nhanh.
Nguồn tham khảo
http.ListenAndServe với server mặc định thiếu cấu hình quan trọng nào?Đáp án: A
Các mốc thời gian chờ đọc và ghi. Mặc định không có giới hạn nào, nên một client chậm hoặc cố ý giữ kết nối mở sẽ chiếm tài nguyên vô thời hạn — và đây là một dạng tấn công thật.
Nguồn tham khảo
Đáp án: C
Tên trường viết thường nên không được export. Gói mã hoá dùng reflection và chỉ truy cập được trường export, nên nó bỏ qua hoàn toàn — không có lỗi nào được trả về.
Nguồn tham khảo
sync.RWMutex phù hợp hơn sync.Mutex trong trường hợp nào?Đáp án: D
Khi số lần đọc vượt trội hẳn số lần ghi. Nhiều lượt đọc chạy song song được nên thông lượng tăng. Nếu tỉ lệ ghi cao, lợi ích không bù được chi phí quản lý phức tạp hơn của loại khoá này.
Nguồn tham khảo
Đáp án: D
Bên gửi, vì chỉ nó biết khi nào hết dữ liệu. Gửi vào channel đã đóng gây panic, nên để bên nhận đóng là tạo ra khả năng làm chương trình dừng bất ngờ.
Nguồn tham khảo
defer f.Close() bên trong vòng lặp xử lý 10 nghìn file gây vấn đề gì?Đáp án: B
Mọi file mở tới cuối hàm mới đóng, vì lệnh hoãn gắn với hàm chứ không phải vòng lặp. Với mười nghìn file, chương trình cạn mô tả file trước khi hàm kết thúc.
Nguồn tham khảo
init() trong một package chạy khi nào?Đáp án: D
Sau khi các biến cấp package được khởi tạo và trước hàm chính. Mỗi package chạy đúng một lần theo thứ tự phụ thuộc: các package được import khởi tạo xong trước rồi mới tới package hiện tại.
Nguồn tham khảo
== trong Go hoạt động thế nào?Đáp án: B
Nó so từng trường theo giá trị, nhưng chỉ hợp lệ khi mọi trường đều so sánh được. Struct chứa slice, map hoặc hàm bị từ chối ngay lúc biên dịch chứ không phải lúc chạy.
Nguồn tham khảo
strings.Split(s, " ") và strings.Fields(s) khác nhau thế nào với chuỗi có nhiều dấu cách?Đáp án: B
Hàm cắt theo dấu phân cách tạo ra các phần tử rỗng khi có hai dấu cách liên tiếp, còn hàm kia gom mọi khoảng trắng lại và bỏ qua phần thừa. Với văn bản do người dùng nhập, hàm thứ hai gần như luôn đúng ý hơn.
Nguồn tham khảo
context.WithValue nên dùng để truyền loại dữ liệu nào?Đáp án: D
Chỉ dữ liệu gắn với một request như mã theo dõi, danh tính người gọi hay thông tin ngôn ngữ. Không dùng để truyền tham số bắt buộc hay các phụ thuộc — những thứ đó phải nằm ở chữ ký hàm hoặc được tiêm lúc khởi tạo.
Nguồn tham khảo
bufio.Scanner bị dừng giữa chừng không báo lỗi rõ. Nguyên nhân?Đáp án: A
Gặp một dòng dài vượt giới hạn bộ đệm mặc định. Vòng lặp quét dừng lại như thể đã hết file, và lỗi chỉ lộ ra khi kiểm tra hàm báo lỗi sau vòng lặp — bước rất hay bị bỏ qua.
Nguồn tham khảo
go test lần thứ hai in ra (cached) mà không chạy lại. Vì sao?Đáp án: C
Kết quả được lưu đệm khi mã nguồn và các yếu tố đầu vào không đổi. Muốn buộc chạy lại thì thêm tham số đặt số lần chạy bằng một, hoặc dọn bộ nhớ đệm của công cụ dựng.
Nguồn tham khảo
Phần Nâng cao đi vào tình huống chuyên sâu và các bẫy kỹ thuật hay gặp, dành cho thành viên Pro.
Nâng cấp gói