...
Pregătire interviuri

100 de întrebări de interviu Go, cu răspunsuri

Întrebările despre Go care apar des la interviurile tehnice, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse. Înveți de la zero cu Curs Go: primele 15 lecții sunt gratuite.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 129 minde citit
Întrebări de interviu Go cu răspunsuri

La un interviu în care se verifică limbajul Go, întrebările merg de obicei în trei direcții: detaliile limbajului (zero values, slice-uri și capacitatea lor, map-uri, string-uri și rune, metode cu receiver valoare sau pointer, interfețe), tratarea erorilor și concurența (goroutine, canale, select, sync, context). Foarte multe întrebări sunt de tip „ce afișează codul” sau „unde e bug-ul”, pentru că în Go capcanele sunt puține, dar precise, și separă rapid pe cine a scris cod real de cine a citit doar sintaxa. Urmează de obicei un exercițiu de live coding sau o temă pentru acasă, în care contează codul idiomatic, tratarea erorilor și testele.

La nivel junior se așteaptă să știi exact ce face codul în situațiile obișnuite: diferența dintre lungime și capacitate, de ce range lucrează pe copii, când defer rulează, cum aștepți goroutine-urile. La nivel mid se adaugă method sets, comportamentul interfețelor, generice, context, condiții de cursă și modele de concurență precum semaforul sau worker pool-ul. La nivel senior intervin modelul de memorie, costurile de performanță, depanarea în producție și deciziile de design.

Pagina conține 100 de întrebări grupate pe teme, de la junior la senior în fiecare temă. Încearcă să răspunzi singur înainte să citești răspunsul, iar la întrebările cu cod rulează exemplele local (go run, go test -race) și modifică-le până înțelegi de ce se comportă așa. Răspunsul scurt e ce poți spune în primele secunde, iar cel detaliat arată cât de adânc poate merge discuția. Întrebările despre arhitectura serviciilor backend (HTTP, baze de date, cloud) sunt pe pagina dedicată meseriei de Go Backend Developer.

Tipuri, constante și control al fluxului

1 Junior

Ce afișează codul următor și de ce?

GO
x := 1
if true {
	x := 2
	x++
}
fmt.Println(x)

Răspuns scurt: Afișează 1. În interiorul blocului if, x := 2 declară o variabilă nouă care o ascunde (shadowing) pe cea din exterior, iar modificările afectează doar variabila interioară.

Operatorul := înseamnă întotdeauna „declară și inițializează”, nu „atribuie”. Fiecare pereche de acolade deschide un bloc nou, iar într-un bloc nou poți declara un nume care există deja în afară. Asta se numește shadowing: numele interior îl acoperă pe cel exterior până la sfârșitul blocului. După }, variabila interioară dispare și x înseamnă din nou variabila cu valoarea 1.

Unde doare în practică este combinația cu err:

GO
var cfg *Config
if path != "" {
	cfg, err := load(path) // cfg nou, doar în acest bloc
	if err != nil {
		return err
	}
	_ = cfg
}
fmt.Println(cfg == nil) // true, cfg din exterior n-a fost setat

Codul compilează, dar cfg din exterior rămâne nil. Corect este să declari err înainte și să folosești atribuire simplă: cfg, err = load(path).

Reguli utile:

  • := cere cel puțin o variabilă nouă în stânga, în același bloc; celelalte sunt doar reatribuite;
  • if, for, switch cu instrucțiune de inițializare au propriul bloc;
  • go vet nu semnalează shadowing implicit, dar analizorul shadow din golang.org/x/tools și linterele din golangci-lint pot face asta.

Ce urmărește intervievatorul: Verifică dacă știi că := declară mereu o variabilă nouă. Greșeala tipică: o variabilă (des err sau un rezultat) setată într-un bloc interior și presupusă vizibilă în afara lui.

Eroarea, în practică:no new variables on left side of :=x (local variable) is not a type

2 Junior

Ce afișează codul următor?

GO
var f float64 = 7 / 2
fmt.Println(7/2, 7/2.0, f)

const big = 1 << 100
fmt.Println(big >> 98)

Răspuns scurt: Afișează 3 3.5 3 și apoi 4. 7 / 2 sunt constante întregi, deci împărțirea e întreagă înainte de conversie, iar constantele netipizate au precizie mare, așa că 1 << 100 e valid cât timp rezultatul final încape.

În Go, literalii precum 7, 2 sau 2.0 sunt constante netipizate (untyped constants). Ele au un „fel” (întreg, real, rună, text), dar nu un tip concret ca int sau float64 până nu sunt folosite într-un context care cere un tip.

7 / 2 sunt două constante întregi, deci expresia se evaluează ca împărțire întreagă și dă constanta 3. Abia apoi 3 este convertit la float64 pentru f. De aceea f este 3, nu 3.5. În 7 / 2.0 unul dintre operanzi este real, deci rezultatul e 3.5. La afișare, fmt.Println scrie float64(3) ca 3.

Constantele sunt calculate de compilator cu precizie mult mai mare decât 64 de biți. 1 << 100 nu încape în niciun tip întreg, dar este o constantă perfect validă. big >> 98 dă 4, care încape în int, deci compilează. Dacă ai scrie var x int = big, ai primi eroare de compilare: constanta depășește tipul.

Practic:

GO
a, b := 7, 2
fmt.Println(float64(a) / float64(b)) // 3.5

Cu variabile int, trebuie conversie explicită a operanzilor, nu a rezultatului: float64(a / b) ar da tot 3.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi diferența dintre constante netipizate și variabile tipizate. Greșeala tipică este conversia rezultatului în loc de conversia operanzilor.

Eroarea, în practică:mismatched types float64 and intconstant overflows byte

3 Junior

De ce nu compilează codul următor și cum îl repari?

GO
var a int32 = 5
var b int64 = a
x := 3
y := 2.5
fmt.Println(b, x*y)

Răspuns scurt: Go nu face conversii implicite între tipuri numerice: int32 nu se poate atribui unui int64, iar int nu se poate înmulți cu float64. Reparația este conversia explicită: int64(a) și float64(x) * y.

Go are o regulă strictă: două valori numerice de tipuri diferite nu se amestecă fără conversie explicită, chiar dacă una „încape” evident în cealaltă. int, int32 și int64 sunt tipuri distincte, chiar dacă pe o platformă de 64 de biți int are aceeași dimensiune ca int64. Scopul este să vezi în cod fiecare loc în care se poate pierde precizie sau semn.

GO
var a int32 = 5
var b int64 = int64(a)
x := 3      // int
y := 2.5    // float64
fmt.Println(b, float64(x)*y) // 5 7.5

Ce trebuie să știi despre conversii:

  • int(-2.7) dă -2: conversia din real în întreg trunchiază spre zero, nu rotunjește; pentru rotunjire folosești math.Round;
  • conversia între întregi de dimensiuni diferite păstrează biții de jos, deci int8(200) dă -56;
  • int și uint au 32 sau 64 de biți în funcție de platformă;
  • o constantă netipizată se adaptează: var f float64 = 3 e valid, pentru că 3 nu are încă tip.

Conversia string(n) dintr-un întreg nu produce cifre, ci caracterul cu acel cod, de aceea pentru text folosești strconv.Itoa.

Ce urmărește intervievatorul: Se verifică faptul că știi că Go nu are promovare numerică implicită. Candidații veniți din Java sau C se așteaptă ca int32 să treacă automat în int64.

Eroarea, în practică:cannot use x (variable of type int) as string valuemismatched types float64 and int

4 Junior

Ce afișează codul următor?

GO
var x uint8 = 255
x++
var y int8 = 127
y++
var u uint = 0
u--
fmt.Println(x, y, u == math.MaxUint)

Răspuns scurt: Afișează 0 -128 true. Aritmetica pe întregi în Go face wrap-around la depășire, fără panică și fără eroare; doar depășirea unei constante la compilare este eroare.

Întregii cu dimensiune fixă se comportă modular. uint8 are valori între 0 și 255, deci 255 + 1 revine la 0. int8 are valori între -128 și 127, iar 127 + 1 trece în -128 (reprezentarea în complement față de doi). uint scăzut sub 0 devine valoarea maximă. Runtime-ul nu verifică depășirile, deci nu primești nicio panică.

Diferența importantă este între variabile și constante:

GO
var a uint8 = 256        // eroare de compilare: constanta depășește uint8
var b uint8 = 255
b = b + 1                // compilează, b devine 0

Unde apare bug-ul în cod real: bucle cu indici fără semn.

GO
s := []int{}
for i := uint(len(s)) - 1; i >= 0; i-- { // i >= 0 e mereu adevărat
	fmt.Println(s[i])                    // panică: index out of range
}

uint(0) - 1 este valoarea maximă, condiția i >= 0 nu devine niciodată falsă, iar accesul în slice panichează. De aceea în Go se folosește int pentru indici și lungimi, chiar dacă valorile nu sunt negative.

Când depășirea contează (sume de bani, contoare), verifici explicit înainte de operație sau folosești math/big pentru valori arbitrar de mari. Pachetul math/bits oferă bits.Add64 și bits.Mul64, care întorc și transportul.

Ce urmărește intervievatorul: Verifică dacă știi că overflow-ul la runtime e silențios. Greșeala tipică: bucle descrescătoare cu uint sau presupunerea că Go aruncă o eroare la depășire.

Eroarea, în practică:constant overflows byte

5 Junior

Ce afișează codul următor? Cum diferă switch din Go de cel din C sau Java?

GO
switch x := 2; x {
case 1:
	fmt.Println("unu")
case 2:
	fmt.Println("doi")
	fallthrough
case 3:
	fmt.Println("trei")
case 4:
	fmt.Println("patru")
}

Răspuns scurt: Afișează doi și trei. În Go fiecare case se oprește automat, fără break; fallthrough trece forțat în corpul următorului case fără să-i mai evalueze condiția.

În C și Java, un case fără break continuă în următorul. Go a inversat comportamentul: implicit nu se continuă, iar dacă vrei asta o ceri explicit cu fallthrough. Asta elimină o clasă întreagă de bug-uri.

Detalii care apar la interviu:

  • fallthrough sare în corpul următorului case necondiționat. Aici case 3 rulează deși x nu este 3; case 4 nu rulează, pentru că case 3 nu are fallthrough.
  • fallthrough trebuie să fie ultima instrucțiune din case și nu poate apărea în ultimul case sau într-un type switch.
  • un case poate avea mai multe valori: case 1, 2, 3:.
  • valorile din case nu trebuie să fie constante; pot fi expresii.
  • switch fără expresie este echivalent cu switch true și înlocuiește lanțurile if-else if:
GO
switch {
case nota >= 9:
	fmt.Println("foarte bine")
case nota >= 5:
	fmt.Println("promovat")
default:
	fmt.Println("respins")
}

Cazurile se evaluează de sus în jos și se oprește la primul adevărat, deci ordinea contează. default poate sta oriunde, dar se execută doar dacă niciun alt caz nu se potrivește.

Instrucțiunea de inițializare (x := 2;) creează o variabilă vizibilă doar în interiorul lui switch.

Ce urmărește intervievatorul: Se verifică dacă știi că nu e nevoie de break și ce face exact fallthrough. Mulți candidați cred că fallthrough verifică și condiția cazului următor.

Eroarea, în practică:fallthrough statement out of place

6 Junior

Go are o singură buclă, for. Ce forme are și ce afișează codul următor?

GO
for i := range 3 {
	fmt.Print(i, " ")
}
fmt.Println()
n := 0
for n < 3 {
	n++
}
fmt.Println(n)

Răspuns scurt: Afișează 0 1 2 și apoi 3. for acoperă bucla clasică, bucla de tip while, bucla infinită și range, iar începând cu Go 1.22 range merge și peste un întreg.

Go nu are while sau do-while; toate se scriu cu for:

GO
for i := 0; i < 5; i++ { }  // clasic: init; condiție; pas
for n < 3 { }               // ca while
for { }                     // infinit, ieși cu break sau return
for i, v := range slice { } // index și valoare
for k, v := range m { }     // cheie și valoare, ordine nespecificată
for i, r := range "aș" { }  // index de octet și rună
for v := range ch { }       // până la închiderea canalului
for i := range 10 { }       // Go 1.22+: 0..9

Din Go 1.23, range funcționează și peste funcții iterator (iter.Seq).

range 3 produce valorile 0, 1, 2. Dacă numărul este n <= 0, bucla nu rulează deloc. Tipul variabilei urmează tipul lui n.

Lucruri pe care merită să le menționezi:

  • începând cu Go 1.22, fiecare iterație are propria copie a variabilei de buclă, deci closure-urile nu mai văd toate aceeași valoare;
  • expresia din range se evaluează o singură dată, la început;
  • poți ignora indexul cu _: for _, v := range s, sau poți lua doar indexul: for i := range s.

Echivalentul lui do-while:

GO
for {
	citeste()
	if !continua() {
		break
	}
}

Ce urmărește intervievatorul: Intervievatorul verifică familiaritatea cu sintaxa idiomatică și cu noutățile din versiunile recente. Greșeala tipică este să cauți un while sau să nu știi de range peste întregi.

