golang（5） 函数

基本语法

func 函数名 （形参列表）（返回值列表）{
	执行语句
	return 返回值
}

形参：表示函数的输入
函数中的语句表示为了实现某一功能代码
函数可以有返回值也可以没有

例：运算

package main

import "fmt"

func cal(n1 float64 , n2 float64,operator byte) float64  {

	var res float64
	switch operator {
		case '+':
			res = n1 + n2
		case '-':
			res = n1 - n2
		case '*':
			res = n1 * n2
		case '/':
			res = n1 / n2
		default:
			fmt.Println("操作类型错误")
	}
	return res
}
func main() {
	result := cal(1.2, 2.3, '-' )
	fmt.Println("result = ", result)

}

包的引入

包的本质就是创建不同的文件夹，文件夹下才是程序

包的作用
1.区分相同名字的函数变量等标识符
2.当程序文件很多时可以很好的管理项目
3.控制函数变量等访问范围

打包语法

package 包名

引入语法
import 包路径

例：
设置的时候需要设置包名

1.utils包中设置一个函数

package utils

import "fmt"

//为了让其他包的文件可以使用Cal函数，首字母需要大写
func Cal(n1 float64 , n2 float64,operator byte) float64  {

   var res float64
   switch operator {
   case '+':
      res = n1 + n2
   case '-':
      res = n1 - n2
   case '*':
      res = n1 * n2
   case '/':
      res = n1 / n2
   default:
      fmt.Println("操作类型错误")
   }
   return res
}

2.在主函数中进行引用

package main

import (
   "chapter/utils"  //src下包的路径
   "fmt"
)


func main() {
   result := utils.Cal(1.2, 2.3, '-' )  //引用时包的名字加函数
   fmt.Printf("result = %.2f ", result)

}

init函数

1.每一个源文件都可以包含一个init函数，这个函数会在main函数执行前被go调用

func init()  {
   fmt.Println("init()")
}
func main() {

   fmt.Println("main()")
}
/* 结果
init()
main()
*/

2.全局变量是最先初始化的

var age = test()

func test() int {
   fmt.Println("test()")
   return 90

}
func init()  {
   fmt.Println("init()")
}
func main() {

   fmt.Println("main()",age )
}
/* 结果
test()
init()
main() 90
*/

3.在引用包时 一般函数的顺序为

包中的定义函数->包中的init函数->主函数外的定义函数->主函数外的init函数->主函数 

匿名函数

当一个函数只希望使用一次时可以使用匿名函数

1
func main() {

   res := func (n1 int, n2 int) int {  //直接定义函数
      return n1 + n2
   } (10,20)  //传入参数
   fmt.Println(res)
}

2，将匿名函数直接赋值给变量

func main() {

   a := func (n1 int, n2 int) int {
      return n1 - n2
   }
   res2 := a(100,200)  //将参数直接传给a
   fmt.Println(res2)
}

3，全局匿名函数
设置全局变量的时候直接进行定义

var (
   Func1 = func(n1 int,n2 int) int {
      return n1 * n2
   }
)
调用
res3 := Func1(10,20)
fmt.Println(res3)

闭包

一个函数和与其相关的引用环境组合的一个整体

func makeSuffix(suffix string) func (string) string{  //suffix和匿名函数组成了一个闭包
   return func ( name string) string{  //2.suffix接收参数并保留
      if !strings.HasSuffix(name,suffix){ //3.引入一个新函数作用判断后缀，这个时候suffix会自动传入
         return name + suffix
      }
   return name
   }
}

func main() {
   f := makeSuffix(".jpg")   //1.给函数传一个参数
   fmt.Println(f("winter"))  //4.传入name的参数
   fmt.Println(f("bird.jpg"))

}

函数参数的传递方式

两种方式
值传递和引用传递：都是变量的副本
值传递：是值的拷贝（基本数据类型，结构体等）
引用传递：是地址传递的拷贝，效率较高（指针，切片等）

字符串常用系统函数

1. 统计字符串长度，len（str）

str := "hello"
fmt.Println(len(str))

//5

2. 字符串遍历，同时处理有中文的问题r:=[]rune(str) //切片

str2 := "hello 哈哈"
r := []rune(str2)
for i :=0 ; i< len(r) ; i ++{
   fmt.Printf("%c \n",r[i])
}

3. 字符串转整数：strconv.Atoi()

n,err := strconv.Atoi("123")
if err != nil{
   fmt.Println("转换错误",err)
}else {
   fmt.Println("转换成功",n)
}

//转换成功 123
如果转换的不是数字的字符串就会产生报错
//转换错误 strconv.Atoi: parsing "aaaa": invalid syntax

4. 整数转字符串

str :=  strconv.Itoa(123)
fmt.Printf("%v %T",str,str)

//123 string

5. 字符串转byte

var bytes = []byte("hello")
fmt.Printf("%v",bytes)

//[104 101 108 108 111] ascii编码

6. Byte转字符串

str := string([]byte{97,98,99})
fmt.Printf("%v",str)

//abc 使用码值转换为字符

7. 10进制转换进制

