Download Law Run Modules Zip Fixed
If a module might be depended on by other modules, these rules must be followedso that the go command can find and download the module. There are alsoseveral lexical restrictions on characters allowed inmodule paths.
Download Law Run Modules zip
Major version suffixes are not allowed at major versions v0 or v1. There isno need to change the module path between v0 and v1 because v0 versionsare unstable and have no compatibility guarantee. Additionally, for mostmodules, v1 is backwards compatible with the last v0 version; a v1 versionacts as a commitment to compatibility, rather than an indication ofincompatible changes compared with v0.
As a special case, modules paths starting with gopkg.in/ must always have amajor version suffix, even at v0 and v1. The suffix must start with a dotrather than a slash (for example, gopkg.in/yaml.v2).
Many Go projects released versions at v2 or higher without using a majorversion suffix before migrating to modules (perhaps before modules were evenintroduced). These versions are annotated with a +incompatible build tag (forexample, v2.0.0+incompatible). See Compatibility with non-modulerepositories for more information.
The go command starts by searching the build list formodules with paths that are prefixes of the package path. For example, if thepackage example.com/a/b is imported, and the module example.com/a is in thebuild list, the go command will check whether example.com/a contains thepackage, in the directory b. At least one file with the .go extension mustbe present in a directory for it to be considered a package. Buildconstraints are not applied for thispurpose. If exactly one module in the build list provides the package, thatmodule is used. If no modules provide the package or if two or more modulesprovide the package, the go command reports an error. The -mod=mod flaginstructs the go command to attempt to find new modules providing missingpackages and to update go.mod and go.sum. The go get and go mod tidy commands do this automatically.
For each entry in the GOPROXY list, the go command requests the latestversion of each module path that might provide the package (that is, each prefixof the package path). For each successfully requested module path, the gocommand will download the module at the latest version and check whether themodule contains the requested package. If one or more modules contain therequested package, the module with the longest path is used. If one or moremodules are found but none contain the requested package, an error isreported. If no modules are found, the go command tries the next entry in theGOPROXY list. If no entries are left, an error is reported.
If the module path appears in a require directive and is not replaced, orif the module paths appears on the right side of a replace directive,the go command may need to download modules with that path, and someadditional requirements must be satisfied.
A deprecation applies to all minor versions of a module. Major versions higherthan v2 are considered separate modules for this purpose, since their majorversion suffixes give them distinct module paths.
The go directive was originally intended to support backward incompatiblechanges to the Go language (see Go 2transition). There have been no incompatiblelanguage changes since modules were introduced, but the go directive stillaffects use of new language features:
Conceptually, MVS operates on a directed graph of modules, specified withgo.mod files. Each vertex in the graph represents amodule version. Each edge represents a minimum required version of a dependency,specified using a requiredirective. The graph may be modified by excludeand replace directives in the go.mod file(s) of the mainmodule(s) and by replace directives in the go.work file.
MVS starts at the main modules (special vertices in the graph that have noversion) and traverses the graph, tracking the highest required version of eachmodule. At the end of the traversal, the highest required versions comprise thebuild list: they are the minimum versions that satisfy all requirements.
The go get command may also be used to downgrade a set ofmodules. To perform a downgrade, the go command changes the module graph byremoving versions above the downgraded versions. It also removes versions ofother modules that depend on removed versions, since they may not be compatiblewith the downgraded versions of their dependencies. If the main module requiresa module version removed by downgrading, the requirement is changed to aprevious version that has not been removed. If no previous version is available,the requirement is dropped.
Since a go 1.17 go.mod file includes a requiredirective for every dependency needed to build anypackage or test in that module, the pruned module graph includes all of thedependencies needed to go build or go test the packages in any dependencyexplicitly required by the main module. A module that isnot needed to build any package or test in a given module cannot affect therun-time behavior of its packages, so the dependencies that are pruned out ofthe module graph would only cause interference between otherwise-unrelatedmodules.
Modules whose requirements have been pruned out still appear in the module graphand are still reported by go list -m all: their selectedversions are known and well-defined, and packages canbe loaded from those modules (for example, as transitive dependencies of testsloaded from other modules). However, since the go command cannot easilyidentify which dependencies of these modules are satisfied, the arguments to go build and go test cannot include packages from modules whose requirementshave been pruned out. go get promotes the module containing eachnamed package to an explicit dependency, allowing go build or go test to beinvoked on that package.
If all imported packages can be found without loading the module graph, thego command then loads the go.mod files for only the modules containingthose packages, and their requirements are checked against the requirements ofthe main module to ensure that they are locally consistent. (Inconsistencies canarise due to version-control merges, hand-edits, and changes in modules thathave been replaced using local filesystem paths.)
A workspace can be declared in a go.work file that specifiesrelative paths to the module directories of each of the modules in the workspace.When no go.work file exists, the workspace consists of the single modulecontaining the current directory.
Most go subcommands that work with modulesoperate on the set of modules determined by the current workspace.go mod init, go mod why, go mod edit, go mod tidy, go mod vendor,and go get always operate on a single main module.
A repository that migrates to modules after version v2.0.0 is tagged shouldusually release a new major version. In the example above, the author shouldcreate a module with the path example.com/m/v5 and should release versionv5.0.0. The author should also update imports of packages in the module to usethe prefix example.com/m/v5 instead of example.com/m. See Go Modules: v2and Beyond for a more detailed example.
Most go commands may run in Module-aware mode or GOPATH mode. Inmodule-aware mode, the go command uses go.mod files to find versioneddependencies, and it typically loads packages out of the modulecache, downloading modules if they are missing. In GOPATHmode, the go command ignores modules; it looks in vendordirectories and in GOPATH to find dependencies.
In module-aware mode, GOPATH no longer defines the meaning of imports during abuild, but it still stores downloaded dependencies (in GOPATH/pkg/mod; seeModule cache) and installed commands (in GOPATH/bin, unlessGOBIN is set).
When using modules, the go command typically satisfies dependencies bydownloading modules from their sources into the module cache, then loadingpackages from those downloaded copies. Vendoring may be used to allowinteroperation with older versions of Go, or to ensure that all files used for abuild are stored in a single file tree.
go mod vendor also creates the file vendor/modules.txt that contains a listof vendored packages and the module versions they were copied from. Whenvendoring is enabled, this manifest is used as a source of module versioninformation, as reported by go list -m and go version -m. When the go command reads vendor/modules.txt, it checksthat the module versions are consistent with go.mod. If go.mod has changedsince vendor/modules.txt was generated, the go command will report an error.go mod vendor should be run again to update the vendor directory.
When vendoring is enabled, build commands like go build andgo test load packages from the vendor directory instead of accessing thenetwork or the local module cache. The go list -m command onlyprints information about modules listed in go.mod. go mod commands such asgo mod download and go mod tidy do notwork differently when vendoring is enabled and will still download modules andaccess the module cache. go get also does not work differently whenvendoring is enabled.
The first step is to determine which modules to update. go get accepts a listof packages, package patterns, and module paths as arguments. If a packageargument is specified, go get updates the module that provides the package.If a package pattern is specified (for example, all or a path with a ...wildcard), go get expands the pattern to a set of packages, then updates themodules that provide the packages. If an argument names a module but not apackage (for example, the module golang.org/x/net has no package in its rootdirectory), go get will update the module but will not build a package. If noarguments are specified, go get acts as if . were specified (the package inthe current directory); this may be used together with the -u flag to updatemodules that provide imported packages.
Other modules may be upgraded when a module named on the command line is added,upgraded, or downgraded if the new version of the named module requires othermodules at higher versions. For example, suppose module example.com/a isupgraded to version v1.5.0, and that version requires module example.com/bat version v1.2.0. If module example.com/b is currently required at versionv1.1.0, go get example.com/a@v1.5.0 will also upgrade example.com/b tov1.2.0. 041b061a72