Eroarea, în practică:unexpected name in, expected {requires go1.22 or later

7 Junior

Ce afișează codul următor?

GO
fmt.Println(0.1+0.2 == 0.3)

a, b := 0.1, 0.2
fmt.Println(a+b == 0.3)

Răspuns scurt: Afișează true și apoi false. Prima expresie e calculată de compilator cu constante de precizie mare, a doua la runtime în float64, unde 0.1 și 0.2 nu se pot reprezenta exact.

Numerele float64 sunt în format binar IEEE 754, în care 0.1, 0.2 și 0.3 nu au reprezentare exactă. La runtime, a + b dă 0.30000000000000004, iar 0.3 convertit la float64 este o valoare puțin mai mică, deci comparația cu == e falsă.

Prima linie e diferită: 0.1+0.2 == 0.3 conține doar constante netipizate. Compilatorul calculează cu precizie mult mai mare (practic exact pentru astfel de valori zecimale), obține exact 0.3 de ambele părți și înlocuiește expresia cu true. Este una dintre puținele situații în care Go se comportă diferit de majoritatea limbajelor.

Cum compari corect numere reale:

GO
const eps = 1e-9
if math.Abs((a+b)-0.3) < eps {
	fmt.Println("aproximativ egale")
}

Toleranța depinde de ordinul de mărime al valorilor; pentru numere foarte mari ai nevoie de o toleranță relativă.

Pentru bani nu folosești float64 deloc. Variantele obișnuite sunt:

  • sume în unități întregi (bani, cenți) într-un int64;
  • o bibliotecă de numere zecimale, de exemplu github.com/shopspring/decimal;
  • math/big (big.Rat) când ai nevoie de precizie exactă.

math.NaN() nu este egal nici cu el însuși; verifici cu math.IsNaN.

Ce urmărește intervievatorul: Se verifică înțelegerea reprezentării în virgulă mobilă și a constantelor netipizate. Greșeala tipică: comparații cu == pe float64 sau folosirea lor pentru sume de bani.

8 Junior

Ce afișează codul următor? Cum ieși dintr-o buclă aflată în exteriorul unui switch?

GO
for i := 0; i < 5; i++ {
	switch {
	case i == 2:
		break
	}
	fmt.Print(i)
}

Răspuns scurt: Afișează 01234. break dintr-un switch (sau select) iese doar din switch, nu din for; ca să oprești bucla folosești o etichetă: break loop.

În Go, break oprește cea mai interioară instrucțiune for, switch sau select în care se află. Aici aceasta este switch, deci break doar încheie cazul, iar bucla continuă și afișează toate valorile. De fapt, break aici nu are niciun efect, pentru că un case se oprește oricum singur.

Soluția idiomatică este o etichetă:

GO
loop:
	for i := 0; i < 5; i++ {
		switch {
		case i == 2:
			break loop
		}
		fmt.Print(i)
	}
// afișează 01

Etichetele funcționează și cu continue, util în bucle imbricate:

GO
outer:
	for _, row := range grid {
		for _, v := range row {
			if v < 0 {
				continue outer // trece la rândul următor
			}
			sum += v
		}
	}

Aceeași capcană apare în buclele cu select, de exemplu la citirea dintr-un canal până la un semnal de oprire: un break în case <-done: nu oprește for-ul, iar goroutine-ul continuă la nesfârșit. Acolo folosești fie return, fie o etichetă.

Etichetele nefolosite sunt eroare de compilare. Alternativa la etichete este extragerea buclei într-o funcție și folosirea lui return, ceea ce face adesea codul mai clar.

Ce urmărește intervievatorul: Se verifică dacă știi domeniul lui break. Greșeala clasică apare în bucle for cu select, unde un break nu oprește goroutine-ul.

Eroarea, în practică:break is not in a loop, switch, or selectlabel defined and not used

9 Junior

Cum folosești funcțiile ca valori în Go? Scrie un mic calculator care alege operația dintr-un map de funcții. Se pot compara două funcții?

Răspuns scurt: Funcțiile sunt valori de prim rang: au tip (func(int, int) int), se pot pune în variabile, map-uri și parametri. Nu se pot compara între ele, doar cu nil, iar apelul unei funcții nil produce panică.

Un tip de funcție este definit de parametri și valorile întoarse. Poți să-i dai un nume ca să faci codul mai lizibil:

GO
type Op func(a, b int) (int, error)

var ops = map[string]Op{
	"+": func(a, b int) (int, error) { return a + b, nil },
	"-": func(a, b int) (int, error) { return a - b, nil },
	"/": func(a, b int) (int, error) {
		if b == 0 {
			return 0, errors.New("împărțire la zero")
		}
		return a / b, nil
	},
}

func calc(a int, op string, b int) (int, error) {
	f, ok := ops[op]
	if !ok {
		return 0, fmt.Errorf("operator necunoscut %q", op)
	}
	return f(a, b)
}

Acest model (dispatch table) înlocuiește un switch lung și permite adăugarea de operații fără a modifica funcția calc.

Reguli importante:

  • valoarea zero a unui tip de funcție este nil; apelul unei funcții nil panichează, deci verifici if f != nil când funcția e opțională;
  • f == g nu compilează pentru două funcții; doar f == nil este permis. De aceea funcțiile nu pot fi chei de map;
  • o funcție anonimă care folosește variabile din exterior este un closure și păstrează referința la acele variabile, nu o copie.

Funcțiile ca parametri apar peste tot în biblioteca standard: slices.SortFunc, strings.Map, http.HandleFunc, sync.OnceFunc.

Ce urmărește intervievatorul: Verifică dacă știi să folosești funcțiile pentru a simplifica cod. Mulți candidați nu știu că funcțiile nu se pot compara sau că o funcție nil panichează la apel.

Eroarea, în practică:unexpected name ..., expected ( (funcție în funcție)

10 Mid

Ce afișează codul următor?

GO
const (
	A = iota
	B
	_
	D
	E = "x"
	F
	G = iota
)

const (
	H, I = iota, iota * 10
	J, K
)

fmt.Println(A, B, D, E, F, G, H, I, J, K)

Răspuns scurt: Afișează 0 1 3 x x 6 0 0 1 10. iota este indexul liniei din blocul const, iar o linie fără expresie repetă expresia de deasupra cu noul iota.

iota pornește de la 0 la începutul fiecărui bloc const și crește cu 1 la fiecare linie (ConstSpec), indiferent ce conține linia. Două reguli explică totul:

  • o linie fără expresie repetă textul expresiei precedente, dar evaluat cu valoarea curentă a lui iota;
  • pe aceeași linie, iota are aceeași valoare peste tot.

Pas cu pas: A = 0, B repetă iota = 1, _ consumă 2, D = 3. E = "x" (iota e 4, dar nu e folosit), F repetă "x", deci tot "x". G = iota pe linia a șaptea, deci 6.

În al doilea bloc, iota repornește de la 0. Pe prima linie H = 0 și I = 0 * 10 = 0. A doua linie repetă perechea de expresii cu iota = 1: J = 1, K = 10.

Modele utile în practică:

GO
type Perm uint8

const (
	Read Perm = 1 << iota // 1
	Write                 // 2
	Exec                  // 4
)

const (
	_  = iota
	KB = 1 << (10 * iota) // 1024
	MB                    // 1048576
)

Pentru enumerări, e bine ca valoarea 0 să însemne „necunoscut” sau „invalid”, pentru ca o variabilă neinițializată să nu treacă drept o valoare validă. iota nu e sigur pentru valori persistate în baza de date: inserarea unei constante în mijloc renumerotează tot ce urmează.

Ce urmărește intervievatorul: Verifică înțelegerea exactă a regulilor lui iota și a repetării expresiei implicite. Greșeala tipică: credința că E și F primesc numere sau că iota se resetează după o valoare explicită.

Eroarea, în practică:cannot use iota outside constant declaration

11 Mid

Ce afișează codul următor? Ce se întâmplă cu un slice transmis unei funcții variadice?

GO
func double(nums ...int) {
	for i := range nums {
		nums[i] *= 2
	}
}

func main() {
	s := []int{1, 2, 3}
	double(s...)
	fmt.Println(s)
	double(1, 2, 3)
}

Răspuns scurt: Afișează [2 4 6]. Când apelezi double(s...), funcția primește chiar slice-ul s, fără copiere, deci modifică elementele apelantului; la double(1, 2, 3) se creează un slice nou.

Un parametru variadic nums ...int este, în interiorul funcției, un []int. Există două moduri de apel, cu semantici diferite:

  • double(1, 2, 3): compilatorul creează un slice nou cu aceste valori și îl transmite; modificările nu se văd nicăieri în afară;
  • double(s...): slice-ul s este transmis direct, cu același array de bază. Nu există copiere, deci nums[i] *= 2 modifică s.

Reguli de sintaxă:

  • parametrul variadic trebuie să fie ultimul;
  • nu poți amesteca valori și ...: double(0, s...) nu compilează;
  • dacă nu transmiți nimic, nums este nil, cu lungime 0.

Același mecanism stă la baza lui append:

GO
a := []int{1, 2}
b := []int{3, 4}
a = append(a, b...)

Capcana cu []any: o funcție func log(args ...any) nu primește un []string cu ..., pentru că []string nu este []any:

GO
names := []string{"a", "b"}
// fmt.Println(names...) nu compilează
args := make([]any, len(names))
for i, n := range names {
	args[i] = n
}
fmt.Println(args...)

Dacă funcția nu are voie să modifice datele apelantului, fă o copie la intrare cu slices.Clone(nums).

Ce urmărește intervievatorul: Se verifică dacă știi că s... nu copiază slice-ul. Greșeala tipică este o funcție variadică ce sortează sau modifică argumentele și strică datele apelantului.

Eroarea, în practică:cannot use ... in call to non-variadiccan only use ... with final parameter

12 Senior

Ce afișează codul următor? Ce garantează specificația Go despre ordinea de evaluare?

GO
i := 0
s := []int{10, 20}
i, s[i] = 1, 99
fmt.Println(i, s)

Răspuns scurt: Afișează 1 [99 20]. Atribuirea multiplă are două faze: întâi se evaluează indicii din stânga și expresiile din dreapta, apoi se fac atribuirile de la stânga la dreapta, deci s[i] folosește încă i = 0.

Specificația spune că atribuirea multiplă se face în două faze. În prima fază se evaluează operanzii expresiilor de indexare și ai dereferențierilor din stânga, plus toate expresiile din dreapta. În a doua fază se fac atribuirile, de la stânga la dreapta. Așadar indexul din s[i] este fixat la 0 înainte ca i să primească 1. De aici vine și swap-ul fără variabilă temporară: a, b = b, a.

Ce garantează Go despre ordinea de evaluare în general:

  • apelurile de funcții, metodele, operațiile de primire pe canal și operatorii logici se evaluează de la stânga la dreapta;
  • ordinea dintre aceste apeluri și citirea simplă a unei variabile nu este specificată.

Exemplul din specificație:

GO
a := 1
f := func() int { a++; return a }
x := []int{a, f()} // x poate fi [1 2] sau [2 2]

Nu este garantat dacă a este citit înainte sau după apelul f(). Același lucru pentru m[k], v = f(), g(): f se apelează înaintea lui g, dar momentul evaluării lui k față de ele nu e fixat.

Concluzia practică: nu scrie expresii în care un apel cu efecte secundare modifică o variabilă citită în aceeași expresie. Desparte în instrucțiuni separate. Codul devine previzibil, ușor de citit și nu depinde de versiunea compilatorului.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi semantica precisă a atribuirii multiple și limitele garanțiilor de evaluare. Greșeala tipică este presupunerea că i e actualizat înainte de s[i].

Slice-uri, array-uri și map-uri

13 Junior

Ce afișează codul următor? Unde e bug-ul?

GO
s := make([]int, 3)
for i := 0; i < 3; i++ {
	s = append(s, i)
}
fmt.Println(s, len(s))

Răspuns scurt: Afișează [0 0 0 0 1 2] 6. make([]int, 3) creează un slice cu lungimea 3, plin de zerouri, iar append adaugă după ele; voiai make([]int, 0, 3).

Un slice are trei componente: un pointer spre array-ul de bază, lungimea (len) și capacitatea (cap). make([]int, n) creează un slice cu len = n și cap = n, cu toate elementele la valoarea zero. append scrie întotdeauna la poziția len, deci adaugă după cele trei zerouri.

Ai două variante corecte, în funcție de stilul ales:

GO
// 1. prealocare de capacitate + append
s := make([]int, 0, 3)
for i := 0; i < 3; i++ {
	s = append(s, i)
}

// 2. lungime fixă + atribuire pe index
s := make([]int, 3)
for i := 0; i < 3; i++ {
	s[i] = i
}

Ambele produc [0 1 2] și fac o singură alocare.

Recapitulare:

  • make([]T, len): lungime și capacitate egale;
  • make([]T, len, cap): capacitate mai mare, pentru append fără realocare;
  • accesul s[i] cu i >= len(s) panichează chiar dacă i < cap(s);
  • len(s) și cap(s) sunt O(1).

Regula de lucru: dacă folosești append, pornește de la lungime 0. Dacă atribui pe index, pornește de la lungimea finală. Amestecul celor două este o sursă frecventă de bug-uri în taskurile de live coding, iar rezultatul are aspect plauzibil (zerouri la început), așa că trece ușor neobservat.

Ce urmărește intervievatorul: Se verifică diferența dintre lungime și capacitate. Este o greșeală foarte frecventă la live coding, mai ales la candidații care vin din limbaje cu liste dinamice.

Eroarea, în practică:append(...) (value of type []int) is not usedmake([]int) expects 2 or 3 arguments

14 Junior

Care este diferența dintre un slice nil și un slice gol? Ce afișează codul următor?

GO
var a []int
b := []int{}
fmt.Println(len(a), len(b), a == nil, b == nil)

ja, _ := json.Marshal(a)
jb, _ := json.Marshal(b)
fmt.Println(string(ja), string(jb))

Răspuns scurt: Afișează 0 0 true false și null []. Ambele au lungimea 0 și se comportă la fel la len, range și append, dar slice-ul nil nu are array de bază și se serializează în JSON ca null.

Un slice nil are pointerul, lungimea și capacitatea zero. Un slice gol ([]int{} sau make([]int, 0)) are lungimea 0, dar pointerul nu este nil. Pentru aproape toate operațiile sunt echivalente:

  • len și cap dau 0;
  • range nu face nicio iterație;
  • append(a, 1) funcționează pe un slice nil și alocă la nevoie;
  • a[0] panichează în ambele cazuri.

Diferențele apar în câteva locuri:

  • comparația cu nil: a == nil e true, b == nil e false;
  • encoding/json scrie null pentru slice-ul nil și [] pentru cel gol, ceea ce poate strica un client JavaScript care face data.items.length;
  • reflect.DeepEqual(a, b) este false.

Recomandarea idiomatică:

  • declari cu var s []T când nu știi încă dacă vei adăuga ceva; nu alocă nimic;
  • verifici „este gol?” cu len(s) == 0, nu cu s == nil, ca funcția să trateze la fel ambele cazuri;
  • când răspunsul unui API trebuie să conțină [], inițializezi explicit: items := []Item{} sau make([]Item, 0).

În teste, slices.Equal(a, b) tratează nil și gol ca egale, spre deosebire de reflect.DeepEqual.

Ce urmărește intervievatorul: Verifică dacă știi diferența subtilă și efectul ei asupra JSON-ului. Greșeala tipică este un API care întoarce null în loc de listă goală.

Eroarea, în practică:slice can only be compared to nil

15 Junior

Cum verifici dacă o valoare există într-un slice? Ce complexitate are și când e mai bine să folosești un map?

Răspuns scurt: Din Go 1.21 folosești slices.Contains sau slices.Index, care fac o căutare liniară O(n). Dacă faci multe căutări pe aceeași colecție, construiești un map[T]struct{} cu căutare O(1) în medie, sau sortezi și folosești slices.BinarySearch.

Pachetul slices din biblioteca standard (Go 1.21+) are funcții generice pentru operațiile frecvente:

GO
nume := []string{"ana", "ion", "maria"}
fmt.Println(slices.Contains(nume, "ion"))  // true
fmt.Println(slices.Index(nume, "maria"))   // 2
fmt.Println(slices.Index(nume, "dan"))     // -1

i := slices.IndexFunc(nume, func(s string) bool {
	return strings.HasPrefix(s, "m")
}) // 2

Înainte de 1.21 scriai o buclă for manuală; rezultatul e același.

Toate acestea parcurg slice-ul, deci costă O(n). Pentru o singură căutare e ideal. Dacă însă verifici apartenența pentru fiecare element dintr-o altă listă, ajungi la O(n·m). Atunci construiești o mulțime:

GO
set := make(map[string]struct{}, len(nume))
for _, n := range nume {
	set[n] = struct{}{}
}
if _, ok := set["ion"]; ok {
	fmt.Println("găsit")
}

struct{} ocupă zero octeți, deci map-ul stochează doar cheile.

A treia variantă: sortezi o dată cu slices.Sort și cauți cu slices.BinarySearch, care întoarce poziția și dacă a găsit valoarea, în O(log n). E utilă când datele sunt deja sortate sau când vrei și ordinea.

La un interviu, merită să spui explicit ce alegi și de ce: pentru câteva zeci de elemente căutarea liniară e adesea mai rapidă decât un map, din cauza costului de hashing și a localității în memorie.

Ce urmărește intervievatorul: Se verifică dacă știi biblioteca standard modernă și dacă te gândești la complexitate. Greșeala tipică: căutări liniare repetate în bucle imbricate.

16 Junior

Ce afișează codul următor? De ce prețurile nu se dublează?

GO
type Item struct{ Price int }

items := []Item{{10}, {20}}
for _, it := range items {
	it.Price *= 2
}
fmt.Println(items)

Răspuns scurt: Afișează [{10} {20}]. Variabila it din range este o copie a fiecărui element, deci modificarea ei nu ajunge în slice; modifici prin index: items[i].Price *= 2.

La fiecare iterație, range copiază elementul curent în variabila de buclă. Pentru un slice de structuri, it este o copie completă a structurii, deci it.Price *= 2 modifică doar copia, care dispare la sfârșitul iterației.

Variantele corecte:

GO
for i := range items {
	items[i].Price *= 2
}

// sau, dacă ai mult cod în buclă:
for i := range items {
	it := &items[i]
	it.Price *= 2
}

&items[i] este adresa elementului din array-ul de bază, deci modificările ajung în slice.

Dacă slice-ul conține pointeri ([]*Item), atunci it este o copie a pointerului, care indică spre aceeași structură, și it.Price *= 2 funcționează. De aici vine confuzia: același cod se comportă diferit în funcție de tipul elementelor.

Două observații suplimentare:

  • copierea are cost: pentru structuri mari, for _, it := range items copiază fiecare structură. Iterarea pe index evită copia;
  • aceeași regulă se aplică la map-uri: for _, v := range m dă copii ale valorilor, iar o structură dintr-un map nu poate fi modificată pe loc. Trebuie s-o citești, s-o modifici și s-o scrii înapoi: v := m[k]; v.Price *= 2; m[k] = v.

Începând cu Go 1.22, variabila de buclă este nouă la fiecare iterație, dar tot copie a elementului rămâne.

Ce urmărește intervievatorul: Verifică înțelegerea semanticii de copiere a lui range. Este una dintre cele mai frecvente capcane și apare des în exerciții de tip „găsește bug-ul”.

17 Junior

Ce afișează codul următor? Cum se folosește corect copy?

GO
src := []int{1, 2, 3}
dst := make([]int, 0, 3)
n := copy(dst, src)
fmt.Println(n, dst)

Răspuns scurt: Afișează 0 []. copy copiază min(len(dst), len(src)) elemente și se uită la lungime, nu la capacitate; dst are lungimea 0, deci nu se copiază nimic.

Semnătura este copy(dst, src []T) int. Funcția copiază cel mult atâtea elemente câte încap în lungimea destinației și întoarce numărul de elemente copiate. Capacitatea nu contează, pentru că copy nu modifică lungimea lui dst.

Variantele corecte:

GO
dst := make([]int, len(src))
copy(dst, src)              // [1 2 3]

dst2 := slices.Clone(src)   // Go 1.21, cel mai simplu
dst3 := append([]int(nil), src...)

Diferență mică: slices.Clone pe un slice nil întoarce nil, iar pe unul gol întoarce un slice gol.

Alte lucruri utile despre copy:

  • funcționează corect și când sursa și destinația se suprapun, deci poți muta elemente în același slice: copy(s[1:], s) deplasează totul cu o poziție la dreapta;
  • poate copia dintr-un string într-un []byte: copy(buf, "salut");
  • copiază valorile elementelor. Dacă elementele sunt pointeri, slice-uri sau map-uri, copia împarte în continuare datele interne (copie superficială).

De ce ai nevoie de copie: un slice e doar o „fereastră” peste un array. Dacă dai mai departe același slice, oricine îl modifică modifică datele tale. O funcție care păstrează un slice primit (de exemplu îl salvează într-o structură) ar trebui să-l copieze, ca apelantul să-l poată refolosi fără efecte neașteptate.

Ce urmărește intervievatorul: Se verifică dacă știi că copy lucrează cu lungimea. Candidații prealocă cu make(..., 0, n) din obișnuința de la append și obțin un slice gol.

Eroarea, în practică:invalid copy: argument must be a slice

18 Junior

Cum ștergi elementul de la indexul i dintr-un slice? Ce afișează codul următor?

GO
a := []int{1, 2, 3, 4}
b := append(a[:1], a[2:]...)
fmt.Println(a, b)

Răspuns scurt: Afișează [1 3 4 4] [1 3 4]. append scrie peste array-ul lui a, deci elementele se mută la stânga, iar ultimul rămâne duplicat. Din Go 1.21 există slices.Delete, care din Go 1.22 pune și zero în pozițiile eliberate.

a[:1] are lungimea 1 și capacitatea 4. append(a[:1], a[2:]...) copiază 3 și 4 în array-ul existent, începând de la poziția 1, fără realocare. Array-ul devine 1 3 4 4. b vede primele trei elemente, iar a, care are în continuare lungimea 4, vede și ultimul element rămas.

Variante de ștergere:

GO
// păstrează ordinea, O(n)
s = append(s[:i], s[i+1:]...)

// biblioteca standard, Go 1.21+
s = slices.Delete(s, i, i+1)

// nu păstrează ordinea, O(1)
s[i] = s[len(s)-1]
s = s[:len(s)-1]

Începând cu Go 1.22, slices.Delete pune valoarea zero în pozițiile de la noua lungime până la cea veche. În exemplul de mai sus, a ar deveni [1 3 4 0]. Asta e important pentru slice-uri de pointeri: fără ștergerea capătului, elementul rămas în array ține obiectul în viață și împiedică garbage collector-ul să-l elibereze.

Ce trebuie reținut:

  • reatribuie mereu rezultatul: s = slices.Delete(s, i, i+1);
  • nu folosi după ștergere alte slice-uri care împart același array;
  • pentru ștergerea mai multor elemente după o condiție, folosește slices.DeleteFunc sau filtrarea pe loc, nu ștergeri repetate în buclă, care dau O(n²).

Ce urmărește intervievatorul: Verifică înțelegerea faptului că ștergerea modifică array-ul de bază. Greșeala tipică: folosirea vechiului slice după ștergere sau ștergerea în buclă cu indici care se decalează.

Eroarea, în practică:is not a map (delete)

19 Junior

Ce afișează codul următor? De ce append din funcție nu se vede în main?

GO
func add(s []int) {
	s[0] = 100
	s = append(s, 4)
}

func main() {
	s := []int{1, 2, 3}
	add(s)
	fmt.Println(s)
}

Răspuns scurt: Afișează [100 2 3]. Funcția primește o copie a antetului slice-ului (pointer, lungime, capacitate): modificarea unui element se vede, pentru că array-ul e comun, dar lungimea nouă după append rămâne doar în copia locală.

În Go totul se transmite prin valoare. Pentru un slice, valoarea transmisă este antetul: pointerul spre array, lungimea și capacitatea. Funcția add are propriul antet, care indică spre același array.

  • s[0] = 100 scrie în array-ul comun, deci se vede în main;
  • s = append(s, 4): capacitatea este 3, deci append alocă un array nou și actualizează doar antetul local. În main, s are tot lungimea 3 și indică spre array-ul vechi.

Chiar dacă ar exista capacitate liberă și append ar scrie în același array, main tot nu ar vedea elementul nou, pentru că lungimea lui rămâne 3. Ar fi și mai înșelător: datele există în memorie, dar sunt invizibile.

Variante corecte:

GO
func add(s []int) []int {
	return append(s, 4)
}
s = add(s)

// sau, mai rar:
func addPtr(s *[]int) {
	*s = append(*s, 4)
}
addPtr(&s)

Varianta care întoarce slice-ul este cea idiomatică; așa funcționează și append din limbaj.

Ce să spui la interviu: slice-urile nu sunt „transmise prin referință”. Se transmite prin valoare o structură mică ce conține un pointer. Map-urile și canalele se comportă diferit, pentru că valoarea lor este chiar un pointer spre structura internă, deci operațiile din funcție se văd în exterior.

Ce urmărește intervievatorul: Se verifică modelul mental corect: antetul slice-ului se copiază, array-ul nu. Candidații spun des că slice-urile „sunt referințe”, ceea ce nu explică acest rezultat.

Eroarea, în practică:append(...) (value of type []int) is not used

20 Junior

Scrie o funcție care primește un text și întoarce de câte ori apare fiecare cuvânt, ignorând majusculele și punctuația de la capete. Cum afișezi apoi rezultatul în ordine alfabetică?

Răspuns scurt: Împarți textul cu strings.Fields, normalizezi cu strings.ToLower și strings.Trim, apoi incrementezi counts[w]++ într-un map[string]int; pentru afișare ordonată sortezi cheile, de exemplu cu slices.Sorted(maps.Keys(counts)) din Go 1.23.

Soluția se bazează pe faptul că un map întoarce valoarea zero pentru o cheie lipsă, deci counts[w]++ funcționează și la prima apariție.

GO
func wordCount(text string) map[string]int {
	counts := make(map[string]int)
	for _, w := range strings.Fields(strings.ToLower(text)) {
		w = strings.Trim(w, ".,;:!?\"()")
		if w != "" {
			counts[w]++
		}
	}
	return counts
}

func main() {
	c := wordCount("Ana are mere. Ana are, și pere!")
	for _, w := range slices.Sorted(maps.Keys(c)) {
		fmt.Println(w, c[w])
	}
}

Puncte de discutat:

  • strings.Fields desparte după orice spațiu alb (spații multiple, tab, linie nouă), spre deosebire de strings.Split(text, " "), care produce elemente goale;
  • ordinea de parcurgere a unui map este intenționat nespecificată, deci pentru ieșire stabilă sortezi cheile. Înainte de Go 1.23 colectai cheile manual într-un slice și foloseai sort.Strings;
  • pentru top N cuvinte, colectezi perechi într-un slice și sortezi cu slices.SortFunc după frecvență, apoi alfabetic;
  • strings.ToLower funcționează corect cu diacritice, pentru că lucrează pe rune.

Complexitatea este O(n) pentru numărare plus O(k log k) pentru sortarea celor k cuvinte distincte. Pentru texte foarte mari, citești pe linii cu bufio.Scanner în loc să încarci tot fișierul în memorie.

Ce urmărește intervievatorul: Este un exercițiu clasic de live coding pentru juniori. Se urmărește folosirea valorii zero din map și faptul că știi că ordinea map-urilor nu este garantată.

21 Junior

Ce tipuri pot fi chei într-un map? Ce se întâmplă la rularea codului următor?

GO
m := map[any]int{}
m[1] = 1
m["a"] = 2
m[[]int{1}] = 3
fmt.Println(len(m))

Răspuns scurt: Cheile trebuie să fie de tip comparabil: numere, string, bool, pointeri, canale, interfețe, array-uri și structuri formate din tipuri comparabile. Codul compilează, dar panichează la runtime: hash of unhashable type []int.

Un map are nevoie să compare chei cu == și să le calculeze hash-ul. Tipurile care nu suportă == (slice-uri, map-uri, funcții) nu pot fi chei, iar compilatorul respinge map[[]int]bool.

Cu cheie de tip interfață (any), compilatorul acceptă orice valoare, pentru că interfețele sunt comparabile. Verificarea reală se mută la runtime: când pui un []int în interfață și îl folosești drept cheie, programul panichează. Primele două atribuiri reușesc, a treia oprește programul înainte de Println.

Chei compuse utile:

GO
type Pos struct{ X, Y int }
visited := map[Pos]bool{}
visited[Pos{1, 2}] = true

grid := map[[2]int]rune{}
grid[[2]int{0, 0}] = '#'

Structurile și array-urile sunt comparabile dacă toate câmpurile, respectiv elementele, sunt comparabile. Sunt mult mai bune decât chei construite cu fmt.Sprintf("%d,%d", x, y), care alocă la fiecare acces.

Alte detalii:

  • două chei pointer sunt egale doar dacă indică spre același obiect, nu dacă au același conținut;
  • math.NaN() nu este egal cu el însuși, deci fiecare inserare cu cheia NaN creează o intrare nouă, imposibil de citit înapoi;
  • pentru chei float64, valorile 0.0 și -0.0 sunt aceeași cheie.

În cod generic, constrângerea comparable exprimă exact această cerință pentru chei.

Ce urmărește intervievatorul: Verifică regula comparabilității și faptul că interfețele mută eroarea la runtime. Greșeala tipică: chei din string-uri formatate în loc de structuri.

Eroarea, în practică:slice can only be compared to nilhash of unhashable type

22 Junior

Unde e bug-ul în codul următor și cum creezi corect o matrice de 3x4?

GO
grid := make([][]int, 3)
grid[0][0] = 1

Răspuns scurt: make([][]int, 3) creează doar slice-ul exterior, cu trei rânduri nil, deci grid[0][0] panichează cu index out of range. Fiecare rând trebuie alocat separat, de exemplu cu make([]int, 4) într-o buclă.

Un [][]int este un slice de slice-uri. make([][]int, 3) alocă trei antete de slice, toate cu valoarea zero, adică nil, cu lungime 0. Accesul grid[0][0] încearcă indexul 0 într-un slice gol și produce panică.

Varianta corectă:

GO
rows, cols := 3, 4
grid := make([][]int, rows)
for i := range grid {
	grid[i] = make([]int, cols)
}
grid[0][0] = 1

Variantă cu o singură alocare, utilă pentru performanță la matrice mari:

GO
data := make([]int, rows*cols)
grid := make([][]int, rows)
for i := range grid {
	grid[i] = data[i*cols : (i+1)*cols : (i+1)*cols]
}

Indexul cu trei valori limitează capacitatea fiecărui rând, astfel încât un append pe un rând nu suprascrie începutul rândului următor.

Capcana inversă: refolosirea aceluiași rând.

GO
row := make([]int, cols)
for i := range grid {
	grid[i] = row // toate rândurile împart același array
}
grid[0][0] = 5 // apare în toate rândurile

Dacă dimensiunile sunt cunoscute la compilare, un array [3][4]int este mai simplu: e un singur bloc contiguu, inițializat cu zero, fără nicio alocare suplimentară, și se copiază complet la atribuire.

Ce urmărește intervievatorul: Se verifică înțelegerea structurii slice-urilor imbricate. Este o eroare frecventă în exercițiile cu grile, matrice și programare dinamică.

Eroarea, în practică:index out of range [3] with length 3

23 Mid

Ce afișează codul următor? Se termină bucla?

GO
s := []int{1, 2, 3}
for i := range s {
	s = append(s, i)
}
fmt.Println(s)

Răspuns scurt: Afișează [1 2 3 0 1 2]. Expresia din range se evaluează o singură dată, la începutul buclei, deci numărul de iterații este fixat la lungimea inițială, 3, chiar dacă s crește.

range evaluează expresia o singură dată și lucrează cu copia antetului de slice obținută atunci. Lungimea folosită pentru iterații este 3. append creează slice-uri noi (și, aici, un array nou), dar range nu le vede. După trei iterații, bucla se oprește, iar s conține valorile adăugate: 0, 1, 2.

Comparația cu bucla clasică:

GO
s := []int{1, 2, 3}
for i := 0; i < len(s); i++ {
	s = append(s, i) // len(s) se reevaluează: buclă infinită
}

Aici condiția se recalculează la fiecare pas și bucla nu se termină niciodată (până la epuizarea memoriei).

Un detaliu mai fin: dacă folosești și valoarea, for i, v := range s, valorile se citesc din array-ul inițial pe măsură ce bucla avansează. Dacă în timpul buclei modifici un element viitor prin index, iar array-ul nu a fost realocat, vei vedea valoarea modificată:

GO
s := []int{1, 2, 3}
for i, v := range s {
	if i == 0 {
		s[2] = 99
	}
	fmt.Print(v, " ") // 1 2 99
}

Pentru array-uri (nu slice-uri), for i, v := range arr copiază întregul array la început, deci modificarea nu s-ar vedea.

Când ai nevoie să procesezi elemente adăugate în timpul parcurgerii (o coadă BFS), folosești explicit for len(queue) > 0.

Ce urmărește intervievatorul: Verifică dacă știi că range evaluează expresia o singură dată. Este o întrebare care separă candidații care au citit specificația de cei care ghicesc.

24 Mid

Este sigur să ștergi sau să adaugi chei într-un map în timp ce îl parcurgi cu range? Cum golești un map?

Răspuns scurt: Ștergerea în timpul parcurgerii este sigură, iar intrările șterse și neatinse încă nu vor mai apărea. Adăugarea este permisă, dar cheile noi pot apărea sau nu în aceeași parcurgere. Din Go 1.21, clear(m) golește map-ul.

Specificația spune explicit: dacă o intrare care nu a fost încă vizitată este ștearsă în timpul iterației, ea nu va fi produsă. Dacă se adaugă intrări, ele pot fi produse sau omise, fără garanție. Deci filtrarea pe loc este un model corect:

GO
for k, v := range stocuri {
	if v == 0 {
		delete(stocuri, k)
	}
}

Adăugarea în timpul parcurgerii, în schimb, face rezultatul nedeterminist. Dacă ai nevoie de chei derivate, le colectezi într-un map separat și le adaugi după buclă.

Restricția importantă este concurența: această garanție e valabilă doar într-o singură goroutine. Scrierea concurentă în map, chiar și în timpul unei parcurgeri din altă goroutine, oprește programul cu eroare fatală.

Pentru golire:

GO
clear(m) // Go 1.21+, păstrează memoria alocată pentru refolosire
m = make(map[string]int) // map nou, cel vechi va fi eliberat de GC

Înainte de Go 1.21 se folosea for k := range m { delete(m, k) }, pe care compilatorul îl optimiza oricum.

Alte funcții utile din pachetul maps:

  • maps.Clone(m) face o copie superficială;
  • maps.Copy(dst, src) copiază intrările;
  • maps.DeleteFunc(m, func(k, v) bool) șterge după condiție;
  • maps.Keys și maps.Values (Go 1.23) întorc iteratori, pe care îi transformi în slice cu slices.Collect.

clear pe un slice nu schimbă lungimea, ci pune valoarea zero în toate elementele.

Ce urmărește intervievatorul: Se verifică cunoașterea garanțiilor de iterare și a funcțiilor noi. Mulți candidați cred greșit că ștergerea în timpul range provoacă erori, ca în Java.

25 Mid

Ai un slice de studenți cu nume și notă. Sortează-l descrescător după notă, iar la note egale alfabetic după nume. Ce diferență este între sort.Slice și slices.SortFunc?

Răspuns scurt: Folosești slices.SortFunc cu o funcție care întoarce un întreg negativ, zero sau pozitiv, combinând criteriile cu cmp.Compare și cmp.Or. sort.Slice este API-ul mai vechi, bazat pe o funcție less și pe reflecție; pentru ordine stabilă există variantele Stable.

Soluția modernă (Go 1.21 pentru slices și cmp, Go 1.22 pentru cmp.Or):

GO
type Student struct {
	Name  string
	Grade int
}

slices.SortFunc(students, func(a, b Student) int {
	return cmp.Or(
		cmp.Compare(b.Grade, a.Grade), // descrescător: b înaintea lui a
		strings.Compare(a.Name, b.Name),
	)
})

cmp.Or întoarce primul argument diferit de zero, deci al doilea criteriu contează doar la egalitate pe primul. Inversarea lui a și b dă ordinea descrescătoare.

Varianta mai veche:

GO
sort.Slice(students, func(i, j int) bool {
	if students[i].Grade != students[j].Grade {
		return students[i].Grade > students[j].Grade
	}
	return students[i].Name < students[j].Name
})

Diferențe:

  • slices.SortFunc e generic, primește elementele direct și este de obicei mai rapid; sort.Slice primește indici și folosește reflecție pentru a interschimba elementele;
  • ambele nu sunt stabile: elementele egale își pot schimba ordinea relativă. Pentru stabilitate folosești slices.SortStableFunc sau sort.SliceStable;
  • funcția de comparare trebuie să fie consecventă (ordine strictă slabă). O funcție greșită, de exemplu care întoarce true și pentru less(a, b) și pentru less(b, a), produce rezultate imprevizibile.

strings.Compare compară octeții, nu regulile limbii române. Pentru sortare corectă cu diacritice folosești golang.org/x/text/collate.

Ce urmărește intervievatorul: Se verifică stăpânirea API-ului modern și a sortării multi-criteriu. Greșeala tipică: comparare greșită la egalitate sau ignorarea stabilității.

26 Senior

Cum crește capacitatea unui slice la append? De ce contează prealocarea și cum o faci?

Răspuns scurt: La capacitate epuizată, append alocă un array nou și copiază elementele. Din Go 1.18 capacitatea se dublează sub 256 de elemente, apoi crește treptat spre circa 1,25x. Prealocarea cu make sau slices.Grow evită realocările.

Algoritmul din runtime (growslice) arată, începând cu Go 1.18, astfel:

  • dacă lungimea necesară depășește dublul capacității vechi, noua capacitate este chiar lungimea necesară;
  • altfel, dacă capacitatea veche este sub 256 de elemente, se dublează;
  • peste prag, creșterea scade treptat de la 2x spre aproximativ 1,25x, pentru a nu risipi memorie la slice-uri mari;
  • rezultatul se rotunjește în sus la clasa de dimensiune a alocatorului, deci capacitatea exactă poate fi puțin mai mare.

Este un detaliu de implementare care s-a schimbat între versiuni, deci codul nu trebuie să depindă de valori exacte.

Creșterea geometrică face ca append să fie O(1) amortizat. Totuși, fiecare realocare înseamnă alocare, copiere și gunoi pentru GC. Când știi dimensiunea finală, prealoci:

GO
out := make([]Result, 0, len(input))
for _, in := range input {
	out = append(out, transform(in))
}

// Go 1.21: garantează spațiu pentru încă n elemente
buf = slices.Grow(buf, n)

Diferența se vede în benchmark-uri cu -benchmem prin numărul de alocări pe operație.

Capcane la nivel senior:

  • un slice mare din care păstrezi doar câteva elemente ține tot array-ul în memorie; copiază cu slices.Clone ce păstrezi;
  • slices.Clip(s) reduce capacitatea la lungime, ca un append ulterior să nu scrie peste date partajate;
  • prealocarea excesivă, pe baza unei estimări mari venite din input extern, poate consuma memorie inutil sau poate fi exploatată. Limitează estimarea.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi costul amortizat și impactul asupra alocărilor. Greșeala tipică este presupunerea unei dublări fixe sau scrierea de cod care depinde de capacitatea exactă.

27 Senior

Un serviciu ține un map mare de sesiuni. După ce majoritatea sesiunilor expiră și sunt șterse cu delete, memoria procesului nu scade. De ce și ce faci?

Răspuns scurt: Map-urile din Go nu își micșorează structura internă după ștergeri: delete eliberează intrarea, dar spațiul alocat pentru tabelă rămâne. Soluția este reconstruirea periodică a map-ului cu doar intrările vii, ca vechea tabelă să fie eliberată de GC.

Un map crește când numărul de elemente depășește un anumit grad de încărcare, dar nu se micșorează niciodată. Este valabil și pentru implementarea bazată pe Swiss Tables, introdusă în Go 1.24. Dacă map-ul a ajuns la un milion de intrări într-un vârf de trafic, tabela pentru un milion de intrări rămâne alocată chiar dacă acum conține o mie. clear(m) are același efect: golește, dar păstrează memoria.

Valorile șterse sunt eliberate (dacă nu mai sunt referite din altă parte), dar spațiul pentru sloturi și chei rămâne. Cu valori mari stocate direct (structuri de câteva sute de octeți), pierderea poate fi semnificativă.

Strategii:

GO
func (s *Store) compact() {
	s.mu.Lock()
	defer s.mu.Unlock()
	fresh := make(map[string]*Session, len(s.sessions))
	for k, v := range s.sessions {
		fresh[k] = v
	}
	s.sessions = fresh // vechea tabelă devine gunoi
}
  • rulezi compactarea periodic sau când raportul dintre vârful istoric și dimensiunea curentă depășește un prag;
  • stochezi pointeri (map[string]*Session) în loc de structuri mari, ca tabela în sine să rămână mică;
  • pentru cache-uri cu expirare, folosești o structură cu limită de dimensiune (LRU) sau mai multe map-uri rotite pe intervale de timp: ștergi un map întreg în loc de intrări individuale.

Cum confirmi: profil de heap cu pprof (go tool pprof -inuse_space), unde vezi alocările persistente atribuite funcției care inserează în map. Ține minte și că memoria eliberată de GC nu este întoarsă imediat sistemului de operare, deci RSS-ul procesului poate rămâne mare un timp.

Ce urmărește intervievatorul: Se verifică cunoașterea comportamentului de memorie al map-urilor în producție. Mulți candidați presupun că delete reduce memoria și caută degeaba un leak în altă parte.

Șiruri, rune și formatare

Exersează capitolul cu exerciții reale: Curs Go →
28 Junior

Ce afișează codul următor?

GO
s := "aș!"
fmt.Println(len(s), s[1])
for i, r := range s {
	fmt.Println(i, string(r))
}

Răspuns scurt: Afișează 4 200, apoi 0 a, 1 ș, 3 !. Un string este o secvență de octeți UTF-8: ș ocupă 2 octeți, s[1] întoarce primul dintre ei, iar range decodează rune și dă indexul de octet unde începe fiecare.

În Go, string este o secvență imutabilă de octeți, de obicei UTF-8. len(s) numără octeții, nu caracterele. Litera ș (U+0219) se codifică pe doi octeți, 0xC8 și 0x99, deci șirul are 4 octeți.

Indexarea s[i] întoarce un byte (alias pentru uint8), adică un octet brut: s[1] este 0xC8, afișat ca 200. Nu este o literă.

for i, r := range s decodează UTF-8 pe parcurs: la fiecare pas r este o rune (alias pentru int32, un cod Unicode), iar i este poziția în octeți unde începe acea rună. De aceea indexurile sunt 0, 1, 3: rune ș ocupă pozițiile 1 și 2.

Operații utile:

GO
utf8.RuneCountInString(s) // 3 caractere
[]rune(s)                 // [97 537 33], copie decodată
for i := 0; i < len(s); i++ {
	// parcurgere pe octeți, utilă pentru protocoale ASCII
}

Dacă șirul conține octeți care nu formează UTF-8 valid, range produce rune utf8.RuneError (U+FFFD) și avansează cu un octet. Poți verifica cu utf8.ValidString.

Consecință practică: s[:n] poate tăia o literă în două și produce UTF-8 invalid. Când trunchiezi un text pentru afișare, numără rune, nu octeți.

Ce urmărește intervievatorul: Se verifică distincția dintre octeți și rune, esențială pentru textul în română. Greșeala tipică: indexarea directă a unui string cu diacritice ca și cum fiecare poziție ar fi o literă.

Eroarea, în practică:more than one character in rune literalmismatched types byte and untyped string

29 Junior

De ce nu compilează s[0] = 'H' pentru un string? Cum modifici un caracter dintr-un șir?

Răspuns scurt: String-urile din Go sunt imutabile, deci nu poți atribui unui octet din ele. Construiești un șir nou: convertești în []byte sau []rune, modifici și convertești înapoi, sau folosești funcții precum strings.Replace.

Imutabilitatea are motive practice: string-urile se pot partaja între goroutine fără sincronizare, pot fi chei sigure în map-uri, iar un subșir s[2:5] poate refolosi memoria originalului fără copiere, pentru că nimeni nu o poate modifica.

Moduri de a obține un șir modificat:

GO
s := "hello"

b := []byte(s)   // copie
b[0] = 'H'
s1 := string(b)  // altă copie: "Hello"

r := []rune("țară")
r[0] = 'Ț'
s2 := string(r)  // "Țară"

s3 := strings.Replace(s, "h", "H", 1)
s4 := strings.ToUpper(s[:1]) + s[1:]

[]byte funcționează pentru text ASCII. Dacă poziția conține o literă pe mai mulți octeți (diacritice), lucrezi cu []rune, altfel obții UTF-8 invalid.

Ce costă: fiecare conversie []byte(s) și string(b) alocă și copiază, pentru că altfel imutabilitatea ar putea fi încălcată. Compilatorul elimină copia în câteva cazuri sigure, de exemplu m[string(b)] la căutarea în map sau comparația string(b) == "x".

Atribuirea s = "altceva" este permisă: variabila primește alt șir, dar șirul inițial nu a fost modificat. Iar s += "!" creează mereu un șir nou, ceea ce devine costisitor în bucle mari.

Ce urmărește intervievatorul: Verifică înțelegerea imutabilității și a costului conversiilor. Greșeala tipică: modificarea cu []byte a unui text cu diacritice.

Eroarea, în practică:cannot assign to s[0] (neither addressable nor...)

30 Junior

Scrie o funcție care construiește șirul "1, 2, 3, ..., n". De ce nu e bine să folosești += într-o buclă?

Răspuns scurt: Folosești strings.Builder, care adaugă într-un buffer intern și construiește șirul o singură dată, sau colectezi bucățile și le unești cu strings.Join. += creează un șir nou la fiecare pas, copiind tot ce exista, deci costul total devine O(n²).

Pentru că string-urile sunt imutabile, s += x alocă un șir nou de lungime len(s) + len(x) și copiază ambele părți. Într-o buclă cu n pași, fiecare pas copiază tot textul de până atunci, deci costul total crește pătratic, iar fiecare șir intermediar devine gunoi pentru GC.

Soluția cu strings.Builder:

GO
func joinNumbers(n int) string {
	var b strings.Builder
	b.Grow(n * 4) // estimare, opțional
	for i := 1; i <= n; i++ {
		if i > 1 {
			b.WriteString(", ")
		}
		b.WriteString(strconv.Itoa(i))
	}
	return b.String()
}

Builder crește bufferul ca un slice (amortizat O(1) pe adăugare), iar String() nu copiază octeții, ci îi întoarce direct ca string.

Alternativa cu strings.Join:

GO
parts := make([]string, 0, n)
for i := 1; i <= n; i++ {
	parts = append(parts, strconv.Itoa(i))
}
s := strings.Join(parts, ", ")

Join calculează lungimea finală și face o singură alocare pentru rezultat.

Detalii:

  • valoarea zero a lui strings.Builder e gata de folosit;
  • un Builder folosit nu se copiază prin valoare: copierea lui produce panică la următoarea scriere;
  • fmt.Fprintf(&b, "%d;", i) merge, pentru că *strings.Builder implementează io.Writer;
  • pentru două-trei concatenări simple, a + b + c este perfect și chiar optim, pentru că compilatorul face o singură alocare.

Ce urmărește intervievatorul: Se verifică dacă știi costul concatenării repetate. Intervievatorii acceptă + pentru câteva bucăți, dar urmăresc ce faci în bucle.

Eroarea, în practică:strings: non-zero Builder copied by value

31 Junior

Ce afișează codul următor?

GO
fmt.Println(strings.Trim("abcHellocba", "abc"))
fmt.Println(strings.TrimLeft("www.web.ro", "www."))
fmt.Println(strings.TrimPrefix("www.web.ro", "www."))
fmt.Println(len(strings.Split("a  b", " ")), len(strings.Fields("a  b")))

Răspuns scurt: Afișează Hello, eb.ro, web.ro și 3 2. Trim, TrimLeft și TrimRight primesc o mulțime de caractere de eliminat, nu un prefix; pentru prefix sau sufix exact folosești TrimPrefix și TrimSuffix.

Al doilea argument al lui strings.Trim se numește cutset: este interpretat ca o mulțime de caractere. Funcția elimină de la capete orice caracter din mulțime, cât timp găsește. Pentru "abcHellocba" cu mulțimea {a, b, c}, se elimină abc din stânga și cba din dreapta, rezultând Hello.

TrimLeft("www.web.ro", "www.") folosește mulțimea {w, .}. Elimină w, w, w, ., apoi încă un w din web, și se oprește la e. Rezultatul este eb.ro, un bug clasic la curățarea URL-urilor. TrimPrefix elimină exact prefixul "www." o singură dată, dacă există.

La împărțire:

  • strings.Split("a b", " ") taie la fiecare spațiu, deci obține ["a", "", "b"], cu un element gol între cele două spații;
  • strings.Fields desparte după secvențe de spații albe și ignoră capetele, deci obține ["a", "b"].

Alte cazuri utile:

GO
strings.Split("", ",")        // [""], lungime 1, nu 0
strings.SplitN("a=b=c", "=", 2) // ["a", "b=c"]
k, v, ok := strings.Cut("key=value", "=") // Go 1.18
strings.TrimSpace("  text\n") // "text"
strings.EqualFold("Go", "GO") // true

strings.Cut este alegerea idiomatică pentru împărțirea în două la primul separator; înlocuiește combinațiile cu Index și tăieri manuale.

Ce urmărește intervievatorul: Verifică atenția la API-ul pachetului strings. Confuzia dintre TrimLeft și TrimPrefix produce bug-uri care trec de testele simple.

32 Junior

Ce afișează codul următor și cum convertești corect între numere și text?

GO
n := 65
fmt.Println(string(rune(n)), strconv.Itoa(n))

v, err := strconv.Atoi("12a")
fmt.Println(v, err)

Răspuns scurt: Afișează A 65, apoi 0 strconv.Atoi: parsing "12a": invalid syntax. Conversia string(rune(n)) dă caracterul cu codul 65, nu cifrele; pentru text numeric folosești strconv.Itoa, iar pentru parsare strconv.Atoi sau ParseInt, verificând eroarea.

Conversia unui întreg la string interpretează valoarea ca punct de cod Unicode. Scrierea directă string(n) cu n de tip int compilează, dar go vet o semnalează din Go 1.15, pentru că aproape mereu e o greșeală. Dacă chiar vrei caracterul, scrii explicit string(rune(n)).

Pentru conversii numerice, pachetul strconv:

GO
s := strconv.Itoa(42)                 // "42"
n, err := strconv.Atoi("42")          // 42, nil
x, err := strconv.ParseInt("ff", 16, 64) // 255
f, err := strconv.ParseFloat("3.14", 64)
b, err := strconv.ParseBool("true")
s2 := strconv.FormatFloat(3.14159, 'f', 2, 64) // "3.14"
q := strconv.Quote("ș\n")             // "\"ș\\n\""

Erorile de parsare sunt de tip *strconv.NumError, care conține funcția, intrarea și cauza. Cauza poate fi strconv.ErrSyntax sau strconv.ErrRange (valoare prea mare pentru dimensiunea cerută), verificabile cu errors.Is.

Când parsarea eșuează, valoarea întoarsă este 0 (sau valoarea limită, la depășire). Dacă ignori eroarea cu _, un input invalid devine 0 în tăcere, ceea ce poate fi grav pentru prețuri sau cantități.

fmt.Sprint(n) și fmt.Sscanf funcționează și ele, dar sunt mai lente și mai puțin precise în tratarea erorilor. strconv este alegerea standard în cod de producție.

Ce urmărește intervievatorul: Se verifică faptul că știi capcana string(int) și tratezi erorile de parsare. Greșeala tipică: ignorarea erorii de la Atoi.

Eroarea, în practică:mismatched types string and intstrconv.Atoi: parsing "12a": invalid syntax

33 Junior

Ce afișează fiecare linie?

GO
type P struct {
	Name string
	Age  int
}

p := P{"Ana", 30}
fmt.Printf("%v\n", p)
fmt.Printf("%+v\n", p)
fmt.Printf("%#v\n", p)
fmt.Printf("%T %q\n", p, p.Name)
fmt.Printf("[%6.2f][%-4d][%04d]\n", 3.14159, 7, 7)

Răspuns scurt: Afișează {Ana 30}, {Name:Ana Age:30}, main.P{Name:"Ana", Age:30}, main.P "Ana" și [ 3.14][7 ][0007]. %v e formatul implicit, %+v adaugă numele câmpurilor, %#v dă sintaxa Go, iar lățimea și precizia controlează alinierea.

Verbele principale din fmt:

  • %v afișează valoarea în formatul implicit; %+v adaugă numele câmpurilor la structuri, foarte util în loguri; %#v afișează valoarea ca literal Go, inclusiv tipul și ghilimelele;
  • %T afișează tipul;
  • %d întregi, %x hexazecimal, %b binar, %o octal;
  • %f, %e, %g pentru numere reale;
  • %s string, %q string între ghilimele, cu caracterele speciale escapate;
  • %p adresa unui pointer;
  • %% caracterul procent.

Lățimea și precizia: %6.2f înseamnă minim 6 caractere, 2 zecimale, aliniat la dreapta. - aliniază la stânga, iar 0 completează cu zerouri.

Dacă tipul implementează String() string (interfața fmt.Stringer), %v și %s folosesc acea metodă. Pentru erori se folosește metoda Error().

Greșelile de format nu opresc programul. Rezultatul conține un marcaj, de exemplu %!d(string=Ana) pentru %d cu un string sau %!(EXTRA int=5) pentru argumente în plus. Din acest motiv go vet verifică apelurile de tip Printf la compilare și semnalează nepotrivirile; rulează automat și la go test.

Variante: Sprintf întoarce string-ul, Fprintf scrie într-un io.Writer, Errorf creează o eroare.

Ce urmărește intervievatorul: Verifică familiaritatea cu formatarea, folosită zilnic la loguri și depanare. Mulți candidați nu cunosc %+v și %#v, care fac depanarea mult mai rapidă.

Eroarea, în practică:%!d(string=...) în fmt.Printf%!(EXTRA ...) și %!d(MISSING) în fmt

34 Mid

Scrie o funcție care inversează un string. Ce se întâmplă cu diacriticele dacă inversezi octeții?

Răspuns scurt: Convertești în []rune, inversezi cu doi indici care se apropie și convertești înapoi. Dacă inversezi octeții, literele pe mai mulți octeți, cum ar fi ș, se strică și obții UTF-8 invalid.

Soluția corectă pentru majoritatea textelor:

GO
func reverse(s string) string {
	r := []rune(s)
	for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
		r[i], r[j] = r[j], r[i]
	}
	return string(r)
}

fmt.Println(reverse("șarpe")) // "epraș"

Rezultatul pentru „șarpe” este „epraș”. Complexitatea este O(n) timp și O(n) memorie suplimentară pentru slice-ul de rune.

Varianta greșită, pe []byte, mută cei doi octeți ai lui ș în ordine inversă. Secvența obținută nu mai este UTF-8 valid și apare ca un caracter de înlocuire la afișare.

Limita soluției cu rune: unele caractere vizibile sunt formate din mai multe rune. Un „ș” poate fi scris și ca s urmat de semnul combinat „virgulă dedesubt” (U+0326), iar emoji-urile compuse pot avea mai multe puncte de cod. Inversarea pe rune separă semnul de litera lui. Biblioteca standard nu are segmentare pe grafeme (grapheme clusters); dacă ai nevoie de ea, folosești o bibliotecă externă sau normalizezi întâi textul în forma compusă (NFC) cu golang.org/x/text/unicode/norm.

Întrebarea are des continuare: verifică dacă un text este palindrom. Același principiu, cu doi indici, comparând rune, după unicode.ToLower și eliminarea caracterelor care nu sunt litere (unicode.IsLetter).

În cod de interviu, menționează explicit presupunerea despre input: ASCII, UTF-8 cu rune simple sau text arbitrar.

Ce urmărește intervievatorul: Este un exercițiu clasic care testează înțelegerea UTF-8. Candidații buni explică și limita inversării pe rune, nu doar că folosesc []rune.

35 Senior

Citești un fișier de log de 200 MB într-un string și păstrezi într-un map doar primele 20 de caractere din fiecare linie. Memoria rămâne mare. De ce și cum repari?

Răspuns scurt: Un subșir obținut prin tăiere (s[:20]) partajează memoria șirului original, deci fiecare cheie păstrează în viață întregul buffer de 200 MB. Repari copiind explicit subșirul cu strings.Clone (Go 1.20) înainte de a-l păstra.

Un string este intern un pointer și o lungime. Tăierea line[:20] creează un antet nou care indică în același bloc de memorie, fără copiere. E o optimizare excelentă pentru prelucrări temporare, dar devine problemă când păstrezi pe termen lung o bucată mică dintr-un șir mare: garbage collector-ul nu poate elibera parțial un bloc, deci cele 20 de caractere țin în viață tot fișierul.

Același lucru se întâmplă cu strings.Split, strings.Fields sau regexp pe șirul mare: rezultatele sunt subșiruri ale originalului.

Reparația:

GO
data, _ := os.ReadFile("app.log")
text := string(data)
for _, line := range strings.Split(text, "\n") {
	if len(line) >= 20 {
		key := strings.Clone(line[:20]) // copie independentă
		index[key]++
	}
}

Înainte de Go 1.20 se folosea string([]byte(line[:20])) sau strings.Builder.

O variantă și mai bună este să nu încarci tot fișierul: citești pe linii cu bufio.Scanner. scanner.Text() întoarce un șir nou pentru fiecare linie, iar memoria pentru fișier nu mai este necesară deloc. Atenție: scanner.Bytes() întoarce un slice peste bufferul intern, care este suprascris la următorul apel, deci trebuie copiat dacă îl păstrezi.

Aceeași problemă apare cu []byte: b[:20] păstrează array-ul mare. Folosești bytes.Clone sau slices.Clone.

Diagnosticul se face cu profilul de heap din pprof, unde alocarea mare apare atribuită lui os.ReadFile, deși codul tău „nu o mai folosește”.

Ce urmărește intervievatorul: Se verifică înțelegerea partajării memoriei la subșiruri, o sursă reală de consum mare de memorie în producție. Greșeala tipică este căutarea unui leak în altă parte.

Structuri, metode și pointeri

36 Junior

Ce afișează codul următor? Când sunt două structuri egale?

GO
type Point struct{ X, Y int }

a := Point{1, 2}
b := Point{Y: 2, X: 1}
c := Point{X: 1}
fmt.Println(a == b, c)

Răspuns scurt: Afișează true {1 0}. Structurile se compară câmp cu câmp cu == dacă toate câmpurile sunt comparabile, iar câmpurile neinițializate primesc valoarea zero.

Ai trei moduri de a inițializa o structură:

  • pozițional, Point{1, 2}: trebuie să dai toate câmpurile, în ordine. Dacă cineva adaugă un câmp, codul nu mai compilează. Pentru tipuri din alte pachete, go vet semnalează literalii poziționali;
  • cu nume de câmpuri, Point{Y: 2, X: 1}: ordinea nu contează, câmpurile omise primesc valoarea zero. Este varianta recomandată;
  • valoarea zero, var p Point sau Point{}.

Pentru pointeri: &Point{X: 1} creează structura și îi întoarce adresa; new(Point) face același lucru, dar fără inițializare de câmpuri.

Comparația a == b compară toate câmpurile, în ordine. Funcționează doar dacă toate câmpurile sunt de tipuri comparabile. Cu un câmp slice, map sau funcție, == nu compilează:

GO
type Order struct {
	ID    int
	Items []string
}
// o1 == o2 nu compilează

Pentru astfel de structuri scrii o metodă Equal proprie, folosești slices.Equal pentru câmpurile slice sau, în teste, reflect.DeepEqual ori github.com/google/go-cmp.

Structurile comparabile pot fi chei de map, ceea ce le face utile pentru chei compuse.

Două valori ale unor tipuri structură diferite, chiar dacă au câmpuri identice, nu se pot compara fără conversie explicită.

Ce urmărește intervievatorul: Verifică regulile de inițializare și comparare. Greșeala tipică este folosirea literalilor poziționali sau încercarea de a compara structuri cu slice-uri.

37 Junior

Ce afișează codul următor?

GO
type Team struct {
	Name    string
	Members []string
}

a := Team{"A", []string{"Ana", "Ion"}}
b := a
b.Name = "B"
b.Members[0] = "Maria"
fmt.Println(a.Name, a.Members)

Răspuns scurt: Afișează A [Maria Ion]. Atribuirea copiază structura, dar copia este superficială: câmpul Name e independent, însă slice-ul Members din ambele copii indică spre același array.

Atribuirea unei structuri copiază toate câmpurile, valoare cu valoare. Pentru Name, copia este independentă, deci a.Name rămâne A. Pentru Members, se copiază antetul slice-ului (pointer, lungime, capacitate), nu elementele. Ambele structuri indică spre același array, deci modificarea unui element prin b se vede și prin a.

Același comportament apare la câmpuri de tip map, pointer, canal sau la interfețe care conțin pointeri. Structura este copiată, dar datele la care indică nu.

Pentru o copie independentă scrii o metodă explicită:

GO
func (t Team) Clone() Team {
	t.Members = slices.Clone(t.Members)
	return t
}

b := a.Clone()

Metoda primește t prin valoare, deci are deja o copie a câmpurilor simple; trebuie doar să înlocuiască slice-ul cu o copie. Pentru map-uri folosești maps.Clone, iar pentru structuri imbricate cu pointeri copiezi fiecare nivel.

Unde contează în practică:

  • o funcție care primește o structură „prin valoare” poate totuși modifica datele apelantului prin câmpurile slice sau map;
  • un getter care întoarce un câmp slice expune datele interne; dacă vrei încapsulare, întorci o copie;
  • configurații partajate între goroutine: o copie superficială nu elimină condițiile de cursă pe câmpurile partajate.

Ce urmărește intervievatorul: Verifică înțelegerea copiei superficiale. Mulți candidați cred că o structură transmisă prin valoare este complet izolată.

38 Junior

Unde e bug-ul în codul următor? Ce este diferența dintre new(T) și &T{}, și poți apela o metodă pe un pointer nil?

GO
type Config struct{ Port int }

func main() {
	var c *Config
	c.Port = 8080
	fmt.Println(c.Port)
}

Răspuns scurt: c este un pointer nil, deci c.Port produce panica invalid memory address or nil pointer dereference. Trebuie inițializat cu &Config{} sau new(Config), care sunt echivalente. O metodă cu receiver pointer poate fi apelată pe nil dacă tratează explicit acest caz.

Valoarea zero a unui pointer este nil. Declarația var c *Config nu creează nicio structură, doar o variabilă care poate indica spre una. Accesul la un câmp prin pointer nil dereferențiază adresa zero, iar runtime-ul oprește programul cu panică.

Corect:

GO
c := &Config{Port: 8080} // literal cu adresă, cel mai folosit
c2 := new(Config)        // structură zero, întoarce *Config
c2.Port = 8080

new(T) și &T{} alocă la fel; &T{...} permite și inițializarea câmpurilor. Compilatorul decide prin escape analysis dacă obiectul stă pe stivă sau pe heap, deci nu există diferență de performanță între cele două forme.

Un detaliu mai puțin știut: o metodă cu receiver pointer se poate apela pe un pointer nil, pentru că apelul doar transmite pointerul. Panica apare abia dacă metoda accesează câmpuri.

GO
func (c *Config) Addr() string {
	if c == nil {
		return ":80" // valoare implicită
	}
	return fmt.Sprintf(":%d", c.Port)
}

var c *Config
fmt.Println(c.Addr()) // ":80"

Biblioteca standard folosește modelul în câteva locuri. O metodă cu receiver valoare, în schimb, panichează mereu pe nil, pentru că apelul trebuie să copieze structura.

Unde apare des bug-ul: câmpuri pointer neinițializate în structuri (s.db.Query cu db nil), rezultate ignorate de la funcții care întorc (*T, error).

Ce urmărește intervievatorul: Se verifică înțelegerea valorii zero a pointerilor și a semanticii apelului de metodă. Greșeala tipică: dereferențierea unui pointer neinițializat dintr-o structură.

Eroarea, în practică:invalid memory address or nil pointer dereference

39 Junior

Poți defini metode pe tipuri care nu sunt structuri? Poți adăuga o metodă tipului int sau lui time.Duration?

Răspuns scurt: Da: poți defini metode pe orice tip numit declarat în pachetul tău, de exemplu type Celsius float64 sau type IDs []int. Nu poți adăuga metode tipurilor predeclarate sau tipurilor din alte pachete; pentru asta declari un tip nou bazat pe ele.

Regula este simplă: receiver-ul unei metode trebuie să fie un tip numit definit în același pachet. Tipul de bază poate fi aproape orice: număr, string, slice, map, funcție.

GO
type Celsius float64

func (c Celsius) Fahrenheit() float64 {
	return float64(c)*9/5 + 32
}

type IDs []int

func (ids IDs) Contains(id int) bool {
	return slices.Contains(ids, id)
}

t := Celsius(25)
fmt.Println(t.Fahrenheit()) // 77

time.Duration este chiar un astfel de tip în biblioteca standard: type Duration int64, cu metode precum Seconds() și String(). http.HandlerFunc este un tip funcție cu metoda ServeHTTP.

Nu poți scrie func (i int) Double(), pentru că int nu e definit în pachetul tău, și nici func (d time.Duration) Days(). Soluția este un tip nou:

GO
type Days time.Duration

Atenție: tipul nou nu moștenește metodele tipului de bază. Days nu are String(); trebuie să convertești înapoi la time.Duration sau să încorporezi tipul într-o structură, caz în care metodele sunt promovate.

Diferența dintre type A B (tip nou, distinct, fără metodele lui B) și type A = B (alias, același tip, aceleași metode) apare des la interviu. Aliasurile se folosesc în special la refactorizări, când muți un tip între pachete fără să strici codul existent.

Ce urmărește intervievatorul: Verifică înțelegerea sistemului de tipuri numit. Candidații veniți din limbaje orientate pe obiecte cred că doar structurile pot avea metode.

Eroarea, în practică:cannot define new methods on non-local typeinvalid receiver type (pointer or interface)

40 Junior

Ce este struct{} și unde se folosește? Cât spațiu ocupă?

Răspuns scurt: struct{} este structura goală, fără câmpuri, și ocupă zero octeți. Se folosește ca valoare în map-uri folosite drept mulțimi (map[string]struct{}) și ca tip pentru canale de semnalizare (chan struct{}), unde contează doar evenimentul, nu datele.

unsafe.Sizeof(struct{}{}) întoarce 0. Runtime-ul poate folosi aceeași adresă pentru toate valorile de acest tip, deci nu se alocă memorie pentru ele.

Utilizări idiomatice:

GO
// mulțime
seen := make(map[string]struct{})
seen["go"] = struct{}{}
if _, ok := seen["go"]; ok {
	fmt.Println("există")
}

// semnal de oprire
done := make(chan struct{})
go func() {
	defer close(done)
	work()
}()
<-done

Comparat cu map[string]bool, mulțimea cu struct{} economisește un octet pe intrare (plus aliniere) și exprimă clar intenția: nu există o a treia stare, „prezent dar false”. Diferența de memorie e mică pentru map-uri mici, dar intenția clară este principalul argument. Multe echipe acceptă și map[string]bool pentru lizibilitatea lui if seen[k].

Pentru canale, chan struct{} arată că se transmite doar un semnal. Închiderea canalului notifică toți cei care așteaptă.

Alte utilizări:

  • tipuri care există doar pentru metode, fără stare: type noopLogger struct{} care implementează o interfață;
  • chei de context neexportate: type ctxKey struct{};
  • elemente de sincronizare: semafor cu make(chan struct{}, n).

Un detaliu fin: un câmp struct{} pus ultimul într-o structură poate adăuga octeți de completare, ca un pointer spre el să nu indice în afara obiectului. Nu contează decât în optimizări extreme.

Ce urmărește intervievatorul: Verifică familiaritatea cu idiomurile Go. Candidații care folosesc chan bool pentru semnale sau nu știu de mulțimi cu struct{} arată mai puțină experiență cu codul idiomatic.

41 Junior

Ce sunt structurile anonime și unde le folosești în practică?

Răspuns scurt: Sunt structuri declarate și folosite pe loc, fără nume de tip: p := struct{ X, Y int }{1, 2}. Le folosești pentru date temporare, cum ar fi cazurile din testele table-driven, decodarea unui JSON folosit o singură dată sau gruparea unor câmpuri de configurare.

O structură anonimă combină declararea tipului cu crearea valorii:

GO
point := struct {
	X, Y int
}{1, 2}
fmt.Println(point.X)

Cel mai frecvent loc este testul table-driven:

GO
tests := []struct {
	name string
	in   string
	want int
}{
	{"gol", "", 0},
	{"un cuvânt", "go", 1},
	{"spații multiple", "a  b", 2},
}
for _, tt := range tests {
	t.Run(tt.name, func(t *testing.T) {
		if got := countWords(tt.in); got != tt.want {
			t.Errorf("got %d, want %d", got, tt.want)
		}
	})
}

Alte utilizări:

  • decodarea unui răspuns JSON din care te interesează doar două câmpuri, într-o singură funcție;
  • construirea unui răspuns JSON ad-hoc într-un handler;
  • datele trimise unui template html/template;
  • gruparea câmpurilor într-o structură mai mare: Server struct { Host string; TLS struct { Cert, Key string } }.

Limite: nu poți defini metode pe o structură anonimă și nu poți refolosi tipul ușor în altă funcție. Două structuri anonime cu aceleași câmpuri (nume, tipuri, tag-uri, în aceeași ordine) sunt de același tip, deci se pot atribui una alteia. Dacă aceeași formă apare în mai multe locuri, merită un tip numit.

Ce urmărește intervievatorul: Verifică familiaritatea cu un idiom omniprezent în testele Go. Candidații care nu-l cunosc declară tipuri numite pentru fiecare tabel de test.

42 Mid

Ce afișează codul următor și de ce?

GO
type User struct{ Name string }

func (u *User) String() string {
	return "User(" + u.Name + ")"
}

func main() {
	u := User{"Ana"}
	fmt.Println(u)
	fmt.Println(&u)
}

Răspuns scurt: Afișează {Ana} și apoi User(Ana). Metoda String are receiver pointer, deci doar *User implementează fmt.Stringer; valoarea User nu are metoda în method set, iar fmt o afișează în formatul implicit.

fmt.Println primește argumentele ca any și verifică la runtime dacă valoarea implementează fmt.Stringer. Valoarea u, de tip User, este copiată în interfață. Method set-ul tipului User conține doar metodele cu receiver valoare, iar String are receiver pointer. Verificarea eșuează și se folosește formatarea implicită. Pentru &u, de tip *User, metoda există și se apelează.

Codul u.String() ar compila, pentru că u este adresabil și compilatorul ia automat adresa. Dar în interfață nu se ia adresa, de aceea comportamentul diferă.

Variante de reparare:

  • receiver valoare pentru String(), dacă structura nu e mare și metoda nu modifică nimic. Așa merge și pentru valori, și pentru pointeri;
  • afișezi mereu pointerul, dacă tipul este gândit să fie folosit doar prin pointer.

A doua capcană clasică cu String() este recursivitatea:

GO
func (u User) String() string {
	return fmt.Sprintf("%v", u) // apelează din nou String: stack overflow
}

Soluția este un tip local fără metode:

GO
func (u User) String() string {
	type plain User
	return fmt.Sprintf("User%+v", plain(u))
}

Aceleași reguli se aplică pentru Error(): o eroare cu receiver pointer trebuie întoarsă ca pointer, altfel nu satisface interfața error.

Ce urmărește intervievatorul: Verifică dacă înțelegi method sets într-un caz concret și subtil. Este o întrebare de tip „ce afișează” la care majoritatea candidaților răspund greșit.

Eroarea, în practică:does not implement (method has pointer receiver)cannot call pointer method

43 Mid

Ce afișează codul următor? Ce înseamnă că embedding-ul nu este moștenire?

GO
type Animal struct{}

func (Animal) Sound() string { return "..." }
func (a Animal) Speak() string { return "Spune: " + a.Sound() }

type Dog struct{ Animal }

func (Dog) Sound() string { return "Ham" }

func main() {
	d := Dog{}
	fmt.Println(d.Sound())
	fmt.Println(d.Speak())
}

Răspuns scurt: Afișează Ham și Spune: .... Speak este definită pe Animal și primește ca receiver câmpul încorporat Animal, care nu știe nimic de Dog, deci apelează Animal.Sound; Go nu are dispatch virtual prin embedding.

Embedding-ul promovează metodele câmpului încorporat: d.Speak() este doar o prescurtare pentru d.Animal.Speak(). În interiorul lui Speak, receiver-ul este o valoare de tip Animal. Nu există un „this” care să indice spre Dog, deci a.Sound() înseamnă mereu Animal.Sound.

Dog.Sound doar ascunde Animal.Sound când apelezi direct pe Dog. Într-un limbaj cu moștenire și metode virtuale (Java), Speak ar fi afișat „Spune: Ham”. Acesta e modelul „template method”, care în Go nu funcționează prin embedding.

Cum obții comportamentul dorit: prin interfețe, transmițând explicit partea variabilă.

GO
type Sounder interface{ Sound() string }

func Speak(s Sounder) string {
	return "Spune: " + s.Sound()
}

fmt.Println(Speak(Dog{})) // Spune: Ham

Alte reguli de embedding care apar la interviu:

  • dacă două tipuri încorporate la același nivel au o metodă cu același nume, apelul direct x.Metoda() nu compilează (selector ambiguu), dar tipul compilează până folosești metoda;
  • metodele promovate contează pentru implementarea interfețelor: Dog implementează orice interfață pe care o implementează Animal;
  • încorporarea unui pointer (*Animal) promovează și metodele cu receiver pointer, dar pointerul trebuie inițializat, altfel apelul panichează.

Formularea potrivită la interviu: embedding-ul este compoziție cu delegare automată, nu moștenire.

Ce urmărește intervievatorul: Verifică dacă înțelegi limita embedding-ului și nu o confunzi cu moștenirea. Candidații din Java răspund aproape mereu „Spune: Ham”.

Eroarea, în practică:ambiguous selector

44 Mid

Ce afișează codul următor? Ce sunt method values și method expressions?

GO
type Counter struct{ n int }

func (c Counter) Show()  { fmt.Println(c.n) }
func (c *Counter) Inc()  { c.n++ }

func main() {
	c := Counter{}
	show := c.Show
	inc := c.Inc
	inc()
	inc()
	show()
	fmt.Println(c.n)
}

Răspuns scurt: Afișează 0 și 2. c.Show este un method value: receiver-ul se evaluează și se copiază în momentul creării, când n era 0; c.Inc capturează adresa &c, deci incrementările ajung în c.

Expresia c.Show, fără paranteze, produce o funcție cu receiver-ul deja legat (method value). Receiver-ul se evaluează imediat:

  • pentru o metodă cu receiver valoare, se face o copie a lui c în acel moment. Orice modificare ulterioară a lui c nu se vede în show;
  • pentru o metodă cu receiver pointer, compilatorul ia adresa lui c ((&c).Inc), deci funcția lucrează pe variabila originală.

De aceea show() afișează 0, deși c.n este 2 la momentul apelului.

Aceeași regulă explică un caz întâlnit în practică:

GO
c := Counter{}
defer c.Show() // receiver copiat acum: va afișa 0
c.Inc()

Method expressions sunt forma în care receiver-ul devine primul parametru:

GO
f := Counter.Show     // func(Counter)
g := (*Counter).Inc   // func(*Counter)
g(&c)
f(c)

Utilizări practice:

  • transmiterea unei metode ca handler sau callback: http.HandleFunc("/", srv.handleIndex), time.AfterFunc(d, w.flush);
  • pornirea unei goroutine: go srv.run() evaluează receiver-ul la momentul instrucțiunii go;
  • tabele de operații construite din method expressions.

Când receiver-ul este o interfață, method value-ul păstrează valoarea dinamică de la momentul evaluării, deci schimbarea ulterioară a variabilei interfață nu afectează funcția obținută.

Ce urmărește intervievatorul: Se verifică momentul evaluării receiver-ului, care apare în defer, goroutine și callback-uri. Greșeala tipică: presupunerea că method value-ul citește starea la apel.

45 Mid

Cum scrii un constructor în Go? Explică modelul functional options și când îl folosești.

Răspuns scurt: Go nu are constructori, ci funcții convenționale NewX care întorc *X sau (*X, error) când pot eșua. Functional options înseamnă o funcție variadică NewX(obligatorii, opts ...Option), unde fiecare opțiune modifică configurarea, păstrând API-ul compatibil când apar opțiuni noi.

Un constructor simplu validează datele și setează valori implicite:

GO
func NewAccount(owner string, balance int64) (*Account, error) {
	if owner == "" {
		return nil, errors.New("titularul este obligatoriu")
	}
	return &Account{owner: owner, balance: balance}, nil
}

Când tipul are multe setări opționale, lista de parametri devine greu de citit, iar o structură Config cu zeci de câmpuri nu arată clar ce e implicit. Modelul functional options rezolvă asta:

GO
type Server struct {
	addr    string
	timeout time.Duration
	maxConn int
}

type Option func(*Server)

func WithTimeout(d time.Duration) Option {
	return func(s *Server) { s.timeout = d }
}

func WithMaxConn(n int) Option {
	return func(s *Server) { s.maxConn = n }
}

func NewServer(addr string, opts ...Option) *Server {
	s := &Server{addr: addr, timeout: 30 * time.Second, maxConn: 100}
	for _, opt := range opts {
		opt(s)
	}
	return s
}

srv := NewServer(":8080", WithTimeout(5*time.Second))

Avantaje: valori implicite clare, opțiuni noi fără a schimba semnătura, apeluri lizibile. Dezavantaje: mai mult cod și mai greu de descoperit decât o structură de configurare. Pentru un tip intern cu trei câmpuri e exagerat.

O alternativă la fel de idiomatică este proiectarea tipului astfel încât valoarea zero să fie utilizabilă: sync.Mutex, bytes.Buffer și strings.Builder funcționează fără constructor. Când e posibil, e cea mai simplă soluție.

Ce urmărește intervievatorul: Verifică dacă știi convențiile de construire și un model frecvent în biblioteci. Greșeala tipică: constructori cu zece parametri poziționali sau abuzul de functional options pentru tipuri banale.

46 Senior

Ce dimensiuni au cele două structuri pe o platformă de 64 de biți și de ce diferă?

GO
type A struct {
	a bool
	b int64
	c bool
}

type B struct {
	b int64
	a bool
	c bool
}

fmt.Println(unsafe.Sizeof(A{}), unsafe.Sizeof(B{}))

Răspuns scurt: Afișează 24 16. Fiecare câmp trebuie aliniat la multiplul dimensiunii lui, deci în A compilatorul adaugă 7 octeți de completare după fiecare bool; în B cele două bool stau unul lângă altul după int64.

Pe amd64 și arm64, un int64 trebuie să înceapă la o adresă multiplu de 8. Go păstrează ordinea câmpurilor așa cum e scrisă, deci compilatorul inserează padding:

  • A: a la offset 0, 7 octeți de completare, b la offset 8, c la offset 16, apoi încă 7 octeți ca dimensiunea totală să fie multiplu al alinierii maxime (8). Total 24;
  • B: b la offset 0, a la 8, c la 9, apoi 6 octeți de completare. Total 16.

Diferența de 8 octeți pare mică, dar la un slice de zece milioane de elemente înseamnă zeci de megaocteți și mai puține elemente în cache-ul procesorului.

Unelte:

  • unsafe.Sizeof, unsafe.Alignof, unsafe.Offsetof pentru inspecție;
  • analizorul fieldalignment din golang.org/x/tools sugerează ordinea optimă.

Regula practică: ordonezi câmpurile de la cele mai mari la cele mai mici, dar numai unde contează (structuri create în cantități mari). În rest, ordinea logică pentru cititor e mai valoroasă decât câțiva octeți.

Alinierea contează și pentru corectitudine. Operațiile atomice pe 64 de biți cer adrese aliniate la 8 octeți, ceea ce pe platforme de 32 de biți nu era garantat pentru câmpuri int64 din structuri. Tipurile atomic.Int64 și atomic.Uint64 (Go 1.19) garantează alinierea corectă.

Un alt efect, la nivel de performanță: două contoare scrise intens de goroutine diferite, aflate în aceeași linie de cache, se încetinesc reciproc (false sharing). Se rezolvă cu padding explicit între ele.

Ce urmărește intervievatorul: Verifică înțelegerea layout-ului în memorie, relevant la optimizări. Candidații seniori ar trebui să știe și când nu merită optimizarea.

Interfețe

47 Junior

Ce afișează codul următor?

GO
type Box struct{ N int }

func (b Box) String() string { return fmt.Sprint("Box ", b.N) }

func main() {
	b := Box{1}
	var s fmt.Stringer = b
	b.N = 2
	fmt.Println(s, b)
	fmt.Printf("%T\n", s)
}

Răspuns scurt: Afișează Box 1 Box 2 și apoi main.Box. Când atribui o valoare unei interfețe, interfața stochează o copie a valorii, deci modificarea ulterioară a lui b nu o afectează; %T arată tipul dinamic.

O valoare de tip interfață are două componente: tipul dinamic (aici Box) și valoarea dinamică. La atribuirea s = b, valoarea lui b este copiată în interfață. b și conținutul lui s sunt de acum independente, deci b.N = 2 nu schimbă ce afișează s.

fmt.Println vede că ambele argumente implementează fmt.Stringer și apelează String() pe fiecare. %T afișează tipul dinamic al interfeței, nu tipul ei static.

Dacă atribui un pointer, situația se schimbă:

GO
b := Box{1}
var s fmt.Stringer = &b // *Box are și el metoda String
b.N = 2
fmt.Println(s) // Box 2

Acum interfața conține o copie a pointerului, care indică spre aceeași variabilă.

Consecințe practice:

  • dacă un tip are metode care modifică starea (receiver pointer), îl pui în interfață ca pointer, altfel modificările nu se văd sau tipul nu satisface interfața;
  • atribuirea unei structuri mari într-o interfață copiază structura și, de obicei, o alocă pe heap;
  • o valoare scoasă din interfață cu type assertion (s.(Box)) este și ea o copie; modificarea ei nu schimbă conținutul interfeței.

Formularea corectă la interviu: o interfață nu este o referință către variabila ta, ci un container cu tipul și o copie a valorii (care poate fi un pointer).

Ce urmărește intervievatorul: Se verifică modelul mental al valorilor interfață. Greșeala tipică este presupunerea că interfața „indică” spre variabila originală.

48 Junior

Cum verifici la compilare că un tip implementează o interfață, fără să-l folosești efectiv?

Răspuns scurt: Adaugi o declarație de tipul var _ io.Writer = (*MyWriter)(nil). Dacă *MyWriter nu are toate metodele lui io.Writer, compilarea eșuează cu un mesaj care spune ce metodă lipsește; declarația nu costă nimic la runtime.

În Go, implementarea unei interfețe este implicită: nu scrii implements. Asta e flexibil, dar înseamnă că o semnătură greșită (de exemplu Write(p []byte) error în loc de Write(p []byte) (int, error)) nu este semnalată în fișierul tipului. Eroarea apare doar acolo unde tipul este folosit ca interfață, poate într-un alt pachet, sau deloc dacă tipul se folosește prin reflecție.

Declarația de verificare forțează compilatorul să facă testul imediat:

GO
type FileStore struct{ dir string }

func (s *FileStore) Save(ctx context.Context, key string, data []byte) error {
	// ...
	return nil
}

var _ Store = (*FileStore)(nil)

Ce face fiecare parte:

  • var _ declară o variabilă pe care nu o folosești, deci nu primești eroare de variabilă nefolosită;
  • (*FileStore)(nil) este un pointer nil cu tipul *FileStore; nu se alocă nimic;
  • atribuirea către tipul Store cere ca *FileStore să implementeze interfața.

Dacă metodele au receiver valoare, poți scrie var _ Store = FileStore{}.

Când merită: pentru tipuri publice dintr-o bibliotecă, pentru adaptoare sau implementări de test ale unor interfețe, și pentru tipuri care trebuie să satisfacă interfețe opționale precum http.Flusher, io.WriterTo sau json.Marshaler. Acestea din urmă sunt verificate de biblioteci prin type assertion la runtime, deci o greșeală ar trece complet neobservată.

Ce urmărește intervievatorul: Verifică familiaritatea cu un idiom util în biblioteci. Candidații care nu-l cunosc descoperă greșelile de semnătură abia la runtime.

Eroarea, în practică:X does not implement Y (missing method Z)

49 Junior

Ai type Shape interface { Area() float64 } și Circle implementează Shape. De ce nu poți transmite un []Circle unei funcții care cere []Shape?

Răspuns scurt: []Circle și []Shape sunt tipuri diferite, cu reprezentări diferite în memorie: un Shape are două cuvinte (tip și valoare), un Circle are câmpurile lui. Conversia cere construirea unui slice nou, element cu element, sau o funcție generică.

Un Circle poate fi atribuit unui Shape, pentru că la atribuire Go construiește valoarea interfață (tipul dinamic plus valoarea). Pentru un slice întreg ar trebui să facă asta pentru fiecare element și să aloce un array nou, o operație O(n). Go nu ascunde astfel de costuri în conversii implicite, deci nu permite []Circle acolo unde se cere []Shape.

Variante:

GO
func TotalArea(shapes []Shape) float64 {
	var sum float64
	for _, s := range shapes {
		sum += s.Area()
	}
	return sum
}

circles := []Circle{{R: 1}, {R: 2}}
shapes := make([]Shape, len(circles))
for i, c := range circles {
	shapes[i] = c
}
fmt.Println(TotalArea(shapes))

Sau cu generice (Go 1.18+), fără conversie:

GO
func TotalAreaOf[S Shape](shapes []S) float64 {
	var sum float64
	for _, s := range shapes {
		sum += s.Area()
	}
	return sum
}

fmt.Println(TotalAreaOf(circles))

Varianta generică acceptă []Circle, []Square, dar și []Shape, deci este mai flexibilă când toate elementele sunt de același tip.

Dacă ai nevoie de forme amestecate (cercuri și pătrate în aceeași listă), construiești direct un []Shape de la început.

Aceeași regulă explică de ce []string nu poate fi transmis ca []any unei funcții variadice ca fmt.Println(names...).

Ce urmărește intervievatorul: Verifică înțelegerea reprezentării interfețelor în memorie. Mulți candidați așteaptă ca slice-urile să fie covariante, ca în unele limbaje.

50 Mid

Care este contractul interfeței io.Reader? Scrie o buclă corectă care citește dintr-un io.Reader până la final.

Răspuns scurt: Read(p []byte) (n int, err error) poate întoarce mai puțini octeți decât len(p) și poate întoarce simultan n > 0 și o eroare, inclusiv io.EOF. Corect procesezi întâi cei n octeți și abia apoi tratezi eroarea.

Regulile documentate pentru io.Reader:

  • Read citește până la len(p) octeți, dar poate întoarce mai puțini fără să fie o eroare;
  • la sfârșitul datelor întoarce io.EOF, eventual împreună cu ultimii octeți citiți (n > 0);
  • apelantul trebuie să proceseze n > 0 înainte să se uite la eroare;
  • implementările sunt descurajate să întoarcă 0, nil, dar apelantul nu trebuie să considere asta un final.

Buclă corectă:

GO
func countBytes(r io.Reader) (int64, error) {
	buf := make([]byte, 32*1024)
	var total int64
	for {
		n, err := r.Read(buf)
		total += int64(n) // înainte de verificarea erorii
		if err == io.EOF {
			return total, nil
		}
		if err != nil {
			return total, err
		}
	}
}

Greșeala frecventă este if err != nil { break } înainte de procesarea lui n, care pierde ultimul fragment de date. Alta este presupunerea că un Read umple tot bufferul.

În practică rareori scrii bucla manual, pentru că biblioteca standard o face corect:

  • io.ReadAll(r) citește tot în memorie;
  • io.ReadFull(r, buf) cere exact len(buf) octeți;
  • io.Copy(dst, src) mută datele în bucăți;
  • bufio.Scanner citește pe linii sau cuvinte.

Comparația err == io.EOF este corectă aici, pentru că Read trebuie să întoarcă io.EOF neîmpachetat. Pentru erori care pot fi împachetate folosești errors.Is.

Ce urmărește intervievatorul: Verifică dacă știi contractul exact al uneia dintre cele mai folosite interfețe. Greșeala tipică este pierderea ultimelor date când Read întoarce simultan octeți și io.EOF.

Eroarea, în practică:EOF (io.EOF)

51 Mid

Ce se întâmplă la rularea codului următor?

GO
var x any = 1
var y any = int64(1)
fmt.Println(x == y)

var a any = []int{1}
var b any = []int{1}
fmt.Println(a == b)

Răspuns scurt: Prima linie afișează false, pentru că tipurile dinamice diferă (int și int64). A doua compilează, dar panichează la runtime cu comparing uncomparable type []int, pentru că valorile dinamice sunt slice-uri.

Două valori interfață sunt egale dacă au același tip dinamic și valori dinamice egale. Ordinea verificării este: întâi tipul, apoi valoarea. 1 stocat ca int și 1 stocat ca int64 au tipuri diferite, deci rezultatul este false fără să se compare valorile. Este o sursă de bug-uri când valorile vin din JSON decodat în any (unde numerele devin float64) și sunt comparate cu constante int.

La a doua comparație, tipurile coincid ([]int), iar runtime-ul trebuie să compare valorile. Slice-urile nu sunt comparabile, iar compilatorul nu poate detecta asta, pentru că static vede doar any == any. Rezultatul este panică.

Unde apare în practică:

  • chei de map de tip any sau interfață, unde inserarea unei valori necomparabile panichează;
  • comparații de erori cu ==, când tipul de eroare este o structură care conține un slice sau un map;
  • cod generic cu constrângerea comparable, care din Go 1.20 acceptă și interfețe, deci poate panica la runtime.

Cum te aperi:

GO
func safeEqual(a, b any) (eq bool) {
	defer func() {
		if recover() != nil {
			eq = reflect.DeepEqual(a, b)
		}
	}()
	return a == b
}

Mai simplu în majoritatea cazurilor: nu compari interfețe arbitrare. Faci type switch pe tipurile așteptate sau folosești reflect.DeepEqual în teste. Pentru erorile proprii, preferă tipuri pointer sau structuri fără câmpuri necomparabile, și compară cu errors.Is.

Ce urmărește intervievatorul: Verifică regulile de egalitate ale interfețelor și faptul că pot panica. Puțini candidați știu că == pe any poate opri programul.

Eroarea, în practică:hash of unhashable type

52 Mid

Scrie un tip care implementează io.Writer și numără câți octeți au fost scriși prin el, transmițând datele mai departe către alt writer.

Răspuns scurt: Definești o structură cu un io.Writer intern și un contor, cu metoda Write(p []byte) (int, error) pe receiver pointer, care apelează writer-ul intern și adună numărul de octeți întors. Tipul poate fi apoi folosit oriunde se cere un io.Writer.

Este un exemplu de decorator: un tip care implementează aceeași interfață ca obiectul pe care îl împachetează și adaugă un comportament.

GO
type CountingWriter struct {
	W     io.Writer
	Count int64
}

func (c *CountingWriter) Write(p []byte) (int, error) {
	n, err := c.W.Write(p)
	c.Count += int64(n)
	return n, err
}

func main() {
	cw := &CountingWriter{W: os.Stdout}
	fmt.Fprintf(cw, "salut, %s\n", "Go")
	io.Copy(cw, strings.NewReader("încă o linie\n"))
	fmt.Println(cw.Count)
}

Detalii care contează:

  • receiver-ul este pointer, pentru că metoda modifică Count. Prin urmare transmiți &CountingWriter{...} sau cw ca pointer;
  • adaugi n, nu len(p), pentru că writer-ul intern poate scrie parțial;
  • întorci exact n și err primite. Contractul io.Writer cere ca Write să întoarcă o eroare dacă n < len(p);
  • Write nu are voie să modifice sau să păstreze p după întoarcere.

Variantă cu fmt.Fprint care funcționează automat, pentru că acesta primește orice io.Writer. Asta este puterea interfețelor mici: fmt, io.Copy, json.NewEncoder, log.New și compresoarele din compress/gzip lucrează toate cu tipul tău, fără să știe de el.

Dacă tipul trebuie folosit din mai multe goroutine, protejezi contorul cu un sync.Mutex sau folosești atomic.Int64. Biblioteca standard are decoratori similari: io.MultiWriter, io.TeeReader, bufio.NewWriter.

Ce urmărește intervievatorul: Verifică dacă știi să implementezi corect o interfață standard și să respecți contractul ei. Greșeala tipică este receiver valoare, care pierde contorul.

Generice și iteratori

Exersează capitolul cu exerciții reale: Curs Go →
53 Junior

Scrie o funcție generică Filter care păstrează elementele unui slice care îndeplinesc o condiție, și o funcție Max care întoarce cel mai mare element. Ce constrângeri folosești?

Răspuns scurt: Filter[T any](s []T, keep func(T) bool) []T merge pentru orice tip, pentru că nu face operații pe elemente. Max are nevoie de >, deci folosește constrângerea cmp.Ordered din Go 1.21 și trebuie să trateze slice-ul gol.

Constrângerea spune ce operații sunt permise pe parametrul de tip. any permite doar atribuire, transmitere și stocare. cmp.Ordered include toate tipurile întregi, reale și string, deci permite < și >. comparable permite == și !=.

GO
func Filter[T any](s []T, keep func(T) bool) []T {
	var out []T
	for _, v := range s {
		if keep(v) {
			out = append(out, v)
		}
	}
	return out
}

func Max[T cmp.Ordered](s []T) (T, bool) {
	var zero T
	if len(s) == 0 {
		return zero, false
	}
	m := s[0]
	for _, v := range s[1:] {
		if v > m {
			m = v
		}
	}
	return m, true
}

pare := Filter([]int{1, 2, 3, 4}, func(n int) bool { return n%2 == 0 })
m, ok := Max([]string{"ana", "ion", "dan"}) // "ion", true

Puncte de discutat:

  • tipul se deduce din argumente (type inference), deci rareori scrii Filter[int](...);
  • var zero T obține valoarea zero a oricărui tip, util pentru cazurile fără rezultat;
  • pentru slice gol, întoarcerea unui bool sau a unei erori este mai sigură decât o panică;
  • din Go 1.21 există funcțiile predeclarate min și max pentru un număr fix de argumente, și slices.Max, care panichează pe slice gol;
  • Go 1.21 are și slices.DeleteFunc, care face filtrarea pe loc.

Filter alocă un slice nou; dacă vrei să eviți alocarea, poți filtra pe loc refolosind s[:0], cu dezavantajul că modifici datele apelantului.

Ce urmărește intervievatorul: Este un exercițiu standard de cod generic. Se verifică alegerea constrângerii minime și tratarea cazului fără elemente.

Eroarea, în practică:type parameter T cannot use operator

54 Mid

Ce face simbolul ~ într-o constrângere? De ce nu compilează apelul următor fără el?

GO
type Number interface {
	int | int64 | float64
}

func Sum[T Number](xs []T) T {
	var s T
	for _, x := range xs {
		s += x
	}
	return s
}

type Celsius float64

func main() {
	fmt.Println(Sum([]Celsius{20.5, 21}))
}

Răspuns scurt: ~float64 înseamnă „orice tip al cărui tip de bază este float64”, inclusiv tipuri definite ca Celsius. Fără ~, uniunea int | int64 | float64 acceptă doar exact acele tipuri, deci Celsius nu satisface constrângerea.

O interfață folosită drept constrângere poate conține o uniune de tipuri. Un element fără tildă, float64, se potrivește doar tipului float64. Un element cu tildă, ~float64, se potrivește oricărui tip al cărui tip de bază (underlying type) este float64: Celsius, time.Duration pentru ~int64 și așa mai departe.

Varianta corectă:

GO
type Number interface {
	~int | ~int64 | ~float64
}

fmt.Println(Sum([]Celsius{20.5, 21})) // 41.5, de tip Celsius

Rezultatul păstrează tipul Celsius, deci metodele lui rămân disponibile.

Pachetul cmp din biblioteca standard folosește tilde peste tot: cmp.Ordered este definit ca ~int | ~int8 | ... | ~float64 | ~string. Când îți scrii propriile constrângeri numerice, aproape întotdeauna vrei tildă.

Reguli despre constrângerile cu uniuni:

  • operațiile permise sunt cele suportate de toate tipurile din uniune: aici +, -, *, /, <. % nu ar fi permis, pentru că nu merge pe float64;
  • o interfață cu uniune nu poate fi folosită ca tip obișnuit: var n Number nu compilează;
  • poți combina uniunea cu metode: interface { ~int; String() string } cere un tip bazat pe int care are și metoda String.

Pachetul golang.org/x/exp/constraints avea constrângeri ca Integer și Float; pentru majoritatea nevoilor, cmp.Ordered din biblioteca standard este suficient.

Ce urmărește intervievatorul: Verifică înțelegerea tipurilor de bază în constrângeri. Greșeala tipică este o constrângere fără tildă care respinge tipurile definite de utilizator.

Eroarea, în practică:X does not satisfy constraint (missing in ...)interface contains type constraints

55 Mid

Implementează un tip generic Set[T] cu metodele Add, Has și Len. De ce constrângerea trebuie să fie comparable?

Răspuns scurt: Un Set[T comparable] se construiește peste un map[T]struct{}, iar cheile unui map trebuie să suporte ==. Constrângerea comparable garantează asta; cu any, codul nu ar compila.

GO
type Set[T comparable] struct {
	m map[T]struct{}
}

func NewSet[T comparable](items ...T) *Set[T] {
	s := &Set[T]{m: make(map[T]struct{}, len(items))}
	for _, it := range items {
		s.Add(it)
	}
	return s
}

func (s *Set[T]) Add(v T)      { s.m[v] = struct{}{} }
func (s *Set[T]) Has(v T) bool { _, ok := s.m[v]; return ok }
func (s *Set[T]) Len() int     { return len(s.m) }

func (s *Set[T]) Union(o *Set[T]) *Set[T] {
	r := NewSet[T]()
	for k := range s.m {
		r.Add(k)
	}
	for k := range o.m {
		r.Add(k)
	}
	return r
}

nums := NewSet(1, 2, 3)
fmt.Println(nums.Has(2), nums.Len()) // true 3

Observații:

  • metodele unui tip generic folosesc parametrii tipului (Set[T]), dar nu pot introduce parametri de tip proprii. O metodă Map[U any] nu este permisă; o scrii ca funcție separată: func MapSet[T, U comparable](s *Set[T], f func(T) U) *Set[U];
  • la NewSet[T]() fără argumente trebuie să dai tipul explicit, pentru că nu se poate deduce;
  • valoarea zero Set[int]{} are map-ul nil, iar Add ar panica. Fie impui constructorul, fie inițializezi leneș în Add;
  • din Go 1.20, comparable este satisfăcut și de tipuri interfață. Un Set[any] compilează, dar adăugarea unui slice panichează la runtime.

Tipul nu este sigur pentru folosire concurentă, la fel ca map-ul pe care se bazează. Dacă e nevoie, adaugi un sync.RWMutex în structură.

Ce urmărește intervievatorul: Verifică stăpânirea tipurilor generice și a restricțiilor lor. Greșeala tipică este încercarea de a scrie metode generice cu parametri de tip noi.

Eroarea, în practică:invalid map key type K (missing comparable)

56 Mid

De ce nu compilează funcția următoare și cum o repari?

GO
func Describe[T any](v T) string {
	switch x := v.(type) {
	case int:
		return fmt.Sprintf("int %d", x)
	case string:
		return "string " + x
	}
	return "altceva"
}

Răspuns scurt: Type switch și type assertion funcționează doar pe valori de tip interfață, iar v are tipul parametru T. Repari convertind întâi la interfață: switch x := any(v).(type).

În interiorul funcției generice, v nu este o interfață, ci o valoare de tipul T, oricare ar fi el la instanțiere. Compilatorul respinge v.(type), deoarece aserțiunile de tip sunt definite doar pentru interfețe. Conversia any(v) împachetează valoarea într-o interfață și face switch-ul posibil:

GO
func Describe[T any](v T) string {
	switch x := any(v).(type) {
	case int:
		return fmt.Sprintf("int %d", x)
	case string:
		return "string " + x
	}
	return "altceva"
}

Totuși, dacă ajungi să faci type switch într-o funcție generică, merită să te întrebi dacă genericele sunt alegerea potrivită. Scopul lor este cod care se comportă la fel pentru toate tipurile.

Alte limite ale genericelor în Go:

  • metodele nu pot avea parametri de tip proprii;
  • nu există specializare: nu poți scrie o implementare separată pentru T = string;
  • nu poți folosi metodele lui T decât dacă apar în constrângere;
  • nu poți accesa câmpuri ale lui T, chiar dacă toate tipurile din constrângere au acel câmp;
  • un tip generic nu poate încorpora parametrul de tip (type W[T any] struct{ T } nu compilează);
  • valorile constante de tipul T nu se pot scrie direct; obții zero cu var zero T, iar alte valori prin conversie, dacă constrângerea o permite: T(1) merge pentru o constrângere numerică.

Aceste restricții sunt alegeri de design care țin compilarea rapidă și codul ușor de citit.

Ce urmărește intervievatorul: Verifică înțelegerea diferenței dintre parametri de tip și interfețe. Este o eroare de compilare pe care candidații o întâlnesc imediat ce scriu cod generic real.

Eroarea, în practică:x is not an interface (type assertion)use of .(type) outside type switch

57 Mid

Ce sunt iteratorii din Go 1.23? Scrie un iterator care numără descrescător de la n la 1 și explică rolul valorii întoarse de yield.

Răspuns scurt: Un iterator este o funcție de tip iter.Seq[V], adică func(yield func(V) bool), care poate fi parcursă cu for range. yield întoarce false când bucla consumatorului s-a oprit (prin break sau return), iar iteratorul trebuie atunci să se oprească imediat.

Din Go 1.23, range acceptă funcții cu formele func(yield func() bool), func(yield func(V) bool) și func(yield func(K, V) bool). Pachetul iter le dă nume: iter.Seq[V] și iter.Seq2[K, V].

GO
func Countdown(n int) iter.Seq[int] {
	return func(yield func(int) bool) {
		for i := n; i > 0; i-- {
			if !yield(i) {
				return
			}
		}
	}
}

for v := range Countdown(5) {
	if v == 2 {
		break
	}
	fmt.Print(v, " ") // 5 4 3
}

Compilatorul transformă corpul buclei într-o funcție transmisă ca yield. Când corpul face break, yield întoarce false. Dacă iteratorul ignoră asta și apelează din nou yield, runtime-ul panichează, deci verificarea este obligatorie.

Biblioteca standard oferă iteratori gata făcuți:

  • slices.All, slices.Values, slices.Backward;
  • maps.Keys, maps.Values, maps.All;
  • slices.Collect(seq) și slices.Sorted(seq) transformă un iterator în slice;
  • strings.SplitSeq și strings.Lines (Go 1.24) evită alocarea unui slice intermediar.

Avantajele: parcurgi structuri proprii (arbori, liste) cu sintaxa for range, generezi valori leneș, fără să construiești tot rezultatul în memorie, și poți compune etape (filtrare, transformare). Pentru iteratori care țin resurse sau trebuie consumați pas cu pas există iter.Pull, care întoarce funcții next și stop; stop trebuie apelat ca să elibereze resursele.

Ce urmărește intervievatorul: Verifică familiaritatea cu o funcționalitate recentă a limbajului. Greșeala tipică este ignorarea valorii întoarse de yield, care produce panică la break.

Eroarea, în practică:range function continued iteration

58 Senior

Cum sunt implementate genericele în compilatorul Go și ce impact are asta asupra performanței? Când alegi generice și când interfețe?

Răspuns scurt: Compilatorul folosește GC shape stenciling cu dicționare: un cod pentru fiecare „formă” de tip (toate tipurile pointer împart una), cu detaliile tipului transmise printr-un dicționar. Codul pe valori e rapid, dar apelurile de metode pe T pot fi mai lente decât prin interfețe.

Existau două abordări clasice: monomorfizare completă (o copie de cod pentru fiecare tip, ca în C++ și Rust), rapidă dar cu binare mari și compilare lentă, și boxing (un singur cod, totul prin pointeri), compact dar mai lent. Go, începând cu 1.18, folosește un compromis:

  • tipurile sunt grupate după „GC shape”, practic după tipul de bază și dimensiune. int și type ID int au aceeași formă; toate tipurile pointer au aceeași formă;
  • pentru fiecare formă se generează o singură instanță de cod;
  • funcția primește un parametru ascuns, un dicționar, cu informații despre tipul concret: metode, descriptori de tip, funcții de egalitate.

Consecințe practice:

  • Max[int], Sum[float64] sau un container generic de valori se compilează în cod la fel de bun ca cel scris de mână;
  • pentru T pointer sau interfață, apelul unei metode a lui T trece prin dicționar și apoi printr-un apel indirect. Poate împiedica inlining-ul și uneori iese mai lent decât o interfață simplă;
  • compilatorul poate inline-a funcții generice mici și, cu PGO, poate devirtualiza apeluri fierbinți, deci singura sursă de adevăr este benchmark-ul.

Regula de alegere:

  • generice pentru cod care lucrează cu date într-un mod independent de tip: colecții, algoritmi pe slice-uri și map-uri, utilitare de concurență tipizate;
  • interfețe pentru comportament: când ce contează sunt metodele (io.Reader, un Store), mai ales dacă ai implementări diferite alese la runtime.

Dacă scrii o funcție generică care doar apelează metode ale lui T, aproape sigur o interfață ca parametru ar fi mai simplă.

Ce urmărește intervievatorul: Se verifică înțelegerea compromisurilor de implementare și o regulă de design matură. Candidații fără experiență presupun că genericele sunt mereu mai rapide decât interfețele.

Erori, defer și panic

59 Junior

Unde e bug-ul în codul următor?

GO
resp, err := http.Get(url)
defer resp.Body.Close()
if err != nil {
	return err
}

Răspuns scurt: defer este înregistrat înainte de verificarea erorii. Când http.Get eșuează, resp este nil, iar la ieșirea din funcție resp.Body.Close() produce panică; defer trebuie pus după if err != nil.

Argumentele și receiver-ul unei instrucțiuni defer se evaluează imediat, dar apelul are loc la ieșirea din funcție. Aici, resp.Body se evaluează chiar în momentul defer. Dacă resp este nil, accesul la câmpul Body panichează pe loc. Oricum ar fi, codul folosește o valoare care nu e garantată.

Convenția Go este: o funcție care întoarce (valoare, error) dă o valoare utilizabilă doar dacă eroarea este nil. Ordinea corectă:

GO
resp, err := http.Get(url)
if err != nil {
	return fmt.Errorf("get %s: %w", url, err)
}
defer resp.Body.Close()

Ce merită spus în plus:

  • unele tipuri tolerează nil: (*os.File).Close pe un pointer nil întoarce os.ErrInvalid în loc să panicheze. Asta ascunde bug-ul, nu-l repară; regula rămâne aceeași;
  • pentru http.Response, corpul trebuie închis chiar dacă nu-l citești, altfel conexiunea nu se poate refolosi și ai scurgeri de resurse;
  • un status 404 sau 500 nu este eroare pentru http.Get. err este nil, deci trebuie să verifici separat resp.StatusCode;
  • după defer, nu reatribui resp în aceeași funcție, pentru că defer a capturat deja valoarea veche.

Linterele (de exemplu bodyclose din golangci-lint) și go vet prind unele dintre aceste situații, dar ordinea „verifică eroarea, apoi defer” trebuie să devină reflex.

Ce urmărește intervievatorul: Este o greșeală clasică de tip „găsește bug-ul”. Se verifică ordinea între verificarea erorii și defer și înțelegerea faptului că valoarea nu e validă când există eroare.

Eroarea, în practică:invalid memory address or nil pointer dereference

60 Junior

Ce operații produc panică la runtime în Go și care întorc eroare? Dă câteva exemple din fiecare categorie.

Răspuns scurt: Panichează greșelile de programare: indexare în afara limitelor, dereferențierea unui pointer nil, scrierea într-un map nil, împărțirea întreagă la zero, type assertion fără ok, trimiterea pe un canal închis. Întorc eroare situațiile așteptate: fișiere lipsă, parsări eșuate, rețea, input invalid.

Filosofia Go: erorile sunt valori pentru situații care pot apărea în mod normal, iar panica este pentru bug-uri sau stări din care programul nu ar trebui să continue.

Exemple de panici din runtime:

GO
s := []int{1, 2}
_ = s[5]               // index out of range

var p *User
_ = p.Name             // nil pointer dereference

var m map[string]int
m["a"] = 1             // assignment to entry in nil map

a, b := 10, 0
_ = a / b              // integer divide by zero

var x any = "text"
_ = x.(int)            // interface conversion

ch := make(chan int)
close(ch)
ch <- 1                // send on closed channel
close(ch)              // close of closed channel

Împărțirea la zero cu constante (10 / 0) este eroare de compilare. Împărțirea reală la zero nu panichează: dă +Inf, -Inf sau NaN.

Exemple de funcții care întorc erori: os.Open, strconv.Atoi, json.Unmarshal, http.Get, db.Query, time.Parse.

Variante sigure pentru operațiile care pot panica:

  • v, ok := x.(int) în loc de x.(int);
  • v, ok := m[k] pentru citire (citirea dintr-un map nil nu panichează, întoarce zero);
  • verifică len(s) înainte de indexare.

Funcțiile cu prefixul Must (regexp.MustCompile, template.Must) panichează intenționat la eroare. Se folosesc la inițializare, cu valori fixe din cod, unde o eroare înseamnă bug al programatorului.

Ce urmărește intervievatorul: Verifică dacă știi ce oprește un program și filosofia erorilor ca valori. Greșeala tipică este folosirea panic pentru erori obișnuite de validare.

Eroarea, în practică:index out of range [3] with length 3assignment to entry in nil map

61 Junior

Unde e problema în codul următor, care procesează mii de fișiere?

GO
func processAll(files []string) error {
	for _, name := range files {
		f, err := os.Open(name)
		if err != nil {
			return err
		}
		defer f.Close()
		if err := process(f); err != nil {
			return err
		}
	}
	return nil
}

Răspuns scurt: defer rulează la ieșirea din funcție, nu la sfârșitul iterației, deci toate fișierele rămân deschise până termină bucla. Cu mii de fișiere poți atinge limita de descriptori (too many open files). Repari mutând corpul buclei într-o funcție separată.

Apelurile amânate se pun într-o stivă legată de funcția curentă și rulează doar când funcția se termină. Într-o buclă, fiecare iterație adaugă încă un f.Close() în stivă, iar fișierele se închid toate deodată, abia la return. Sistemul de operare limitează numărul de fișiere deschise per proces, deci programul eșuează la un moment dat cu o eroare de la os.Open. Pe lângă asta, memoria pentru apelurile amânate crește cu numărul de iterații.

Reparația idiomatică:

GO
func processAll(files []string) error {
	for _, name := range files {
		if err := processFile(name); err != nil {
			return fmt.Errorf("%s: %w", name, err)
		}
	}
	return nil
}

func processFile(name string) error {
	f, err := os.Open(name)
	if err != nil {
		return err
	}
	defer f.Close()
	return process(f)
}

Acum fiecare fișier se închide la ieșirea din processFile, adică la sfârșitul fiecărei iterații.

Alternative:

  • o funcție anonimă apelată imediat în corpul buclei: func() error { ...; defer f.Close(); ... }(). Funcționează, dar e mai greu de citit;
  • f.Close() explicit la finalul iterației, cu riscul de a-l uita pe căile de ieșire timpurie.

Același tipar se aplică la mu.Lock() cu defer mu.Unlock() într-o buclă (blocare care nu se mai eliberează) și la rows.Close() pentru interogări în buclă. Regula: defer aparține unei funcții, deci dacă resursa trăiește o iterație, iterația trebuie să fie o funcție.

Ce urmărește intervievatorul: Verifică dacă știi exact când rulează defer. Bug-ul trece de teste cu puține fișiere și apare doar în producție, la volum mare.

62 Junior

Ce afișează programul următor? Ce se întâmplă cu defer la os.Exit și log.Fatal?

GO
func main() {
	defer fmt.Println("curățenie")
	fmt.Println("start")
	os.Exit(1)
}

Răspuns scurt: Afișează doar start. os.Exit oprește procesul imediat, fără să ruleze funcțiile amânate; log.Fatal apelează os.Exit(1), deci are același efect. Spre deosebire de ele, o panică rulează funcțiile amânate.

os.Exit termină procesul cu codul dat, direct prin sistemul de operare. Nu se mai execută defer, nu se golesc bufferele care nu au fost scrise explicit și nu se închid conexiunile în mod elegant. log.Fatal și log.Fatalf scriu mesajul și apoi apelează os.Exit(1).

Consecințe practice:

  • un defer db.Close() sau defer file.Sync() în main, urmat de un log.Fatal, nu rulează;
  • un bufio.Writer cu defer w.Flush() pierde datele rămase în buffer;
  • un log.Fatal într-o funcție de bibliotecă oprește tot programul și sare peste curățarea apelanților. De aceea bibliotecile întorc erori și lasă decizia de oprire lui main.

Modelul recomandat: toată logica stă într-o funcție run care întoarce eroare, iar main doar decide codul de ieșire.

GO
func main() {
	if err := run(); err != nil {
		fmt.Fprintln(os.Stderr, "eroare:", err)
		os.Exit(1)
	}
}

func run() error {
	db, err := openDB()
	if err != nil {
		return err
	}
	defer db.Close() // rulează înainte de os.Exit
	return serve(db)
}

Comparație cu panica: la panic, funcțiile amânate din goroutine-ul curent rulează, apoi programul se oprește cu codul 2 și afișează stack trace-ul. runtime.Goexit termină doar goroutine-ul curent și rulează și el funcțiile amânate; așa funcționează t.Fatal în teste.

Ce urmărește intervievatorul: Se verifică dacă știi cazurile în care defer nu rulează. Greșeala tipică este log.Fatal folosit peste tot, inclusiv în biblioteci și înainte de curățări importante.

63 Mid

Ce afișează codul următor?

GO
func f() (result int) {
	defer func() { result *= 2 }()
	return 3
}

func g() int {
	x := 3
	defer func() { x *= 2 }()
	return x
}

func main() {
	fmt.Println(f(), g())
}

Răspuns scurt: Afișează 6 3. return 3 atribuie întâi valoarea variabilei numite result, apoi rulează funcțiile amânate, care o pot modifica; în g valoarea întoarsă este o copie făcută înainte de defer, deci modificarea lui x nu mai contează.

Instrucțiunea return nu este atomică. Pașii sunt:

  • se evaluează expresiile din return și se atribuie parametrilor de rezultat;
  • rulează funcțiile amânate, în ordine inversă;
  • funcția revine la apelant cu valorile parametrilor de rezultat.

În f, parametrul de rezultat are nume (result). return 3 setează result = 3, apoi closure-ul amânat face result *= 2, iar apelantul primește 6.

În g, rezultatul nu are nume. return x copiază valoarea lui x (3) într-un slot de rezultat ascuns. Closure-ul modifică variabila locală x, dar nu are acces la acel slot, deci apelantul primește 3.

Utilizarea practică principală este adăugarea de context sau transformarea erorilor într-un singur loc:

GO
func loadUser(id int) (u *User, err error) {
	defer func() {
		if err != nil {
			err = fmt.Errorf("loadUser %d: %w", id, err)
		}
	}()
	// mai multe căi de return cu erori
	return fetch(id)
}

Al doilea caz frecvent este convertirea unei panici în eroare cu recover și raportarea erorii de la Close.

Atenție la lizibilitate: un defer care modifică rezultatul face codul mai greu de urmărit. Folosește-l pentru tipare cunoscute (împachetarea erorilor, recover), nu pentru logică de business. Și evită „naked return” (return fără valori) în funcții lungi.

Ce urmărește intervievatorul: Verifică înțelegerea ordinii exacte dintre return și defer. Este o întrebare clasică de tip „ce afișează” la interviurile pentru Go.

Eroarea, în practică:result parameter not in scope at return

64 Mid

Ce afișează programul următor? În ce condiții funcționează recover?

GO
func handle() {
	if r := recover(); r != nil {
		fmt.Println("recuperat:", r)
	}
}

func main() {
	defer func() {
		handle()
	}()
	panic("boom")
}

Răspuns scurt: Programul nu se recuperează: se oprește cu panic: boom. recover oprește panica doar dacă este apelat direct de funcția amânată; aici este apelat dintr-o funcție chemată de funcția amânată, deci întoarce nil. Cu defer handle() ar funcționa.

Specificația spune că recover întoarce nil dacă nu este apelat direct de o funcție amânată. Funcția amânată aici este closure-ul anonim. handle este apelată de el, deci este cu un nivel mai jos, iar recover() din handle întoarce nil și nu oprește panica.

Variante corecte:

GO
defer handle() // handle este chiar funcția amânată

defer func() {
	if r := recover(); r != nil { // recover direct în funcția amânată
		fmt.Println("recuperat:", r)
	}
}()

Alte reguli despre recover:

  • recuperează doar panicile din goroutine-ul curent. O panică într-o goroutine pornită cu go nu poate fi oprită din main și oprește tot programul;
  • după recuperare, funcția care conținea defer se încheie normal, cu valorile curente ale rezultatelor. Execuția nu continuă de la locul panicii;
  • unele erori nu sunt panici și nu pot fi recuperate: fatal error: concurrent map writes, depășirea memoriei, deadlock-ul detectat de runtime;
  • din Go 1.21, panic(nil) produce un *runtime.PanicNilError, deci recover() nu mai întoarce nil în acest caz.

Când folosești recover în practică: la granița unui server (fiecare cerere sau job își recuperează panicile și le transformă în eroare plus log cu stack trace, prin debug.Stack()), în wrapper-ele pentru goroutine și în biblioteci care folosesc panica intern pentru a ieși din recursivitate. Nu îl folosești pentru controlul obișnuit al fluxului.

Ce urmărește intervievatorul: Verifică dacă știi regula precisă pentru recover și limitele lui. Greșeala tipică este un helper de recuperare apelat indirect, care nu funcționează niciodată.

65 Mid

De ce defer f.Close() nu e suficient când scrii într-un fișier? Scrie o funcție care raportează și eroarea de la Close.

Răspuns scurt: La scriere, o eroare la Close poate însemna date neajunse pe disc, iar defer f.Close() o ignoră. Folosești un rezultat numit err și, în funcția amânată, îl setezi cu eroarea de la Close dacă nu exista deja alta.

Pentru fișiere deschise doar la citire, eroarea de la Close nu contează practic. La scriere, situația e diferită: sistemul de operare poate raporta abia la închidere probleme precum disc plin sau eroare de rețea pe un sistem de fișiere montat. Dacă o ignori, funcția întoarce nil, iar apelantul crede că fișierul a fost salvat.

GO
func writeFile(path string, data []byte) (err error) {
	f, err := os.Create(path)
	if err != nil {
		return err
	}
	defer func() {
		if cerr := f.Close(); cerr != nil && err == nil {
			err = cerr
		}
	}()

	if _, err = f.Write(data); err != nil {
		return err
	}
	return f.Sync()
}

Detalii:

  • err este rezultat numit, deci funcția amânată îl poate citi și modifica după return;
  • condiția err == nil păstrează prima eroare, care este de obicei cauza reală. Alternativ, combini ambele cu errors.Join(err, cerr);
  • f.Sync() cere sistemului de operare să scrie efectiv datele pe disc. Fără el, Close reușit nu garantează că datele au supraviețuit unei căderi de curent;
  • pentru salvări sigure se scrie într-un fișier temporar din același director, se face Sync, Close, apoi os.Rename peste fișierul final, care este atomic pe sistemele POSIX.

Același principiu se aplică la bufio.Writer.Flush, gzip.Writer.Close și csv.Writer.Flush (verificat cu w.Error()): ultimele date se scriu la închidere, deci eroarea acelui pas trebuie verificată.

Ce urmărește intervievatorul: Se verifică atenția la erorile ignorate în căile de curățare. Mulți candidați nu știu că Close la scriere poate eșua și că datele pot fi pierdute.

66 Senior

Unele biblioteci din Go folosesc panic intern și o transformă în eroare la granița API-ului public. Când este acceptabil acest model și cum îl implementezi corect?

Răspuns scurt: Este acceptabil într-un cod recursiv adânc (parsere, interpretoare), unde propagarea erorii prin fiecare nivel ar complica mult codul. Panica se folosește doar intern, cu un tip propriu, iar funcția publică o recuperează și o întoarce ca eroare, re-panicând orice altceva.

Regula generală rămâne: o bibliotecă nu lasă panica să iasă prin API-ul public pentru erori de input. În interiorul pachetului, însă, un parser recursiv-descendent ar avea zeci de funcții care ar face doar if err != nil { return nil, err }. Pachetele standard care parsează sau interpretează text recursiv au folosit acest model pentru a ieși direct din recursivitate.

Implementarea corectă:

GO
type parseError struct{ err error }

func (p *parser) fail(format string, args ...any) {
	panic(parseError{fmt.Errorf(format, args...)})
}

func Parse(src string) (node *Node, err error) {
	defer func() {
		if r := recover(); r != nil {
			pe, ok := r.(parseError)
			if !ok {
				panic(r) // bug real: nu-l ascundem
			}
			err = pe.err
		}
	}()
	p := &parser{src: src}
	return p.parseExpr(), nil
}

Cerințe:

  • tipul panicii este neexportat și specific pachetului, ca să recuperezi doar panicile tale;
  • orice altă panică (nil pointer, index) este re-aruncată, pentru că reprezintă un bug și trebuie să fie vizibilă;
  • recuperarea se face la fiecare punct de intrare public;
  • starea internă afectată (structuri parțial construite) este aruncată sau resetată, pentru că panica a întrerupt operațiile la jumătate.

Un caz înrudit este net/http: serverul recuperează panicile din handlere, le loghează și închide conexiunea, ca o cerere defectă să nu oprească procesul. Asta nu e un motiv să te bazezi pe el; e o plasă de siguranță.

Costul: codul este mai greu de urmărit, iar defer/recover are un cost mic. Merită doar când simplifică semnificativ codul recursiv.

Ce urmărește intervievatorul: Verifică judecata de design asupra folosirii panicii. Seniorii trebuie să știe și modelul, și condițiile stricte în care este acceptabil.

Goroutine, canale și select

67 Junior

Ce afișează programul următor? Cum îl repari?

GO
func main() {
	go fmt.Println("din goroutine")
	fmt.Println("din main")
}

Răspuns scurt: De obicei afișează doar din main. Programul se termină când se încheie main, fără să aștepte celelalte goroutine; repari cu sync.WaitGroup sau cu un canal, nu cu time.Sleep.

go f() pornește f într-o goroutine nouă și continuă imediat. Nu există nicio garanție despre momentul în care goroutine-ul rulează efectiv. Când funcția main se întoarce, procesul se oprește, iar goroutine-urile rămase sunt pur și simplu abandonate, fără să li se ruleze funcțiile amânate. În practică, rezultatul variază: uneori apare și „din goroutine”, de cele mai multe ori nu.

Reparații corecte:

GO
func main() {
	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		defer wg.Done()
		fmt.Println("din goroutine")
	}()
	fmt.Println("din main")
	wg.Wait()
}

