Golang基础笔记一之变量声明和类型介绍
本文首发于公众号：Hunter后端原文链接：Golang基础笔记一之变量声明和类型介绍
这一篇笔记主要介绍 Golang 的基础内容，包括 Golang 的运行，变量声明以及 Golang 里的各种数据类型。
以下是本篇笔记目录：
[*]Golang 的运行
[*]变量声明
[*]Golang 数据类型
[*]fmt 函数
1、Golang 的运行
在介绍后面的函数前，我们所有的代码都放在 main 函数里，如果有特殊需要引入的包，这里会提前说明。
下面我们创建一个 main.go 文件，内容如下：
// main.go
package main
import "fmt"
func main() {
fmt.Println("hello world")
}运行的方式，我们直接使用 go run main.go，执行了之后在控制台看到 hello world 的输出说明我们已经运行成功了。
2、变量声明
Go 中使用变量前必须要先声明，声明变量可以使用 var 来修饰，也可以使用 := 来声明。
如果使用 := 则必须要在声明的时候赋值，而使用 var 的时候则不需要，会自动给定该变量类型的初始值。
使用 var 声明变量并赋值
var i int = 10使用 var 声明变量不赋值
var i int上面声明了 i 变量不赋值，因为声明了变量类型为 int，则该变量初始化为 0。
使用 := 声明变量
i := 10通过这种方式声明的变量会根据变量值自动为其获取变量类型。
批量声明变量
可以批量声明多个变量：
var a, b int批量声明多个变量的时候赋值：
var (
a = 100
b = "456"
)或者这样声明：
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 次方减一。
package main
import (
"fmt"
)
func main() {
var a int8 = -128
fmt.Println(a)
var b uint8 = 255
fmt.Println(b)
}对于我们常用的 int，它的范围则取决于我们使用的系统，我们的系统是 32 位，则范围是 负的 2 的 31 次方到 2 的 31 次方减一。
2) 浮点型
Go 中的浮点型有两种，单精度 float32 和双精度 float64，分别是 32 位浮点数和 64 位浮点数。
比如我们这样定义：
var a float64 = 16.789float32 可以精确到小数点后 6 位，float64 可以精确到小数点后 15 位。
可以精确到小数点后的位数是怎么计算的，比如 float32，使用 32位表示一个浮点数，其中，1位表示符号，8位表示指数，23位表示位数，而浮点数在计算机中以二进制形式存储，所以 23 位的位数从二进制转为十进制精度可以如下计算：
d = n * log(2)float32 的尾数有 23 位，大概可以精确到十进制的小数点后位数位 23 * log(2) = 6.9，大约在 6-7，所以可以提供 6-7位十进制数字的精度。
同理 float64 使用 64位表示一个浮点数，1位表示符号，11位表示指数，52位表示尾数，所以可以精确到的小数点位数是 15 位。
2. 布尔类型
布尔类型只有两个值，true 和 false：
var a bool = true
fmt.Println(a)3. 字符串
字符串使用双引号包起来，下面是其定义：
var a string = "abc"
fmt.Println("a: ", a)
var b = "abc"
fmt.Println("b: ", b)
c := "abc"
fmt.Println("c: ", c)4. 字符
字符类型有两种，一种是 byte，一种是 rune，其实他们分别是 uint8 和 int32 的别名，分别用来表示 ASCII 字符和 Unicode 字符，使用单引号包起来。
1) byte
先来介绍 byte，前面说过，byte 实际上就是 uint8，所以虽然我们给其赋值 ASCII 字符，但是它的值本身还是一个整型：
var a byte = 'a'
fmt.Println("a: ", a)
// 输出结果是 97如果我们想要其输出原本的字符内容，可以使用 fmt.Printf() 函数：
var byteContent byte = 'a'
fmt.Printf("byteContent 的内容是: %c\n", byteContent)
// byteContent 的内容是: a2) rune
rune 本质上是 int32，所以它的使用和 byte 是一样的：
var runeContent rune = '中'
fmt.Println("runeContent 的值是: ", runeContent)
// runeContent 的值是:20013
fmt.Printf("runeContent 的内容是: %c\n", runeContent)
// runeContent 的内容是: 中5. 指针
指针用于存储变量的内存地址，我们可以通过指针访问这个变量的内存地址，也可以通过指针访问到这个变量的内存地址存储的值。
使用 & 符号来获取变量的内存地址，使用 * 获取指针指向的内存地址的值：
var a int = 10
var a_ptr *int = &a
fmt.Println("a 的内存地址是: ", &a)
fmt.Println("a_ptr 的值是: ", a_ptr)
fmt.Println("根据指针获取的值是: ", *a_ptr)6. 数组
数组是具有固定长度的相同类型元素的序列。
这里有两个点需要注意，数组的长度是固定的，数组的元素是相同的，且在定义的时候就定好的。
var arr int
arr = 1
arr = 2
arr = 3
fmt.Println("arr: ", arr)也可以在定义的时候直接对其赋值：
var arr int = int{1, 2, 3}
fmt.Println("arr: ", arr)或者定义的时候不指定数量，自动获取：
var arr = [...]int{1, 2, 3}
fmt.Println("arr: ", arr)还可以在定义的时候，指定索引位置的值：
var arr = [...]string{0: "Peter", 3: "Tome", 1: "Hunter"}
fmt.Println("arr: ", arr)7. 切片
切片是对数组的一个连续片段的引用，它本身不存储数据，而是指向底层数组。
var arr = [...]int{1, 2, 3, 4, 5}
slice := arr
fmt.Println("slice 内容为: ", slice)有关于切片的更多的内容在后面笔记中会更详细的介绍。
8. map
map 是 Golang 里的映射：
m := make(mapint)
m["apple"] = 1
m["banana"] = 2
fmt.Println(m)9. 结构体
结构体是将零个或多个任意类型的命名变量组合在一起的聚合数据类型，其定义和使用方式如下：
type Person struct {
Ageint
Name string
}
func main() {
var person Person
person.Age = 25
person.Name = "Hunter"
fmt.Println("结构体 person: ", person)
}10. 通道
goroutine 是 Go 协程，而通道（channel）是用于在不同的 goroutine 之间进行通信的工具。
创建一个通道的方式如下：
ch := make(chan int)上面的操作表示我们创建了一个 ch 通道，可以往通道里传入 int 型数据。
使用
页:
[1]