Golang学习+深入(八)-函数

目录

一、概述

1、时间和日期相关函数

2、内置函数(builtin)

3、错误处理

自定义错误

---

一、概述

1、时间和日期相关函数

1、时间和日期相关函数，需要导入time包
2、time.Time类型，用于表示时间
	now := time.Now()
	fmt.Printf("type=%T val= %v",now,now)
3、获取到当前时间的方法
now := time.Now() //now的类型就是time.Time
4、如何获取到其他的日期信息
	now := time.Now()
	fmt.Printf("type=%T val= %v\n",now,now)
	fmt.Printf("年=%v\n",now.Year())
	fmt.Printf("月=%v\n",now.Month())
	fmt.Printf("月=%v\n",int(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())
5、格式化日期时间
方式1:
now := time.Now()
fmt.Printf("当前年月日%02d-%02d-%02d:%02d:%02d:%02d\n",now.Year(),now.Month(),now.Day(),now.Hour(),now.Minute(),now.Second())
方式2:
        now := time.Now()
	fmt.Printf(now.Format("2006/01/02 15:04:05"))
	fmt.Println()
	fmt.Printf(now.Format("2006/01/02"))
	fmt.Println()
	fmt.Printf(now.Format("15:04:05"))
	fmt.Println()
//"2006/01/02 15:04:05"这个字符串的各个数字是固定的，必须这样写。/可以改成-等
//"2006/01/02 15:04:05"这个字符串各个数字可以自由的组合，这样可以按程序需求来返回时间和日期

6、时间的常量
const (
    Nanosecond  Duration = 1  //纳秒
    Microsecond          = 1000 * Nanosecond //微妙
    Millisecond          = 1000 * Microsecond //毫秒
    Second               = 1000 * Millisecond //秒
    Minute               = 60 * Second  //分
    Hour                 = 60 * Minute  //时
)
//常量的作用:在程序中可用于获取指定时间单位的时间，比如想得到100毫秒 100 * time.Millisecond
7、休眠
func Sleep(d Duration)
//例:
	fmt.Println("start ...")
	time.Sleep(1000 * time.Millisecond) //休眠1000毫秒
	fmt.Println("end ...")
8、获取当前Unix时间戳和UnixNano时间戳(作用是可以获取随机数字)
func (t Time) Unix() int64：Unix将t表示为Unix时间，即从时间点January 1, 1970 UTC到时间点t所经过的时间（单位秒）。
func (t Time) UnixNano() int64：UnixNano将t表示为Unix时间，即从时间点January 1, 1970 UTC到时间点t所经过的时间（单位纳秒）。如果纳秒为单位的unix时间超出了int64能表示的范围，结果是未定义的。注意这就意味着Time零值调用UnixNano方法的话，结果是未定义的。
	fmt.Printf("unix=%v\n",now.Unix())
	fmt.Printf("unixNano=%v\n",now.UnixNano())

2、内置函数(builtin)

Golang设计者为了编程方便，提供了一些函数，这些函数可以直接使用，我们称为Go的内置函数。在godoc文档的builtin下。内置函数也叫内建函数。

1、len:用来求长度，比如string、array、slice、map、channel
2、new:用来分配内存，主要用来分配值类型，比如int、float32,struct....返回的是指针
func new(Type) *Type：内建函数new分配内存。其第一个实参为类型，而非值。其返回值为指向该类型的新分配的零值的指针。
3、make:用来分配内存，主要用来分配引用类型，比如chan、map、slice。

package main
import (
	"fmt"
)
func main(){
	n1 := 100
	fmt.Printf("n1的类型=%T,n1的值=%v,n1的地址=%v\n",n1,n1,&n1)
	n2 := new(int)
	*n2 = 100
	fmt.Printf("n2的类型=%T,n2的值=%v,n2的地址=%v,n2指向的值=%v\n",n2,n2,&n2,*n2)
        //n2的类型=*int,n2的值=0xc00000e0e0,n2的地址=0xc00000a030,n2指向的值=100//默认值是0
}

 

3、错误处理

package main
import (
	"fmt"
)
func test() {
        n1 := 10
	n2 := 0
	res := n1 / n2
	fmt.Println("res=",res)
}
func main(){
	test()
	fmt.Println("main()...")
}
//panic: runtime error: integer divide by zero
//...exit status 2
//在默认情况下，当发生错误后，程序就会退出(崩溃)
//我们希望，发生错误后，可以捕获错误，并进行处理，保证程序可以继续执行

1. Go语言追求简洁优雅，所以，Go语言不支持传统的try...catch...finally这种处理。
2. Go中引入的处理方式为:defer,panic,recover
3. Go中可以抛出一个panic的异常，然后在defer中通过recover捕获这个异常，然后正常处理
4. 错误处理的好处:进行错误处理后，程序不会轻易挂掉，如果加入预警代码，就可以让程序更加的健壮。

例:defer+recover来处理错误

package main
import (
	"fmt"
)
func test() {
	defer func(){
		err := recover()//recover()内置函数，可以捕获到异常
		if err != nil {
			fmt.Println("err=",err)
		}
	}()
	n1 := 10
	n2 := 0
	res := n1 / n2
	fmt.Println("res=",res)
}
func main(){
	test()
	fmt.Println("main()...")
}

自定义错误

Go程序中，也支持自定义错误，使用errors.New和panic内置函数。

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

package main
import (
	"fmt"
	"errors"
)
func readConf(name string) (err error){
	if name == "config.ini" {
		return nil
	}else{
		return errors.New("读取文件错误...")
	}
}
func test() {
	err := readConf("config1.ini")
	if err != nil {
		panic(err) //输出这个错误，并终止程序
	}
	fmt.Println("test()继续执行..")
}


func main(){
	test()
	fmt.Println("main()...")
}
//panic: 读取文件错误...
//...exit status 2

干我们这行，啥时候懈怠，就意味着长进的停止，长进的停止就意味着被淘汰，只能往前冲，直到凤凰涅槃的一天！