What is the difference between = and <- in golang

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?

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.

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

• "=" 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.

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)
}