Golang 【basic_leaming】1 基本语法

桃扇骨 2023-10-07 22:17 33阅读 0赞

#### 阅读目录 ####

*  Go 语言变量
 *   *  Go 语言 - 声明变量
     *   *  1. 标准格式
         *  2. 批量格式
     *  Go 语言 - 初始化与定义变量
     *   *  1. 标准格式
         *  2. 编译器推导类型格式
         *  3. 短变量声明与初始化
     *  Go语言 - 多变量同时赋值
     *  Go 语言 - 匿名变量
     *  参考资料
 *  Go 语言整型（整数类型）
 *   *  1 自动匹配平台的 int 和 unit
     *  1.1、什么情况要使用 int 和 unit
     *  2 整数类型 uintptr
 *  Go 语言浮点型 (小数类型)
 *   *  浮点型 Float32
     *  浮点型 Float64
     *  浮点数精度
     *  打印浮点数
 *  Go 语言布尔型 (bool)
 *   *  关于布尔型类型转换
 *  Go 语言字符串
 *   *  1 计算字符串的长度
     *  2 遍历字符串
     *  2.1 遍历每一个 ASCII 字符
     *  2.2 按 Unicode 字符遍历字符串
     *  3 获取字符串某一段字符
     *  4 修改字符串
     *  5 拼接字符串
     *  6 字符串比较
     *  7 字符串转义符
     *  8 定义多行字符串
     *  9 Go 语言字符串格式化常用动词
 *  Go 语言字符（byte与rune）
 *   *  UTF-8 和 Unicode 有何区别？
 *  参考资料:整型、浮点型、布尔型、字符串、Go 语言字符（byte与rune）
 *  Go 语言常量定义与声明 (const)
 *   *  1 Go 语言常量定义 & 声明
     *  2 定义多个 Go 语言常量
     *  3 iota 常量生成器生成枚举
 *  Go 语言枚举类型（iota自增）
 *   *  1 Go 语言定义枚举类型
     *  2 Go 语言枚举值转换字符串
 *  Go 语言指针
 *   *  1 什么是指针
     *  2 Go 语言指针
     *  3 C/C++中的指针
     *  4 Go 语言指针地址和指针类型
     *  5 获取指针指向的值
     *  6 使用指针修改值
     *  7 通过 new() 函数来创建指针

## Go 语言变量 ##

编程中可以说最常见的就是变量了，主要被用来存储各种类型数据。

关于变量的类型，主要有:

*  整型
 *  浮点型
 *  布尔型
 *  结构体
 *  …

Go 语言中不同类型的变量，需要先声明，才能够被使用。

### Go 语言 - 声明变量 ###

#### 1. 标准格式 ####

Go 语言中声明变量需以 `var` 关键字开头，变量名放在中间，变量类型放在最后。

var 变量名 变量类型

> 注意： 行尾无分号 `;` 。

下面是 Go 语言常见的基本变量声明:

// 声明一个整型的变量，被用来保存整数数值
    var a int                 
    
    // 声明一个字符串类型的变量
    var b string   
    
    // 声明一个 32 位浮点切片类型的变量          
    var c []float32       
    
    // 声明一个返回值为布尔型的函数变量，将函数以变量的形式保存起来    
    var d func() bool    
    
    // 声明一个结构体类型的变量，结构体中声明了一个整型的 `f` 变量     
    var e struct {
                    
    	f int
    }

#### 2. 批量格式 ####

若觉得每次前面都要定义 `var` 非常繁琐, 还可以通过 `var` 和括号来批量声明：

var (
    	a int
    	b string
    	c []float32
    	d func() bool
    	e struct {
        
    		f int
    	}
    )

### Go 语言 - 初始化与定义变量 ###

Go 语言中，初始化变量有如下几种写法：

#### 1. 标准格式 ####

var 变量名 变量类型 = 变量值

例如想初始化一个人的年龄，可以这样写：

// 初始化一个整型，变量名为 age, 初始值为 18 的变量
    var age int = 18

#### 2. 编译器推导类型格式 ####

我们还可以在上述格式的基础上，再精简点：

var age = 18

无需定义 **变量类型**，编译器会根据等号右边的变量值，来推断 `age` 的变量类型。

#### 3. 短变量声明与初始化 ####

还可以在第二种的基础上，再做简化：

age := 18

这也是 Go 语言中变量推导的一种写法，但是与上面不同的是：

注意： 因为使用了 `:=` , 而不是赋值的 `=`, 这就限制了**等号左边的变量名必须是没有定义过的变量名，否则将会发生编译错误。**

举个反例，代码如下：

// 声明一个整型 age 变量
    var age int
    
    // 再次声明与赋值
    age := 18

编译报错如下：no new variables on left side of :=

![在这里插入图片描述][ff74b193c6734572bc4f1f6fc60113fb.png]

> PS: 报错信息意思表示：`:=` 左边的变量已经被声明了。

### Go语言 - 多变量同时赋值 ###

假设这样一个场景，需要交互互相两个变量的值，先看看传统的写法：

var a int = 100  // 定义变量 a
    var b int = 200  // 定义变量 b
    var c int        // 定义一个中间变量
    
    // 开始互相交互 a 与 b 变量的值
    c = a
    a = b
    b = c
    
    fmt.Println(a, b)

