go学习 模块与包 - Init函数 - 如何导入第三方包 - 切片与数组的数据传递方式 - go中文件的读写

最新推荐文章于 2023-12-27 19:22:37 发布
最新推荐文章于 2023-12-27 19:22:37 发布
阅读量489 收藏 2
点赞数
文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lpfstudy/article/details/131845188
版权

目录

包（package）是组织和复用代码的基本单元。

包的种类：

包的导入

包的组成

如下两个文件中定义了A变量和 sc_num变量，他们的首字母开头分别为大写和小写，因此可以说明A变量是公有变量，而sc_num是私有变量。

go 风格指南

go中的Init函数

如何导入第三方包：

1、查看go的配置变量基本信息

2、开启GOMODULE管理方式（默认GO111MODULE=auto）

3、启用国内下载代理

4、创建go.mod文件

​编辑5、安装第三方包

go第三方安装包下载官网：Go Packages - Go Packages

6、导入实验代码

7、运行程序：

8、测试Web服务

如何在linux上运行该go语言Web服务器？

1、首先安装go语言环境

2、如果版本太低了，就需要卸载原来的go版本，安装新的go版本，而这则需要源码安装

3、源码安装go

4、部署Web服务

5、运行go语言程序

6、测试Web服务效果：

go的切片与数组（详细的数据传输解释）（go传递数据的时候使用的是传值的方式）

切片类型下数据的传递方式： 

数组类型下数据的传递方式：

什么是传值和传地址，他们的区别又是什么？

传值和传址的区别总结如下：

如何在go的函数中直接修改原数据的数组呢，而不是修改函数副本空间中的复制的数组呢？

如果输入数据超过切片的容量限制，会发生什么呢？

go的文件操作（文件的读写方式）：

什么时候会用到go中的文件读写呀

包（package）是组织和复用代码的基本单元。

一个包可以包含多个Go源文件（以.go为扩展名），这些文件通常属于同一个功能或领域。每个源文件的开头都需要声明所属的包名。

包名 --》告知当前这个go文件属于哪个包（目录）

go文件 --》定义包中的内容（代码写在go文件中）

        --》main --》这是一个主运行文件

包的种类：

  1. 标准库包（Standard Library Packages）：Go标准库提供了丰富的包来支持各种常见任务和功能，如字符串处理、文件操作、网络通信等。这些包无需额外安装，可以直接使用。（内置包：不需要安装、直接import导入即可使用）

  2. 第三方包（Third-Party Packages）：Go社区拥有众多的第三方包，以满足各种特定需求。这些包通常由其他开发者或组织维护，并且需要使用工具如Go Modules或GOPATH来管理和导入。（第三方包：需要安装，再导入使用）

  3. 自定义包（Custom Packages）：任何人都可以创建自己的Go包，并根据需要组织和导出函数、类型和变量。自定义包使代码更易于重用和维护。可以通过在代码文件的开头使用package关键字声明包名，并使用import语句在其他代码中导入自定义包。（自定义包：自己写的go包）

包的导入

// import "sc/user"      直接导入包的内容

// import u "sc/user"   导入之后取别名

// import _ "sc/user"   仅执行init函数中的内容

// import . "sc/user"    导入包中所有的内容

包的组成

一个目录表示一个包(sanchuang)、user子包
代码写到go文件中 => 

第一行声明当前文件属于当个包（建议包名与目录名同名）

同一个包下的文件，声明的包名应该一致
同一个包中，变量、函数等都是共享的（相互可见的）
文件中定义的对象 =》大写的标识符 表示Public , 小写的标识符表示Private

以大写字母开头的标识符（如变量名，函数名），都是表示Public

以小写字母开头的标识符，都是表示Private

如下两个文件中定义了A变量和 sc_num变量，他们的首字母开头分别为大写和小写，因此可以说明A变量是公有变量，而sc_num是私有变量。

 main文件

package main

// import 包名/子包名
// 取别名 => 有时候有些包的名字特别长.可以取别名
//u "sc/user"
// 仅仅执行sc/user包中的初始化信息
//_ "sc/user"
//. "sc/user"
// 注意事项:包名与目录名不一致，必须取一个别名 "sc/user" => 路径
//import (
//	"fmt"
//	"sc/user"
//)
import "fmt"
import u "sc/user"