Sau cu un canal de semnalizare:

GO
done := make(chan struct{})
go func() {
	defer close(done)
	fmt.Println("din goroutine")
}()
<-done

De ce nu time.Sleep(time.Second): nu sincronizează nimic. Pe o mașină încărcată, o secundă poate să nu ajungă, iar pe una rapidă pierzi timp. Și nu stabilește relația de ordine din modelul de memorie, deci nu garantează că main vede datele scrise de goroutine.

Ordinea celor două mesaje nu este garantată nici după reparație, pentru că main și goroutine-ul rulează concurent. Dacă ordinea contează, sincronizezi explicit înainte de a afișa.

În servere, aceeași problemă apare la oprire: dacă procesul primește semnal de oprire și main iese, sarcinile pornite în fundal se pierd. De aceea oprirea elegantă așteaptă goroutine-urile active.

Ce urmărește intervievatorul: Verifică înțelegerea ciclului de viață al unui program Go. Greșeala tipică este folosirea time.Sleep ca sincronizare.

68 Junior

Ce afișează codul următor? Ce se întâmplă la operațiile pe un canal nil și pe un canal închis?

GO
ch := make(chan int, 2)
ch <- 1
ch <- 2
close(ch)
fmt.Println(<-ch, <-ch, <-ch)
v, ok := <-ch
fmt.Println(v, ok)

