python转go学习笔记———常用函数

字符串函数

字符串中的常用系统函数，内置函数，和python的没有很大的区别，名字也很像

**len函数：**返回字符串的长度。不同于python的len()函数，golang因为是utf-8编码，所以汉字会变成3个长度。

func main() {
    str := "123北京"
    fmt.Println("str len = ",len(str))
}
//str len = 9

**strconv.Atoi:**字符串转整数（可以做用户输入校验）

**strconv.Itoa:**整数转字符串

func main() {
   n,err := strconv.Atoi("123")
   if err != nil {
      fmt.Println("转换失败,错误是：",err)
   }else{
      fmt.Println("转换陈坤,数据是：",n)
   }
    
    str := strconv.Itoa(123)
	fmt.Println(str)
}

[]byte():字符串转[]byte

string()：[]byte转字符串

func main() {
    bt := []byte("翠花")
	fmt.Println(bt)
    
    str := string([]byte{97,98,99})
    fmt.Println(str)
}
//[231 191 160 232 138 177]
//abc

strconv.FormatInt():10进制转2，8，16进制（类似于python中的int(num,2)）

func main() {
	str := strconv.FormatInt(132,2)
	fmt.Println(str)
}
//10000100

strings.Contains(s,substr)：判断子串是否在指定的字符串，返回true/false

strings.Count(s,substr)：统计字符串包含几个子串，返回int

strings.EqualFold(s1,s2):判断字符串是否相同,不区分大小写(==区分大小写)

strings.Index(s,substr):返回子串在字符串中第一次出现的下标

strings.LastIndex(s,substr):返回子串在字符串中最后一次出现的下标

func main() {
	b := strings.Contains("seafood","food")
	fmt.Println(b)								//true
    
    num := strings.Count("familia","a")
    fmt.Println(num)							//2
    
    fmt.Println(strings.EqualFold("Abc","aBC"))	//true
    
    index := strings.Index("familia","mi")
	fmt.Println(index)							//4
}

strings.Replace(s,old,new,n)：python的str.replace()，字符串替换，n表示替换几个(-1表示全部)

strings.Split(s,sep)：python的str.split()，字符串分割

strings.ToLower(s):python的str.lower()，小写

strings.ToUpper(s):python的str.upper()，大写

func main() {
	str := "我是一个来自中国的中国人"
	str2 := strings.Replace(str,"中国","宝鸡",-1) //我是一个来自宝鸡的宝鸡人
	fmt.Println(str2)
}

strings.TrimSpace(s)：去掉两边的空格

strings.Trim(s,sep)：去掉两边指定的字符

strings.TrimLeft(s,sep):去掉左边指定的字符

strings.TrimRight(s,sep):去掉右边指定的字符 （相当于python的str.lstrip()、str.rstrip()、str.strip()）

日期函数

golang中有time.time类型，表示时间

func main() {
	now := time.Now()	// 获取当前时间
	fmt.Printf("now = %v,type = %T\n",now,now)
    //now = 2021-12-20 23:59:19.1477705 +0800 CST m=+0.006507101,type = time.Time
	fmt.Println("年 = ",now.Year())			//年 =  2021
	fmt.Println("月 = ",now.Month())			//月 =  December
	fmt.Println("月 = ",int(now.Month()))	//月 =  12
	fmt.Println("日 = ",now.Day())			//日 =  20
	fmt.Println("时 = ",now.Hour())			//时 =  23
	fmt.Println("分 = ",now.Minute())		//分 =  59
	fmt.Println("秒 = ",now.Second())    	//秒 =  19
}

格式化输出：

func main() {
    //fmt输出
	fmt.Printf("当前年月日 %d-%d-%d %d:%d:%d \n",now.Year(),now.Month(),now.Day(),
		now.Hour(),now.Minute(),now.Second())
    //当前年月日 2021-12-20 23:59:19 
    
    //time提供的方法
    fmt.Printf(now.Format("2006/01/02 15:04:05")) //固定写法才能拿到时间，格式可以改，数字不能改
    //2021/12/21 00:12:09
}

休眠：time.Sleep

time.Sleep(100*time.Millisecond) //休眠100毫秒

内置函数(builtin)

**new：**用来分配内存，主要用来分配值类型，返回的是指针

func main() {
	num1 := 100 //int类型
	fmt.Printf("type of num1 = %T,value of num1 = %v,address of num1 = %v\n",num1,num1,&num1)
	num2 := new(int) //*int类型
	fmt.Printf("type of num2 = %T,value of num2 = %v,address of num2 = %v\n",num2,num2,&num2)
}
//type of num1 = int,value of num1 = 100,address of num1 = 0xc00010e018
//type of num2 = *int,value of num2 = 0xc00010e050,address of num2 = 0xc000108018

**make：**用来分配内存，主要用来分配引用类型

var 切片名 []type = make([],len,[cap]) //声明一个切片

异常处理

go语言异常处理不使用python这种try…except…finally这种模式，在go中抛出一个panic的异常，然后在defer中通过recover捕获异常，然后处理

• 第一种写法：defer一个匿名函数，做异常捕获

func test()  {
	// defer + recover
	defer func() {
		err := recover() //内置函数,用于捕获异常
		if err != nil {
			fmt.Println("error = ",err)
		}
	}()
	num1 := 10
	num2 := 0
	res := num1/num2
	fmt.Println(res)
}
//error =  runtime error: integer divide by zero

• 第二种写法：写一个异常捕获函数，去调用

func except() {
	if err := recover();err != nil {
		fmt.Println("error = ",err)
	}
}

func test()  {
	// defer + recover
	defer except()

	num1 := 10
	num2 := 0
	res := num1/num2
	fmt.Println(res)
}

自定义异常

使用errors.New和panic内置函数

1. errors.New(“错误说明”)，返回一个error类型的值，表示一个错误
2. panic内置函数，接收一个interface{}类型的值作为参数。可以接受error类型的变量，输出错误信息并退出程序

func readConf(name string) (err error) {
	if name == "config.ini" {
		//读取。。。
		return nil
	}else {
		//返回一个自定义错误
		return errors.New("读取文件错误")
	}
}

func test()  {
	err := readConf("config.ing")
	if err != nil{
		//读取文件错误输出错误并终止程序
		panic(err)
	}
	fmt.Println("test")
}

func main() {
	test()
	fmt.Println("flandre")
}