func main(){
	fmt.Printf("start.....")
	//TeacherInfo()
	user.TeacherInfo()
	//u.TeacherInfo()
	//TeacherInfo()
	 变量，大写字母开头，小写字母开头
	 大写字母开头的变量，Public
	//fmt.Println(user.A)
	// 小写字母开头，私有的不能使用
	//fmt.Println(user.sc_num)
}

// init函数 => 初始化一些变量/数据的时候使用
func init(){
	fmt.Println("main init1")
}
func init(){
	fmt.Println("main init2")
}


go 风格指南

// 包名 => 小写+单数
// 文件名 => 小写+下划线
// 函数、结构体、接口、...:大驼峰 => UserName
// 变量名 => 小驼峰 => userName

go中的Init函数

init 函数是一种特殊的函数（初始化函数），它在程序运行时自动执行，而不需要显式调用。

init 函数有以下特点：

  • init 函数没有参数和返回值。
  • 一个包中可以定义多个init，一个文件中也可以定义多个init
  • 当一个程序运行时，首先会按照包的导入顺序初始化包级别的变量和常量。
  • 然后，在完成包级别的变量和常量初始化后，会按照导入顺序依次执行每个包中的 init 函数。
  • 如果一个包中有多个 init 函数，它们的执行顺序与定义顺序相同。

  • 当包被导入的时候init函数自动执行（）

init 函数通常用于执行一些初始化操作，例如注册驱动、初始化全局变量、设置配置信息等。它可以提供程序运行前的一些准备工作。

下面是一个示例，展示了 init 函数的使用：

package main

import (
	"fmt"
)

var a int

func init() {
	fmt.Println("初始化 a 变量")
	a = 10
}

func main() {
	fmt.Println("main 函数执行")
	fmt.Println("a =", a)
}

在上面的例子中，init 函数用来初始化变量 a。当程序运行时，先执行 init 函数，然后再执行 main 函数。输出结果为：

初始化 a 变量 main 函数执行 a = 10

需要注意的是，init 函数在程序中只会执行一次，无论包被导入多少次。而且它不可以被其他函数调用或引用。

如何导入第三方包：

1、查看go的配置变量基本信息

go env --》查看go的配置变量信息

D:\衡山-开发\GO\Day_01\2023-07-21-go模块与包\sanchuang>go env
set GO111MODULE=auto         #用于控制Go Modules（模块）的行为
set GOARCH=amd64
set GOBIN=
set GOCACHE=C:\Users\23843\AppData\Local\go-build
set GOENV=C:\Users\23843\AppData\Roaming\go\env
set GOEXE=.exe
set GOEXPERIMENT=
set GOFLAGS=
set GOHOSTARCH=amd64
set GOHOSTOS=windows
set GOINSECURE=
set GOMODCACHE=C:\Users\23843\go\pkg\mod
set GONOPROXY=
set GONOSUMDB=
set GOOS=windows
set GOPATH=C:\Users\23843\go   #指定Go语言工作区的根目录，被用来指定存放Go源代码、编译后二进制文件和第三方包的位置。三方的依赖都安装到$GOPATH/pkg/mod目录下
set GOPRIVATE=
set GOPROXY=https://goproxy.cn,direct  #设置Go模块的代理服务器，默认情况下，Go模块会从官方的代理服务器 https://proxy.golang.org 下载模块的依赖包，但是我们需要修改为国内源，direct：直接从源地址下载依赖包，不通过代理服务器。
set GOROOT=E:\Go            #指定Go语言的安装路径，包含了Go语言的标准库和工具，$GOROOT\src:go的标准模块存储的地方
set GOSUMDB=sum.golang.org
set GOTMPDIR=
set GOTOOLDIR=E:\Go\pkg\tool\windows_amd64
set GOVCS=
set GOVERSION=go1.19.2
set GCCGO=gccgo
set GOAMD64=v1
set AR=ar
set CC=gcc
set CXX=g++
set CGO_ENABLED=1
set GOMOD=D:\衡山-开发\GO\Day_01\2023-07-21-go模块与包\sanchuang\go.mod
set GOWORK=
set CGO_CFLAGS=-g -O2
set CGO_CPPFLAGS=
set CGO_CXXFLAGS=-g -O2
set CGO_FFLAGS=-g -O2
set CGO_LDFLAGS=-g -O2
set PKG_CONFIG=pkg-config
set GOGCCFLAGS=-m64 -mthreads -Wl,--no-gc-sections -fmessage-length=0 -fdebug-prefix-map=C:\Users\23843\AppData\Local\Temp\go-build3093873577
=/tmp/go-build -gno-record-gcc-switches

