Golang基础笔记一之变量声明和类型介绍

本文首发于公众号：Hunter后端
原文链接：Golang基础笔记一之变量声明和类型介绍

这一篇笔记主要介绍 Golang 的基础内容，包括 Golang 的运行，变量声明以及 Golang 里的各种数据类型。
以下是本篇笔记目录：

• Golang 的运行
  
• 变量声明
  
• Golang 数据类型
  
• fmt 函数
  

1、Golang 的运行

在介绍后面的函数前，我们所有的代码都放在 main 函数里，如果有特殊需要引入的包，这里会提前说明。
下面我们创建一个 main.go 文件，内容如下：

1. // main.go
3. package main
5. import "fmt"
7. func main() {
8.     fmt.Println("hello world")
9. }

复制代码

运行的方式，我们直接使用 go run main.go，执行了之后在控制台看到 hello world 的输出说明我们已经运行成功了。
2、变量声明

Go 中使用变量前必须要先声明，声明变量可以使用 var 来修饰，也可以使用 := 来声明。
如果使用 := 则必须要在声明的时候赋值，而使用 var 的时候则不需要，会自动给定该变量类型的初始值。
使用 var 声明变量并赋值

1. var i int = 10

复制代码

使用 var 声明变量不赋值

1. var i int

复制代码

上面声明了 i 变量不赋值，因为声明了变量类型为 int，则该变量初始化为 0。
使用 := 声明变量

1. i := 10

复制代码

通过这种方式声明的变量会根据变量值自动为其获取变量类型。
批量声明变量

可以批量声明多个变量：

1. var a, b int

复制代码

批量声明多个变量的时候赋值：

1. var (
2. a = 100
3. b = "456"
4. )

复制代码

或者这样声明：

1. a, b := 123, "456"

复制代码

3、Golang 的数据类型

1. 数值类型

Golang 里数值类型有整型、浮点型等，这里介绍整型和浮点型
1) 整型

整数类型分为两种，有符号整数和无符号整数。
有符号整型就是是否包含负数，如果包含负数，则其范围是对应的无符号的一半。
有符号整数：int8, int16, int32, int64 和 int
有符号整数：uint8, uint16, uint32, uint64 和 uint
int8 的整数范围是 -2^7 ～ 2^7 -1
uint8 的整数范围是 0 - 2^8-1
同理，对于 int16，int32，int64 都是对应的负的 2 的 n-1 次方到 2 的 n-1 次方减一。

1. package main
3. import (
4.         "fmt"
5. )
7. func main() {
8.         var a int8 = -128
9.         fmt.Println(a)
11.         var b uint8 = 255
12.         fmt.Println(b)
13. }

复制代码

对于我们常用的 int，它的范围则取决于我们使用的系统，我们的系统是 32 位，则范围是 负的 2 的 31 次方到 2 的 31 次方减一。
2) 浮点型

Go 中的浮点型有两种，单精度 float32 和双精度 float64，分别是 32 位浮点数和 64 位浮点数。
比如我们这样定义：

1. var a float64 = 16.789

复制代码

float32 可以精确到小数点后 6 位，float64 可以精确到小数点后 15 位。
可以精确到小数点后的位数是怎么计算的，比如 float32，使用 32位表示一个浮点数，其中，1位表示符号，8位表示指数，23位表示位数，而浮点数在计算机中以二进制形式存储，所以 23 位的位数从二进制转为十进制精度可以如下计算：

1. d = n * log(2)

复制代码

float32 的尾数有 23 位，大概可以精确到十进制的小数点后位数位 23 * log(2) = 6.9，大约在 6-7，所以可以提供 6-7位十进制数字的精度。
同理 float64 使用 64位表示一个浮点数，1位表示符号，11位表示指数，52位表示尾数，所以可以精确到的小数点位数是 15 位。
2. 布尔类型

布尔类型只有两个值，true 和 false：

1.         var a bool = true
2.         fmt.Println(a)

复制代码

3. 字符串

字符串使用双引号包起来，下面是其定义：

