Go语言--包(Package)

最新推荐文章于 2024-05-15 00:16:20 发布
最新推荐文章于 2024-05-15 00:16:20 发布
阅读量3k 收藏 12
点赞数 3
分类专栏： # Go语言学习笔记 文章标签： go go语言 golang package
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010429831/article/details/110558346
版权

1 命名空间和作用域

1.1 命名空间

命名空间（Namespace）在编程语言中常用来表示标识符（identifier）的可见范围。编程语言借助命名空间来解决标识符不能同名的问题，命名空间实际上相当于给标识符添加了标识前缀，使标识符变得全局唯一。另外，命名空间是程序组织更加模块化，降低了程序内部的耦合性。

一个标识符可以在多个命名空间中定义，它在不同命名空间中的含义是不互相干的。新的命名空间中可定义任意的标识符，它们不会与位于其他命名空间上的同名标识符发生冲突，当然自定义标识符尽量不要使用编程语言自身的关键字，因为这些标识符具有全局作用域。

Go语言继承了命名空间的概念，采用包来组织代码，包名构成Go命名空间的一部分，不同的包就是一个独立的命名空间。

Go语言除了包级显式的命名空间，还有隐式的命名空间。函数、方法，以及 if、for、switch 等和 “{ }” 一起构成了一个个代码块，代码块可以嵌套代码块，每一个代码块都构成一个隐式的命名空间。

不同命名空间可以声明相同的标识符，所以不同的隐式的命名空间同样允许声明相同的标识符（包括变量），这里就有变量覆盖的问题。在介绍变量覆盖之前，先来介绍作用域。

1.2 作用域

在高级编程语言中，作用域（scope）是指名字（name）与实体（可以理解为特定内存地址）的绑定（binding）保持有效的那部分程序逻辑区间。Go语言是静态作用域的编程语言。所谓静态作用域就是变量的作用域不依赖程序执行时的因素，变量作用域在编译器就能确定。

Go语言有三种类型的作用域：

  • 全局作用域

在任何地方都可以访问的标识符，称其具有全局作用域。在Go语言中，全局作用域有两类：

（1）Go语言内置的预声明标识符（包括预声明的类型名、关键字、内置函数等），它们具有全局作用域，在任意命名空间内都可见。

（2）Go语言包内以大写字母开头的标识符（包括变量、常量、函数和方法名、自定义类型、结构体字段等），它们具有全局作用域，在任意命名空间内都可见。

  • 包内作用域

在Go语言包内以小写字母开头的标识符（包括变量、常量、函数和方法名、自定义类型、结构体字段等），它们在本包可见，在其他包都是不可见的，这些标识符具有包内作用域。

  • 隐式作用域

每个代码块内定义的变量称为“局部变量”，这些局部变量只在当前代码块内可见，其作用域属于当前代码块的隐式作用域。

1.3 变量覆盖

Go语言编译器解析变量名到引用实体采用的是从里到外的搜索模式，里层的局部变量能够覆盖掉外层变量，使得同名的外层变量不可见，这种现象称为变量覆盖。

由于命名空间允许同名变量的存在，大量的同名变量可能会给程序的可读性带来影响，Go语言通过包、代码缩进和大括号“{ }” 组织嵌套的方式来改善程序的可读性，这也是众多编程语言的通用做法。一些临时变量可以同名，一些关键变量还是尽量起一个有意义的名称。

2 包的基本概念

2.1 基本概念

Go语言的源码复用是建立在包（package）基础之上。Go语言的入库 main() 函数所在的包（package）叫 main 包，main包想要引用别的代码，必须同样以包的方式进行引用。Go语言使用包来组织代码的，并实现命名空间的管理。任何源代码文件必须属于某个包。源码文件的第一行有效代码必须是 package pkgName 语句，通过该语句声明自己所在的包。

Go语言的包借助了目录树的组织形式，一般包的名称就是其源文件所在目录的名称，虽然Go没有强制包名必须和其所在的目录名同名，但还是建议包名和所在目录同名，这样结构更清晰。包可以定义在很深的目录中，包的定义是不包括路径的，但是包的引用一般是全路径引用。比如在 $GOPATH/src/a/b 下定义一个包 c，在包 c 的源码中只需要声明为 package c，而不是声明为 package a/b/c，但是在 import 包 c 时，需要带上路径 import a/b/c。包的引用有两种形式，在下面的内容中会详细介绍。