为了达到交换后数据的正确性，通常都需要定义一个临时中间变量来做中转，如上所示。

代码输出结果：200 100

但是，在 Go 语言中利用**多重赋值的特性**，还可以这样写：

var a int = 100
    var b int = 200
    
    a, b = b, a
    fmt.Println(a, b)

代码运行结果同样是：200 100

### Go 语言 - 匿名变量 ###

**匿名变量就是一个没有名字的变量**，通常用下划线 `_` 来表示。

这玩意什么场景下会用到呢？

举个例子，假设有这种场景，需要调用某个函数 `findStudent()`，来查询数据库中某个学生的数据，函数会返回两个数值，分别是：

*  学生姓名；
 *  学生年龄；

但是呢，我们只需要获取学生的姓名就行了，年龄并不需要，但是又不想为其单独声明一个变量，这时**匿名变量**就有用武之地了：

func findStudent() (string, int) {
        
      return "犬小哈", 100
    }
    
    name, _ := findStudent()
    
    fmt.Println(name)

代码输出：犬小哈

> 注意： 匿名变量不占用命名空间，也不会占用内存。匿名变量与匿名变量直接不会因为多次声明而无法使用。

### 参考资料 ###

[Golang 【basic\_leaming】变量、常量、变量命名规则][Golang _basic_leaming]

![在这里插入图片描述][a7ba4abadde1446b9dd5f1b2cc5cc9ed.png]

## Go 语言整型（整数类型） ##

在 Go 语言中，整型分为以下两个大类：

*  有符号类型，按长度分为: int8 、int16、int32、int64
 *  无符号类型，与上面对应的分别是: uint8、uint16、uint32、uint64

> PS: 这里 unit8 就是我们熟知的 byte型，int16 对应 C 语言中的 short型，int64对应 C 语言中的 long 类型。

### 1 自动匹配平台的 int 和 unit ###

看了上面这些类型，你可能在想，这也太繁琐了，有没有一种类型，它能根据平台 CPU 机器字节大小来调整长度呢？

有的，那就是：

*  有符号类型: int
 *  无符号类型： uint

这里 `int` 是应用最广泛的数值类型。

这两种类型都有同样的大小，32 或 64bit，但是我们不能对此做任何的假设, 因为不同的编译器即使在相同的硬件平台上可能产生不同的大小。

### 1.1、什么情况要使用 int 和 unit ###

实际应用中，切片或者 `map` 的元素数量均可通过 `int` 来表示。

但是，在二进制传输、读写文件的结构描述时，为了保证文件的结构不受不同编译目标平台的字节长度影响，不要使用 int 和 unit。

### 2 整数类型 uintptr ###

最后，还有一种无符号的整数类型 uintptr，它没有指定具体的 bit 大小但是足以容纳指针。uintptr 类型只有在底层编程时才需要，特别是 Go 语言和 C 语言函数库或操作系统接口相交互的地方。

尽管在某些特定的运行环境下 int、uint 和 uintptr 的大小可能相等，但是它们依然是不同的类型，比如 int 和 int32，虽然 int 类型的大小也可能是 32 bit，但是在需要把 int 类型当做 int32 类型使用的时候必须显示的对类型进行转换，反之亦然。

Go 语言中有符号整数采用 2 的补码形式表示，也就是最高 bit 位用来表示符号位，一个 n-bit 的有符号数的取值范围是从 -2(n-1) 到 2(n-1)-1。无符号整数的所有 bit 位都用于表示非负数，取值范围是 0 到 2n-1。例如，int8 类型整数的取值范围是从 -128 到 127，而 uint8 类型整数的取值范围是从 0 到 255。

## Go 语言浮点型 (小数类型) ##

Go 语言中提供了两种精度浮点型 float32 和 float64。

这两种浮点型数据格式遵循 IEEE754 浮点数国际标准，该浮点数规范被所有现代的CPU支持。

### 浮点型 Float32 ###

float32，即我们常说的单精度，存储占用4个字节，也即 4\*8=32 位，其中 1 位用来符号，8 位用来指数，剩下的 23 位表示尾数。

### 浮点型 Float64 ###

float64, 即我们熟悉的双精度，存储占用8个字节，也即8\*8=64位，其中1位用来符号，11位用来指数，剩下的52位表示尾数。

### 浮点数精度 ###

float32 的浮点数最大值约为 3.4e38, 可以通过 `match` 包的方法来获取: `match.MaxFloat32`。

float64 的浮点数最大值约为 1.8e308, 可以通过 `match` 包的方法来获取： `match.MaxFloat64`。

它们分别能表示的最小值近似为 1.4e-45 和 4.9e-324。

一个 float32 类型的浮点数可以提供大约 6 个十进制数的精度，而 float64 则可以提供约 15 个十进制数的精度；

通常应该优先使用 float64 类型，因为 float32 类型的累计计算误差很容易扩散，并且 float32 能精确表示的正整数并不是很大（注意：因为float32的有效bit位只有23个，其它的bit位用于指数和符号；

当整数大于 23bit 能表达的范围时，float32的表示将出现误差）：