Răspuns scurt: Afișează 1 2 0 și 0 false. Un canal închis livrează întâi valorile din buffer, apoi zero, cu ok fals; trimiterea pe el sau a doua închidere panichează. Pe un canal nil, trimiterea și primirea blochează pentru totdeauna.

Comportamentul pe stări, pe scurt:

  • canal deschis: trimiterea și primirea funcționează normal, blocând când e cazul;
  • canal închis: primirea întoarce valorile rămase în buffer, apoi valoarea zero imediat, cu ok == false; trimiterea produce panică (send on closed channel); close produce panică (close of closed channel);
  • canal nil (valoarea zero a tipului chan T): trimiterea și primirea blochează pentru totdeauna; close produce panică.

range ch se oprește după ce canalul este închis și golit, ceea ce face din close semnalul natural de „nu mai vin date”.

Canalul nil pare inutil, dar este util în select: un caz cu un canal nil nu este niciodată ales, deci poți dezactiva un caz punând canalul pe nil.

GO
for a != nil || b != nil {
	select {
	case v, ok := <-a:
		if !ok {
			a = nil // nu mai citim din a
			continue
		}
		fmt.Println("a:", v)
	case v, ok := <-b:
		if !ok {
			b = nil
			continue
		}
		fmt.Println("b:", v)
	}
}