包的习惯用法：

  • 包名一般是小写的，使用一个简短的命名。
  • 包名一般要和所在目录名同名。
  • 包一般放在公司的域名目录下，这样能保证包名的唯一性，便于共享代码。比如个人的GitHub项目的包一般放到 $GOPATH/src/github.com/userName/projectName 目录下。

2.2 工作目录（GOPATH）

Go语言的包名和文件夹(Linux系统称为目录)是一一对应的，所有与包相关的操作，必须依赖于工作目录($GOPATH)。

GOPATH 是Go语言中的一个环境变量，它使用绝对路径提供项目的工作目录。工作目录是一个工程开发的相对参考目录。GOPATH 适合处理大量Go语言源码、多个包组合而成的复杂项目。对于比较大的项目开发，如果不使用工作目录，在多人协同开发时，每个人有一套自己的目录结构，读取配置文件的位置不统一，输出的二进制运行文件也不统一，这样会导致开发的标准不统一，影响开发效率。

 <提示> C、C++、Java、C# 及其他编程语言发展到后期，都拥有自己的 IDE（集成开发环境），并且工程（Project）、解决方案（Solution）和 工作区（Workspace）等概念将源码和资源组织了起来，，方便编译和输出。

2.2.1 使用命令行查看 GOPATH 信息

在命令行下运行 go env 命令查看Go开发包的环境配置信息，这些配置信息里可以查看到当前的 GOPATH 路径设置情况。

$ go env
GO111MODULE=""
GOARCH="amd64"
GOBIN=""
GOCACHE="/home/kobe/.cache/go-build"
GOENV="/home/kobe/.config/go/env"
GOEXE=""
GOFLAGS=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOINSECURE=""
GOMODCACHE="/home/kobe/go/pkg/mod"
GONOPROXY=""
GONOSUMDB=""
GOOS="linux"
GOPATH="/home/kobe/go"
GOPRIVATE=""
GOPROXY="https://proxy.golang.org,direct"
GOROOT="/usr/local/go"
GOSUMDB="sum.golang.org"
GOTMPDIR=""
GOTOOLDIR="/usr/local/go/pkg/tool/linux_amd64"
GCCGO="gccgo"
AR="ar"
CC="gcc"
CXX="g++"
CGO_ENABLED="1"
GOMOD=""
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"
PKG_CONFIG="pkg-config"
GOGCCFLAGS="-fPIC -m64 -pthread -fno-caret-diagnostics -Qunused-arguments -fmessage-length=0 -fdebug-prefix-map=/tmp/go-build058793071=/tmp/go-build -gno-record-gcc-switches"

命令行说明如下：

  • 执行 go env 命令，将输出当前Go开发包的环境变量状态。
  • GOARCH 表示目标处理器硬件架构，这里是 x64 架构。
  • GOBIN 表示编译器和链接器的安装位置。
  • GOOS 表示目标操作系统，这里是 Linux 操作系统。
  • GOPATH 表示当前工作目录，默认是用户名主目录下的go目录，例如我的是："/home/kobe/go"。
  • GOROOT 表示Go开发包的安装目录，我这里的安装路径是："/usr/local/go"

在Go 1.8 版本之前，GOPATH 环境变量默认是空的。从Go 1.8 版本开始，Go开发包在安装完成之后，将 GOPATH 赋予了一个默认的目录，参见下表所示：

GOPATH 在不同平台上的默认路径
平台GOPATH 默认值举例
Windows 平台%USERPROFILE%\goC:\User\用户名\go
Linux/Unix 平台$HOME/go/home/用户名/go

2.2.2 使用 GOPATH 的工程结构

在 GOPATH 指定的工作目录下，代码总是会保存在 $GOPATH/src 目录下。在工程经过 go build、go install 或 go get 等命令后，会将产生的二进制可执行文件放在 $GOPATH/bin 目录下，生成的中间缓存文件会被保存在 $GOPATH/pkg 目录下。

如果需要将整个源码添加到版本控制工具（Version Control System，VCS）中时，只需要添加 $GOPATH/src 目录的源码即可。bin 和 pkg 目录的内容都可以由 src 目录生成。

2.2.3 设置和使用 GOPATH

