Shulou(Shulou.com)05/31 Report--

This article mainly introduces the Go language package management tool dep how to use the relevant knowledge, the content is detailed and easy to understand, the operation is simple and fast, has a certain reference value, I believe that everyone after reading this Go language package management tool dep how to use the article will have a harvest, let's take a look.

What is dep?

Dep and go, to some extent, are equivalent to maven to Java,composer to PHP,dep is an official package management tool for the go language.

Compared with go get, dep can directly give a dedicated directory to imported third-party packages, and can develop a special configuration file to control the packages, versions, and other dependencies introduced by go projects.

The official explanation for dep is: dep is the official experiment, but not yet the official tool. In other words, dep is still in the experimental stage and has not yet become an official tool. After all, the go language is still very young, but it also fully proves that the ecological circle of the go language is very rich.

Installation

There are many ways to install the dep tool. If you are a mac computer, you only need the following command:

Brew install dep

For Linux and Unix-like systems, we can also install dep as follows:

Curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh

Or install it directly using the source code.

For windows computers, it may be relatively troublesome. We can directly use the source code to compile and install or use the go get command to install:

Go get-u github.com/golang/dep/cmd/dep

After the installation is complete, put dep.exe in the environment variable and you can use it.

Use

Next let's take a look at how dep is used.

When dep is installed, we can see the command about dep by typing dep on the command line.

Dep is a tool for managing dependencies for Go projectsUsage: "dep [command]" Commands: init Set up a new Go project, or migrate an existing one status Report the status of the project's dependencies ensure Ensure a dependency is safely vendored in the project version Show the dep version informationExamples: dep init set up a new project dep ensure install the project's dependencies dep ensure-update update the locked versions of all dependencies dep ensure-add github.com/pkg/errors add a dependency to the projectUse "dep help [command]" for more information about a command.

We can see that dep usually uses three commands when entering the game:

Init- is used to initialize the project

Status- is used to view the status of dependent packages for the current project

Ensure- is used to synchronize the configuration files of packages and incoming packages

Let's officially use dep to create a project. First set up a project path, which we call depProject. Then create the src source code directory in the project path. Create a directory in src to store the dep file and the project master file, which we can call depmain for the time being, and create a go file.

So our directory structure is as follows:

DepProject

| |-src |

| |-depmain |

| |-main.go |

Once established, we write a simple go program in main.go:

Package mainimport ("fmt") func main () {fmt.Println ("hello)}

Then we run the following command in this directory:

Dep init

After running, dep will automatically generate the following files and directories for us:

It looks a bit like a regular go project, but it is important to note that the cache file of the go language import package is stored in pkg, and the real imported package content is stored in vendor. Next are two files, Gopkg.lock and Gopkg.toml. The Gopkg.lock file is generated automatically, and the Gopkg.toml file is a file that we can edit. You can import the package by editing this file and running the dep command:

# required package required = ["github.com/gin-gonic/gin"] # ignore package # ignored = [] No # project metadata # [metadata] # constraints [[constraint]] # name = # optional: version # version = # branch # branch # revision # revision # optional: specify source # source = "github.com/gin-gonic/gin"

The above code is an example, which we will run after we have written it.

Dep ensure

That's it, we'll see a little more dependency and introduction of this package under vendor.

We have introduced the package of the gin framework, so we can now use the gin framework to write the same as our usual go language projects:

Package mainimport "github.com/gin-gonic/gin" func main () {r: = gin.Default () r.GET ("/ ping", func (c * gin.Context) {c.JSON (200, gin.H {"message": "pong",}) r.Run () / / listen and serve on 0.0.0.0 r.GET 8080}

There is no problem with this, we just need to consider the original path of the package, github.com/gin-gonic/gin.

Then we can compile and run the project.

It is also important to note that when using the dep management package to control dependencies, if we need to create a new directory and write our own new package name, we only need to create a new directory under src. Only in this way can we introduce it correctly.

For example: we want to write an add function, we can do this, under the src resume a utils directory, write an add.go file:

Package utilsfunc Add (an int, b int) int {return aquib}

In this way, in the main program, you can import your own package and use your own functions:

Package mainimport ("utils"fmt") func main () {fmt.Println ("hello") utils.Add (1,1)} this article on "how to use the Go language Pack Management tool dep" ends here, thank you for reading! I believe you all have a certain understanding of the knowledge of "how to use dep, a Go language pack management tool". If you want to learn more, you are welcome to follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.