Fără setarea pe nil, un canal închis ar fi gata mereu și bucla ar consuma procesorul primind zerouri.

Reguli practice: închide canalul doar din partea care trimite și doar o singură dată; nu închide un canal doar ca să elibereze resurse, garbage collector-ul colectează canalele nefolosite.

Ce urmărește intervievatorul: Verifică dacă știi tabelul de comportament al canalelor, inclusiv cazurile mai rare. Mulți candidați nu știu că un canal nil blochează sau la ce folosește în select.

Eroarea, în practică:all goroutines are asleep - deadlock!send on closed channel

69 Junior

Ce sunt canalele direcționale (chan<- T și <-chan T) și de ce le folosești în semnăturile funcțiilor?

Răspuns scurt: chan<- T permite doar trimiterea, iar <-chan T doar primirea. Un canal bidirecțional se convertește automat la oricare dintre ele, iar compilatorul împiedică folosirea greșită, de exemplu citirea dintr-un canal destinat ieșirii sau închiderea unui canal de intrare.

Direcția exprimă rolul fiecărei funcții și mută verificarea la compilare:

GO
func produce(n int, out chan<- int) {
	defer close(out)
	for i := range n {
		out <- i
	}
}

func consume(in <-chan int) int {
	sum := 0
	for v := range in {
		sum += v
	}
	return sum
}

