go-函数和错误处理

函数基本语法

func 函数名（形参列表）（返回值列表）{

   执行语句

   return 返回值列表

}//返回值可以没有可以有多个可以有一个

包

引入

为了解决两个程序员取得函数名同名的情况

原理

本质就是创建不同的文件夹

概念

go的每一个文件都属于一个包，即go是以包来管理文件和项目目录结构的

作用

区分相同名字的函数，变量等标识符

程序文件很多时，很好的管理项目

控制变量，函数等访问范围，即作用域，大写公有，小写私有

说明

package：包名

import：包的路径

使用注意事项

给一个文件打包，该包对应一个文件夹，文件的包名通常和文件所在的文件夹名一致，一般为小写字母

要用包，先引包

import(

"包名"

”包名“

)

import “包名”

package指令在第一行，然后是import

在import包时，路径从$GOPATH的src下开始，不用带src，编译器会自己从src下引入

函数首字母大写才可以让其他包文件访问本包文件

访问：包名.函数名

如果包名较长，支持给包取别名，但是，取别名后原来的包名不能再用

在import里：别名包名

同一包下，不能有相同函数名，否则报错

语法规范

编译生成一个可执行文件，需要将这个包名声明称main，即package main，但如果写的是一个库，包名可以自己定义

go build go_code/...../main

不需要带src编译器会自动带上

编译需编译main所在的文件夹

项目的目录结构最好按照规范来写

函数调用

说明

基本数据类型一般存放在栈区，编译器存在逃逸分析

引用类型存放在堆区，编译器存在逃逸分析

另外还有一个代码区

调用时分配新的空间，和其他栈区分开，每个空间独立不会混淆，函数执行完毕后销毁该空间

return语句

可接受多个，不想要可用占位符_忽略

若返回值有多个加（返回值类型列表），一个则不用_

res1, res2 := getsunAndsub(1,2)//该函数两个返回值

_, res2 := getsunAndsub(1,2)//占位符_忽略

递归

总结

执行函数，创建一个新的受保护的独立空间（新函数栈）

函数局部变量独立，不会相互影响

递归向退出递归条件的逼近，否则无限递归

函数执行完毕或遇到return就会返回，谁调用返回睡，自身销毁

小细节

数组是值传递，函数内修改，不会影响原来的值

希望函数可以改变函数外变量可以用&

函数内以指针操作

效果上看类似于引用

funct test(n1 *int){...}

test(&n1)

不同于c++的引用

int fun(int &a,int &b){...}

fun(a,b);

go中函数不支持重载，会报函数重复定义的错误

go中函数也是一种数据类型，可以赋值给一个变量，则该变量就是函数类型变量，可以通过改变量来对函数进行调用

func test(n int ,m,int){...}

a :=tset

res := a(10,20)//等价于res := test(10,20)

函数既然是一种数据类型，因此可以作为形参，并且调用

res2 :=myFun(getSun,n1,n2)

func myFun( funcvar fun(int, int) int,   num1 int,  num2 int) int{

   return funcvar(num1,num2)

}

### go

支持自定义数据类型,可化简定义

type 自定数据类型名  数据类型

type myIny int

type myFuncType  func(int,  int )int

这是可用myFunType代替形参 func（int，int）int

支持函数返回值命名

func getSunAndSub( n1 int, n2 int) (sum int ,sub int){

   sub = n1-n2

   sum = n1+n2

   return

}

_表示忽略

go支持可变参数

//支持0到多个参数

func sun(args...int) sun int{...}

//支持1到多个参数

func sum(n int, args...int) sun int{...}

//args是切片，通过args[index]访问到各个值

`func sum(n1,n2 float)float{...}//n1 type=float`

给函数类型的变量赋值函数：形参个数一样，返回值个数一样才算同种类型的即一个形参对应于一种函数类型

type myFuncType  func(int,  int )int

不能把func sum（n1,n2,n3 int）int{...}赋值给myFuncType

类型要匹配

init函数

介绍

每一个源文件都可以有一个init函数，会在main前执行，被go运行框架调用