D:\衡山-开发\GO\Day_01\2023-07-21-go模块与包\sanchuang>

GO MODULES：是自Go 1.11版本引入的官方依赖管理工具，用于管理Go项目中的包版本和依赖关系。它解决了早期Go语言项目中对于第三方包的管理问题。

功能：依赖管理、版本选择、自动拉取、代理服务器支持、私有仓库支持

使用Go Modules的基本步骤如下：

  1. 初始化模块：在项目根目录下执行go mod init + 《项目名》命令，可以创建一个新的go.mod文件来初始化模块。

  2. 导入依赖包：通过import语句导入所需的依赖包。Go Modules会自动检测并下载缺失的依赖包。

  3. 构建和运行：使用go build命令构建项目，并使用go run命令运行项目。

  4. 管理依赖：可以使用go get命令来添加、更新或删除依赖包。Go Modules会自动更新go.mod文件和下载相应的包。

  5. 版本控制：可以在go.mod文件中指定所需的包版本，使用正确的语义版本控制规则。

因此我们创建的包中必须包含一个go.mod文件（下面的步骤都是在你的项目地址下进行的）

D:\衡山-开发\GO\Day_01\2023-07-21-go模块与包\MyWeb

2、开启GOMODULE管理方式（默认GO111MODULE=auto）

go env -w GO111MODULE=on

3、启用国内下载代理

go env -w GOPROXY=https://goproxy.cn,direct

4、创建go.mod文件

go mod init web

5、安装第三方包

单个依赖安装
go get github.com/gin-gonic/gin
整体项目依赖的处理
go mod tidy

go第三方安装包下载官网：Go Packages - Go Packages

6、导入实验代码

package main

//server.go是主运行文件
import (
	"github.com/gin-gonic/gin"
	"net/http"
)
//gin是go中的一个Web框架

// 入口函数
func main(){
	// 创建一个web服务器
	r := gin.Default()

	// 当访问/sc => 返回{"message":"hello sanchang"}
	r.GET("/sc", func(c *gin.Context){
		// 200,
		c.JSON(http.StatusOK, gin.H{
			"message": "hello, sanchuang",
		})
	})

	// 运行web服务
	r.Run()
}

 

7、运行程序：

运行项目
go run server.go

8、测试Web服务

访问网址http://127.0.0.1:8080/sc

 

如何在linux上运行该go语言Web服务器？

1、首先安装go语言环境

[root@master ~]# yum install golang -y

2、如果版本太低了，就需要卸载原来的go版本，安装新的go版本，而这则需要源码安装

卸载软件

yum remove go -y

源码卸载：rm -rf /usr/local/go

3、源码安装go

首先找到go的安装包

路径：All releases - The Go Programming Language (google.cn)

我们需要安装go 1.19.11版本的安装包

wget https://golang.google.cn/dl/go1.19.11.linux-amd64.tar.gz

 解压安装包

[root@master ~]# tar -zxf go1.19.11.linux-amd64.tar.gz

 配置环境变量

[root@master ~]# vim ~/.bashrc


#添加下面3条
GOROOT=/usr/local/go
export GOPATH=~/go
export PATH=$PATH:$GOPATH:$GOROOT/bin

#重新加载环境
[root@master ~]# source ~/.bashrc
[root@master ~]# echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/usr/local/scnginx66/sbin:/usr/local/scnginx66/sbin:/root/go:/usr/local/go/bin

移动go程序到/usr/local/ 目录下，并查看go版本

[root@master ~]# mv go /usr/local/
[root@master ~]# ls /usr/local/go/bin
go  gofmt
[root@master ~]# go version
go version go1.19.11 linux/amd64
[root@master ~]#

4、部署Web服务

首先创建server.go文件存放go语言Web程序

[root@master ~]# cd /
[root@master /]# mkdir myweb
[root@master /]# cd myweb/
[root@master myweb]# vim server.go
[root@master myweb]# ls
server.go
[root@master myweb]# cat server.go 
package main

//server.go是主运行文件
import (
	"github.com/gin-gonic/gin"
	"net/http"
)
//gin是go中的一个Web框架

