golang安装与使用

环境准备

windows安装

下载地址：https://studygolang.com/dl
下载：go1.18.10.windows-amd64.msi

环境配置

1. GOROOT：Go 的安装目录，表示 Go 编译器和工具的路径。这个路径包含 Go 标准库和编译器二进制文件。
2. GOPATH：传统的Go 工作区路径，表示存储 Go 项目和依赖包的地方。
   GOPATH 通常有以下三个子目录：
   src：源代码目录，存放你的项目和依赖包的源码。
   pkg：编译后的依赖包文件目录。
   bin：go install编译后可执行文件的存放目录。
3. GOBIN：即GOPATH的bin目录。
4. GOPROXY：如果不设置 GOPROXY，Go 会直接从源代码仓库（如 GitHub）下载依赖模块。
   默认值：GOPROXY=https://proxy.golang.org,direct
   这意味着：https://proxy.golang.org 是第一个模块代理；如果代理不可用，Go 会尝试直接从模块的源仓库获取（direct）。

   # 阿里云代理
   go env -w GOPROXY=https://mirrors.aliyun.com/goproxy/,direct
   

Go Modules

• Go 新型依赖管理系统，从 Go 1.11 开始引入，在 Go 1.16 后成为默认模式。
• 摆脱了对 GOPATH 的依赖，不用过分关注GOPATH的目录，GOPATH主要用作依赖缓存的路径。
• 允许项目代码存放在任意位置，并通过go.mod文件管理依赖。go.mod: 定义模块名称和依赖信息;go.sum: 记录模块的依赖版本和校验完整性。

go命令行工具

go version：查看版本。
go env：查看环境变量。
go get：下载并安装模块或依赖。
go run：编译并执行 Go 源代码文件。

# 只编译并运行指定的文件。
# 注意：如果项目中有多个源文件（如 main.go 和其他实现文件），而你只运行了 go run main.go，可能导致部分文件未包含在编译中。
go run main.go
# 在当前模块下运行
go run .

go build：编译 Go 源代码文件或模块并生成可执行文件。
go install：编译并将可执行文件安装到 $GOBIN 目录（或默认的 $GOPATH/bin）。
go clean：清理临时的编译文件、缓存等。

go mod命令行工具

go mod init：初始化当前目录为一个模块，并生成 go.mod 文件。

# 唯一标识模块
# 模块路径：对应的正是 go.mod 文件中的 module 声明部分。
# 1. 共有仓库/私有仓库：通常使用代码托管服务的完整路径
# 2. 本地路径：对于未托管在代码仓库中的项目，可以使用简单的逻辑名称或路径
go mod init <模块路径>

go mod tidy：清理模块依赖，删除未使用的模块并添加遗漏的依赖。
go mod edit：直接修改 go.mod 文件（添加、移除或更改依赖）。

• go mod edit -require=path@version：添加指定模块依赖。
• go mod edit -droprequire=path：删除指定模块依赖。
• go mod edit -replace=oldPath@oldVersion=newPath@newVersion：替换依赖路径或版本。

开发工具

使用GoLand新建一个项目
File->setting->Go

1. 配置GOROOT为你要使用的Go版本
2. 配置Go Modules Environment增加阿里云代理

go语法

基础数据类型

go	java	说明
bool	boolean	布尔类型，Go 中是 bool，Java 中是 boolean。
int	int	整型类型，在 Go 中 int 是平台相关的（32 位或 64 位），Java 中是固定的 32 位。
int8	byte	8 位有符号整数，Go 中是 int8，Java 中是 byte（范围 -128 到 127）。
int16	short	16 位有符号整数，Go 中是 int16，Java 中是 short（范围 -32,768 到 32,767）。
int32	int	32 位有符号整数，Go 中是 int32，Java 中是 int（范围 -2,147,483,648 到 2,147,483,647）。
int64	long	64 位有符号整数，Go 中是 int64，Java 中是 long（范围 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807）。
uint	无对应类型	Go 中的无符号整数类型，Java 没有直接对应的类型。通常使用 long 或 BigInteger 来处理无符号整数。
uint8	byte	8 位无符号整数，Go 中是 uint8，Java 中是 byte（范围 0 到 255）。
uint16	char	16 位无符号整数，Go 中是 uint16，Java 中是 char（范围 0 到 65,535）。
uint32	无对应类型	Go 中的 32 位无符号整数，在 Java 中没有直接对应的类型，通常使用 long 或 BigInteger。
uint64	无对应类型	Go 中的 64 位无符号整数，Java 中通常使用 long 或 BigInteger 来处理。
float32	float	单精度浮点数，Go 中是 float32，Java 中是 float。
float64	double	双精度浮点数，Go 中是 float64，Java 中是 double。
complex64	无对应类型	Go 中的复数类型，由 float32 组成。Java 没有内建复数类型，可以使用外部库或自定义类来表示复数。
complex128	无对应类型	Go 中的复数类型，由 float64 组成，Java 也没有内建复数类型。