func main() {
	ch := make(chan int)
	go produce(5, ch)
	fmt.Println(consume(ch)) // 10
}

Ce previne compilatorul:

  • v := <-out în produce: eroare, canalul este doar pentru trimitere;
  • in <- 1 în consume: eroare, canalul este doar pentru primire;
  • close(in) în consume: eroare, nu poți închide un canal doar pentru primire. Asta impune regula că doar producătorul închide canalul.

Conversia funcționează doar într-o direcție: chan T devine implicit chan<- T sau <-chan T, dar nu invers.

Un model foarte folosit: funcția care creează canalul îl întoarce ca doar-citire, ca nimeni din afară să nu poată trimite sau închide.

GO
func generate(ctx context.Context) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for i := 0; ; i++ {
			select {
			case out <- i:
			case <-ctx.Done():
				return
			}
		}
	}()
	return out
}

time.After și ctx.Done() din biblioteca standard întorc canale doar pentru citire, din același motiv.

Ce urmărește intervievatorul: Verifică dacă folosești sistemul de tipuri pentru a face codul concurent mai sigur. Candidații care nu folosesc canale direcționale lasă loc unor bug-uri ușor de prevenit.

Eroarea, în practică:cannot send to receive-only channel

70 Junior

Găsește cele două bug-uri legate de sync.WaitGroup din codul următor.

GO
func worker(id int, wg sync.WaitGroup) {
	defer wg.Done()
	fmt.Println("worker", id)
}

func main() {
	var wg sync.WaitGroup
	for i := 0; i < 3; i++ {
		go func() {
			wg.Add(1)
			worker(i, wg)
		}()
	}
	wg.Wait()
}

Răspuns scurt: wg.Add(1) se apelează în goroutine, deci wg.Wait() poate rula înainte de orice Add și întoarce imediat. Iar worker primește WaitGroup prin valoare, deci Done se apelează pe o copie; trebuie Add înainte de go și transmitere prin pointer.

Primul bug este o condiție de cursă logică. Goroutine-urile pornesc cu întârziere, iar main ajunge la wg.Wait() cu contorul încă la zero, deci nu așteaptă nimic. Documentația cere ca Add cu valoare pozitivă să fie apelat înainte de pornirea goroutine-ului sau a altui eveniment de așteptat.

Al doilea bug este copierea. sync.WaitGroup conține un contor intern; transmis prin valoare, worker decrementează contorul copiei, nu al originalului. Dacă primul bug ar fi reparat, main ar aștepta la nesfârșit și runtime-ul ar raporta deadlock. go vet semnalează copierea tipurilor din sync (verificarea copylocks).

Varianta corectă:

GO
func worker(id int, wg *sync.WaitGroup) {
	defer wg.Done()
	fmt.Println("worker", id)
}

func main() {
	var wg sync.WaitGroup
	for i := 0; i < 3; i++ {
		wg.Add(1)
		go worker(i, &wg)
	}
	wg.Wait()
}

Și mai bine, funcția worker nu ar trebui să știe de WaitGroup. Lași sincronizarea în apelant:

GO
for i := range 3 {
	wg.Go(func() { work(i) }) // Go 1.25
}
wg.Wait()

wg.Go (Go 1.25) face Add(1), pornește goroutine-ul și apelează Done la final, eliminând ambele bug-uri. În versiunile mai vechi, scrii explicit wg.Add(1) și go func() { defer wg.Done(); work(i) }().

Din Go 1.22, capturarea lui i în closure este sigură, pentru că fiecare iterație are propria variabilă.

Ce urmărește intervievatorul: Este un exercițiu clasic de găsire a bug-urilor. Se verifică ordinea Add față de go și faptul că tipurile din sync nu se copiază.

Eroarea, în practică:sync: negative WaitGroup counter

71 Junior

Cum oprești deodată mai multe goroutine care așteaptă un semnal? De ce se folosește close și nu o trimitere pe canal?

Răspuns scurt: Închizi un canal chan struct{} pe care toate goroutine-urile îl ascultă: o primire de pe un canal închis reușește imediat pentru toți cei care așteaptă. O trimitere ajunge doar la o singură goroutine, deci nu poate notifica pe toată lumea.

O valoare trimisă pe un canal este primită de exact un receptor. Dacă zece goroutine așteaptă și trimiți un semnal, doar una îl primește. close este un eveniment de difuzare (broadcast): după închidere, toate primirile, prezente și viitoare, se încheie imediat.

GO
func main() {
	done := make(chan struct{})
	var wg sync.WaitGroup
	for i := range 3 {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for {
				select {
				case <-done:
					fmt.Println("oprit", i)
					return
				default:
					// lucru util, apoi verificăm din nou
					time.Sleep(10 * time.Millisecond)
				}
			}
		}()
	}
	time.Sleep(50 * time.Millisecond)
	close(done)
	wg.Wait()
}

De ce chan struct{}: canalul nu transportă date, doar semnalul. Tipul gol arată intenția și nu ocupă memorie.

Atenție:

  • canalul se închide o singură dată. Dacă mai multe locuri pot declanșa oprirea, protejezi close cu sync.Once;
  • după închidere, canalul nu poate fi „redeschis”; pentru o nouă rundă creezi un canal nou.

În cod modern, acest model este oferit de context.Context: ctx.Done() întoarce exact un astfel de canal, care se închide la apelul cancel(), la expirarea termenului sau la anularea părintelui. Pentru oprirea unor goroutine legate de o cerere, context este alegerea standard; canalul done manual rămâne util pentru componente simple, interne.

Ce urmărește intervievatorul: Verifică înțelegerea semanticii de broadcast a lui close. Greșeala tipică este trimiterea unui singur true pe un canal și așteptarea ca toate goroutine-urile să se oprească.

Eroarea, în practică:close of closed channel

72 Junior

Ce face un select cu ramura default? Scrie o trimitere care nu blochează când bufferul canalului este plin.

Răspuns scurt: Cu default, select nu mai așteaptă: dacă niciun alt caz nu este gata imediat, rulează default. Astfel obții trimiteri și primiri neblocante, de exemplu renunți la un eveniment când consumatorul nu ține pasul.

Fără default, select blochează până când unul dintre cazuri poate continua. Cu default, verifică o singură dată toate cazurile și, dacă niciunul nu e gata, execută default și merge mai departe.

Trimitere neblocantă, utilă pentru metrici sau evenimente care pot fi pierdute:

GO
events := make(chan Event, 100)

func publish(e Event) bool {
	select {
	case events <- e:
		return true
	default:
		droppedEvents.Add(1) // bufferul e plin, renunțăm
		return false
	}
}

Primire neblocantă:

GO
select {
case msg := <-inbox:
	handle(msg)
default:
	// nimic de procesat acum
}

Capcana principală este bucla activă:

GO
for {
	select {
	case v := <-ch:
		process(v)
	default:
		// nimic: bucla se rotește continuu
	}
}

Acest cod consumă un nucleu de procesor la 100% cât timp canalul e gol. Dacă vrei doar să aștepți date, scoți default și lași select să blocheze, eventual cu un caz pentru ctx.Done().

Alte observații:

  • len(ch) îți spune câte elemente sunt în buffer acum, dar valoarea poate fi depășită de evenimente imediat după citire; nu decizi pe baza ei, folosești select cu default;
  • renunțarea la date trebuie să fie o decizie conștientă și vizibilă, de aceea e bine să numeri evenimentele pierdute.

Ce urmărește intervievatorul: Verifică dacă știi să faci operații neblocante și dacă recunoști bucla activă. Greșeala tipică este un default gol într-o buclă, care încarcă procesorul.

73 Mid

Ce afișează codul următor? Cum dai prioritate unui canal într-un select?

GO
a := make(chan string, 1)
b := make(chan string, 1)
a <- "a"
b <- "b"
select {
case v := <-a:
	fmt.Println(v)
case v := <-b:
	fmt.Println(v)
}

Răspuns scurt: Poate afișa a sau b: când mai multe cazuri sunt gata, select alege unul aleatoriu, uniform, ca să evite înfometarea. Ordinea în care sunt scrise cazurile nu înseamnă prioritate; prioritatea se obține cu un select separat cu default, verificat înainte.

Specificația spune că, dacă mai multe comunicări pot avea loc, se alege una prin selecție pseudo-aleatoare uniformă. Alegerea aleatorie împiedică un canal foarte activ să blocheze complet un altul.

Uneori ai nevoie de prioritate, de exemplu semnalul de oprire trebuie să câștige în fața lucrului nou:

GO
for {
	select {
	case <-ctx.Done():
		return ctx.Err()
	default:
	}

	select {
	case <-ctx.Done():
		return ctx.Err()
	case job := <-jobs:
		process(job)
	}
}

Primul select verifică neblocant oprirea. Al doilea așteaptă oricare eveniment. Fără prima verificare, dacă jobs are mereu elemente, oprirea ar putea fi amânată câteva iterații, în funcție de alegerea aleatorie.

Model pentru două cozi cu priorități diferite:

GO
select {
case j := <-high:
	process(j)
default:
	select {
	case j := <-high:
		process(j)
	case j := <-low:
		process(j)
	}
}

Lucrările urgente sunt luate primele dacă există. Altfel se așteaptă oricare.

Prioritatea strictă poate înfometa coada cu prioritate mică dacă cea urgentă e mereu plină. Dacă asta e o problemă, folosești o pondere (procesezi cel mult N lucrări urgente, apoi una normală) sau o coadă de priorități (container/heap) protejată de un mutex.

Ce urmărește intervievatorul: Verifică dacă știi că select alege aleatoriu și dacă poți construi prioritate explicit. Greșeala tipică este credința că primul caz scris are prioritate.

74 Mid

Ai 1.000 de URL-uri de descărcat, dar vrei cel mult 10 descărcări simultane. Implementează limitarea folosind un canal.

Răspuns scurt: Folosești un canal cu buffer de capacitate 10 ca semafor: fiecare goroutine trimite un struct{} înainte de lucru și îl scoate la final. Când bufferul e plin, următoarele goroutine blochează până se eliberează un loc.

GO
func fetchAll(ctx context.Context, urls []string) []error {
	errs := make([]error, len(urls))
	sem := make(chan struct{}, 10)
	var wg sync.WaitGroup

	for i, url := range urls {
		wg.Add(1)
		go func() {
			defer wg.Done()
			select {
			case sem <- struct{}{}: // ocupăm un loc
			case <-ctx.Done():
				errs[i] = ctx.Err()
				return
			}
			defer func() { <-sem }() // eliberăm locul

			errs[i] = fetch(ctx, url)
		}()
	}
	wg.Wait()
	return errs
}

Cum funcționează: capacitatea canalului este numărul maxim de goroutine care pot fi „în interior” simultan. A unsprezecea goroutine blochează la trimitere până când una termină și citește din canal.

Observații pentru discuție:

  • această variantă pornește 1.000 de goroutine, din care 990 așteaptă. Goroutine-urile sunt ieftine, deci de obicei e acceptabil. Pentru milioane de elemente, un worker pool cu 10 goroutine fixe care citesc dintr-un canal de joburi este mai economic;
  • fiecare goroutine scrie la propriul index în errs, deci nu e nevoie de mutex;
  • select cu ctx.Done() permite anularea celor care încă așteaptă;
  • variabilele de buclă i și url sunt per-iterație din Go 1.22, deci capturarea lor e sigură.

Alternative din ecosistem: errgroup.Group cu SetLimit(10) din golang.org/x/sync/errgroup, care combină limitarea, așteptarea și prima eroare, și golang.org/x/sync/semaphore pentru semafoare ponderate (o sarcină poate ocupa mai multe locuri).

Ce urmărește intervievatorul: Verifică dacă știi un model de concurență cerut des la live coding. Se urmărește și dacă te gândești la anulare și la colectarea erorilor.

75 Mid

Procesezi concurent o listă de elemente și rezultatele trebuie întoarse în aceeași ordine ca intrarea. Cum faci asta fără sortare la final?

Răspuns scurt: Prealoci un slice de rezultate cu lungimea intrării și fiecare goroutine scrie la indexul elementului său. Scrierile la indici diferiți nu sunt condiții de cursă, iar după wg.Wait() slice-ul este complet și ordonat.

Soluția cea mai simplă nu folosește canale pentru rezultate:

GO
func processOrdered(items []string) []Result {
	results := make([]Result, len(items))
	var wg sync.WaitGroup
	for i, it := range items {
		wg.Add(1)
		go func() {
			defer wg.Done()
			results[i] = process(it) // fiecare goroutine are indexul ei
		}()
	}
	wg.Wait()
	return results
}

De ce nu e condiție de cursă: un data race apare când două goroutine accesează aceeași locație de memorie și cel puțin una scrie. Elementele unui slice sunt locații distincte, deci goroutine-urile care scriu la indici diferiți nu interferează. wg.Wait() garantează, conform modelului de memorie, că main vede toate scrierile.

Ce nu merge: results = append(results, r) din mai multe goroutine. append modifică antetul comun al slice-ului și este o condiție de cursă reală.

Varianta cu worker pool și canal, când vrei un număr fix de goroutine:

GO
type job struct {
	idx  int
	item string
}

jobs := make(chan job)
for w := 0; w < 8; w++ {
	wg.Add(1)
	go func() {
		defer wg.Done()
		for j := range jobs {
			results[j.idx] = process(j.item)
		}
	}()
}
for i, it := range items {
	jobs <- job{i, it}
}
close(jobs)
wg.Wait()

Indexul călătorește împreună cu jobul. Dacă rezultatele vin pe un canal și trebuie emise în flux, în ordine, păstrezi un buffer cu cele care au venit prea devreme și le emiți când apare indexul următor așteptat.

Un detaliu de performanță: scrierile intense la elemente vecine dintr-un slice de valori mici pot cauza false sharing; pentru rezultate costisitoare de calculat, efectul este neglijabil.

Ce urmărește intervievatorul: Verifică dacă înțelegi ce este și ce nu este un data race. Mulți candidați adaugă un mutex inutil sau sortează rezultatele la final.

76 Mid

Ce se întâmplă dacă o goroutine pornită dintr-un handler panichează? Scrie un helper care pornește goroutine fără să riște oprirea întregului proces.

Răspuns scurt: O panică nerecuperată în orice goroutine oprește tot procesul, iar un recover din main sau din goroutine-ul părinte nu o poate prinde. Helper-ul pune un defer cu recover chiar în goroutine-ul nou, loghează panica și stack trace-ul și, eventual, raportează o eroare.

recover funcționează doar în goroutine-ul care panichează. Goroutine-urile nu au o relație părinte-copil la runtime, deci nimic nu se propagă în sus. Dacă o goroutine de fundal panichează, programul afișează stack trace-ul și se oprește cu codul 2, chiar dacă handler-ul HTTP care a pornit-o este protejat. Recuperarea automată pe care o face net/http acoperă doar goroutine-ul cererii, nu și pe cele pornite de tine.

GO
func SafeGo(logger *slog.Logger, name string, f func()) {
	go func() {
		defer func() {
			if r := recover(); r != nil {
				logger.Error("panică în goroutine",
					"task", name,
					"panic", r,
					"stack", string(debug.Stack()))
			}
		}()
		f()
	}()
}

SafeGo(log, "trimite-email", func() { sendEmail(order) })

Variantă care transformă panica în eroare, pentru cazurile în care cineva așteaptă rezultatul:

GO
func runSafe(f func() error) (err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("panică: %v", r)
		}
	}()
	return f()
}

Ce trebuie discutat:

  • recuperarea nu repară bug-ul; starea poate fi inconsistentă (un mutex rămas blocat, date scrise pe jumătate). Logul cu stack trace și o alertă sunt obligatorii;
  • pentru sarcini critice, un proces oprit și repornit de orchestrator poate fi mai sigur decât unul care continuă într-o stare coruptă;
  • erorile fatale (concurrent map writes, lipsa memoriei) nu pot fi recuperate oricum.

Ce urmărește intervievatorul: Se verifică faptul că știi că panica dintr-o goroutine nu poate fi prinsă din exterior. Greșeala tipică este presupunerea că middleware-ul de recuperare acoperă și goroutine-urile pornite din handler.

77 Senior

Ce probleme are folosirea time.After într-o buclă cu select și ce s-a schimbat la timere în Go 1.23?

GO
for {
	select {
	case msg := <-inbox:
		handle(msg)
	case <-time.After(5 * time.Minute):
		return errIdle
	}
}

Răspuns scurt: Fiecare iterație creează un timer nou. Înainte de Go 1.23, timerele neexpirate nu erau colectate de GC, deci la mesaje dese se acumulau mii de timere de 5 minute. Din Go 1.23 sunt colectate, dar un singur timer resetat rămâne mai eficient.

În versiunile mai vechi de 1.23, un timer creat cu time.After sau time.NewTimer rămânea în structurile runtime-ului până la expirare, chiar dacă nimeni nu mai avea referință la el. Într-o buclă care primește mii de mesaje pe secundă, fiecare iterație lăsa în urmă un timer de 5 minute, iar memoria creștea vizibil.