// 入口函数
func main(){
	// 创建一个web服务器
	r := gin.Default()

	// 当访问/sc => 返回{"message":"hello sanchang"}
	r.GET("/sc", func(c *gin.Context){
		// 200,
		c.JSON(http.StatusOK, gin.H{
			"message": "hello, sanchuang",
		})
	})

	// 运行web服务
	r.Run()
}
[root@master myweb]#

对go语言模块进行初始化（生成go.mod文件）

[root@master myweb]# go mod init web
go: creating new go.mod: module web
go: to add module requirements and sums:
	go mod tidy
[root@master myweb]# ls
go.mod  server.go
[root@master myweb]#

下面对go语言模块进行加载

[root@master myweb]# go mod tidy

发现如下错误

[root@master myweb]# go mod tidy
go: finding module for package github.com/gin-gonic/gin
web imports
	github.com/gin-gonic/gin: module github.com/gin-gonic/gin: Get "https://proxy.golang.org/github.com/gin-gonic/gin/@v/list": dial tcp 172.217.160.113:443: i/o timeout
[root@master myweb]#

是安装超时了，我们需要将它的源更改为国内源

[root@master myweb]# go env -w GO111MODULE=on
[root@master myweb]# go env -w GOPROXY=https://goproxy.cn,direct

安装成功：

[root@master myweb]# go mod tidy
go: finding module for package github.com/gin-gonic/gin
go: downloading github.com/gin-gonic/gin v1.9.1
go: found github.com/gin-gonic/gin in github.com/gin-gonic/gin v1.9.1
go: downloading github.com/gin-contrib/sse v0.1.0
go: downloading github.com/mattn/go-isatty v0.0.19
go: downloading golang.org/x/net v0.10.0
go: downloading github.com/stretchr/testify v1.8.3
go: downloading google.golang.org/protobuf v1.30.0
go: downloading github.com/go-playground/validator/v10 v10.14.0
go: downloading github.com/pelletier/go-toml/v2 v2.0.8
go: downloading github.com/ugorji/go/codec v1.2.11
go: downloading gopkg.in/yaml.v3 v3.0.1
go: downloading github.com/bytedance/sonic v1.9.1
go: downloading github.com/goccy/go-json v0.10.2
go: downloading github.com/json-iterator/go v1.1.12
go: downloading golang.org/x/sys v0.8.0
go: downloading github.com/davecgh/go-spew v1.1.1
go: downloading github.com/pmezard/go-difflib v1.0.0
go: downloading github.com/gabriel-vasile/mimetype v1.4.2
go: downloading github.com/go-playground/universal-translator v0.18.1
go: downloading github.com/leodido/go-urn v1.2.4
go: downloading golang.org/x/crypto v0.9.0
go: downloading golang.org/x/text v0.9.0
go: downloading github.com/go-playground/locales v0.14.1
go: downloading github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd
go: downloading github.com/modern-go/reflect2 v1.0.2
go: downloading github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311
go: downloading golang.org/x/arch v0.3.0
go: downloading github.com/twitchyliquid64/golang-asm v0.15.1
go: downloading github.com/klauspost/cpuid/v2 v2.2.4
go: downloading github.com/go-playground/assert/v2 v2.2.0
go: downloading github.com/google/go-cmp v0.5.5
go: downloading gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405
go: downloading golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543
[root@master myweb]#

5、运行go语言程序

