golang.org | The mirror of all golang.org/x libraries

1. It is the main method, so there is no need to cleanup. When main returns, the program exits. If this wasn't the main, then you would be correct.

2. There is no best practice that fits all use cases. The code you show here is a very common pattern. The function creates a goroutine, and returns a channel so that others can communicate with that goroutine. There is no rule that governs how channels must be created. There is no way to terminate that goroutine though. One use case this pattern fits well is reading a large resultset from a database. The channel allows streaming data as it is read from the database. In that case usually there are other means of terminating the goroutine though, like passing a context.

3. Again, there are no hard rules on how channels should be created/closed. A channel can be left open, and it will be garbage collected when it is no longer used. If the use case demands so, the channel can be left open indefinitely, and the scenario you worry about will never happen.

Call ParseUint to parse an unsigned integer.

The ParseInt function parses signed integers. The maximum signed integer is 9223372036854775807.

There is no significance to the empty lines in the import group.

Some editors (including VSCode) put standard library imports first, then add an empty line, and then other (3rd party imports). Also the 2 groups are sorted alphabetically.

Again, there is no significance to this other than being easier to read. It also comes handy if everyone formats imports like this, so there are no "meaningless" commits in a version system due to different import sorting / organizing.

Looking at your code, two things can cause a deadlock:

• errg.Wait() blocks the execution of the main goroutine until all initialized goroutines are finished. However, each goroutine is blocked when trying to write to mapChan, because you never get to read from it (because it is below the errg.Wait()).
• You never read from sliceChan, so that is a potential deadlock right there.

Here is the link to the modified Playground code, but most of the changes are in the main function.

Kubernetes handles this exact process in the runtime.Scheme structure. The idea is that you register types with names or some other identifier, then you can ask for new instances of those types at will based on the identifier. Generally speaking this identifier is derived during a serialization process for example, rather then hard-coded into the source.

The catch is as you said, you need to create a new instance initially. While this pattern is un-common, I have come across two cases in my professional career where this was the logical solution. Here is an example of a very stripped down version of what the K8s runtime.Scheme does to accomplish this and it may work for what you're trying to do and here it is in action:

I have found tomb to be useful for this. Below is a stripped-down non-working example that shows the gist, without handling things like variable encapsulation in the loop. It should give you the idea, but I'm happy to clarify on any points.

In the first case your custom marshaller is not getting called - but instead the default reflection-based json.Marshaler:

https://play.golang.org/p/fGxTjKbsM5X

To fix, change your function signature to a non-pointer receiver:

// Reverse32 returns the value of x with its bits in reversed order.
func Reverse32(x uint32) uint32 {...}

e.g.: 1234 became: 4321

What you are looking for is all bits toggle:

Ahaha it worked! this is so awesome! Yes just follow the tutorial and for me that was doing go mod init test3 to create a module. No one else has been upgrading from old version or everyone else just understood it properly I guess.