记录了go语言基础部分做为后续学习的查询笔记。

变量和常量的定义和使用

在 Go 中，声明一个变量但不使用它时，Go会抛出错误
变量被声明后系统会自动赋值初始化，int 为 0，float 为 0.0，bool 为 false，string 为空字符串，指针为 nil
变量名使用驼峰命名法，需要被外部包使用的变量名应该将首个单词字母大写

变量的声明和初始化

go语言为类型后置,定义时依次表示关键字变量名类型名，变量声明关键字 var


var s1 string 

var (
    s1,s2 string
    s3 int
)

可以对值直接进行初始化赋值，赋值时可以指定类型，不指定go会进行自动推导

var (
	s1,s2,s3 = "a","b","c"
)

此外还可以使用 := 的方式实现声明和初始化

 name := "coco"

常量的声明

go中的常量声明关键字为 const ，同样可以实现自动推导 iota 可以实现枚举，iota的其他看到了再补充

const Status = 15 

const ( 
    a = iota 
    b = iota 
    c = iota
) //a=0 b=1 c=2
与下方等价
const ( 
    a = iota 
    b 
    c 
) //a=0 b=1 c=2

基本类型

类型别名

可以使用type关键字为某个类型起名

type hello int

布尔类型 bool true/false

运算符

！非，&& 和，或||，== 相等， != 不等

优先级     运算符
 7      ^ !
 6      * / % << >> & &^
 5      + - | ^
 4      == != < <= >= >
 3      <-
 2      &&
 1      ||

数字类型

int 强制类型转换需要显示的进行类似于 x := int32(6),此时x为int32型，类型转换至会导致数字切除 strconv 提供类型转换函数

整数：
int8（-128 -> 127）
int16（-32768 -> 32767）
int32（-2,147,483,648 -> 2,147,483,647）
int64（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807）


无符号整数：
uint8（0 -> 255）
uint16（0 -> 65,535）
uint32（0 -> 4,294,967,295）
uint64（0 -> 18,446,744,073,709,551,615）

float

浮点型：
float32（+- 1e-45 -> +- 3.4 * 1e38）
float64（+- 5 1e-324 -> 107 1e308）

数字相关格式化说明符
- %d 格式化整数输出
- %g 格式化浮点型输出
- %f 输出浮点数
- %e 输出自然计数法
- %0d 用于规定输出长度
- %6.2e 表示3.4的输出结果为 3.40e+00
- %6f 表示3.4的输出结果为 3.40000
- %6.2f 表示3.4的输出结果为 3.40
复数

complex64 (32 位实数和虚数)
complex128 (64 位实数和虚数)

var c complex64 = 5 + 6i

c = complex (re,im)
可以从real(c),imag(c)获取实部和虚部

字符串类型

字符串类型使用 "" 双引号引用有以下转义字符


\n  换行符
\r  回车符
\t  制表符
\u  
\\   反斜杠
\'  单引号
\"  双引号

函数的声明

一个函数的声明由一个函数名字、参数列表（由函数的调用者提供参数变量的具体值）、一个可选的返回值列表和包含函数定义的函数体组成。固定结构 func 函数名(参数列表) 返回值列表 {函数体}

func main(){
 ...
}

func PopCount(x uint64) int {
    return 50
}

也可以为返回值命名
func PopCount(x int32) (result int) {
    result = x + 50
    return 
}

返回多个值
func calc(number1 string, number2 string) (sum int, mul int) { 
    int1, _ := strconv.Atoi(number1) 
    int2, _ := strconv.Atoi(number2) 
    sum = int1 + int2 
    mul = int1 * int2 
    return
}

sum, mul := calc("15","20")
_ 用于丢弃不要的值

更改函数参数值

更改函数参数值需要使用指针，由于Go按值传递，直接修改值不会对原变量产生影响

func main() {
    Name := "avc"
    updateName(&Name)
    fmt.Println(Name)
}

func updateName(name *string) {
    *name = "des"
}

控制流

if/esle

if 7%2 == 0 {  
    fmt.Println("7 is even")  
} else {  
    fmt.Println("7 is odd")  
}


if num%2 == 0 {  
    fmt.Println("2")  
} else if num%3 == 0 {  
    fmt.Println("3")  
}else {
    fmt.Println("1")  
}

switch

switch 对变量做判断 go允许在case条件中对变量进行判断，且每个case结束自动break，除非使用 fallthrough

case 条件允许用逗号隔开多个 switch 条件运行包含函数，也可以省略条件，在case中判断

switch i {
case 0:
    fmt.Print("0")
case 1:
    fmt.Print("1")
case 2:
    fmt.Print("2")
default:
    fmt.Print("no match")
}

case "a","b","c","d" :
    fmt.Print("yes")
    
    
switch {
    case r>2:
        fmt.Printf(">2")
    default:
        fmt.Printf("<2")
}

循环 for

for 不带条件时等价与 while(0)
for 条件不带括号，条件中间由；隔开

defer

推迟函数，直到包含defer的语句完成时调用
多个defer语句按照定义顺序逆序执行

panic

内置 panic()函数可以停止 Go 程序中的正常控制流。当你使用 panic 调用时，任何延迟的函数调用都将正常运行。

recover

可以使得程序崩溃后继续运行

数组

数组的定义

var arr [len]int

数组的遍历和赋值

var arr [5]int

for i:=0;i<5;i++ {
    arr[i] = i
    }

for index,_ :=range arr{
    arr[index[ = index
    }
    初始化
var arr = [5]int{1,2,3,4,5}
var arr = [5]int {1,2,3}  其余自动为0
var arr = [5]int {3:"a",4:"s"}

切片slice

长度可变的数组，其优点在于是一个引用，不需要额外的内存，不能用指针指向切片
len() 当前长度
cap() 最大容量声明格式

var arr2 []int
初始化
var arr2 []int = arr1[3:2]
arr2 := []int{1,2,3}

切片结构体包含三个部分
指向数组的指针，当前切片长度，切片容量

用make创建切片

var slice1 []type = make([]type, len)
s := make([]string, 3)
还可以指定cap
s := make([]string, 3， 5)

make和new的区别

new (T) 为每个新的类型 T 分配一片内存，初始化为 0 并且返回类型为 * T 的内存地址：这种方法返回一个指向类型为 T，值为 0 的地址的指针，它适用于值类型如数组和结构体；它相当于 &T{}。
make(T) 返回一个类型为 T 的初始值，它只适用于 3 种内建的引用类型：切片、map 和 channel。

Map

类似字典，可以使用range遍历

var map1 map[string]int
//测试值是否存在，存在返回true
_, ok := map1[key1]

其它

os.Args 变量包含传递给程序的每个命令行参数

Go 语言入门｜ 青训营