我们以Linux平台为例，演示使用 GOPATH 的方法。

1. 设置当前目录为 GOPATH

选择一个目录，在目录中的命令行中执行下面的命令：

$ export GOPATH=`pwd`
$ echo $GOPATH
/home/kobe/go_work

使用 export 命令可以将当前目录的值设置到环境变量 GOPATH  中。

2. 建立GOPATH 的源码目录 src

使用下面的命令创建 GOPATH 中的 src 目录，在 src 目录下还有一个 hello 目录，该目录用于保存项目源码。

$ pwd
/home/kobe/go_work
$ mkdir -p src/hello
$ cd src/;ls
hello

3. 添加 main.go 源码文件

将 main.go 源码文件保存到 $GOPATH/src/hello 目录下。main.go 源码内容如下：

package main

import (
    "fmt"
)

func main() {
    fmt.Println("hello golang")
}

4. 编译源码并运行

由于此时我们已经设置好了环境变量 GOPATH，因此在Go语言中可以通过 GOPATH 找到工程的位置。在命令行中执行如下命令编译源码：

$ pwd
/home/kobe/go_work
$ go install hello    # 编译项目名
$ cd bin/;ls          # 编译完成后的可执行文件会保存在$GOPATH/bin目录下
hello
$ ./hello             # 在bin目录中执行 ./hello，命令行输出结果如下
hello golang

2.2.4 在多项目工程中使用 GOPATH

当我们有多个相互独立的项目同时进行开发时，比如说：项目A的源码保存在 /home/kobe/projectA 目录下，而项目B的源码保存在 /home/kobe/projectB 目录下。在这样的情况下，建议无论是使用命令行或者集成开发环境编译Go的项目源码时，GOPATH 跟随项目而定。在 JetBrain 公司的 GoLand 集成开发环境（IDE）中的 GOPATH 设置为全局 GOPATH 和 项目 GOPATH。

GoLand 中的 Global GOPATH 代表全局 GOPATH，一般来源于系统环境变量中的 GOPATH；Project GOPATH 代表项目所在的 GOPATH，该设置会被保存在工作目录的 .idea 目录下，不会被设置到环境变量 GOPATH 中，但会在编译时使用到这个目录。建议在开发时只填写项目 GOPATH，每一个项目尽量只设置一个 GOPATH，不要使用多个 GOPATH 和全局的 GOPATH。

2.3 包引用

标准包的源码位于 $GOROOT/src 目录下，标准包可以直接引用。自定义的包和第三方包的源码必须放到 $GOPATH/src 目录下才能被引用。

包引用路径

包的引用路径有两种写法，一种是全路径，另一种是相对路径。

  • 全路径引用

包的绝对路径就是 “$GOROOT/src 或 $GOPATH/src” 路径后包的源码路径的全路径，比如下面的包引用：

import "lab/test"
import "database/sql"
import "database/sql/driver"

test 包是自定义的包，其源码位于 $GOPATH/src/lab/test 目录下；sql 和 driver 包的源码分别位于 $GOROOT/src/database/sql 和 $GOROOT/src/database/sql/driver 下。

  • 相对路径引用

相对路径引用只用于引用 $GOPATH/src 下的包，标准包的引用只能使用全路径引用。比如下面两个包：包 a 的源码路径是 $GOPATH/src/lab/a，包 b 的源码路径为 $GOPATH/src/lab/b，假设包 b 引用了包 a，则可以使用相对路径引用方式。示例如下：

// 在包b中使用相对路径方式引用包a
import "../a"

// 在包b中使用全路径方式引用包a
import "lab/a"

包引用格式

包引用有四种格式，为叙述方便，我们以标准库中的 fmt 包为例进行说明。

  • 标准引用方式
import "fmt"

此时可以用 “fmt.” 作为前缀引用包内的可导出元素，这是常见的一种方式。例如：fmt.Println()。

  • 别名引用方式
import F "fmt"

此时相对于给包 fmt 起了一个别名 F，用 "F." 代替标准的 "fmt." 作为前缀引用 fmt 包内可导出的元素。

  • 省略方式
import . "fmt"

此时相对于把包 fmt 的命名空间直接合并到当前程序的命名空间中，使用 fmt 包内的可导出元素可以不用前缀 "fmt." ，直接引用。示例如下：