1.         var a string = "abc"
2.         fmt.Println("a: ", a)
4.         var b = "abc"
5.         fmt.Println("b: ", b)
7.         c := "abc"
8.         fmt.Println("c: ", c)

复制代码

4. 字符

字符类型有两种，一种是 byte，一种是 rune，其实他们分别是 uint8 和 int32 的别名，分别用来表示 ASCII 字符和 Unicode 字符，使用单引号包起来。
1) byte

先来介绍 byte，前面说过，byte 实际上就是 uint8，所以虽然我们给其赋值 ASCII 字符，但是它的值本身还是一个整型：

1.         var a byte = 'a'
2.         fmt.Println("a: ", a)
3.     // 输出结果是 97

复制代码

如果我们想要其输出原本的字符内容，可以使用 fmt.Printf() 函数：

1.         var byteContent byte = 'a'
2.         fmt.Printf("byteContent 的内容是: %c\n", byteContent)
3.     // byteContent 的内容是: a

复制代码

2) rune

rune 本质上是 int32，所以它的使用和 byte 是一样的：

1.         var runeContent rune = '中'
2.         fmt.Println("runeContent 的值是: ", runeContent)
3.     // runeContent 的值是:  20013
4.         fmt.Printf("runeContent 的内容是: %c\n", runeContent)
5.     // runeContent 的内容是: 中

复制代码

5. 指针

指针用于存储变量的内存地址，我们可以通过指针访问这个变量的内存地址，也可以通过指针访问到这个变量的内存地址存储的值。
使用 & 符号来获取变量的内存地址，使用 * 获取指针指向的内存地址的值：

1.         var a int = 10
2.         var a_ptr *int = &a
3.         fmt.Println("a 的内存地址是: ", &a)
4.         fmt.Println("a_ptr 的值是: ", a_ptr)
5.         fmt.Println("根据指针获取的值是: ", *a_ptr)

复制代码

6. 数组

数组是具有固定长度的相同类型元素的序列。
这里有两个点需要注意，数组的长度是固定的，数组的元素是相同的，且在定义的时候就定好的。

1.         var arr [3]int
2.         arr[0] = 1
3.         arr[1] = 2
4.         arr[2] = 3
5.         fmt.Println("arr: ", arr)

复制代码

也可以在定义的时候直接对其赋值：

1.         var arr [3]int = [3]int{1, 2, 3}
2.         fmt.Println("arr: ", arr)

复制代码

或者定义的时候不指定数量，自动获取：

1.         var arr = [...]int{1, 2, 3}
2.         fmt.Println("arr: ", arr)

复制代码

还可以在定义的时候，指定索引位置的值：

1.         var arr = [...]string{0: "Peter", 3: "Tome", 1: "Hunter"}
2.         fmt.Println("arr: ", arr)

复制代码

7. 切片

切片是对数组的一个连续片段的引用，它本身不存储数据，而是指向底层数组。

1.         var arr = [...]int{1, 2, 3, 4, 5}
2.         slice := arr[1:3]
3.         fmt.Println("slice 内容为: ", slice)

复制代码

有关于切片的更多的内容在后面笔记中会更详细的介绍。
8. map

map 是 Golang 里的映射：

1.         m := make(map[string]int)
2.         m["apple"] = 1
3.         m["banana"] = 2
4.         fmt.Println(m)

复制代码

9. 结构体

结构体是将零个或多个任意类型的命名变量组合在一起的聚合数据类型，其定义和使用方式如下：

1. type Person struct {
2.         Age  int
3.         Name string
4. }
6. func main() {
7.         var person Person
8.         person.Age = 25
9.         person.Name = "Hunter"
11.         fmt.Println("结构体 person: ", person)
12. }

复制代码

10. 通道

goroutine 是 Go 协程，而通道（channel）是用于在不同的 goroutine 之间进行通信的工具。
创建一个通道的方式如下：

1. ch := make(chan int)

复制代码

上面的操作表示我们创建了一个 ch 通道，可以往通道里传入 int 型数据。

使用