What is the difference between = and <- in golang - go

Question

func worker(id int, jobs <-chan int, results chan<- int) {
for j := range jobs {
fmt.Println("worker", id, "processing job", j)
time.Sleep(time.Second)
results <- j * 2
}
}
func main() {
t := time.Now()
fmt.Println(t)
jobs := make(chan int, 100)
results := make(chan int, 100)
for w := 1; w <= 4; w++ {
go worker(w, jobs, results)
}
for j := 1; j <= 20; j++ {
jobs <- j
}
close(jobs)
for a := 1; a <= 20; a++ {
<-results
}
t = time.Now()
fmt.Println(t)
}
I am confused of the "<-" and I can not find any related documents about "<-". So what is the difference between <- and =?? why I can not use = here?

Answer 1

The = operator deals with variable assignment as in most languages. It expresses the idea of wanting to update the value that an identifier references. The <- operator represents the idea of passing a value from a channel to a reference. If you think of the channel as a queue using an assignment operator = would assign the reference to the queue to the target variable. The receive operator <- is equivalent to dequeuing from the queue and assigning the value of the item to the target variable.
You cannot use the operators interchangeably because of a type mismatch. Please note the links to the Go specification which speak at greater length to the operators.

Answer 2

This is related to channels in Go. You are thinking it's related to assignment as in other languages. In your code, a value "j" is being sent to the channel "jobs".
https://gobyexample.com/channels

Answer 3

"=" is assignment,just like other language.
<- is a operator only work with channel,it means put or get a message from a channel.
channel is an important concept in go,especially in concurrent programming.you can try this Channel TourPage to see its using scene.

Answer 4

This example is meant to illustrate the usage of channels and of the <- notation, so if it's still confusing, providing annotation/explanation should help:
func worker(id int, jobs <-chan int, results chan<- int) {
// each worker will be a goroutine
// it has an integer id,
// the notation `jobs <-chan int` means `jobs` is a channel
// of ints, and that `worker` can only read from the channel
// the notation `results chan<- int` means results is also
// a channel of ints, and that `worker` can only write to
// the channel
for j := range jobs {
fmt.Println("worker", id, "processing job", j)
time.Sleep(time.Second)
results <- j * 2 // This notation means `j * 2` is
// written to the channel `results`
}
// so the job the worker is doing is multiplication by 2
}
func main() {
t := time.Now()
fmt.Println(t)
// jobs and results channels of capacity 100
jobs := make(chan int, 100)
results := make(chan int, 100)
// We start running 4 worker goroutines
for w := 1; w <= 4; w++ {
go worker(w, jobs, results)
}
// We load up the jobs queue with 20 jobs
for j := 1; j <= 20; j++ {
jobs <- j // This syntax means `j` is written
// to the channel `jobs`
}
close(jobs) // Signals that we won't be adding any more jobs
// We wait until we've pulled 20 expected
// results from the results queue
for a := 1; a <= 20; a++ {
<-results // This syntax means we pull an element out of
// the results queue and discard it (since we
// aren't assigning to any variable)
}
// Count how much time all that work took
t = time.Now()
fmt.Println(t)
}