字符串类型

go	java	说明
string	String	字符串类型，Go 和 Java 中都表示字符的序列。在 Go 中，字符串是不可变的，类似于 Java 中的 String。

数组和切片

go	java	说明
array	array	Go 和 Java 都支持数组类型，Go 中的数组是固定大小的，Java 中的数组也是固定大小的。
slice	List 或 ArrayList	Go 的切片（slice）是动态数组，类似于 Java 中的 List 或 ArrayList。切片是 Go 中数组的动态扩展。

映射类型（字典）

go	java	说明
map	Map	Go 的 map 类型和 Java 的 Map 类型类似，都用于存储键值对。在 Java 中常用的实现包括 HashMap 和 TreeMap。

结构体与接口

go	java	说明
struct	class	Go 中的 struct 与 Java 中的 class 类似，但 Go 不支持继承、构造方法和类成员变量的默认值。Go 中的 struct 用于组合不同的字段，可以包含方法和接口实现。
interface	interface	Go 和 Java 都支持接口类型，Go 接口的实现是隐式的，而 Java 中接口的实现是显式的。

常量

const Pi = 3.14159
const Greeting = "Hello, World!"

const (
    Red   = "red"
    Green = "green"
    Blue  = "blue"
)

枚举

1. 使用常量实现枚举

// 定义一个名为 Color 的新类型，底层类型是 int32
type Color int32

// 使用 const 定义具体的枚举值。
const (
	// iota 是一个递增的常量生成器，从 0 开始
	Red Color = iota
	Green
	Blue
)

2. 结合map实现枚举值到字符串的映射

// 枚举值到字符串的映射
var ColorMsg = map[Color]string{
	Red:   "red",
	Green: "green",
	Blue:  "blue",
}

func getMsgByColorCode(code int32) (string, bool) {
	color := Color(code)
	colorMsg, exist := ColorMsg[color]
	return colorMsg, exist
}

func main {
	if colorMsg, exist := getMsgByColorCode(2); exist {
		fmt.Println("color=>", colorMsg)
	}
}

3. 结合swith实现不同枚举值的不同处理

// 配合switch 实现校验功能
func isValidColor(code int32) bool {
	color := Color(code)
	switch color {
	case Red, Green, Blue:
		fmt.Println("current color:", color)
		return true
	default:
		fmt.Println("unknown")
		return false
	}
}

func main {
	if isValidColor(4) {
		fmt.Println("valid color.")
	} else {
		fmt.Println("invalid color.")
	}
}

指针

• 指针类型：*T 表示指向类型 T 的指针。
• 取地址操作符：& 用于获取变量的地址。
• 解引用操作符：* 用于访问指针指向的值。

func main() {
    // 定义普通变量
    var x int = 42

    // 获取变量的地址
    var p *int = &x

    // 打印变量的值和地址
    fmt.Println("x:", x)       // 输出: x: 42
    fmt.Println("Address of x:", p) // 输出: Address of x: 0xc0000120a8 (地址值可能不同)

    // 通过指针修改值
    *p = 21
    fmt.Println("Modified x:", x) // 输出: Modified x: 21
}

1. 使用指针创建结构体的实例

// 定义结构体
type Person struct {
    Name string
    Age  int
}

func main() {
    // 先创建一个值，不是指针
    p := Person{"Alice", 25}
    // 获取值的指针
    ptr := &p
    // 或者 直接创建一个指针
   	//p := &Person{"Alice", 25}
	//fmt.Println(p1)

    // 修改结构体字段
    ptr.Age = 30

    // 访问结构体字段
    fmt.Println("Name:", ptr.Name) // 输出: Name: Alice
    fmt.Println("Age:", ptr.Age)   // 输出: Age: 30
}

2. 使用关键字new返回一个指向指定类型零值（默认值）的指针

// 定义结构体
type Person struct {
    Name string
    Age  int
}

func main() {
    // 创建一个指针，类型是空值，等价于&Person{}
	p3 := new(Person)
	// 或者 直接创建一个零值指针
	//p4 := &Person{}
	//fmt.Println(p4)

	// 修改结构体字段
	p3.Name = "jack"
	p3.Age = 30

	// 访问结构体字段
	fmt.Println("Name:", p3.Name) // 输出: Name: jack
	fmt.Println("Age:", p3.Age)   // 输出: Age: 30
}