Go学习-Day4

个人博客：CSDN博客

函数

值传递，引用传递

值传递直接拷贝值，一般是基本数据类型，数组，结构体也是
引用传递传递地址，效率高，指针，slice切片，map，管道，interface等

常用的函数

len(string str)//求字符串长度，自带的不用包，中文一个字三字节

转成[]rune来处理
[]byte转string
```
str = string([]byte{...})
```
查找子串是否存在
若干字符函数

strings.Contains("aaa", "aaa") //bool
strings.Index("aaa", "aaa")//返回下标
strings.LastIndex("aaa", "aaa")//返回最后一个下标,没有就返回-1
strings.Replace(str, str1, str2, n)//把1中str1替换成str2,n是替换个数，-1表示全部替换
strings.Split(str, "某字符")//分割字符串
strings.TrimSpace(str)//裁剪空格,去掉前导和后导空格
strings.Trim(str, "字符集")//去掉指定字符
strings.TrimLeft()//同上，去掉左侧，并且还有TrimRight
strings.HasPrefix(str, "后缀")//前缀匹配
strings.HasSuffix()//同上，但是后缀

若干时间函数

now := time.Now()//返回时间类型，当前时间
//2023-08-23 16:37:07.5402748 +0800 CST m=+0.001148901 大概是这样
//时间类型是结构体，可以使用.运算符来获取其他时间信息,now.Year()
//月份可以直接转int
time.Sleep(time.Millisecond * 100)//只能用乘法，不能有浮点数，利用时间单位常量
time.Unix()//获取unix秒时间戳
time.UnixNano()//unix纳秒时间戳

内置函数built-in

len()//统计字符串长度，数组大小
new(Type) *Type //参数为类型，返回一块对应大小的清空的内存块的指针

异常处理

Go中没有try catch
Go利用defer panic recover来处理异常
抛出一个panic的异常，在defer中通过recover捕获异常

package mainimport "fmt"func test() {defer func() {err := recover() //捕获异常if err != nil {fmt.Println(err)}}()num1 := 10num2 := 0res := num1 / num2fmt.Println(res)
}
func main() {test()fmt.Println("ok")
}

通过捕获异常，可以使得程序不崩溃停止！main函数的其他部分照常运行
自定义错误

func myError(x int) (err error) {if x == 0 {return nil} else {return errors.New("错误")}
}func test() {err := myError(1)if err != nil {panic(err)}
}func main() {test()
}

panic会终止程序
捕获自定义错误

func myError(x int) (err error) {if x == 0 {return nil} else {return errors.New("错误")}
}func test() {defer func() {err := recover() //捕获异常if err != nil {fmt.Println(err)}}()err := myError(1)if err != nil {panic(err)}
}func main() {test()fmt.Println("ok")
}

数组

定义

func main() {var arr [10]intarr[0] = 1fmt.Println(arr)}

数组名地址&arr
初始化

var arr [3]int = [3]int{1, 2, 3}var arr = [3]int{1, 2, 3}var arr = [...]int{1, 2, 3}var arr = [...]int{1: 800, 0: 900, 2: 999}//指定下标var arr := [...]int{1, 2, 3} //自动推导

遍历for-range 同string 不赘述
数组中的元素可以是任何合法的类型，但是不能混用
Go中数组是值类型，会进行拷贝，要想修改原数组，需要使用指针，写法类似C语言的行指针

Slice切片

切片是引用类型，传递地址
切片和数组类似，但是长度是可以变化的！
声明
```
var a []int
```

func main() {var arr [5]int = [...]int{1, 2, 3, 4, 5}slice := arr[1:3] //从下标1与下标3,左闭右开的区间fmt.Println(slice)
}

通过make声明

func main() {slice := make([]int, 2, 4)fmt.Println(slice)
}

make在底层维护一个数组，这个数组对外不可见
直接声明
```
var slive []string = []string 
```
遍历和数组类似，不再赘述
简写

var slice = arr[:end] // var slice = arr[0:end]前缀，不含end
var slice = arr[start:]//var slice = arr[start:]后缀
var slice = arr[:]//var slice = arr[0:len(arr)]全长

切片可以继续切片
切片可以追加，可以追加多个数，可以追加多个切片，利用append将追加后的切片赋值给原来的切片

slice1 = append(slice1, 1, 2, 3)//追加数
slice1 = append(slice1, slice1...)//要三个点

Go底层会创建一个新的数组，然后切片这个新的数组，这些过程均不可见
string可以进行切片处理

str := "sssssss"
slice := str[2:]//从下标2开始切后缀

string底层也指向一个byte数组，我们用切片来拷贝这个只读的byte数组再进行操作
通过切片能够改变字符串

arr := byte[](str)
arr[0] = 'a'
str = string(arr)
//但是不支持中文
arr := rune[](str)
arr[0] = '好'
str = string(arr)
//弄中文
func main() {str := "?????"arr := []rune(str)arr[0] = '好'fmt.Println(string(arr))
}