Go 1.23 a schimbat două lucruri (activate când go.mod declară go 1.23 sau mai nou):

  • timerele și ticker-ele care nu mai sunt referite pot fi colectate de GC, chiar dacă nu au fost oprite;
  • canalul unui timer este nebufferizat (sincron), deci după Stop sau Reset nu mai poți primi o valoare veche. Dispare modelul complicat „Stop, apoi golește canalul”.

Varianta eficientă, independentă de versiune:

GO
idle := time.NewTimer(5 * time.Minute)
defer idle.Stop()
for {
	select {
	case msg := <-inbox:
		handle(msg)
		idle.Reset(5 * time.Minute)
	case <-idle.C:
		return errIdle
	case <-ctx.Done():
		return ctx.Err()
	}
}

Pentru time.Ticker, apelezi defer t.Stop(). Înainte de 1.23, un ticker neoprit era o scurgere permanentă de resurse.

Alte observații:

  • pentru timeout-ul unei operații, context.WithTimeout este de obicei mai potrivit, pentru că se propagă în apelurile din aval;
  • time.Sleep într-o buclă nu poate fi întrerupt; dacă trebuie să reacționezi la oprire, folosești select cu un timer și ctx.Done();
  • time.Tick era nerecomandat înainte de 1.23 din cauza scurgerii; acum e acceptabil când tickerul trăiește cât programul.

Ce urmărește intervievatorul: Verifică experiența cu timerele în cod de producție și cunoașterea schimbărilor recente. Candidații seniori ar trebui să știe și de ce modelul vechi era periculos.

78 Senior

Ce garantează modelul de memorie Go despre canale? De ce bucla următoare poate să nu se termine niciodată?

GO
var done bool

func main() {
	go func() {
		time.Sleep(time.Millisecond)
		done = true
	}()
	for !done {
	}
	fmt.Println("gata")
}

Răspuns scurt: Fără sincronizare nu există relație happens-before între scrierea lui done și citirile din buclă, deci compilatorul poate citi flag-ul o singură dată. Canalele, mutex-urile și operațiile atomice creează astfel de relații: trimiterea pe canal precede încheierea primirii.

Modelul de memorie spune când o citire dintr-o goroutine este garantată să vadă o scriere din alta. Garanția există doar dacă scrierea „se întâmplă înainte” (happens-before) de citire, printr-un lanț de evenimente de sincronizare. Aici nu există niciunul: codul are un data race, iar comportamentul nu este garantat. Compilatorul are voie să citească done o singură dată, înainte de buclă, pentru că nimic din buclă nu o modifică. go run -race raportează imediat problema.

Garanțiile principale pentru canale:

  • o trimitere pe canal se întâmplă înainte de încheierea primirii corespunzătoare;
  • închiderea unui canal se întâmplă înainte de o primire care întoarce valoarea zero din cauza închiderii;
  • pentru un canal nebufferizat, primirea se întâmplă înainte de încheierea trimiterii;
  • pentru un canal cu capacitate C, a k-a primire se întâmplă înainte de încheierea trimiterii cu numărul k + C. Pe această regulă se bazează semaforul cu canal cu buffer.

Alte surse de sincronizare: Unlock se întâmplă înainte de următorul Lock reușit, wg.Done înainte de întoarcerea din Wait, funcția din once.Do înainte de întoarcerea oricărui Do, iar operațiile din sync/atomic sunt secvențial consistente.

Reparația:

GO
var done atomic.Bool
// în goroutine: done.Store(true)
for !done.Load() {
	runtime.Gosched()
}

Și mai bine, fără așteptare activă:

GO
done := make(chan struct{})
go func() { work(); close(done) }()
<-done

Ideea pentru interviu: în Go nu există „data race benign”; orice acces concurent nesincronizat este un bug, chiar dacă pe o anumită arhitectură pare să funcționeze.

Ce urmărește intervievatorul: Verifică înțelegerea formală a modelului de memorie, nu doar folosirea uneltelor. Seniorii trebuie să explice de ce un flag simplu nu este sigur.

sync, context și condiții de cursă

Exersează capitolul cu exerciții reale: Curs Go →
79 Junior

Ce se întâmplă la apelul lui Incr și de ce?

GO
type Store struct {
	mu sync.Mutex
	m  map[string]int
}

func (s *Store) Get(k string) int {
	s.mu.Lock()
	defer s.mu.Unlock()
	return s.m[k]
}

func (s *Store) Incr(k string) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.m[k] = s.Get(k) + 1
}

Răspuns scurt: Programul intră în deadlock: Incr ține mutex-ul, apoi Get încearcă să-l blocheze din nou și așteaptă pentru totdeauna. sync.Mutex din Go nu este reentrant, deci aceeași goroutine nu-l poate bloca de două ori.

Un mutex reentrant (cum este synchronized în Java) permite aceluiași fir să intre de mai multe ori. sync.Mutex nu are noțiunea de proprietar: nu știe ce goroutine l-a blocat. Al doilea Lock din aceeași goroutine așteaptă eliberarea, care nu va veni, pentru că Unlock din Incr rulează abia după ce Get se termină.

Dacă toate goroutine-urile ajung blocate, runtime-ul afișează fatal error: all goroutines are asleep - deadlock!. Într-un server cu alte goroutine active, nu primești niciun mesaj: cererile care ajung la Incr doar rămân blocate.

Soluția idiomatică este separarea metodelor publice, care blochează, de cele interne, care presupun că lock-ul este deja ținut:

GO
func (s *Store) Get(k string) int {
	s.mu.Lock()
	defer s.mu.Unlock()
	return s.getLocked(k)
}

func (s *Store) Incr(k string) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.m[k] = s.getLocked(k) + 1
}

// getLocked presupune că s.mu este deja blocat.
func (s *Store) getLocked(k string) int {
	return s.m[k]
}

Convenția cu sufixul Locked și comentariul spun clar contractul.

Alte reguli de lucru cu mutex-ul:

  • defer mu.Unlock() imediat după Lock, ca să nu rămână blocat la un return timpuriu sau la panică;
  • secțiunea critică trebuie să fie scurtă: nu faci I/O, apeluri de rețea sau trimiteri pe canale cât timp ții lock-ul;
  • valoarea zero a lui sync.Mutex este un mutex deblocat, gata de folosit.

Ce urmărește intervievatorul: Verifică dacă știi că mutex-ul nu este reentrant. Este o eroare frecventă la candidații veniți din Java sau C#.

Eroarea, în practică:all goroutines are asleep - deadlock!

80 Mid

Codul următor compilează, dar contorul rămâne 0 și nu este protejat. Unde e problema?

GO
type Counter struct {
	mu sync.Mutex
	n  int
}

func (c Counter) Inc() {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.n++
}

Răspuns scurt: Metoda are receiver valoare, deci la fiecare apel lucrează pe o copie a structurii, inclusiv a mutex-ului. Incrementul se pierde, iar fiecare apel blochează alt mutex. Receiver-ul trebuie să fie *Counter; go vet semnalează copierea.

Cu receiver valoare, c este o copie locală a structurii. c.n++ modifică doar copia, care dispare la ieșirea din metodă, deci contorul original nu crește niciodată. Mai grav, fiecare apel are propriul mutex copiat, deci nu există excludere mutuală. Dacă metoda ar modifica un câmp partajat (de exemplu un map, care se copiază ca referință), ai avea un data race, deși codul pare protejat.

Reparația:

GO
func (c *Counter) Inc() {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.n++
}

Copierea unui mutex mai apare în alte forme:

  • transmiterea structurii prin valoare unei funcții: func report(c Counter);
  • atribuirea c2 := c1 sau returnarea structurii prin valoare;
  • parcurgerea cu for _, c := range counters pe un slice de structuri;
  • copierea unui mutex blocat produce o copie blocată, care nu va mai fi deblocată de nimeni.

go vet are verificarea copylocks, care detectează toate aceste cazuri pentru tipurile din sync (Mutex, RWMutex, WaitGroup, Once, Cond) și pentru atomic.Int64 și înrudite. Rulează automat la go test.

Reguli practice:

  • un tip care conține un mutex se folosește doar prin pointer și toate metodele au receiver pointer;
  • dacă un tip trebuie să fie necopiabil, poți adăuga un câmp noCopy (o structură goală cu metodele Lock și Unlock), pe care go vet îl recunoaște;
  • mutex-ul se pune lângă câmpurile pe care le protejează, cu un comentariu.

Ce urmărește intervievatorul: Verifică înțelegerea receiver-ilor în combinație cu sincronizarea. Bug-ul este greu de observat la citire și e prins doar de go vet sau de teste concurente.

81 Mid

Ce este sync.Pool, când îl folosești și ce capcane are?

Răspuns scurt: sync.Pool este un cache de obiecte temporare, sigur pentru goroutine, care reduce alocările în căi fierbinți. Obiectele pot dispărea la orice GC, deci nu e un pool de conexiuni, iar obiectele se resetează înainte de refolosire.

Utilizarea tipică este refolosirea bufferelor într-un serviciu care procesează multe cereri:

GO
var bufPool = sync.Pool{
	New: func() any { return new(bytes.Buffer) },
}

func render(w io.Writer, data Page) error {
	buf := bufPool.Get().(*bytes.Buffer)
	buf.Reset()
	defer bufPool.Put(buf)

	if err := tmpl.Execute(buf, data); err != nil {
		return err
	}
	_, err := buf.WriteTo(w)
	return err
}

Get întoarce un obiect din pool sau creează unul nou cu New. Put îl pune înapoi pentru refolosire.

Capcane:

  • obiectele pot dispărea la orice ciclu de GC (din Go 1.13 supraviețuiesc un ciclu, prin „victim cache”). Nu stochezi în pool nimic care trebuie închis sau păstrat;
  • obiectul întors poate conține date vechi, deci îl resetezi mereu;
  • nu folosești obiectul după Put; altă goroutine îl poate primi imediat;
  • bufferele foarte mari puse înapoi în pool rămân în memorie. Dacă unele cereri produc buffere uriașe, nu le pui înapoi peste o anumită dimensiune;
  • e recomandat să stochezi pointeri, nu valori, ca Put să nu aloce el însuși;
  • pentru conexiuni la baze de date sau worker-i folosești pool-uri dedicate (database/sql are unul), nu sync.Pool.

Când merită: doar după ce profilul de memorie arată multe alocări de obiecte de același tip într-o cale fierbinte. Biblioteca standard îl folosește în fmt și encoding/json. În cod obișnuit, complexitatea suplimentară rareori se justifică.

Ce urmărește intervievatorul: Verifică dacă știi semantica reală a lui sync.Pool. Greșeala tipică este folosirea lui ca pool de conexiuni sau uitarea resetării obiectelor.

82 Mid

Codul următor încearcă o inițializare leneșă eficientă. De ce este greșit și cum îl repari?

GO
var (
	mu          sync.Mutex
	initialized bool
	cfg         *Config
)

func GetConfig() *Config {
	if !initialized {
		mu.Lock()
		if !initialized {
			cfg = loadConfig()
			initialized = true
		}
		mu.Unlock()
	}
	return cfg
}

Răspuns scurt: Prima citire a lui initialized se face fără lock, deci este un data race: o goroutine poate vedea initialized == true înainte să vadă scrierea lui cfg și întoarce nil sau o configurație incompletă. Soluția este sync.Once sau sync.OnceValue.

Modelul se numește double-checked locking. Ideea este să eviți costul lock-ului după inițializare. Problema este că citirea din afara lock-ului nu are nicio relație happens-before cu scrierile din interior. Compilatorul și procesorul pot reordona scrierile cfg = ... și initialized = true, iar o altă goroutine poate observa flag-ul setat și un cfg încă nevizibil. Detectorul de curse (go test -race) raportează imediat accesul.

Reparația idiomatică:

GO
var getConfig = sync.OnceValue(loadConfig) // Go 1.21

func GetConfig() *Config {
	return getConfig()
}

Sau, în versiuni mai vechi:

GO
var (
	once sync.Once
	cfg  *Config
)

func GetConfig() *Config {
	once.Do(func() { cfg = loadConfig() })
	return cfg
}

sync.Once folosește intern exact ideea de double-checking, dar corect: citirea rapidă este o operație atomică, iar funcția se execută sub mutex. După inițializare, costul unui apel este o singură citire atomică.

Dacă vrei totuși varianta manuală, flag-ul trebuie să fie atomic.Bool sau, mai simplu, folosești atomic.Pointer[Config]:

GO
var cfgPtr atomic.Pointer[Config]

func GetConfig() *Config {
	if c := cfgPtr.Load(); c != nil {
		return c
	}
	mu.Lock()
	defer mu.Unlock()
	if c := cfgPtr.Load(); c != nil {
		return c
	}
	c := loadConfig()
	cfgPtr.Store(c)
	return c
}

Varianta cu atomic.Pointer permite și reîncărcarea configurației mai târziu, ceea ce sync.Once nu permite.

Ce urmărește intervievatorul: Se verifică dacă recunoști un data race care pare optimizare inteligentă. Greșeala tipică este afirmația că o cursă pe un bool este inofensivă.

83 Mid

Ce reguli de folosire a context.Context ar trebui să respecte orice cod Go? Ce diferență este între context.Canceled și context.DeadlineExceeded?

Răspuns scurt: Contextul este primul parametru (ctx context.Context), nu se stochează în structuri, nu se transmite nil, iar cancel se apelează mereu, de obicei cu defer. ctx.Err() întoarce context.Canceled când cineva a apelat cancel și context.DeadlineExceeded când a expirat termenul.

Reguli care apar în code review și sunt verificate parțial de unelte:

  • primul parametru al funcțiilor care fac I/O sau pot dura: func Fetch(ctx context.Context, id string);
  • nu stochezi contextul într-o structură; îl transmiți explicit pe fiecare apel. Excepția acceptată este o structură care reprezintă chiar o operație cu durată limitată;
  • nu transmiți nil; dacă nu ai încă un context, folosești context.TODO(), iar la rădăcina programului context.Background();
  • apelezi întotdeauna funcția cancel întoarsă de WithCancel, WithTimeout și WithDeadline, altfel resursele (timere, goroutine interne) rămân până la anularea părintelui. go vet are verificarea lostcancel;
  • valorile din context (WithValue) sunt pentru date legate de cerere (ID-uri de trasare, utilizatorul autentificat), cu chei de tip neexportat, nu pentru parametri opționali ai funcțiilor.
GO
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()

if err := callService(ctx); err != nil {
	if errors.Is(err, context.DeadlineExceeded) {
		return fmt.Errorf("serviciul nu a răspuns la timp: %w", err)
	}
	return err
}

Distincția dintre erori contează la logare și metrici: Canceled înseamnă de obicei că clientul a închis conexiunea (nu e vina serviciului), iar DeadlineExceeded indică lentoare.

Funcții mai noi:

  • context.WithCancelCause și context.Cause (Go 1.20) atașează motivul anulării;
  • context.WithoutCancel (Go 1.21) creează un context care păstrează valorile, dar nu se anulează odată cu părintele, util pentru lucrul care trebuie terminat după răspuns;
  • context.AfterFunc (Go 1.21) rulează o funcție la anulare.

Ce urmărește intervievatorul: Verifică dacă folosești contextul disciplinat, nu doar dacă știi ce este. Greșeala tipică este uitarea lui cancel sau stocarea contextului într-o structură de serviciu.

Eroarea, în practică:context deadline exceeded

84 Mid

Cum inițializezi o singură dată o resursă care poate eșua la încărcare? Ce face sync.OnceValues și ce limite are sync.Once?

Răspuns scurt: sync.OnceValues (Go 1.21) primește o funcție care întoarce o valoare și o eroare, o execută o singură dată și întoarce mereu același rezultat. Limita principală: nici Once, nici OnceValues nu reîncearcă după o eroare, deci dacă ai nevoie de reîncercare scrii logica separat.

Go 1.21 a adăugat trei funcții peste sync.Once:

  • sync.OnceFunc(f) întoarce o funcție care execută f o singură dată;
  • sync.OnceValue(f) pentru funcții care întorc o valoare;
  • sync.OnceValues(f) pentru funcții care întorc două valori, de obicei (T, error).
GO
var loadTemplates = sync.OnceValues(func() (*template.Template, error) {
	return template.ParseFS(templatesFS, "templates/*.html")
})

func handler(w http.ResponseWriter, r *http.Request) {
	tmpl, err := loadTemplates()
	if err != nil {
		http.Error(w, "eroare internă", http.StatusInternalServerError)
		return
	}
	tmpl.Execute(w, nil)
}

Comportament de reținut:

  • funcția rulează la primul apel, iar apelurile concurente așteaptă terminarea ei;
  • rezultatul, inclusiv eroarea, este memorat permanent. Dacă prima încărcare eșuează din cauza unei probleme temporare (rețea), toate apelurile ulterioare primesc aceeași eroare;
  • dacă funcția panichează, OnceFunc, OnceValue și OnceValues re-aruncă aceeași panică la fiecare apel; cu sync.Once clasic, panica marchează inițializarea ca făcută, iar apelurile următoare nu mai fac nimic;
  • un apel recursiv la același Once din interiorul funcției produce deadlock.

Pentru reîncercare după eșec, folosești un mutex și un flag setat doar la succes:

GO
func (c *Client) conn() (*Conn, error) {
	c.mu.Lock()
	defer c.mu.Unlock()
	if c.c != nil {
		return c.c, nil
	}
	cn, err := dial()
	if err != nil {
		return nil, err // următorul apel va reîncerca
	}
	c.c = cn
	return cn, nil
}

Ce urmărește intervievatorul: Verifică familiaritatea cu API-ul modern și cu limitele lui Once. Mulți candidați nu știu că o eroare la inițializare rămâne memorată permanent.

85 Senior

Un serviciu se oprește ocazional cu fatal error: concurrent map writes. De ce nu poate fi recuperat cu recover și cum alegi între sync.Map și un map cu mutex?

Răspuns scurt: Este o eroare fatală a runtime-ului, nu o panică, deci recover nu o oprește. De regulă folosești un map cu sync.Mutex sau RWMutex; sync.Map e gândit pentru chei scrise o dată și citite des sau pentru seturi de chei disjuncte între goroutine.

Map-urile din Go nu sunt sigure pentru acces concurent. Runtime-ul face o verificare ieftină și, când detectează o scriere concurentă cu altă scriere sau citire, oprește procesul cu fatal error. Decizia este intenționată: un map corupt ar produce rezultate greșite în tăcere, deci e mai sigur să oprești totul. Pentru că nu e o panică, nici recover, nici middleware-ul de recuperare din server nu ajută.

Verificarea runtime-ului prinde doar o parte din cazuri. Detectorul de curse (go test -race, sau un binar de test construit cu -race) găsește accesele și când nu se suprapun exact în timp.

Alegerea structurii:

GO
type Cache struct {
	mu sync.RWMutex
	m  map[string]Item
}

func (c *Cache) Get(k string) (Item, bool) {
	c.mu.RLock()
	defer c.mu.RUnlock()
	it, ok := c.m[k]
	return it, ok
}
  • map cu mutex: tipizat, simplu, permite operații compuse atomice (citește-modifică-scrie). Alegerea implicită;
  • sync.Map: documentația îl recomandă pentru două cazuri: intrări scrise o dată și citite de multe ori (cache-uri care doar cresc) și goroutine care citesc și scriu seturi de chei disjuncte. Are metode ca LoadOrStore, CompareAndSwap, dar lucrează cu any, deci pierzi siguranța tipurilor;
  • map partiționat (sharded): N map-uri, fiecare cu mutexul lui, alese după hash-ul cheii, când contenția pe un singur mutex devine vizibilă în profil.

Pentru investigarea incidentului: stack trace-ul erorii fatale arată goroutine-urile implicate și liniile care au scris. Reproduci local cu un test concurent rulat cu -race și -count mare, apoi encapsulezi map-ul într-un tip care nu permite accesul direct.

Ce urmărește intervievatorul: Verifică distincția dintre panică și eroare fatală și alegerea structurii potrivite. Greșeala tipică este folosirea sync.Map peste tot, ca soluție universală.

Eroarea, în practică:concurrent map writes

86 Senior

Profilul arată că un serviciu își petrece mult timp așteptând un singur sync.Mutex care protejează un cache. Cum confirmi problema și ce opțiuni ai pentru a reduce contenția?

Răspuns scurt: Confirmi cu profilurile de mutex și de blocare din pprof, apoi reduci contenția: scurtezi secțiunea critică, scoți I/O din lock, partiționezi datele pe mai multe mutex-uri, folosești RWMutex pentru citiri dominante sau date imutabile înlocuite atomic.

Diagnosticul:

  • activezi profilurile: runtime.SetMutexProfileFraction(5) și runtime.SetBlockProfileRate(...), apoi citești /debug/pprof/mutex și /debug/pprof/block prin net/http/pprof;
  • go tool pprof arată unde se așteaptă și cine ține lock-ul;
  • un profil de execuție (go tool trace) arată goroutine-urile blocate în timp.

Opțiuni, de la cea mai simplă:

  • secțiune critică minimă: calculezi valoarea în afara lock-ului și blochezi doar pentru citirea sau scrierea în map. Nu faci niciodată apeluri de rețea, I/O sau logare cu lock-ul ținut;
  • sync.RWMutex ajută doar când citirile sunt mult mai multe decât scrierile și secțiunea critică nu este trivială. Are cost mai mare decât Mutex, iar un scriitor în așteptare blochează cititorii noi, deci nu este automat mai rapid;
  • partiționare: împarți cache-ul în, de exemplu, 32 de bucăți, fiecare cu mutex propriu, alese după hash-ul cheii;
GO
type Sharded struct {
	shards [32]struct {
		mu sync.Mutex
		m  map[string]Item
	}
}

func (s *Sharded) shard(k string) int {
	h := fnv.New32a()
	h.Write([]byte(k))
	return int(h.Sum32() % 32)
}
  • copy-on-write cu atomic.Pointer[map[string]Item]: cititorii fac doar Load, fără lock, iar scriitorii construiesc un map nou și îl publică atomic. Merge când scrierile sunt rare;
  • contoare cu atomic.Int64 în loc de mutex;
  • date locale per goroutine, agregate periodic.

După fiecare schimbare, rulezi benchmark-uri cu -cpu=1,4,16 ca să vezi cum scalează cu numărul de nuclee și verifici cu -race că optimizarea n-a introdus curse.

Ce urmărește intervievatorul: Verifică experiența practică cu performanța codului concurent și abordarea bazată pe măsurători. Greșeala tipică este înlocuirea automată cu RWMutex fără profilare.

87 Senior

Runtime-ul Go detectează deadlock-ul doar în unele situații. De ce nu vezi mesajul all goroutines are asleep într-un server blocat și cum depanezi un deadlock parțial în producție?

Răspuns scurt: Runtime-ul raportează deadlock doar când toate goroutine-urile sunt blocate. Într-un server există mereu goroutine active (listener-ul HTTP, timere), deci un grup de goroutine blocate reciproc nu este detectat. Depanezi cu un dump al tuturor goroutine-urilor, prin SIGQUIT sau /debug/pprof/goroutine?debug=2.

Detectorul din runtime este simplu: dacă nicio goroutine nu mai poate face progres și nu există timere sau evenimente de rețea în așteptare, programul se oprește cu fatal error: all goroutines are asleep - deadlock!. Într-un program real, goroutine-ul care acceptă conexiuni este mereu „gata” să primească evenimente de rețea, deci condiția nu este îndeplinită. Cererile care ajung la mutex-ul blocat se adună, iar serviciul pare blocat fără nicio eroare.

Pași de depanare:

  • dump de goroutine: kill -QUIT <pid> afișează pe stderr stack-ul fiecărei goroutine și oprește procesul. Dacă nu vrei să-l oprești, folosești net/http/pprof cu /debug/pprof/goroutine?debug=2;
  • cauți goroutine blocate de mult timp; dump-ul arată starea și durata, de exemplu [sync.Mutex.Lock, 12 minutes] sau [chan send, 12 minutes];
  • grupezi după stack trace (debug=1 dă numărul de goroutine cu același stack). Sute de goroutine blocate în același punct indică locul;
  • identifici cine ține resursa: lanțul tipic este A ține mutex-ul X și așteaptă Y, B ține Y și așteaptă X.

Cauze frecvente:

  • ordine inconsecventă de blocare a două mutex-uri;
  • trimitere pe un canal pe care nu mai citește nimeni, făcută în timp ce se ține un lock;
  • apeluri de callback sau de rețea cu lock-ul ținut;
  • RLock recursiv cu un scriitor în așteptare între ele, care blochează.

Prevenire: ordine globală de blocare documentată, fără apeluri externe sub lock, timeout-uri prin context pe orice așteptare, teste concurente cu -race și o alertă pe numărul de goroutine (runtime.NumGoroutine) exportat ca metrică.

Ce urmărește intervievatorul: Verifică experiența de depanare în producție, dincolo de exemplele de manual. Seniorii trebuie să știe să citească un dump de goroutine.

Eroarea, în practică:all goroutines are asleep - deadlock!

Pachete, testare și unelte

88 Junior

Cum sunt organizate pachetele într-un modul Go? Ce rol are directorul internal?

Răspuns scurt: Un director conține un singur pachet (plus testele lui), iar calea de import este calea modulului din go.mod plus calea directorului. Codul din internal/ poate fi importat doar de pachetele aflate în directorul părinte al lui internal și în subdirectoarele acestuia.

Reguli de bază:

  • toate fișierele .go dintr-un director aparțin aceluiași pachet. Excepție: fișierele _test.go pot folosi pachetul nume_test, pentru teste din exterior;
  • numele pachetului e de obicei ultimul element al căii (.../store are package store), scurt, cu litere mici, fără underscore;
  • pachetul main cu funcția main produce un executabil; orice alt pachet este o bibliotecă;
  • importurile circulare sunt interzise; dacă două pachete au nevoie unul de altul, extragi partea comună sau introduci o interfață.

Un aranjament frecvent:

myapp/
  go.mod            module github.com/ana/myapp
  cmd/
    api/main.go     package main
    worker/main.go  package main
  internal/
    order/          package order
    storage/        package storage
  pkg/              opțional, cod destinat altor proiecte

internal este impus de unealta go, nu doar o convenție. github.com/ana/myapp/internal/order poate fi importat din orice pachet aflat sub github.com/ana/myapp/, dar un alt modul care încearcă importul primește eroare de compilare. Așa îți protejezi codul de utilizatori externi și îl poți schimba liber, fără să strici pe cineva.

