invalid operation: cannot send to non-channel []int rezultate (variable of type []int)
Ai folosit <- (trimitere sau primire) pe o valoare care nu e canal, de obicei un slice. Fie declari un canal (make(chan int)), fie, dacă ai vrut un slice, folosești append în loc de <-.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Operatorul <- lucrează doar cu canale: ch <- v trimite, v := <-ch primește, iar close(ch) închide canalul. Pe orice alt tip compilatorul spune ce operație ai încercat: cannot send to non-channel, cannot receive from non-channel sau cannot close non-channel, urmat de tipul real al valorii.
Apare de obicei în cod concurent scris în grabă: ai declarat rezultatele ca []int (cum ai face fără goroutine) și apoi ai scris rezultate <- x dintr-o goroutină. Sau parametrul unei funcții are tipul greșit (func worker(job []int) în loc de chan int).
Când alegi între cele două: un canal e potrivit pentru a transmite valori între goroutine; un slice protejat cu sync.Mutex sau completat după ce goroutinele au terminat e potrivit pentru a strânge rezultatele într-o listă.
De ce apare: cauzele frecvente
1Slice în loc de canal
rezultate := []int{}
go func() {
rezultate <- calcul()
}()
fmt.Println(<-rezultate)rezultate := make(chan int)
go func() {
rezultate <- calcul()
}()
fmt.Println(<-rezultate)Canalul transmite valoarea de la goroutină la main și le sincronizează.
2Parametru cu tipul greșit
func worker(joburi []int) {
for j := range joburi {
fmt.Println(<-joburi, j)
}
}func worker(joburi <-chan int) {
for j := range joburi {
fmt.Println(j)
}
}Cu un canal, range primește valorile până la închidere, fără <- explicit.
Repară eroarea, direct în pagină
O goroutină calculează totalul unei comenzi și i-l trimite lui main, dar programul nu compilează: cannot send to non-channel []int total. Declară total ca un canal de int, ca programul să afișeze:
Total comandă: 175package main
import "fmt"
func main() {
preturi := []int{50, 25, 100}
total := []int{}
go func() {
s := 0
for _, p := range preturi {
s += p
}
total <- s
}()
fmt.Println("Total comandă:", <-total)
}Total comandă: 175
Indiciu
total := make(chan int).
Reparația
package main
import "fmt"
func main() {
preturi := []int{50, 25, 100}
total := make(chan int)
go func() {
s := 0
for _, p := range preturi {
s += p
}
total <- s
}()
fmt.Println("Total comandă:", <-total)
}De ce merge
<- funcționează doar pe canale, iar total era un slice. Cu make(chan int), goroutina trimite suma, iar <-total din main așteaptă până când valoarea sosește. Canalul fără buffer sincronizează cele două goroutine, deci main nu termină înainte de calcul și nu are nevoie de sync.WaitGroup pentru o singură valoare.
Alte forme ale mesajului
invalid operation: cannot receive from non-channel []int x (variable of type []int)invalid operation: cannot close non-channel x (variable of type []int)invalid operation: cannot send to non-channel
Cum o eviți pe viitor
Când pornești o goroutină, decide de la început cum îți dă rezultatul: printr-un canal (chan T), printr-un slice cu index propriu pentru fiecare goroutină, sau printr-o structură protejată cu Mutex. Scrie tipul în semnătura funcției (chan<- int pentru cine trimite, <-chan int pentru cine primește), ca greșelile să fie prinse la compilare.
Întrebări frecvente
Pot transforma un slice într-un canal?
Nu direct. Creezi un canal și trimiți elementele într-o goroutină: go func() { for _, v := range s { ch <- v }; close(ch) }().
Ce tip are un canal doar pentru trimitere?
chan<- int. Un canal doar pentru primire este <-chan int. Un chan int obișnuit se convertește automat la oricare dintre ele când îl dai unei funcții.
Erori înrudite
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. 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. panic: send on closed channel Ai trimis o valoare pe un canal după ce a fost închis cu close. Un canal închis poate fi citit, dar nu mai acceptă trimiteri. Închide canalul o singură dată, doar după ce toți cei care trimit au terminat (de regulă de către cel care trimite, sau după wg.Wait()). Î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.