str := strconv.FormatInt(要转换的10进制，转换为几进制)
str := strconv.FormatInt(123,2) //将123转换为2进制
fmt.Println(str)

8. 查找字符是否在字符串中

str:= strings.Contains("asdfgh","dfg") //查找dfg是否在asdfgh中
fmt.Println(str)
//返回一个布尔值

10. 统计一个字符串中有几个指定的值

str:= strings.Count("asdasdqwe","a")//在这个字符串中有几个a
fmt.Println(str)

11. 字符串比较

str:= strings.EqualFold("asd","AsD") //不区分大小写
fmt.Println(str) //true
fmt.Println("asd"=="ASd") //false  区分大小写

12. 替换指定字符串

str:= strings.Replace("go ,go,hello go" ,"go", "go语言",1) //将go替换为go语言 替换第一个，如果要替换所有那么写-1即可
fmt.Println(str)

//go语言 ,go,hello go

13. 按条件拆分

str := strings.Split("hello, world ,go",",") //按逗号拆分
for i:=0 ; i< len(str); i++{ //遍历str里面的每一个元素
   fmt.Printf("%v\n",str[i])
}

14. 大小写转换

str := "goLang"
str = strings.ToLower(str) //将转换的值又赋给str
struper := strings.ToUpper(str) //新创建一个大写的
fmt.Println(str) //golang
fmt.Println(struper) //GOLANG

15. 去掉字符串两边的空格

str := strings.TrimSpace("   asd asd adas    ")
fmt.Println(str)

16. 去掉两边指定内容

str := strings.Trim("! he!lo  !"," !")//感叹号前有空格 所以去掉的是两边的空格和感叹号
fmt.Println(str)

日期和时间的函数

首先要引入一个time包
1.time.time类型
获取当前时间

package main

import (
	"fmt"
	"time"
)

func main() {
	now := time.Now()
	fmt.Println(now)
}//2020-09-07 14:51:58.3705561 +0800 CST m=+0.005982801

设置输出时间

	fmt.Printf("年 = %v \n",now.Year())
	fmt.Printf("月 = %v \n",now.Month())
	fmt.Printf("日 = %v \n",now.Day())
	fmt.Printf("时 = %v \n",now.Hour())
	fmt.Printf("分 = %v \n",now.Minute())
	fmt.Printf("秒 = %v \n",now.Second())
/*年 = 2020
月 = September
日 = 7
时 = 14
分 = 56
秒 = 53*/

格式化日期
1）直接格式化

fmt.Printf("当前时间 %02d-%02d-%02d %02d:%02d:%02d \n",now.Year(),
		now.Month(),now.Day(),now.Hour(),now.Minute(),now.Second())
//当前时间 2020-09-07 15:01:45

2. 使用format函数格式化

fmt.Printf(now.Format("2006/01/02 15:04:05"))//后面的时间是固定的，数字不能变，但是格式可以随便变化，输出的时候就是你设置格式的样子
fmt.Println()//2020/09/07 15:08:56

时间常量的应用
常量可以在指定程序中可用于获取指定时间单位的时间，比如获取100毫秒

i := 0
for {
	i++
	fmt.Println(i)
	//time.Sleep(time.Second) //每秒休眠
	time.Sleep(time.Millisecond*100) //每0.1秒休眠
}

时间函数的应用
例：计算一个函数运行时间

package main

import (
	"fmt"
	"strconv"
	"time"
)

func test03(){  //将字符拼接100000次
	str := ""
	for i:= 0 ;i< 100000 ; i ++{
		str += "hello" + strconv.Itoa(i) //转为字符串
	}
}
func main() {

	start := time.Now().Unix()//读取现在的时间
	test03() //开始执行函数
	end := time.Now().Unix() //执行之后的时间
	fmt.Println(end - start) //两个时间相减得出运行时间

}

go错误处理

在默认情况下，当发生错误后（panic），程序就会退出
如果我们希望，发生错误后，可以捕获错误，并进行处理，保证程序可以继续执行。还可以捕获错误后，给一个提示

基本用法
go中引入的处理方式为defer，panic，recover

这几个异常步骤为，go中抛出panic异常，然后再defer中通过recover捕获再正常处理。
首先写一个错误的函数进行调用

func test03(){
	n1,n2 := 10,0//定义两个变量
	num := n1/n2
	fmt.Println(num)
	}
func main() {

	test03()//调用函数
	fmt.Println("main") //如果函数可以执行完成会执行这句
}
//runtime error: integer divide by zero 
//输出错误，然后整个程序结束

如果我们不想让函数结束，那么我们需要进行捕获

func test03(){
	defer func() { //开始捕获
		err := recover() //捕获错误信息
		if err != nil{  //如果错误信息不等于nil的正确信息
			fmt.Println(err) //打印错误
		}
	}()
	n1,n2 := 10,0
	num := n1/n2
	fmt.Println(num)
	}

func main() {

	test03()
	fmt.Println("main")
}

//runtime error: integer divide by zero
//main

自定义错误信息
使用errors.New 和panic内置函数
panic内置函数基尔兽一个interface类型的值作为参数，来接收error类型的变量，输出错误信息，并退出程序。