Go学习-Day4

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 main
  
  import "fmt"
  
  func test() {
  	defer func() {
  		err := recover() //捕获异常
  		if err != nil {
  			fmt.Println(err)
  		}
  	}()
  	num1 := 10
  	num2 := 0
  	res := num1 / num2
  	fmt.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]int
  	arr[0] = 1
  	fmt.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))
  }