通常在init中完成初始化工作

注意事项和细节

全局变量在init前执行

若import有utils.go则执行顺序

1.utils.go中的变量定义

2.utils.go中的init

3.main.go中的全局变量定义

4.main.go中的init

5.main.main函数

匿名函数(是一种类型)

没有名字，若只希望用一次，可以考虑使用匿名函数，当然也可调用多次

	res := func( n1 int, n2 int) int {

    return n1 +n2

}(10 ,20)

		//这种方式为定义时调用，只能调用一次

	res := func( n1 int, n2 int) int {

    return n1 +n2

}

res2 := res(10 ,20)

		//将函数付给一个变量，通过变量可多次调用匿名函数

全局匿名函数

将匿名函数付给一个全局变量，那吗可在程序中有效

		var(

   Fun1 = func (n1 int ,n2 int) int {

    return   n1*n2

  }

)

闭包

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

func AddUpper() func (int) int {

   var n int = 10

   return func (x int) int {

  n = n+x

  return n

}

 }

		//AddUpper是一个函数，返回类型为func(int) int

		//n的值类似于一个静态变量

f := AddUpper()

fmt.println(f(1))//11

fmt.println(f(2))//13

上面匿名函数和函数外的形成了一个整体，构成闭包

函数和他引用到的变量构成了闭包

案例

判断文件后缀名是否为jpg，给文件加或不加

闭包完成

内函数引用到外函数的形参或定义的变量构成闭包

闭包可以保留上次引用的值，所以

优点：传入一次就可以反复使用

package main

import (

	"fmt"

	"strings"

)

func makeSuffix(suffix string) func (string) string {

	return func (name string) string {

		//如果 name 没有指定后缀，则加上，否则就返回原来的名字

		if !strings.HasSuffix(name, suffix)  {

			return name + suffix

		}

		return name

	}

}

func makeSuffix2(suffix string, name string)  string {

	//如果 name 没有指定后缀，则加上，否则就返回原来的名字

	if !strings.HasSuffix(name, suffix)  {

		return name + suffix

	}

	return name

}

func main(){

    //测试makeSuffix 的使用

	//返回一个闭包

	f2 := makeSuffix(".jpg") //如果使用闭包完成，好处是只需要传入一次后缀。

	fmt.Println("文件名处理后=", f2("winter")) // winter.jgp

	fmt.Println("文件名处理后=", f2("bird.jpg")) // bird.jpg

	fmt.Println("文件名处理后=", makeSuffix2("jpg", "winter")) // winter.jgp

	fmt.Println("文件名处理后=", makeSuffix2("jpg", "bird.jpg")) // bird.jpg

}

defer

why

函数中，程序员经常需要创建资源，为了在函数执行完毕后，及时释放资源，go的设计组提供了defer（延时机制）

执行到defer时将defer后面的语句压入到独立的栈中（defer栈）

当函数执行完毕后，再从defer栈中按先入后出的方式出栈

注意事项

defer入栈时，会将相关值进行拷贝一起放入栈，注意，此值不收其他表达式影响

其价值在于函数执行完毕后，及时释放函数创建的资源

创建资源

defer 释放资源,其他代码不用再担心在什么时候关闭资源

函数传参机制

值类型值拷贝，引用类型地址拷贝

一般来说地址拷贝效率高，因为数据小，而值拷贝，数据越大，效率越低

变量作用域

函数内部的作用域仅限于函数内

函数外部的定义变量叫作全局变量在整个包内有效，若首字母大写在整个程序有效

在一个代码块中定义，则只在代码块中有效

编译器会采用就近原则

name := "tom"//错误，因为等价于var Name string Name = "tom"

字符串常用的系统函数

统计字符串长度

len(str)

字符串遍历，可带中文

r :=[]rune(str)

字符串转整数

n,err := strconv.Atoi("12")

整数转字符串

str = strconv.Itoa(12345)

字符串转[]byte

var bytes = []byte("hello go")

[]byte转字符串

str = string([]byte{97,98,99})

10进制转2 8 16进制

str = strconv.FormatInt(132,2)