var f float32 = 16777216 // 1 << 24
    fmt.Println(f == f+1)    // "true"!

浮点数的字面值可以直接写小数部分，如下所示：

const e = 2.71828

小数点前面或后面的数字都可能被省略（例如.707或1.）。  
很小或很大的数最好用科学计数法书写，通过e或E来指定指数部分：

const Avogadro = 6.02214129e23  // 阿伏伽德罗常数
    const Planck   = 6.62606957e-34 // 普朗克常数

### 打印浮点数 ###

通过 `Printf` 函数打印浮点数时, 可以使用 `“%f”` 来控制保留几位小数, 代码如下：

package main
    
    import (
    	"fmt"
    	"math"
    )
    
    func main() {
        
    	// 打印默认宽度和精度的圆周率， \n 为换行符
    	fmt.Printf("%f\n", math.Pi)
    
    	// 打印默认宽度, 精度（小数点后的位数)为2的圆周率
    	fmt.Printf("%.2f\n", math.Pi)
    }

运行结果如下：

3.141593
    3.14

## Go 语言布尔型 (bool) ##

在 Go 语言中，以关键字 bool 来声明布尔类型。  
布尔类型只有 true 和 false 两种值。

if 和 for 语句的条件部分都是布尔类型的值，并且 `==` 和 `<` 等比较操作也会产生布尔型的值。

一元操作符 `!` 对应逻辑非操作，因此 `!true` 的值为 `false`，更罗嗦的说法是`(!true==false)==true`，虽然表达方式不一样，不过我们一般会采用简洁的布尔表达式，就像用 x 来表示 `x==true`。

布尔值可以和 &&（AND）和 ||（OR）操作符结合，并且有短路行为：  
如果运算符左边值已经可以确定整个布尔表达式的值，  
那么运算符右边的值将不再被求值，因此下面的表达式总是安全的：

s != "" && s[0] == 'x' 
    // 其中s[0]操作如果应用于空字符串将会导致 panic 异常。

因为 && 的优先级比 || 高（PS：&&对应逻辑乘法，|| 对应逻辑加法，乘法比加法优先级要高），下面形式的布尔表达式是不需要加小括弧的：

if 'a' <= c && c <= 'z' ||
        'A' <= c && c <= 'Z' ||
        '0' <= c && c <= '9' {
        
        // ...ASCII letter or digit...
    }

### 关于布尔型类型转换 ###

Go 语言中布尔类型无法参与数值运算，也无法与其他类型进行转换 ：

package main
    
    import "fmt"
    
    func main()  {
        
    	var a bool
    	fmt.Print(int(a) * 2) 
    	// 将变量 a 强制转换为 int 类型，并乘以 2
    }

![在这里插入图片描述][dc479b55daf24554a05b29b75543b361.png]  
运行上面的代码，会发生编译错误:

cannot convert a (type bool) to type int  
无法将 bool 类型转换为 int 类型

## Go 语言字符串 ##

在 Go 语言中，字符串是一个不可改变的字节序列，类型为原生数据类型，同 int 、bool 、float32 、float64 是一样的。

**字符串的值通过双引号来包裹**，Go 语言中，我们可以直接添加非 ASCII 码字符, 代码如下：

str := "zhiqihei,shouqibai"
    ch := "知其黑、受其白"

### 1 计算字符串的长度 ###

Go 语言内置的 `len()` 函数可以获取切片、字符串、通道(channel) 等的长度。

package main
    
    import "fmt"
    
    func main()  {
        
      str1 := "zhiqihei,shouqibai"
      fmt.Println(len(str1))
      
      str2 := "知其黑、受其白"
      fmt.Println(len(str2))
    }

代码运行结果如下：

PS E:\golang\src> go run .\main.go
    18
    21
    PS E:\golang\src>

`len()` 函数返回值为 int 类型，表示字符串的 ASCII 字符的个数或字节长度。

你可能会奇怪，字符串 str2 的长度居然是21，这是因为 Go 语言的字符串都以 UTF-8 格式保存，每个中文占用 3 个字节，所以 7 ✖️ 3 = 21 个字节。

如果希望按照习惯上的字符个数类计算，可以使用 UTF-8 包提供的 `RuneCountInString()` 来统计 Uncode 字符数量：

package main
    
    import (
    	"fmt"
    	"unicode/utf8"
    )
    
    func main() {
        
    	str2 := "知其黑、受其白"
    	fmt.Println(utf8.RuneCountInString(str2))
    }

PS E:\golang\src> go run .\main.go
    7
    PS E:\golang\src>

注意: `i` 必须满足 `0 ≤ i< len(str)` 条件约束。如果试图访问超出字符串索引范围的字节将会导致 `panic` 异常：

c := str[len(str)] // panic: index out of range

### 2 遍历字符串 ###

遍历字符串有如下两种写法：

### 2.1 遍历每一个 ASCII 字符 ###

遍历 ASCII 字符通过 for 循环来，使用字符串的下标来获取，代码如下：

package main
    
    import "fmt"
    
    func main() {
        
    	str := "知其黑，受其白 wgchen.blog.csdn.net/"
    
    	for i := 0; i < len(str); i++ {
        
    		fmt.Printf("ascii: %c %d\n", str[i], str[i])
    	}
    }