package main

import . "fmt"

func main() {
    //不需要加前缀 fmt.
    Println("hello, world")
}
  • 仅执行包初始化 init() 函数

使用标准格式引用包，但是代码中却没有使用包，编译器会报错。如果包中有 init() 初始化函数，则通过 import _ "pkgName" 这种方式引用包，仅执行包的初始化函数，即使没有 init() 函数，也不会引发编译器报错。示例如下：

import _ "fmt"

<注意事项>

  • 一个包可以有多个 init() 函数，包加载会执行全部的 init 函数，但并不能保证执行顺序，所以不建议在一个包中放入多个 init 函数，将需要初始化的逻辑放到一个 init 函数里面。
  • 包不能出现环形引用。比如：包 a 引用了包 b，包 b 引用了包 c，如果包 c 又引用了包 a，则编译不能通过。
  • 包的重复引用是允许的，比如：包 a 引用了包 b 和包 c，包 b 和 包 c 都引用了包 d，这种场景下相当于包 a 重复引用了包 d，这种情况是允许的，并且Go编译器保证包 d 的 init 函数只会执行一次。

2.4 包加载

Go程序的启动/加载过程，在执行 main.main 之前，Go引导程序会先对整个程序的包进行初始化。整个执行的流程如下图所示：

Go包的初始化
Go包的初始化

Go包的初始化有如下特点：

（1）包初始化程序从 main 函数引用的包开始，逐级检查包的引用，直到找到没有引用其他包的包，最终生成一个包引用的有向无环图。

（2）Go编译器会将有向无环图转换为一颗树，然后从树的叶子结点开始逐层向上对包进行初始化。

（3）单个包的初始化过程如上图所示，先初始化常量，然后是全局变量，最后执行包的 init 函数（如果有的话）。

示例：包导入后的 init 函数初始化顺序。创建一个Go项目 pkginit。

$ echo $GOPATH            //查看一下当前的GOPATH环境变量的值
/home/kobe/go_work
$ pwd
/home/kobe/go_work/src
$ mkdir pkginit           //在$GOPATH/src目录下创建项目目录名pkginit
$ cd pkginit              //进入项目目录下
$ mkdir pkg1 pkg2         //创建两个包名目录
$ ls
pkg1  pkg2

在 pkginit/pkg1 目录下添加源文件：pkg1.go，代码如下：

package pkg1

import (
    "fmt"
    "pkginit/pkg2"  //在包pkg1中引用了包pkg2
)

func ExecPkg1() {
    fmt.Println("ExecPkg1")
    
    pkg2.ExecPkg2()
}

func init() {
    fmt.Println("pkg1 init")
}

在 pkginit/pkg2 目录下添加源文件：pkg2.go，代码如下：

package pkg2

import "fmt"

func ExecPkg2() {
    fmt.Println("ExecPkg2")
}

func init() {
    fmt.Println("pkg2 init")
}

在 pkginit 目录下添加源文件：main.go，代码如下：

package main

import "pkginit/pkg1"     //main包中引用了pkg1包

func main() {
    pkg1.ExecPkg1()
}

查看一下 pkginit 项目的目录树结构：

$ tree -L 2 pkginit
pkginit
├── main.go
├── pkg1
│   └── pkg1.go
└── pkg2
    └── pkg2.go

2 directories, 3 files

执行编译命令并运行，在命令行执行命令如下：

$ go install pkginit
$ cd ~/go_work/bin/;ls     #可以看到，在$GOPATH/bin目录下生成了可执行文件pkginit
pkginit
$ ./pkginit                #执行可执行文件
pkg2 init
pkg1 init
ExecPkg1
ExecPkg2

《代码说明》从运行结果可以看出，包的引用关系为: main-->pkg1-->pkg2，那么这些包的 init() 函数的调用顺序为: pkg2.init()-->pkg1.init()-->main。

3 第三方包管理 —— go module

Go语言的包由于采用目录布局的方式，在管理工程自身源码方面结合版本控制工具很方便，没有任何问题。现代软件工程一个很重要的理念就是代码复用，在软件项目开发中不可能完全基于标准库构建，会使用大量第三方的包和工具。Go语言开发的工程中引用大量第三方库也是一个很普遍的现象。