[root@master myweb]# go run server.go 
[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.

[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
 - using env:	export GIN_MODE=release
 - using code:	gin.SetMode(gin.ReleaseMode)

[GIN-debug] GET    /sc                       --> main.main.func1 (3 handlers)
[GIN-debug] [WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.
Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.
[GIN-debug] Environment variable PORT is undefined. Using port :8080 by default
[GIN-debug] Listening and serving HTTP on :8080

6、测试Web服务效果：

go的切片与数组（详细的数据传输解释）（go传递数据的时候使用的是传值的方式）

package main

import "fmt"

// 切片是一种引用类型（存放的是地址）

func main(){
// 定义了一个切片 len 0, cap 10
var sli = make([]int, 0, 10)
fmt.Printf("原始sli:%v, %p, %p\n",sli, &sli, sli)
test(sli)
fmt.Printf("执行test后sli:%v\n",sli)
// sli[0:cap]
fmt.Printf("执行sli[:10]:%v\n",sli[:10])
}

func test(sli []int){
fmt.Printf("函数中sli:%v, %p, %p\n",sli, &sli, sli)
// 将切片追加数据
sli = append(sli,10,20,30)
fmt.Printf("函数中的结果是：%v\n",sli)
}

输出的结果是：

原始sli:[], 0xc000008078, 0xc00001e140
函数中sli:[], 0xc0000080c0, 0xc00001e140    #源sli和函数中的副本sli的地址是不一样的，但是里面的第一个数据的地址是一样的，说明go分配给切片的方式是传值（传递引用），这才会导致两个不同空间指向的数据中的地址都是一样的
函数中的结果是：[10 20 30]              #在test中运行，go分配空间给test函数中的sli使用
执行test后sli:[]         #test执行后，go收回分配给test函数的空间，导致不存在test中的sli切片了
执行sli[:10]:[10 20 30 0 0 0 0 0 0 0]    #原因是在test中他给副本的sli切片添加了数值，而副本的sli的数据的地址空间与源sli数据的地址空间是一样的，所以才导致源地址空间的sli切片的数据发生了改变


这里复制的是sli这个切片类型，在函数中复制的切片s发生了变化，外面的sl没有改变但是他们底层的数组发生了变化，数组没有被复制还是用的同一个吧
Process finished with exit code 0

切片类型下数据的传递方式： 

数组类型下数据的传递方式：

什么是传值和传地址，他们的区别又是什么？

传值（go语言）：当使用传值方式将参数传递给函数时，函数会创建该参数的一个副本，并在函数内部使用该副本进行操作。这意味着对参数进行的任何修改都只会影响到该副本，不会影响原始的参数。传值方式适用于简单的数据类型（如整数、浮点数、布尔值）或者在函数内部不需要修改原始参数的情况。

传地址（python语言）：当使用传地址方式将参数传递给函数时，实际上是将参数的内存地址传递给函数。这样，在函数内部可以直接访问和修改原始参数的值。因为是直接操作原始参数，所以对参数的修改会影响到原始参数的值。传地址方式适用于复杂的数据类型（如数组、切片、映射、结构体）或者需要在函数内部修改原始参数的情况。

传值和传址的区别总结如下：

  1. 传值是将参数的副本传递给函数，对副本的任何修改都不会影响原始参数。
  2. 传地址是将参数的内存地址传递给函数，允许直接访问和修改原始参数。
  3. 传值适用于简单的数据类型或者不需要修改原始参数的情况。
  4. 传地址适用于复杂的数据类型或者需要在函数内部修改原始参数的情况。

如何在go的函数中直接修改原数据的数组呢，而不是修改函数副本空间中的复制的数组呢？

go语言中,当调用一个函数的时候，函数的每个调用参数将会被赋值给函数内部的参数变量，所以函数参数变量接收的是一个复制的副本，并不是原始调用的变量。
因为函数参数传递的机制导致传递大的数组类型将是低效的，并且对数组参数的任何的修改都是发生在复制的数组上，并不能直接修改调用时原始的数组变量。
我们可以显式地传入一个数组指针，那样的话函数通过指针对数组的任何修改都可以直接反馈到调用者。

如果输入数据超过切片的容量限制，会发生什么呢？

定义了一个切片（slice）变量 sli，长度为 0，容量为 3，如果输入数据超过容量限制，会直接创建一个新的底层数组 

因为我们定义的切片只有3个容量，但是我们需要输入4个容量的数据，因此函数中的sli切片会定义另外一个底层数组用来存储数据（与源地址空间的sli切片的底层数组不同），这导致源地址空间的sli切片的底层数组并没有存储数据，而数据是保存在了函数中副本空间内的sli切片定义的新的底层数组空间中。

go的文件操作（文件的读写方式）：

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main()  {
	// 获取当前路径，防止创建文件的时候不知道文件被创建的路径在哪里
	wd, err := os.Getwd()
	if err != nil{                  //异常处理
		fmt.Println("获取当前路径失败", err)
	}
	fmt.Println("当前路径为:", wd)
	// 在当前目录
	filePath := "./golang.txt"

	file,err := os.OpenFile(filePath,os.O_CREATE|os.O_WRONLY, 0666)
	// go对于错误的错误权交给了用户
	if err!=nil{                    //异常处理
		fmt.Println("打开文件失败", err)
		return
	}
	// 如果打开文件没有出错
	// defer延迟执行（如果程序遇到panic也会执行）
	defer file.Close()                //异常处理

	//写入数据
	write := bufio.NewWriter(file)
	for i:=0;i<5;i++{
		write.WriteString("hello sc！\n")
	}
	//因为我们写入的数据是在缓存中，我们需要写道磁盘中，因此需要对数据进行一个强刷，将数据保存到磁盘（文件）当中
	write.Flush()
}

结果为：

什么时候会用到go中的文件读写呀

爬虫（图片、文件）

写日志 --》 日志模块

Claylpf
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
go导入第三方包
k393393的博客
01-06 1万+
1、先进入golang的官网，然后找到pakage 官网地址 2、搜索找到相关的依赖包 3、点击查看如何导入 4、在命令行执行此命令 5、在代码中添加依赖 6、解决问题 本人用的GoLand开发工具，发现导入的包报错，但是依然可以运行 这是因为goland的搜索库异常，重新更新一下即可 更新完成后正常，直接运行即可 ...
Golang项目引入第三方依赖库
Shelly Long的博客
06-25 3356
因为 g6/util 包线引入，所以先执行 a.go 中的 init 函数，init 函数在 d.go的main函数执行之前执行。初始化函数 init(){}，一个包下面可以有多个 init 函数，甚至一个文件下 也可以有多个 init 函数。引用了包，但可以不使用，仅执行引入包的 init 函数，如下仅执 g6/util 包下的 init 函数。初始化依赖，切换到项目根目录下面，执行一下命令，g6 为 module 的名称。第二种方式：（自动添加/删除 import 中引入的/未使用的第三方依赖包）
go语言引入第三方包
一个从通信转行网络人的博客
08-15 446
假设我们有个项目叫caseshow，我们先创建这个目录，并初始化一下此时在caseshow目录下会自动产生一个go.mod文件目录下会多一个go.sum文件，go.mod文件里面也多了关于redis库的内容,之后就可以直接用了。
Golang 必知必会Go Mod命令
热门推荐
猫轻王的博客
03-15 2万+
通过以上可以轻松了解在Golang中go mod的使用方式。Go mod提供了一系列操作modules的命令，所有的go命令中现在已经内置了对module的支持，而不仅仅是go mod命令。例如使用go get时，会经常自动在后台添加、移除、升级、降级依赖包版本。
【GO】项目import第三方的依赖包
smallbirdnq的专栏
11-07 948
本次学习go如果依赖第三方的包，并根据第三方的包提供的接口进行编程，这里需要使用go get命令。命令用于从远程代码仓库（比如 Github ）上下载并安装代码包。注意，go get 命令会把当前的代码包下载到 $GOPATH 中的第一个工作区的 src 目录中，并安装。go 1.17之后go get只下载源码，并将依赖添加到go.mod，并不会安装。安装油go install完成。专门用来运行命令源码文件的命令，一般用来运行单个文件主要是用于测试编译。编译某个包或者项目，在当前目录下生成可执行文件。
go语言使用第三方包 json化结构体操作示例
09-19
在Go语言中，处理JSON数据是一项常见的任务，特别是在与Web服务交互或存储/检索数据时。本篇文章将深入探讨如何利用第三方包`ffjson`来简化Go语言中的结构体到JSON字符串的转换过程。 首先，确保你的开发环境已经...
Go-glide-Golang的包管理器
08-14
为了解决这个问题，社区开发了多个第三方包管理器，其中glide是早期较为流行的一个。glide是由Masterminds团队开发的，它的目标是为Golang提供类似Java的Maven、Ruby的Bundler以及Python的Pip这样的便捷依赖管理功能...
.rncache React-Native 0.47第三方包
08-22
Mac os react native rncache https://github.com/facebook/react-native/blob/0.47-stable/scripts/ios-install-third-party.sh
Go-在Go中最快和最简便的方式来使用nativeArgon2绑定
08-13
标题中的“Go在Go中最快和最简便的方式来使用native Argon2绑定”指的是在Go语言环境中，高效且简便地利用原生（native）的Argon2库进行密码哈希处理。Argon2是一种安全的密码哈希算法，设计用于防止彩虹表攻击和...
Go-Golang笔记
08-14
Go语言，也称为Golang，是由Google开发的一种静态类型的、编译式的、并发型且具有垃圾回收功能的编程语言。自2009年发布以来，Go语言因其简洁的语法、高效的性能以及对并发处理的良好支持，逐渐在云计算、网络服务和...
初识Go语言20-包与工程化【用go mod管理工程、包引入规则、init调用链、可见性】
m0_52896752的博客
05-02 828
初识Go语言20-包与工程化【用go mod管理工程、包引入规则、init调用链、可见性】
Go初学者踩坑之go mod init与自定义包的使用详解
Linuxprobe18的博客
11-26 1655
入门很容易的 hello world, 到使用自定义包算一个小的进步,然而在使用上竟然浪费了不少时间,上网查了半天,才解决问题.第一明确 是哪种方式,是go mod 方式 还是 go path 方式, 请自己查一下,本小文直说go mog 方式的小问题.说实话, 我最讨厌这种几乎一点儿含金量都没有的系统配置了. 从微软的MFC 到go , 真是无奈.浪费大量时间.例如，在test目录下，即test模块，就用。我能想到的方法都用到了,还是不行.查看 go.mod,内容如下。为了方便,写成别名引用方式。
解放你的依赖管理：Go mod包管理工具详解
BASK2312的博客
05-09 4158
Go语言作为一门静态编译型语言，对于包和依赖的管理非常重要，而Go mod正是这方面的解决方案之一。Go mod能够管理依赖的版本，避免冲突问题，提高包的复用率和依赖的管理效率。与传统的依赖管理工具相比，Go mod具有优势和特点，例如本地缓存、并行下载、精确版本管理等。同时，Go mod也有一些常见的问题需要注意，例如依赖版本的选择、依赖冲突的处理等。因此，在进行Go语言模块化开发时，我们应当充分认识到Go mod的重要性，并鼓励使用它来进行包和依赖的管理。
理解 Go Mod Init
最新发布
csjds的专栏
12-27 824
`go mod init` 是Go编程语言（通常称为Golang）中用于初始化新Go模块的命令。在Go中，一个模块是一组相关的Go包，它们作为一个单元一起进行版本控制。
go项目中引用第三方包或自己写的包
Fengfgg的博客
04-21 5212
引入第三方包 1.打开gomod方式，和设置下载点，在终端输入go env，查看是否更改成功。 go env -w GO111MODULE=on go env -w GOPROXY=https://goproxy.io,direct 2.goget第三方包 go get github.com/rs/zerolog/log 可以看到在GoPath/pkg/mod/目录下会自动下载了文件 3.更新gomod 但是发现在项目中这个包为红色，且不能用。 在打开的项目文件中更新gomod go mod tid
1. GO 之基础命令
qq_48480384的博客
04-02 4994
go mod命令。
一文搞懂Go语言中包导入
itcyy的博客
12-04 1564
/自定义为g，项目中即可使用g调用方法以上就是总结的go中包的相关知识，这些知识可以让我们在操作的过程中有很多的用途，所以还是有必要进行总结，这样下来，会让我们在很多时候有帮助。
golang 学习（二十五）go mod以及自定义包package的用法和init()方法
wangyufeng43400141的专栏
07-07 1万+
go mod以及自定义包package的用法和init()方法 包的介绍和定义 包（packge）是多个 Go 源码的集合，是一种高级的代码复用方案，Go 语言为我们提供了 很多内置包，如:fmt、strconv、strings、sort、eros、time、encoding/json、os、io 等。 Golang 中的包可以分为三种：1、系统内置包 2、自定义包 3、第三方包 系统内置包: Golang 语言给我们提供的内置包，引入后可以直接使用，如 fmt、srconv、strings、sort、e
go mod init小技巧
weixin_43915479的博客
02-01 9690
go.mod package main // import "golang" (此处的注释为go mod init 生成的 module 值) import "fmt" func main() { fmt.Println("xxx") } 1执行 go mod init（不加package main后面的注释，默认为当前gopath路径下执行go mod init位置） module golang // 指定了module go 1.15 ...
使第三方包可以在pkg-config中找到
03-23
你可以使用以下命令将第三方包添加到pkg-config中： pkg-config --cflags --libs third-party-package 其中，third-party-package是你要添加的第三方包的名称。这个命令将返回一个包含编译器选项和链接器选项的字符串，你可以将其添加到你的编译命令中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值