PS E:\golang\src> go run .\main.go
    ascii: ç 231
    ascii: Ÿ 159
    ascii: ¥ 165
    ascii: å 229
    ascii: 
     133
    ascii: ¶ 182
    ascii: é 233
    ascii: » 187
    ascii: ‘ 145
    ascii: ï 239
    ascii: ¼ 188
    ascii: Œ 140
    ascii: å 229
    ascii:  143
    ascii: — 151
    ascii: å 229
    ascii: 
     133
    ascii: ¶ 182
    ascii: ç 231
    ascii: ™ 153
    ascii: ½ 189
    ascii:   32
    ascii: w 119
    ascii: g 103
    ascii: c 99
    ascii: h 104
    ascii: e 101
    ascii: n 110
    ascii: . 46
    ascii: b 98
    ascii: l 108
    ascii: o 111
    ascii: g 103
    ascii: . 46
    ascii: c 99
    ascii: s 115
    ascii: d 100
    ascii: n 110
    ascii: . 46
    ascii: n 110
    ascii: e 101
    ascii: t 116
    ascii: / 47
    PS E:\golang\src>

可以看到，由于没有使用 Unicode 编码，汉字部分全部为乱码。

### 2.2 按 Unicode 字符遍历字符串 ###

Unicode 字符遍历使用 `for range:`

package main
    
    import "fmt"
    
    func main() {
        
    	str := "知其黑，受其白 wgchen.blog.csdn.net/"
    
    	for _, s := range str {
        
    		fmt.Printf("Unicode: %c %d\n", s, s)
    	}
    }

PS E:\golang\src> go run .\main.go
    Unicode: 知 30693
    Unicode: 其 20854
    Unicode: 黑 40657
    Unicode: ， 65292
    Unicode: 受 21463
    Unicode: 其 20854
    Unicode: 白 30333
    Unicode:   32
    Unicode: w 119
    Unicode: g 103
    Unicode: c 99
    Unicode: h 104
    Unicode: e 101
    Unicode: n 110
    Unicode: . 46
    Unicode: b 98
    Unicode: l 108
    Unicode: o 111
    Unicode: g 103
    Unicode: . 46
    Unicode: c 99
    Unicode: s 115
    Unicode: d 100
    Unicode: n 110
    Unicode: . 46
    Unicode: n 110
    Unicode: e 101
    Unicode: t 116
    Unicode: / 47
    PS E:\golang\src>

可以看到，中文正常显示了。

### 3 获取字符串某一段字符 ###

可以通过 `str[i:j]` 基于原始的 `str` 字符串的第 `i` 个字节开始到第 `j` 个字节（并不包含 `j` 本身）生成一个新字符串。生成的新字符串将包含 `j-i` 个字节。

package main
    
    import (
    	"fmt"
    	"strings"
    )
    
    func main() {
        
    	str := "wgchen.blog.csdn.net"
    
    	fmt.Println(str[0:1]) // 输出 w
    
    	// 通过 strings.Index() 函数获取字符 . 的下标
    	index := strings.Index(str, ".")
    	fmt.Println(str[0:index]) // 输出 wgchen
    }

同样，如果索引超出字符串范围或者j小于i的话将导致 `panic` 异常。

不管 `i` 还是 `j` 都可以不填写，若不填写，将采用 `0` 作为开始位置，采用`len(s)` 作为结束的位置。

package main
    
    import (
    	"fmt"
    )
    
    func main() {
        
    	str := "wgchen.blog.csdn.net"
    	fmt.Println(str[:10]) // "wgchen.blo"
    	fmt.Println(str[11:]) // ".csdn.net"
    	fmt.Println(str[:])   // "wgchen.blog.csdn.net"
    }

补充知识点：

*  `strings.Index`: 正向搜索子字符串，并获取下标位置；
 *  `strings.LastIndex`: 反向搜索子字符串，并获取下标位置；

### 4 修改字符串 ###

Go 语言中，无法直接修改字符串中的字符，只能通过重新构造一个新的字符串并赋值给原来的字符串实现：

package main
    
    import (
    	"fmt"
    )
    
    func main() {
        
    	str := "wgchen.blog.csdn.net"
    
    	// 将字符串转换为字符串数组
    	strBytes := []byte(str)
    
    	// 将 .com 替换为空格
    	for i := 10; i < len(str); i++ {
        
    		strBytes[i] = ' '
    	}
    
    	fmt.Println(string(strBytes))
    	// wgchen.blo
    }

看上面的代码，貌似我们是直接通过修改字符串而达到的目的，其实真实的情况是，同 Java、C\# 一样，字符串默认是不可变的。

不可变有很多好处，如天生的线程安全，大家使用的都是只读的，并发情况下，省去了加锁的开销；

另外，方便内存共享，而不必使用写时复制（Copy On Write）等技术；  
字符串 hash 值也只需要制作一份。

所以说，上面代码实际修改的是 `[]byte, []byte` 在 Go 语言中是可变的，它本身就是个切片。

代码中最后打印输出时，实际上通过 string() 将 \[\]byte 转为字符串，重新创造了一个新的字符串。

总结：

