What version of Go is used to compile dependencies?

php editor Baicao will answer your question about which version of Go to use to compile dependencies. When compiling Go code, the choice of dependency versions is crucial. It is generally recommended to use dependency versions that are compatible with Go versions that are known to run stably in your project. This ensures code stability and compatibility. At the same time, you should also consider whether the dependencies used are still under maintenance and whether there are updates compatible with the latest version of Go. Comprehensively considering the project requirements and the characteristics of the dependencies, choosing the appropriate Go version to compile the dependencies can ensure the stable operation of the project to the greatest extent.

Question content

When compiling a Go program, do you use the same version of Go to compile the main code and dependent code?

Solution

This is an interesting question, and has a somewhat subtle answer.

For older versions of Go, the answer is simple: each dependency is compiled using the version of Go you are running locally. If you are running Go 1.9 and have dependencies built for Go 1.10, the compiler will not wisely try to compile Go 1.10 code using Go 1.9. As long as no new features are used in that dependency, everything will work fine. Likewise, if you have a dependency written for Go 1.8, it will also compile with Go 1.9.

However, for modern versions of Go and any project (or dependency) that uses a go.mod file, the behavior is different. From the Go module reference we learn:

• For packages within modules, the compiler refuses to use language features introduced after the version specified by the go directive. For example, if a module has the directive go 1.12, its package may not use numeric literals introduced in Go 1.13, such as 1_000_000.

This means that your dependency will only use the functionality provided in the Go version in which it is declared. However, they are still built using the modern Go runtime. Therefore, any performance enhancements, security improvements, etc. found in your Go version (newer than the version declared by the dependency) will still be used.

Additionally, the next line in the same document says:

• If an older Go version builds a package of a module and encounters a compilation error, the error will indicate that the module was written for a newer Go version. For example, suppose the module's version is 1.13 and the package uses the numeric literal 1_000_000. If the package is built using Go 1.12, the compiler will indicate that the code was written for Go 1.13.

So this means that if you try to build a program with Go 1.19 and one of the dependencies declares version 1.20 and there is a compilation error, the compiler output will notify you of the potential compatibility issue. If there were no compilation errors, you might never notice the difference (because dependencies that might be declared for 1.20 don't actually use any of the new 1.20 compiler features).

This will have a more noticeable impact than before, probably in Go 1.22, assuming less error-prone loop variable scoping The proposal is accepted and implemented in time. Since this proposal would change the way loop variables are handled in a non-backwards compatible way. Assuming this does make it into Go 1.22, this means that any module declaring go 1.21 or earlier will use the old loop semantics, and any module declaring go 1.22 or later will Modules will all use the new loop semantics. This would be the first time Go has violated its backwards compatibility promise, albeit arguably for good reason (since that loop variable thing got almost everyone into trouble).

The above is the detailed content of What version of Go is used to compile dependencies?. For more information, please follow other related articles on the PHP Chinese website!