使用 go get 命令可以轻易地下载并安装第三方的库到本地，但这只是第一步。如果第三方库更新，并且新旧版本不兼容怎么办？因此，Go开发人员迫切需要对第三方库进行精细管理，也就是对项目工程使用的第三方库的版本做精确的管控。

谷歌公司采用的是集中式的版本管理，身在谷歌的Go核心开发人员并不能体会到其他Go开发人员对包的版本管理功能的迫切需求。在很长一段时间内，Go官方并没有第三方包管理的解决方案，直到 Go 1.5 版本引入了 vendor，为Go外部包的管理提供了有限的支持。在Go 1.11 和 Go 1.12 版本中引入了 Go Modules 机制，提供了统一的依赖包管理工具 go mod，依赖包统一收集在 $GOPATH/pkg/mod 中进行集中管理，并且将 import 路径与项目代码的实际存放路径解耦，使 package 定义导入更加灵活。

而从 Go 1.13 版本(released 2019/09/03)开始，Go Modules 机制成为了默认的依赖包管理方法。因此，这里我们只介绍目前最新的 go modules 包管理机制。

待续 ......

参考

《Go语言核心编程》

《Go语言从入门到进阶实战(视频教学版)》

 

yunfan188
关注
  • 3
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Go语言包 package
TCatTime的博客
06-19 982
Go语言包package介绍。
Golang的命名规范
LJFjy_fighting的博客
05-12 2552
除了保留关键字之外，Golang语言系统还提供了36个预定义标识符，包括基础数据类型和系统内嵌函数（不需要引入包，可以直接使用的函数）。预定义标识符预定义标识符预定义标识符预定义标识符预定义标识符预定义标识符appendboolbytecapclosecomplexcomplex64complex128uint16copyfalsefloat32float64imagintint8int16uint32int32int64itoalenmake。
3、go的package介绍和使用
rui_rui96的博客
06-26 4604
go的package使用
Go语言-【包package】-包的基本概念
xyz的专栏
09-01 695
Go语言是使用包来组织源代码的，包（package）是多个 Go 源码的集合，是一种高级的代码复用方案。Go语言中为我们提供了很多内置包，如 fmt、os、io 等。 任何源代码文件必须属于某个包，同时源码文件的第一行有效代码必须是package pacakgeName语句，通过该语句声明自己所在的包。 包的基本概念 Go语言的包借助了目录树的组织形式，一般包的名称就是其源文件所在目录的名称，虽然Go语言没有强制要求包名必须和其所在的目录名同名，但还是建议包名和所在目录同名，这样结构更清晰。 包可以定.
2024年Go最全go语言多package使用实战_golang 多个package(1)，经典Golang开发教程
最新发布
2401_84905010的博客
05-15 313
不过这里仍有点不明白，不清楚go查找包到底是怎么起作用的，先记录下吧。
Go-package
袋鼠的博客
06-26 1209
在 GOPATH 下查包，在 GOMOD 下查包，多个init 方法，go get 拉取远程，提交自己的 package 到 github
4.2 Go语言中包(Packages)的命名
老孙正经胡说
07-18 1878
本节介绍Go语言包的命名并继续使用示例讲述包名与目录的关系。
golang短变量命名空间问题
陈戏猿
10-21 855
场景一 package main func main() { a := 1 println(&a) a, b := 2, true println(b) println(&a) } /** 结果 0xc000085f48 true 0xc000085f48 */ 分析：由于在相同的命名空间下，a, b := 1, true中的变量a并没有覆盖掉之前定义的a变量，仅仅是创建了变量b。如果将b换成_，上面的代码会报:=没有新变量产生的错误，也可佐证。 场景二 package mai
package-managers：各种编程语言与包管理工具
02-04
Go语言内置了go get命令，用于下载和安装Go包及其依赖。这个命令简单易用，能直接从GitHub等源获取代码，然后编译和安装到本地的GOPATH。 7. **C#/.NET - NuGet** .NET开发人员使用NuGet来管理和分享.NET框架的库...
Go-glide-Golang的包管理器
08-14
Go语言在早期版本中并未内置包管理工具，这使得在大型项目中管理依赖变得相对复杂。为了解决这个问题，社区开发了多个第三方包管理器，其中glide是早期较为流行的一个。glide是由Masterminds团队开发的，它的目标是...
Go-gopm-Go包管理器
08-14
`gopm`是一款为Go语言设计的独立包管理器和构建工具，它旨在简化Go项目的依赖管理和构建流程。与`go mod`相比，`gopm`在早期提供了图形化的界面和更直观的命令行操作，对于初学者或者习惯传统包管理方式的开发者来说...
Go-gom-Go包管理器
08-14
本文将深入探讨"gom"——一个Go语言的包管理器。 ### 一、Go语言的包管理系统 Go语言原生的包管理方式是基于`go mod`（Go Modules）系统，它允许开发者明确指定项目依赖，并且在构建时自动下载和管理这些依赖。...
gopkgvc:golang package version control - go语言的企业内部版本控制工具
05-17
gopkgvcIntroductiongopkgvcgo包的版本管理工具，基于 开发。主要用于企业内部包管理。现支持 （gitlab）等仓库的版本管理。ScreenshotTODO该程序仅实现了 http 协议，如需要 https 功能，需结合 nginx 等代理工具...
Go package
CAir2的专栏
03-07 679
磨刀不误砍柴工 在实现自定义package文件之前，我们先了解一下GOROOT和GOPATH。 GOROOT 指向系统安装路径 GOPATH指向工作路径 其中Go语言源代码和编译的中间文件、目标文件存放位置如下： C:\Go &lt;&lt;--- GOROOT 指向的位置 --src &lt;&lt;--- Go 语言自带的源代码 --p...
go package详解
studypi的专栏
08-17 2297
package是go语言程序组成的单位，可以引用自身或者其它的包的内容。一个包下面有很多.go文件，每个.go文件仅属于一个包。文件名可以与包名不重复，与Python类似。 导入包用关键字 “[color=red]import[/color]” [code="java"]import "fmt" import "io"[/code] 或者： [code="java"]import ( ...
golang标识符以及golang包的命名原则
qq_27464987的博客
10-19 1459
标识符以及golang包的命名原则 标识符的定义 标识符（identifier）是指用来标识某个实体的一个符号，在不同的应用环境下有不同的含义。在计算机编程语言中，标识符是用户编程时使用的名字，用于给变量、常量、函数、语句块等命名，以建立起名称与使用之间的关系。 go语言中的变量，函数，以及包名等都属于标志符的一种。 包的命名规则 （1）包名尽可能与它所在的目录名保持一致，不要与标准库进行冲突。 （2）带有main函数的包必须将其package定义为main，这样才能用go run去运行文件，go bui
go语言之package
weixin_44961320的博客
01-19 1000
1、关于包 包（package）是多个Go源码的集合，是一种高级的代码复用方案，Go语言为我们提供了很多内置包，如fmt、os、io等。 2、包定义 我们还可以根据自己的需要创建自己的包。一个包可以简单理解为一个存放.go文件的文件夹。 该文件夹下面的所有go文件都要在代码的第一行添加如下代码，声明该文件归属的包。 package 包名 3、包的可见性 如果想在一个包中引用另外一个包里的标识符（如变量、常量、类型、函数等）时，该标识符必须是对外可见的（public）。在Go语言中只需要将标识
Go（8）--工程管理
wang_zhao_的博客
05-21 281
工程管理1. 编程环境1.1 工程结构1.1.1 环境变量1.1.2 工作目录1.2 交叉编译2. 命名空间和作用域2.1 命名空间2.2 作用域2.3 变量覆盖3. 包的基本概念3.1 基本概念3.2 包引用3.3 包加载4. 第三方包管理4.1 vendor4.2 dep 1. 编程环境 1.1 工程结构 1.1.1 环境变量 $GOROOT       $GOROOT是Go的安装根目录。 $GOPATH   &nb
Go学习：包（package)
baidu_34933057的博客
11-14 349
Go语言包学习
go语言导入包的关键字是package 还是 import
05-24
Go语言导入包的关键字是`import`，`package`是用于定义当前文件所属的包名的关键字。在Go语言中，每个文件都必须属于一个包，而导入其他包则使用`import`关键字。例如： ``` package main import ( "fmt" ) func main() { fmt.Println("Hello, world!") } ``` 在上面的代码中，`import`关键字用于导入标准库中的`fmt`包，以便在`main`函数中使用`fmt.Println`函数输出内容。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值