*  Go 语言中字符串是不可变的；
 *  修改字符串时，可以将字符串转换成 `[]byte` 进行修改；
 *  `[]byte` 和 `string` 可以通过类型转换互转。

### 5 拼接字符串 ###

Go 语言同绝大数其他语言一样，通过操作符 `+` 可以将两个字符串连接构造一个新字符串：

package main
    
    import (
    	"fmt"
    )
    
    func main() {
        
    	str2 := "wgchen.blog.csdn.net"
    	str1 := "hello "
    
    	fmt.Println(str1 + str2) 
    	// "hello wgchen.blog.csdn.net"
    }

除了使用 `+` 来拼接字符串，Go 语言中也有类似于 Java 语言中 `StringBuilder` 的机制，来进行更高效率的字符串拼接。

代码如下：

package main
    
    import (
    	"bytes"
    	"fmt"
    )
    
    func main() {
        
    	str1 := "hello "
    	str2 := "wgchen.blog.csdn.net"
    
    	// 声明字节缓冲
    	var stringBuilder bytes.Buffer
    
    	// 将字符串写入缓冲
    	stringBuilder.WriteString(str1)
    	stringBuilder.WriteString(str2)
    
    	// 将缓冲以字符形式输出
    	fmt.Println(stringBuilder.String())
    	// hello wgchen.blog.csdn.net
    }

bytes.Buffer 做缓冲使用，我们可以通过 WriteString 函数往里面写入各种字节数组。

字符串也是一种字节数组。

最后，再通过 stringBuilder.String() 将缓冲转换为字符串。

### 6 字符串比较 ###

字符串可以用 `== 、 <、>` 进行比较；

比较通过逐个字节比较完成的，因此比较的结果是字符串自然编码的顺序。

package main
    
    import "fmt"
    
    func main() {
        
    	str1 := "wgchen.blog.csdn.net"
    
    	str2 := "wgchen.blog.csdn.net"
    
    	// 是否相等标志位
    	isSame := false
    	if str1 == str2 {
        
    		isSame = true
    	}
    
    	fmt.Println(isSame)
    }

PS E:\golang\src> go run .\main.go
    true
    PS E:\golang\src>

### 7 字符串转义符 ###

Go 语言中，常见转义符包括回车、换行、单双引号、制表符等：

下面是一段示例代码, 简单演示了如何使用双引号与反斜杠：

package main
    
    import "fmt"
    
    func main() {
        
    	fmt.Println("我爱 \"知其黑、受其白教程\" 域名: wgchen\\blog\\csdn\\net")
    }

PS E:\golang\src> go run .\main.go
    我爱 "知其黑、受其白教程" 域名: wgchen\blog\csdn\net
    PS E:\golang\src>

### 8 定义多行字符串 ###