Directorul pkg/ nu are semnificație specială pentru unealta go. Multe proiecte nu îl folosesc deloc.

Recomandări: organizezi pachetele după domeniu (order, payment), nu după tip tehnic (models, utils, helpers). Un pachet utils devine repede o colecție de lucruri fără legătură, de care depinde toată lumea.

Ce urmărește intervievatorul: Verifică familiaritatea cu structura reală a unui proiect Go. Greșeala tipică este un pachet utils uriaș sau neînțelegerea restricției internal.

89 Junior

Ce diferență este între t.Error și t.Fatal? La ce folosesc t.Helper, t.Cleanup și t.TempDir?

Răspuns scurt: t.Error marchează testul ca eșuat și continuă execuția, t.Fatal îl marchează și oprește imediat testul curent. t.Helper face ca erorile să indice linia apelantului, t.Cleanup înregistrează curățări rulate la final, iar t.TempDir creează un director temporar șters automat.

Alegerea între Error și Fatal:

  • t.Errorf când testul poate continua și vrei să vezi toate diferențele dintr-o rulare;
  • t.Fatalf când continuarea nu mai are sens, de exemplu setup-ul a eșuat sau o valoare este nil și ar urma o dereferențiere.

t.Fatal oprește goroutine-ul testului cu runtime.Goexit, deci trebuie apelat doar din goroutine-ul testului, nu din goroutine pornite de test.

GO
func newTestStore(t *testing.T) *Store {
	t.Helper()
	dir := t.TempDir() // șters automat la final
	s, err := Open(filepath.Join(dir, "db"))
	if err != nil {
		t.Fatalf("open: %v", err)
	}
	t.Cleanup(func() { s.Close() })
	return s
}

func TestStoreSave(t *testing.T) {
	s := newTestStore(t)
	if err := s.Save("k", "v"); err != nil {
		t.Fatalf("save: %v", err)
	}
	if got, _ := s.Load("k"); got != "v" {
		t.Errorf("Load = %q, want %q", got, "v")
	}
}
  • t.Helper() marchează funcția ca helper: mesajul de eșec arată linia din test care a apelat-o, nu linia din helper;
  • t.Cleanup rulează funcțiile în ordine inversă, după ce testul și subtestele s-au terminat, chiar și după t.Fatal;
  • t.Setenv setează o variabilă de mediu și o restaurează la final.

Comenzi utile: go test ./... rulează toate pachetele, -run 'TestStore/caz' filtrează după nume, -v afișează detalii, iar -count=1 dezactivează cache-ul rezultatelor.

Ce urmărește intervievatorul: Verifică familiaritatea practică cu pachetul testing. Greșeala tipică este t.Fatal apelat dintr-o goroutine sau helperi fără t.Helper.

90 Junior

Cum măsori acoperirea codului cu teste în Go? Ce sunt funcțiile Example și de ce sunt utile?

Răspuns scurt: Rulezi go test -cover pentru procent, -coverprofile=c.out pentru detalii și go tool cover -html=c.out pentru vizualizarea liniilor neacoperite. Funcțiile Example sunt exemple de folosire care apar în documentație și, dacă au comentariul // Output:, sunt rulate și verificate ca teste.

Acoperirea:

BASH
go test -cover ./...
go test -coverprofile=c.out ./...
go tool cover -func=c.out    # procent pe funcție
go tool cover -html=c.out    # cod colorat în browser

Acoperirea arată ce linii au fost executate, nu dacă au fost verificate. Un test care apelează o funcție fără nicio aserțiune crește acoperirea fără să testeze nimic. De aceea un procent mare nu garantează calitatea; util este să te uiți la ramurile neacoperite, mai ales la tratarea erorilor. Din Go 1.20 poți construi și un binar cu acoperire (go build -cover), util pentru teste de integrare.

Funcțiile Example stau în fișiere _test.go:

GO
func ExampleReverse() {
	fmt.Println(Reverse("abc"))
	// Output: cba
}
  • go test rulează funcția și compară ieșirea standard cu textul după // Output:. Dacă diferă, testul eșuează;
  • // Unordered output: acceptă liniile în orice ordine;
  • fără comentariul de ieșire, exemplul doar se compilează;
  • numele leagă exemplul de identificator: ExampleReverse de funcția Reverse, ExampleStack_Push de metoda Push a tipului Stack.

go doc și site-ul pkg.go.dev afișează exemplele lângă funcții. Avantajul principal: documentația nu se poate învechi fără ca testele să eșueze.

Ce urmărește intervievatorul: Verifică dacă știi uneltele standard de testare și limitele acoperirii. Candidații juniori ar trebui să știe că procentul nu este un scop în sine.

91 Junior

Cum compilezi un program Go pentru alt sistem de operare și cum includi versiunea aplicației în binar? Ce sunt build tags?

Răspuns scurt: Setezi GOOS și GOARCH (de exemplu GOOS=linux GOARCH=arm64 go build), iar cu CGO_ENABLED=0 obții un binar static. Versiunea se injectează cu -ldflags "-X main.version=1.2.3", iar build tags (//go:build linux) includ sau exclud fișiere la compilare.

Compilarea încrucișată este integrată în unealta go, fără compilatoare suplimentare, cât timp nu folosești cgo:

BASH
GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -o bin/api ./cmd/api
GOOS=windows GOARCH=amd64 go build -o bin/api.exe ./cmd/api
go tool dist list   # toate combinațiile suportate

CGO_ENABLED=0 produce un binar static, fără dependențe de biblioteci C ale sistemului, ideal pentru imagini Docker minimale (scratch sau distroless).

Injectarea versiunii la compilare:

GO
package main

var version = "dev"

func main() {
	fmt.Println("versiune:", version)
}
BASH
go build -ldflags "-X main.version=1.4.0 -s -w" -trimpath ./cmd/api

-X setează o variabilă de tip string la nivel de pachet. -s -w elimină informațiile de depanare și micșorează binarul. -trimpath elimină căile locale din binar. Din Go 1.18, runtime/debug.ReadBuildInfo() oferă și informații despre commit-ul VCS și dependențe, fără ldflags.

Build tags (constrângeri de compilare) se pun la începutul fișierului:

GO
//go:build linux && !race

Fișierul este compilat doar pe Linux și fără detectorul de curse. Sufixele de nume au același efect: file_linux.go, file_windows_amd64.go. Etichete proprii se activează cu go build -tags integration, util pentru a separa testele de integrare de cele unitare.

Ce urmărește intervievatorul: Verifică familiaritatea cu livrarea aplicațiilor Go. Candidații care cunosc compilarea încrucișată și ldflags au lucrat de obicei cu aplicații Go reale.

92 Mid

Cum incluzi fișiere statice (template-uri, migrații SQL, fișiere web) direct în binarul Go?

Răspuns scurt: Folosești directiva //go:embed (Go 1.16+) deasupra unei variabile de tip string, []byte sau embed.FS. Compilatorul copiază fișierele în binar, iar aplicația le citește la runtime fără să depindă de sistemul de fișiere al serverului.

GO
package web

import (
	"embed"
	"html/template"
	"net/http"
)

//go:embed version.txt
var version string

//go:embed templates/*.html
var templatesFS embed.FS

//go:embed static
var staticFS embed.FS

var tmpl = template.Must(template.ParseFS(templatesFS, "templates/*.html"))

func Routes(mux *http.ServeMux) {
	mux.Handle("GET /static/", http.FileServerFS(staticFS)) // Go 1.22
}

Reguli:

  • trebuie importat pachetul embed; pentru variabile string sau []byte fără alte folosiri, se importă cu import _ "embed";
  • directiva stă imediat deasupra unei variabile la nivel de pachet;
  • căile sunt relative la directorul pachetului și nu pot ieși din el cu ..;
  • la încorporarea unui director, fișierele care încep cu . sau _ sunt excluse; prefixul all: (de exemplu //go:embed all:static) le include;
  • dacă modelul nu găsește niciun fișier, compilarea eșuează, deci afli imediat de o cale greșită.

embed.FS implementează fs.FS, deci funcționează cu template.ParseFS, http.FileServerFS, fs.WalkDir și uneltele de migrații care acceptă fs.FS.

Avantaje: un singur binar de livrat, fără riscul de fișiere lipsă sau versiuni nepotrivite între cod și resurse. Dezavantaje: orice modificare a unui fișier cere recompilare, iar fișierele mari cresc dimensiunea binarului. În dezvoltare poți folosi os.DirFS("templates") în loc de embed.FS, ca schimbările să apară fără recompilare, alegând implementarea fs.FS după configurare.

Ce urmărește intervievatorul: Verifică familiaritatea cu o funcționalitate folosită des în servicii și unelte CLI. Candidații care nu o cunosc copiază fișierele separat lângă binar.

93 Mid

Ce face t.Parallel() și ce probleme poate introduce în teste table-driven?

Răspuns scurt: t.Parallel() permite testului să ruleze în paralel cu alte teste marcate la fel. Problemele apar la stare partajată (globale, aceeași bază de date, variabile de mediu) și, înainte de Go 1.22, la variabila de buclă, care făcea toate subtestele să verifice ultimul caz.

Cum funcționează: un test care apelează t.Parallel() se oprește și așteaptă până când testele seriale din același pachet se termină, apoi rulează concurent cu celelalte teste paralele. Numărul maxim de teste paralele este dat de flag-ul -parallel, implicit GOMAXPROCS. Pachetele diferite rulează oricum în procese separate, în paralel.

Model tipic:

GO
func TestParse(t *testing.T) {
	t.Parallel()
	tests := []struct {
		name, in string
		want     int
	}{
		{"simplu", "1", 1},
		{"negativ", "-2", -2},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			if got := Parse(tt.in); got != tt.want {
				t.Errorf("Parse(%q) = %d, want %d", tt.in, got, tt.want)
			}
		})
	}
}

Capcane:

  • înainte de Go 1.22, tt era aceeași variabilă pentru toate iterațiile. Subtestele paralele porneau după terminarea buclei și vedeau toate ultimul caz. Testele treceau, dar verificau un singur caz. Soluția veche era tt := tt în buclă; din Go 1.22 (cu go 1.22 în go.mod) nu mai e necesară;
  • t.Setenv și t.Chdir nu pot fi folosite în teste paralele și panichează;
  • stare globală modificată de teste (variabile de pachet, ceasuri falsificate global) produce rezultate aleatorii;
  • testele care folosesc aceeași bază de date sau același port trebuie izolate: scheme separate, porturi alese de sistem (:0), directoare din t.TempDir();
  • t.Cleanup în testul părinte rulează abia după terminarea subtestelor paralele, dar un defer în părinte rulează înainte ca ele să înceapă.

Rulează testele paralele și cu -race, ca să descoperi starea partajată neprotejată.

Ce urmărește intervievatorul: Verifică experiența cu suitele de teste mari. Bug-ul cu variabila de buclă a afectat multe proiecte reale înainte de Go 1.22.

94 Mid

Cum testezi cod care depinde de timpul curent sau de time.Sleep, fără teste lente sau instabile?

Răspuns scurt: Injectezi sursa de timp ca dependență (o funcție now func() time.Time sau o interfață Clock) și o controlezi în teste. Pentru cod concurent cu timere, Go 1.25 oferă pachetul testing/synctest, care rulează testul cu un ceas virtual ce avansează instant când toate goroutine-urile sunt blocate.

Cod greu de testat:

GO
func (s *Session) Expired() bool {
	return time.Since(s.created) > 30*time.Minute
}

Un test ar trebui să aștepte 30 de minute sau să modifice câmpuri interne. Varianta testabilă primește timpul din exterior:

GO
type Service struct {
	now func() time.Time
}

func NewService() *Service {
	return &Service{now: time.Now}
}

func (s *Service) Expired(sess *Session) bool {
	return s.now().Sub(sess.created) > 30*time.Minute
}

func TestExpired(t *testing.T) {
	base := time.Date(2026, 1, 1, 10, 0, 0, 0, time.UTC)
	s := &Service{now: func() time.Time { return base.Add(31 * time.Minute) }}
	if !s.Expired(&Session{created: base}) {
		t.Error("sesiunea ar trebui să fie expirată")
	}
}

Pentru cod cu timeout-uri, ticker-e și goroutine, injectarea ceasului devine complicată. testing/synctest (experimental în Go 1.24, stabil în Go 1.25) rezolvă asta: synctest.Test(t, func(t *testing.T) {...}) rulează codul într-o „bulă” cu ceas fals. time.Sleep(time.Hour) se termină instant, iar synctest.Wait() așteaptă până când toate goroutine-urile din bulă sunt blocate, deci poți verifica starea fără Sleep arbitrare.

Reguli generale:

  • nu folosi time.Sleep ca să „aștepți să termine” o goroutine în test; folosești canale, WaitGroup sau polling cu termen limită;
  • timpul în teste se construiește explicit, în UTC, ca rezultatele să nu depindă de fusul orar al mașinii de CI;
  • testele instabile (flaky) se depistează rulând go test -count=100 -race.

Ce urmărește intervievatorul: Verifică dacă scrii cod testabil și cunoști unelte recente. Testele cu time.Sleep sunt o sursă frecventă de instabilitate în CI.

95 Senior

Ce greșeli faci ușor când scrii benchmark-uri în Go și cum obții rezultate în care poți avea încredere?

Răspuns scurt: Greșelile frecvente sunt: compilatorul elimină calculul al cărui rezultat nu e folosit, setup-ul este inclus în timp, se rulează o singură dată pe o mașină zgomotoasă și se compară cifre fără statistică. Folosești b.Loop() (Go 1.24), b.ReportAllocs(), rulări repetate cu -count și comparații cu benchstat.

Un benchmark clasic arată așa:

GO
func BenchmarkParse(b *testing.B) {
	for i := 0; i < b.N; i++ {
		Parse(input)
	}
}

Probleme posibile:

  • dacă Parse este mică și rezultatul nu e folosit, compilatorul o poate inline-a și elimina complet; măsori o buclă goală. Soluția veche era atribuirea rezultatului unei variabile globale;
  • setup-ul costisitor înainte de buclă intră în timp, dacă nu apelezi b.ResetTimer();
  • intrarea constantă poate fi calculată la compilare (constant folding).

Din Go 1.24, b.Loop() rezolvă o parte din probleme: setup-ul și curățarea din afara buclei nu sunt măsurate, iar compilatorul nu elimină apelurile din corpul buclei.

GO
func BenchmarkParse(b *testing.B) {
	data := loadFixture(b) // nu intră în timp
	b.ReportAllocs()
	for b.Loop() {
		Parse(data)
	}
}

Pentru rezultate de încredere:

  • rulezi de mai multe ori: go test -bench=Parse -benchmem -count=10 > new.txt;
  • compari cu benchstat old.txt new.txt (din golang.org/x/perf), care arată diferența și dacă este semnificativă statistic;
  • folosești o mașină liniștită: fără alte procese grele, cu alimentare stabilă la laptop, fără throttling termic;
  • testezi cu dimensiuni realiste de date, prin sub-benchmark-uri cu b.Run, pentru că algoritmii se comportă diferit la scară mică;
  • verifici că optimizarea nu mută doar costul: alocările din -benchmem contează pentru GC în producție.

Un microbenchmark spune cât de rapid e un fragment izolat. Impactul real se confirmă cu profilare (pprof) pe sarcina reală.

Ce urmărește intervievatorul: Verifică maturitatea în măsurarea performanței. Seniorii ar trebui să știe de eliminarea codului mort și de comparația statistică, nu doar de sintaxa benchmark-ului.

Situații practice

96 Mid

Un coleg cu experiență în Java începe să scrie Go și codul lui arată ca Java tradus. Cum îi explici principalele diferențe de mentalitate?

Răspuns scurt: Îi arăt diferențele pe codul lui, nu teoretic: compoziție în loc de ierarhii de clase, interfețe mici definite de consumator, erori întoarse ca valori, valori zero utile, goroutine și canale în loc de thread pool-uri explicite. Accentul cade pe simplitate și pe uneltele standard.

Un răspuns structurat:

  • context: pornesc de la un PR concret al colegului, ca discuția să fie practică. Recunosc că multe obiceiuri din Java sunt bune acolo, dar în Go produc cod mai greu de citit;
  • tipuri și compoziție: nu există clase și moștenire. Un AbstractBaseService se transformă în structuri mici, compuse prin câmpuri sau embedding. Getter-ele și setter-ele pentru fiecare câmp nu sunt idiomatice; câmpurile exportate sunt acceptabile când nu există invarianți;
  • interfețe: se implementează implicit și se definesc de obicei în pachetul care le folosește, cu una-două metode. Nu se creează o interfață pentru fiecare structură „ca să fie”;
  • erori: nu există excepții. Erorile se întorc, se verifică imediat și se împachetează cu context (fmt.Errorf("...: %w", err)). panic nu înlocuiește throw;
  • concurență: goroutine ieftine, context pentru anulare, canale pentru comunicare, mutex pentru stare partajată. Nu există ExecutorService de configurat;
  • unelte: gofmt decide formatarea, go vet și linterele rulează în CI, biblioteca standard acoperă mult din ce în Java vine din framework-uri.

Ca metodă, propun o sesiune de pair programming pe o funcție a lui, unde refactorizăm împreună: eliminăm o ierarhie, simplificăm tratarea erorilor. Îi recomand „Effective Go”, Go Code Review Comments și proverbele Go, apoi revin la următorul PR cu comentarii scurte, cu link spre explicație.

Rezultatul urmărit: colegul înțelege de ce, nu doar ce să schimbe, și poate aplica singur principiile.

Ce urmărește intervievatorul: Se verifică stăpânirea idiomurilor Go și capacitatea de a le explica fără condescendență. Intervievatorul urmărește exemple concrete, nu doar „Go e mai simplu”.

97 Mid

Faci code review la un PR în Go care pornește o goroutine fără mecanism de oprire, ignoră câteva erori cu _ și transmite o structură cu mutex prin valoare. Cum structurezi comentariile?

Răspuns scurt: Separ problemele blocante (scurgerea de goroutine, mutex-ul copiat, erorile ignorate pe căi importante) de sugestii, explic pentru fiecare riscul concret și propun o soluție. Tonul rămâne despre cod, iar pentru problemele care se repetă propun reguli automate în CI.

Un răspuns structurat:

  • înțeleg intenția: citesc descrierea PR-ului și testele, ca să știu ce problemă rezolvă autorul și să nu propun o soluție pentru altceva;
  • prioritizez: marchez explicit ce blochează aprobarea și ce e opțional. Aici blocante sunt:
  • goroutine-ul fără oprire: explic că la fiecare apel rămâne o goroutine în viață, deci memoria crește și oprirea elegantă nu mai funcționează. Propun ctx ca parametru și select pe ctx.Done();
  • mutex-ul copiat: arăt că fiecare copie are propriul lock, deci nu protejează nimic, și că go vet semnalează asta. Propun receiver pointer;
  • erorile ignorate: întreb dacă ignorarea e intenționată. Pentru Close la citire poate fi acceptabil, cu un comentariu; pentru scrieri sau apeluri de rețea, nu;
  • formulez constructiv: „Aici goroutine-ul nu se oprește la anularea cererii; ce zici de varianta cu ctx?” e mai util decât „greșit”. Dau un exemplu de cod scurt;
  • automatizez: dacă go vet nu rulează în CI, propun adăugarea lui și a unui set de lintere (errcheck, staticcheck), ca astfel de probleme să fie prinse înainte de review;
  • închei: spun ce e bine în PR, rămân disponibil pentru o discuție rapidă dacă autorul nu e de acord, iar după modificări verific din nou, cu prioritate.

Scopul este ca autorul să învețe tiparul și să nu-l mai repete, nu doar ca PR-ul să fie reparat.

Ce urmărește intervievatorul: Se verifică atât cunoașterea problemelor tipice din Go, cât și maturitatea în colaborare. Intervievatorii urmăresc dacă distingi problemele grave de preferințele de stil.

98 Mid

Ai moștenit un pachet Go cu funcții de sute de linii, fără teste, de care depind alte servicii. Trebuie să adaugi o funcționalitate. Cum procedezi?

Răspuns scurt: Întâi adaug teste de caracterizare care fixează comportamentul actual, apoi refactorizez în pași mici, verificați de teste: extrag funcții, introduc interfețe la granițe (bază de date, rețea) pentru izolare. Abia apoi adaug funcționalitatea nouă, cu teste proprii, în PR-uri separate de refactorizare.

Un răspuns structurat:

  • înțeleg: citesc codul și istoricul din git, identific apelanții (go doc, căutare în celelalte servicii) și ce parte a API-ului e publică. Discut cu cine a lucrat înainte pe pachet, dacă e posibil;
  • plasa de siguranță: scriu teste de caracterizare, care descriu ce face codul acum, inclusiv comportamente ciudate. Testele table-driven sunt potrivite: multe intrări, rezultatul observat. Dacă funcțiile accesează direct baza de date, încep cu teste de integrare pe o bază locală (de exemplu într-un container);
  • refactorizare în pași mici:
  • extrag blocuri logice în funcții cu nume clare;
  • înlocuiesc if imbricate cu returnări timpurii;
  • introduc o interfață mică acolo unde codul vorbește cu exteriorul, ca să pot testa logica izolat;
  • rulez testele și go vet după fiecare pas, plus -race dacă există concurență;
  • funcționalitatea nouă: o adaug abia când zona e testată, cu teste noi scrise înainte sau odată cu codul;
  • livrare: separ PR-urile de refactorizare (fără schimbare de comportament) de cele cu funcționalitate. Review-ul devine mai ușor, iar o eventuală regresie se izolează rapid;
  • comunicare: anunț echipele dependente dacă schimb API-ul public. Prefer să păstrez semnăturile vechi, marcate cu // Deprecated:, până migrează toată lumea.

Ce evit: rescrierea completă dintr-odată, care amestecă riscul refactorizării cu riscul funcționalității noi.

Ce urmărește intervievatorul: Verifică abordarea disciplinată a codului legacy. Intervievatorul urmărește dacă începi cu teste și eviți rescrierile mari și riscante.

99 Senior

Echipa propune rescrierea unui serviciu critic din Python în Go, pentru performanță. Cum evaluezi propunerea și cum ai conduce migrarea, dacă e aprobată?

Răspuns scurt: Întâi măsor unde se pierde timpul: dacă problema e I/O sau baza de date, limbajul nu o rezolvă. Dacă Go aduce un câștig real, îl validez cu un prototip pe calea critică, țin cont de competențele echipei și migrez incremental (strangler pattern).

Un răspuns structurat:

  • clarific problema: ce înseamnă „performanță” aici: latență la percentile mari, cost de infrastructură, consum de memorie, concurență? Cer metrici și profiluri din producție;
  • diagnostic: profilez serviciul actual. Dacă timpul e petrecut în interogări lente, apeluri externe sau serializare care se poate optimiza, o rescriere nu ajută, iar o optimizare țintită costă mult mai puțin;
  • criterii de decizie când CPU-ul sau concurența sunt problema reală: câștigul estimat, costul rescrierii și al dublei întrețineri pe perioada tranziției, cine din echipă știe Go, bibliotecile disponibile (de exemplu, pentru componente de machine learning ecosistemul Python poate fi de neînlocuit);
  • prototip: rescriu doar calea critică, rulez un test de încărcare comparativ și prezint datele, nu impresii;
  • migrare incrementală: un proxy sau gateway în față, endpoint-urile mutate pe rând (strangler pattern). Contractul API rămâne identic, verificat cu teste de contract;
  • validare: shadow traffic (cererile reale trimise și noului serviciu, răspunsurile comparate fără a fi servite), apoi canary pe un procent mic, cu metrici și rollback rapid;
  • echipă: training, ghid de stil, review-uri făcute de cei cu experiență în Go, pentru ca serviciul să nu devină „Python scris în Go”;
  • finalizare: definesc dinainte criteriul de succes și de oprire, ca proiectul să nu rămână la nesfârșit în stare hibridă.

Răspunsul meu poate fi și „nu acum”, dacă datele arată că o optimizare mai mică rezolvă problema.

Ce urmărește intervievatorul: Se verifică judecata tehnică și de business la nivel senior. Intervievatorul urmărește decizii bazate pe măsurători, nu pe entuziasm pentru un limbaj.

100 Senior

La un live coding ți se cere să implementezi în Go un cache LRU cu capacitate fixă și operații Get și Put în O(1). Cum abordezi problema și cum arată codul?

Răspuns scurt: Clarific cerințele (tipuri, concurență, ce întoarce Get la lipsă), explic structura înainte de cod (un map pentru acces O(1) plus o listă dublu înlănțuită pentru ordinea folosirii), scriu implementarea cu container/list, apoi o testez pe un exemplu și discut extinderi.

Pașii: pun întrebări (chei și valori, folosire concurentă?), explic structura, scriu codul, apoi trec prin exemple. Map-ul dă elementul din listă după cheie; lista ține ordinea, cu cel mai recent folosit în față.

GO
type entry struct {
	key string
	val int
}

type LRU struct {
	cap   int
	ll    *list.List
	items map[string]*list.Element
}

func NewLRU(capacity int) *LRU {
	return &LRU{cap: capacity, ll: list.New(), items: make(map[string]*list.Element)}
}

func (c *LRU) Get(k string) (int, bool) {
	el, ok := c.items[k]
	if !ok {
		return 0, false
	}
	c.ll.MoveToFront(el)
	return el.Value.(*entry).val, true
}

func (c *LRU) Put(k string, v int) {
	if el, ok := c.items[k]; ok {
		el.Value.(*entry).val = v
		c.ll.MoveToFront(el)
		return
	}
	c.items[k] = c.ll.PushFront(&entry{k, v})
	if c.ll.Len() > c.cap {
		last := c.ll.Back()
		c.ll.Remove(last)
		delete(c.items, last.Value.(*entry).key)
	}
}

Verific cu voce tare: capacitate 2, Put(a), Put(b), Get(a), Put(c): se elimină b. Cheia este păstrată în entry ca să poată fi ștearsă din map la evacuare.

Extinderi de discutat: un sync.Mutex pentru concurență (și Get scrie, deci RWMutex nu ajută), o versiune generică LRU[K comparable, V any], expirare după timp și partiționare pentru contenție.

Ce urmărește intervievatorul: Verifică stăpânirea structurilor de date în Go și modul de lucru la live coding. Intervievatorul urmărește și comunicarea: întrebări, explicarea structurii, testarea pe exemple.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Go, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Go scriind cod, nu doar citind

Curs Go: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.