select case must be send or receive (possibly with assignment)
Într-un select, fiecare case trebuie să fie o operație pe canal: primire (v := <-ch, <-ch) sau trimitere (ch <- v). Ai scris o condiție (len(ch) > 0, x == 5), ca într-un switch. Pune operația pe canal în case, iar condițiile le verifici în corpul ramurii sau cu un switch separat.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
select așteaptă pe mai multe canale deodată și rulează ramura primului canal gata. De aceea fiecare case trebuie să fie chiar o operație pe canal: case v := <-ch:, case v, ok := <-ch:, case <-time.After(d): sau case ch <- v:. O expresie booleană (case len(coada) > 0:), un apel de funcție obișnuit sau o comparație nu sunt operații pe canal, iar compilatorul spune select case must be send or receive (possibly with assignment).
Greșeala apare când confunzi select cu switch (care acceptă condiții) sau când încerci să „verifici dacă un canal are date” înainte să citești. În Go nu întrebi canalul dacă are date: încerci să citești, iar ramura default rulează dacă nimic nu e gata.
De ce apare: cauzele frecvente
1Verificare de lungime în loc de primire
select {
case len(mesaje) > 0:
m := <-mesaje
fmt.Println(m)
default:
fmt.Println("nimic")
}select {
case m := <-mesaje:
fmt.Println(m)
default:
fmt.Println("nimic")
}Primirea din case e chiar testul: rulează doar dacă există un mesaj, altfel se alege default.
2select folosit ca un switch cu condiții
select {
case stoc == 0:
fmt.Println("epuizat")
}switch {
case stoc == 0:
fmt.Println("epuizat")
}Pentru condiții obișnuite folosești switch; select este doar pentru canale.
3Condiție combinată cu primirea
select {
case v := <-preturi && v > 100:
}select {
case v := <-preturi:
if v > 100 {
fmt.Println("scump", v)
}
}Filtrarea valorii se face în corpul ramurii, după ce ai primit-o.
Repară eroarea, direct în pagină
Funcția urmatorul vrea să ia un mesaj din coadă dacă există, fără să blocheze, dar nu compilează: select case must be send or receive. Scrie ramura ca primire din canal, ca programul să afișeze:
comanda 1
comanda 2
coada e goalăpackage main
import "fmt"
func urmatorul(coada chan string) string {
select {
case len(coada) > 0:
return <-coada
default:
return "coada e goală"
}
}
func main() {
coada := make(chan string, 5)
coada <- "comanda 1"
coada <- "comanda 2"
for i := 0; i < 3; i++ {
fmt.Println(urmatorul(coada))
}
}comanda 1 comanda 2 coada e goală
Indiciu
Ramura devine case m := <-coada:; default rulează când nu e niciun mesaj.
Reparația
package main
import "fmt"
func urmatorul(coada chan string) string {
select {
case m := <-coada:
return m
default:
return "coada e goală"
}
}
func main() {
coada := make(chan string, 5)
coada <- "comanda 1"
coada <- "comanda 2"
for i := 0; i < 3; i++ {
fmt.Println(urmatorul(coada))
}
}De ce merge
În select, ramurile sunt operații pe canal, nu condiții. case m := <-coada: încearcă să primească un mesaj: dacă există, ramura rulează și îl întoarce. La al treilea apel coada e goală, deci nicio ramură nu e gata și se alege default. Așa dispare și riscul ca alt cod să golească coada între verificarea len și citire.
Alte forme ale mesajului
select case must be receive, send or assign recv
Cum o eviți pe viitor
Ține minte forma: în select, după case vine întotdeauna <-ch sau ch <- v, eventual cu v := sau v, ok := în față. Pentru „citește dacă există, altfel continuă” folosește select cu default. Pentru decizii pe valori folosește if/switch în corpul ramurii. Nu te baza pe len(ch): între verificare și citire, altă goroutine poate lua mesajul.
Întrebări frecvente
Cum verific dacă un canal are date fără să blochez?
Cu select { case v := <-ch: ... default: ... }. Dacă nu există nicio valoare, rulează imediat default.
Pot pune o condiție ca o ramură să fie dezactivată?
Da, cu un canal nil: o operație pe un canal nil nu e niciodată gata, deci ramura e ignorată. Exemplu: var out chan int; if avemDate { out = rezultate }, apoi case out <- v:.
Erori înrudite
fatal error: all goroutines are asleep - deadlock! Toate goroutinele (inclusiv main) așteaptă la un canal sau la un WaitGroup și niciuna nu mai poate continua. Cauze tipice: trimitere fără receptor pe un canal fără buffer, range peste un canal pe care nu îl închide nimeni, wg.Wait() fără Done() suficiente. Dă fiecărei trimiteri un receptor și închide canalul la final. invalid operation: cannot send to receive-only channel <-chan int ch (variable of type <-chan int) Parametrul e declarat ca un canal doar pentru citire (<-chan T), iar funcția încearcă să trimită pe el (ch <- v) sau să-l închidă. Inversează direcția: producătorul primește chan<- T, consumatorul <-chan T. multiple defaults (first at main.go:8:2) Un switch sau un select are două ramuri default. Fiecare poate avea cel mult una: păstrează un singur default (de obicei la final) și mută codul celeilalte într-un case cu valoarea potrivită. Învață Go de la zero, cu exerciții la fiecare lecție
Curs Go: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
