Golang: Can channels be closed in a deferred function?

I was working on some Go code and wanted to close a channel at the end of it. However, I wanted to test if it'd actually close the channel if I use an anonymous function, passing the channel as an argument and use the function with the defer keyword.

channel := make(chan string, 2) 

defer func (channel chan string) {
		close(channel)
		value, ok := <-channel
		fmt.Println("Value:", value, "Open channel?", ok)
	}(channel)

To my understanding everything in Go is passed by value and not by reference, and make's documentation says that it returns a channel when used to spawn a channel, not a pointer to a channel. Does this imply that if I pass the channel as argument to a function and close the channel within that function, the channel outside the function would remain open? If so, I'm guessing I'd need to pass the channel as a pointer to the function to achieve that behavior?

I'm new to Go, so I'd appreciate if you can explain me the "why" rather than "Oh, just swap this chunk for this other chunk of code" just so I can better understand how it's actually working:)

Thanks!

Channels behaves like slice, map, strings or functions, as in they actually store a wrapped pointer to the underlying data. They behave like opaque pointers.

So passing a channel is copying it by value, but just like a slice, it's "value" is literally just a reference to the actual low-level channel data structure. So there is no need to explicitly pass a channel pointer, since that would be like passing a pointer of a pointer.

To answer your questions: Yes it can and yes it's safe to pass channels by value because they are "pointers" in and of themselves.

You can also verify it with a slightly modified version of your code:

package main

import "fmt"

func main() {
	channel := make(chan string, 2)

    // channel is open here.

    // close the channel by passing it into a function
    // by value and closing it within the function.
	func(channel chan string) {
		close(channel)
	}(channel)

    // is the channel closed?
	value, ok := <-channel
	fmt.Println("Value:", value, "Open channel?", ok)
}

Output (go version go1.16 darwin/amd64):
<pre>
Value: Open channel? false
</pre>

> Does this imply that if I pass the channel as argument to a function and close the channel within that function, the channel outside the function would remain open?

No. Copying a chan variable doesn't produce a copy of the channel itself. Variables of type chan are handles to the underlying channel created by make. Closing any copy of the chan variable closes the channel.