Go 语言中，字符串双引号的书写方式最为常见，但是不能用来表示多行。如果需要使用多行字符串，需要使用 **\`**字符，示例代码如下：

package main
    
    import "fmt"
    
    func main() {
        
    	str := `第一行
    第二行
    第三行
    \r\n`
    
    	fmt.Println(str)
    }

PS E:\golang\src> go run .\main.go
    第一行
    第二行
    第三行
    \r\n
    PS E:\golang\src>

> PS: 反引号 \` 在键盘上 1 键左边的位置，被反引号包裹的字符串将会被原样赋值给 str 变量。

注意： 被反引号包裹的转义符会被当成正常字符串看待，原样被输出。

### 9 Go 语言字符串格式化常用动词 ###

字符串格式化应用场景十分丰富，格式如下：

fmt.Sprintf(格式化样式, 参数列表)

*  格式化样式: 字符串形式，动词以 % 开头；
 *  参数列表: 多个参数通过逗号隔开，个数需要与格式化样式中的动词一一对应，否则会报错。

常见动词以及功能如下：

<table> 
 <thead> 
  <tr> 
   <th>动词</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>%b</code></td> 
   <td>整型以二进制方式显示</td> 
  </tr> 
  <tr> 
   <td><code>%o</code></td> 
   <td>整型以八进制方式显示</td> 
  </tr> 
  <tr> 
   <td><code>%d</code></td> 
   <td>整型以十进制方式显示</td> 
  </tr> 
  <tr> 
   <td><code>%x</code></td> 
   <td>整型以十六进制方式显示</td> 
  </tr> 
  <tr> 
   <td><code>%X</code></td> 
   <td>整型以十六进制、字母大写方式显示</td> 
  </tr> 
  <tr> 
   <td><code>%T</code></td> 
   <td>输出Go语言语法格式的类型和值</td> 
  </tr> 
  <tr> 
   <td><code>%f</code></td> 
   <td>浮点数</td> 
  </tr> 
  <tr> 
   <td><code>%p</code></td> 
   <td>指针，十六进制方式显示</td> 
  </tr> 
  <tr> 
   <td><code>%v</code></td> 
   <td>按值原本的值输出</td> 
  </tr> 
  <tr> 
   <td><code>%+v</code></td> 
   <td>在%v的基础上，对结构体字段名和值进行展开</td> 
  </tr> 
  <tr> 
   <td><code>%#v</code></td> 
   <td>输出Go语言语法格式的值</td> 
  </tr> 
  <tr> 
   <td><code>%%</code></td> 
   <td>输出%本体</td> 
  </tr> 
  <tr> 
   <td><code>%U</code></td> 
   <td>Unicode字符</td> 
  </tr> 
  <tr> 
   <td><code>%s</code></td> 
   <td> 输出以原生的UTF8字节表示的字符，如果console 不支持 utf8 编码，则会乱码</td> 
  </tr> 
 </tbody> 
</table>

下面是一些代码示例：

package main
    
    import (
    	"fmt"
    )
    
    func main() {
        
    	a := 1
    	b := 2
    
    	// 两整型参数格式化
    	fmt.Printf("第一个数: %d, 第二个数: %d\n", a, b)
    
    	str1 := "hello "
    	str2 := "wgchen.blog.csdn.net"
    
    	// 两字符串参数格式化
    	content := fmt.Sprintf("1: %s, 2: %s\n", str1, str2)
    
    	fmt.Println(content)
    }

PS E:\golang\src> go run .\main.go
    第一个数: 1, 第二个数: 2
    1: hello , 2: wgchen.blog.csdn.net
    
    PS E:\golang\src>

## Go 语言字符（byte与rune） ##

Go 语言中，字符串的每一个元素叫做字符，主要分为以下两种：

1、uint8 类型，或者叫 byte 型，代表了 ASCII 码的一个字符。  
提示：byte 类型是 unit8 的别名。

2、rune 类型，代表了一个 UTF-8 字符。  
通常情况下，当需要处理中文、日文、韩文等复合字符时，需要用到 rune 类型。

我们可以在 fmt.Println 中通过 %T 来输出变量的实际类型，代码如下：

package main
    
    import "fmt"
    
    func main() {
        
    	var a byte = 'q'
    	fmt.Printf("%d %T\n", a, a)
    	// byte 的实际类型其实是个 uint8, 对应的 ASCII 编码为 113
    
    	var b rune = '犬'
    	fmt.Printf("%d %T\n", b, b)
    	// rune 的实际类型其实是 int32, 对应的 Unicode 编码为 29356
    }

得出结论：

*  byte 的实际类型其实是个 uint8, 对应的 ASCII 编码为 113；
 *  rune 的实际类型其实是 int32, 对应的 Unicode 编码为 29356；

Go 语言中，使用了 rune 类型来处理 Unicode 编码，这样让基于 Unicode 的文本处理更为方便，同时也可以用 byte 进行默认的字符串处理，这样对性能和拓展性都有照顾。

### UTF-8 和 Unicode 有何区别？ ###

Unicode 与 ASCII 都是一种字符集。

字符集为每个字符分配一个唯一的 ID，我们使用到的所有字符在 Unicode 字符集中都有一个唯一的 ID，例如 q 字符在 Unicode 与 ASCII 中的编码都是 113。汉字“犬”在 Unicode 中的编码为 29356，在不同国家的字符集中，字符所对应的 ID 也会不同。

而无论任何情况下，Unicode 中的字符的 ID 都是不会变化的。

UTF-8 是编码规则，将 Unicode 中的字符 ID 以某种方式进行编码。UTF-8 是一种变长编码规则，从 1 到 4 个字节不等。

编码规则如下：

*  0xxxxxx 表示文字符号 0～127，兼容 ASCII 字符集。
 *  从 128 到 0x10ffff 表示其他字符。

在这种规则之下，拉丁文语系的字符编码一般情况下， 每个字符占用一个字节，而中文每个字符占用 3 个字节。

## 参考资料:整型、浮点型、布尔型、字符串、Go 语言字符（byte与rune） ##

[Golang 【basic\_leaming】基本数据类型][Golang _basic_leaming 1]

![在这里插入图片描述][e04e96de9e514e15ae431c5ace0d668e.png]

## Go 语言常量定义与声明 (const) ##

相对于 Go 语言变量 ，常量是一个不可改变的值，如圆周率 π 等。

常量在代码的编译期就已经确定了，而不是运行时。

每种常量的潜在类型都是基础类型：boolean、string 或 数字。

### 1 Go 语言常量定义 & 声明 ###

const pi = 3.141592
    const domain = "wgchen.blog.csdn.net"

PS E:\golang\src> go run .\main.go
    3.141592 wgchen.blog.csdn.net
    PS E:\golang\src>

### 2 定义多个 Go 语言常量 ###

在 Go 语言 中，常量也是可以同时定义多个的，方式和变量很类似。

代码如下:

const (
     	pi = 3.141592
     	domain = "wgchen.blog.csdn.net"
    )

上面提到，常量因为在代码编译期就已经确定了，所以可以用于数组声明。

代码如下:

const size = 10
    var arr [size]int 
    // 定义一个长度为 10 的 int 数组

### 3 iota 常量生成器生成枚举 ###

常量声明可以使用 iota 常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。

在一个 const 声明语句中，在第一个声明的常量所在的行，iota 默认会被置为 0，然后在每一个有常量声明的行自动加一。

大部分场景下，会用 iota 来生成枚举 。

## Go 语言枚举类型（iota自增） ##

Go 语言中其实是没有枚举类型的，但是，可以使用常量 iota 来模拟枚举。

### 1 Go 语言定义枚举类型 ###

下面这段代码，我们尝试定义一个性别枚举:

package main
    
    import "fmt"
    
    // 定义一个名为 Sex 类型, 实际类型为 int
    type Sex int
    
    // 定义性别男女
    const (
    	// 将枚举值 Woman 定义为 Sex 类型，并搭配 iota 开始生成枚举值，默认从 0 开始
    	Woman Sex = iota
    	Man
    )
    
    func main() {
        
    	// 输出枚举值
    	fmt.Println(Woman, Man)
    
    	// 使用枚举类型，并赋值
    	var sex Sex = Man
    	fmt.Println(sex)
    }

PS E:\golang\src> go run .\main.go
    0 1
    1
    PS E:\golang\src>

const 声明内的每一行常量声明，将会自动套用前面 iota 格式，并自动增加。有点类似于 Excel 表格自动填充功能。

也就是说，第一行 Woman 枚举值定义了 0， 那么 Man 的值会自动加一，值变成了1。

当然，iota 除了每次自增 1 以外，我们还可以利用 iota 来完成一些更复杂的操作。

下面这段代码用来生成一些标志位：

package main
    
    import "fmt"
    
    const (
    	Flag1 = 1 << iota // 移位操作，左移一位
    	Flag2
    	Flag3
    	Flag4
    )
    
    func main() {
        
    	// 输出枚举整型值
    	fmt.Printf("%d %d %d %d\n", Flag1, Flag2, Flag3, Flag4)
    	// 输出枚举二进制格式的值
    	fmt.Printf("%b %b %b %b", Flag1, Flag2, Flag3, Flag4)
    }

PS E:\golang\src> go run .\main.go
    1 2 4 8
    1 10 100 1000
    PS E:\golang\src>

### 2 Go 语言枚举值转换字符串 ###

在实际应用场景中，通常需要获取枚举值对应的字符串描述。

Go 语言中，我们可以这样做：

package main
    
    import "fmt"
    
    // 定义一个名为 Sex 类型
    type Sex int
    
    const (
    	Woman Sex = iota // 开始生成枚举值，默认从 0 开始
    	Man
    )
    
    // 定义一个 Sex 类型的方法 String(), 返回字符串
    func (s Sex) String() string {
        
    	switch s {
        
    	case Woman:
    		return "女"
    	case Man:
    		return "男"
    	}
    	return "N/A"
    }
    
    func main() {
        
    	// 输出枚举 Woman 的字符串描述，以及整型值
    	fmt.Printf("%s %d", Woman, Woman)
    }

PS E:\golang\src> go run .\main.go
    女 0
    PS E:\golang\src>

一旦某个类型需要输出字符串时，Go 语言会自动寻找 String() 方法并调用。

## Go 语言指针 ##

大部分面向对象语言都很少有用到指针的场景了，但是在Go语言中有大量的指针应用场景，要想学好 Go 语言，指针是必须了解的。

### 1 什么是指针 ###

每一个变量都会分配一块内存，数据保存在内存中，内存有一个地址，就像门牌号，通过这个地址就可以找到里面存储的数据。

指针就是保存这个内存地址的变量。

### 2 Go 语言指针 ###

在 Go 语言中， 指针包括两个核心概念:

*  类型指针  
    允许对这个指针类型的数据进行修改。  
    传递数据使用指针，而无需拷贝数据。  
    类型指针不能进行偏移和运算。
 *  切片  
    由指向起始元素的原始指针、元素数量和容量组成。

受益于这样的约束和拆分，Go语言的指针类型变量即拥有指针高效访问的特点，又不会发生指针偏移，从而避免了非法修改关键性数据的问题。同时，垃圾回收也比较容易对不会发生偏移的指针进行检索和回收。

切片比原始指针具备更强大的特性，而且更为安全。切片在发生越界时，运行时会报出宕机，并打出堆栈，而原始指针只会崩溃。

### 3 C/C++中的指针 ###

说到 C/C++ 中的指针，会让许多人“谈虎色变”，尤其是对指针的偏移、运算和转换。 其实，指针是 C/C++ 语言拥有极高性能的根本所在，在操作大块数据和做偏移时即方便又便捷。因此，操作系统依然使用C语言及指针的特性进行编写。

要明白指针，需要知道几个概念：指针地址、指针类型和指针取值，下面将展开详细说明。

### 4 Go 语言指针地址和指针类型 ###

每个变量在程序运行时都有一个地址，这个地址代表变量在内存中的位置。

Go 语言中，通过 & 操作符对变量进行 “**取地址**” 操作，格式如下：

p := &v // v 的类型为 T

上面代码中，v 表示被取地址的变量，取到的地址用变量 p 进行接收， p 的类型为 **“\*T”**, 称为 T 的指针类型。\*代表指针。

下面的代码示例，演示了指针的取地址用法:

package main
    
    import "fmt"
    
    func main() {
        
    	// 声明一个整型的 man 变量
    	var man int = 1
    	// 声明一个字符串类型 domain 变量
    	var domain string = "知其黑，受其白 wgchen.blog.csdn.net"
    
    	// 通过 %p 输出 man 和 domain 变量取地址后的指针值，指针值带有 0x 的十六进制前缀
    	fmt.Printf("%p %p", &man, &domain)
    }

PS E:\golang\src> go run .\main.go
    0xc00000e098 0xc000050250
    PS E:\golang\src>

> 注意：代码每次运行的结果是不同的，表示 man 和 domain 两个变量在运行时的地址。  
>   
> 在 32 位平台上，运行结果是 32 位地址；在 64 位平台上，运行结果是 64 位地址。

**总结: 变量、指针和地址三者的关系是：每个变量都拥有地址，指针的值表示这个地址。**

### 5 获取指针指向的值 ###

我们已经知道了如何通过 & 获取变量的指针，那么要如何通过指针取值呢？

代码如下：

package main
    
    import "fmt"
    
    func main() {
        
    	// 准备一个字符串类型的变量
    	var domain string = "知其黑，受其白 wgchen.blog.csdn.net"
    
    	// 获取字符串的指针， p 类型为*string
    	p := &domain
    
    	// 打印变量 p 的类型
    	fmt.Printf("p type: %T\n", p)
    
    	// 打印变量 p 的指针地址
    	fmt.Printf("address: %p\n", p)
    
    	// 通过 * 对指针进行取值操作
    	value := *p
    
    	// 取值后的类型
    	fmt.Printf("value type: %T\n", value)
    
    	// 指针取值后指向变量的值
    	fmt.Printf("value type: %s\n", value)
    }

PS E:\golang\src> go run .\main.go
    p type: *string
    address: 0xc000050240
    value type: string
    value type: 知其黑，受其白 wgchen.blog.csdn.net
    PS E:\golang\src>

*  `&`， 取地址操作符，功能是取出变量在内存中的地址；
 *  `*`，取值操作符，功能是取出地址指向的实际值。

小结：

变量、指针地址、指针变量、取地址、取值的相互关系和特性如下：

*  对变量进行取地址 `(&)` 操作，可以获取这个变量的指针变量；
 *  指针变量的值是指针地址；
 *  对指针变量进行取值 `（*）` 操作，可以获取指针变量指向的实际值。

### 6 使用指针修改值 ###

指针不但可以取值，同时还可以修改值。

在前面 Go 语言变量 小节中说到了多重赋值的方法进行数值交互，使用指针同样可以。

代码如下：

package main
    
    import "fmt"
    
    // 数值交换函数
    func swap(a, b *int) {
        
    	// 取 a 指针的值，赋给临时变量 t
    	t := *a
    
    	// 取 b 指针的值，赋给 a 指针指向的变量
    	*a = *b
    
    	// 将 a 指针的值赋给 b 指针指向的变量
    	*b = t
    }
    
    func main() {
        
    	// 声明两个变量 x, y, 值分别为 1，2
    	x, y := 1, 2
    
    	// 交换变量值
    	swap(&x, &y)
    
    	// 输出交换后的 x, y 值
    	fmt.Println(x, y)
    }

PS E:\golang\src> go run .\main.go
    2 1
    PS E:\golang\src>

假设，我们在上面 swap() 函数中交换的是指针值，情况会如何呢?

package main
    
    import "fmt"
    
    func swap(a, b *int) {
        
    	b, a = a, b
    }
    
    func main() {
        
    	// 声明两个变量 x, y, 值分别为 1，2
    	x, y := 1, 2
    
    	// 交换变量值
    	swap(&x, &y)
    
    	// 输出交换后的 x, y 值
    	fmt.Println(x, y)
    }

PS E:\golang\src> go run .\main.go
    1 2
    PS E:\golang\src>

可以看到，值交换失败了。

上面 swap() 函数交换的是 a 和 b 的地址，交换完毕后，它们实际指向的值并没有发生改变。

这就好比放在桌子上的两个钱包，将位置交换后，里面存放的钱并没有发现改变一样。

### 7 通过 new() 函数来创建指针 ###

Go 语言中还提供了 new() 函数来创建指针，格式如下:

new (类型)

代码如下：

package main
    
    import "fmt"
    
    func main() {
        
    	str := new(string)
    	*str = "wgchen.blog.csdn.net"
    
    	fmt.Println(*str)
    }

PS E:\golang\src> go run .\main.go
    wgchen.blog.csdn.net
    PS E:\golang\src>

new() 函数可以创建一个对应类型的指针，同时会分配内存。被创建的指针指向的值为默认值。

[ff74b193c6734572bc4f1f6fc60113fb.png]: https://img-blog.csdnimg.cn/ff74b193c6734572bc4f1f6fc60113fb.png
[Golang _basic_leaming]: https://wgchen.blog.csdn.net/article/details/128216672
[a7ba4abadde1446b9dd5f1b2cc5cc9ed.png]: https://img-blog.csdnimg.cn/a7ba4abadde1446b9dd5f1b2cc5cc9ed.png
[dc479b55daf24554a05b29b75543b361.png]: https://img-blog.csdnimg.cn/dc479b55daf24554a05b29b75543b361.png
[Golang _basic_leaming 1]: https://wgchen.blog.csdn.net/article/details/128221003
[e04e96de9e514e15ae431c5ace0d668e.png]: https://img-blog.csdnimg.cn/e04e96de9e514e15ae431c5ace0d668e.png