在母串中查子串

strings.Contains("seafood","food")

母串中统计子串

strings.Counts("seafood","food")

不区分大小写的比较

stringsEqualFold("abc",""ABC)

返回子串在字符串第一次出现的index若没有返回-1

strings.Index("NLT_abc","abc")

指定子串替换为另一个子串

strings.Replace("go go hello","go","go语言"，n)//n可指定几个-1表示全部替换

按照特定的某个字符为标识符将一个字符串拆分成字符数组

strings.Split("hello,word,ok",",")

字符串大小写转换

strings.TOLower("Go")

strings.ToUpper("Go")

将字符串两边的空格去掉

strings.TrimSpace(" asassdf ")

将字符串两边指定字符去掉

strings.Trim("! hello!","!")//["!"],将“!”去掉

strings.TrimLeft()去左边

strings.TrimRight()去右边

判断是否已指定的字符串开头

strings.HasPrefix("ftp://192.168.10.1","ftp")

strings.HasSuffix()判断是否已字符串结束

时间和日期相关的函数

需先引入time包

time.Time获取时间

now := time.now()

now.year()

分秒以此类推，返回类型为字符串型可转换

格式化时间

法一：用Print或Sprintf

法二：用time.Format()完成

注意格式

单位

Nanosecond纳秒

Microsecond微妙

Millisecond毫秒

在程序中获取指定单位的时间 100*time.Millisecond

结合sleep使用：time.Sleep(100*time.Millisecond)

time的UnixNano和Unix

时间戳

获取时间的单位为妙

单位为纳秒

Now.Unix() 从1970年1月1日到现在的时间差

可用来统计一个函数执行的时间。利用时间戳

内置函数

len用来求长度

new用来分配内存，主要分配值类型，返回的是指针返回值是一个地址的数值，地址又是一个数值，都是系统分配的

make用来分配地址主要用于引用类型

错误处理

希望错误出现后可以捕获到错误并进行处理保证程序执行，还可以不货到后给管理员一个提示（邮件或短信），而不是崩溃，所以引出错误处理机制

go追求优雅，所以不支持try..catch...finally处理方式为defer，panic，recover

抛出一个panic错误然后在defer中通过recover捕获这个异常，然后正常处理

defer+recover处理

defer fucn() {

  err := recover()

  if err != nil {

   fmt.Println("err=",err)

  }

}

recover内置函数可以捕获到异常

错误处理好处

程序不会轻易挂掉，加入警戒代码，让代码更健壮

自定义错误

使用errows.New和panic内置函数

errors.New("错误说明")，会返回一个error类型的值，表示一个错误

panic内置函数接受一个interface{}类型的值（也就是任和值了），可以接受error类型变量，输出错误信息，并退出程序

package main

import (

	"fmt"

	_ "time"

	"errors"

)

func test() {

	//使用defer + recover 来捕获和处理异常

	defer func() {

		err := recover()  // recover()内置函数，可以捕获到异常

		if err != nil {  // 说明捕获到错误

			fmt.Println("err=", err)

			//这里就可以将错误信息发送给管理员....

			fmt.Println("发送邮件给admin@sohu.com~")

		}

	}()

	num1 := 10

	num2 := 0

	res := num1 / num2

	fmt.Println("res=", res)

}

//函数去读取以配置文件init.conf的信息

//如果文件名传入不正确，我们就返回一个自定义的错误

func readConf(name string) (err error) {

	if name == "config.ini" {

		//读取...

		return nil

	} else {

		//返回一个自定义错误

		return errors.New("读取文件错误..")

	}

}

func test02() {

	err := readConf("config2.ini")

	if err != nil {

		//如果读取文件发送错误，就输出这个错误，并终止程序

		panic(err)

	}

	fmt.Println("test02()继续执行....")

}

func main() {

	//测试

	// test()

	// for {

	// 	fmt.Println("main()下面的代码...")

	// 	time.Sleep(time.Second)

	// }

	//测试自定义错误的使用

	test02()

	fmt.Println("main()下面的代码...")

}

巴特西