Golang基础-4

日期和时间函数

获取当前日期和时间

time.Now()返回值是一个结构体类型是time.Time(结构体)

返回值的类型也有对应的方法获得具体的年，月，日，时，分，秒

比如：

直接通过.xxx（）的方式获取

日期的格式化

fmt.Sprintf()有返回值可以得到字符串内容以便后续使用

还有种方式是使用其返回值自带的Time.Format()注意里面的参数的数字固定了必须是（2006,01,02,15,04,05）分别对应了年月日时分秒，任意组合都是可以的要年日时：

now:=time.Now()
s:=now.Format("2006.02,15时")

内置函数（内建函数）

可以不用导包直接使用的函数

包builtin下的函数全都不用导包

常用的这两个其中len（）比较简单

其中new(Type)*Type函数返回对应类型的指针，用于声明未命名的函数，初始值为此类型的零值，并返回其地址（指针存放的就是对应的地址）

p:=new (int)
fmt.Println(*P)//输出“0”

new（）是预声明函数，不是关键字，所以可以重新定义

错误处理机制

defer+recover

以下是一个错误案例

错误处理/捕获机制：

具体捕获代码如下

func main(){
	test()
	fmt.Println("方法执行成功")
	fmt.Println("继续执行下面代码")
}
func test(){
	//利用defer+recover来捕获错误：defer后加上匿名函数的调用
	defer func(){
		// 调用recover内置函数，可以捕获错误
		err:=recover()
		// 如果没有错误产生，返回零值-nil
		if err != nil{
			fmt.Println("错误已经捕获")
			fmt.Println("err是：",err)
		}
	}()
	num1:=10
	num2:=0
	result:=num1/num2
	fmt.Println(result)
}

作用-可以暂时跳过err继续执行程序

自定义错误

需要调用errors包下的New（）函数

package main
import (
		"fmt"
		"errors"
)
func main(){
	err := test()
	if err !=nil{
		fmt.Println("自定义错误是：",err)
	}
	fmt.Println("方法执行成功")
	fmt.Println("继续执行下面代码")
}
func test()(err error){
	num1:=10
	num2:=0
	if num2 == 0{
		return errors.New("除数不能为零")
	}else{	
	result:=num1/num2	
	fmt.Println(result)
	// 如果没有错误返回一个零值-nil
		return nil
		}
}

当我们出现错误时候，一般后面的代码都会受到影响，所以一般会在错误出现时中断

程序

这里要借助内置函数

在上面例子的基础上加上panic函数、

可以看到程序被中断了

数组

定义方式；

var 数组名 [数组大小]Type

例子：

var scorces [5]int 
var sum int = 0
scorces[0]=95
scorces[1]=95
scorces[2]=95
scorces[3]=95
scorces[4]=95
//求和
for i:=o;i<len(scorces);i++{
    sum+=scores
}
avg := sum/len(scorces)
fmt.Println(avg)

数组的内存分析如下

注意根据类型决定乘以几，这里乘以2是因为int16占了两个字节

优点：访问速度快

例子：

func main(){
	var scorces [5]int
	// 循环+Scanln来从终端录入学生成绩
	for i:=0;i<len(scorces);i++{
		fmt.Printf("请录用第%d的学生成绩",i+1)
		fmt.Scanln(&scorces[i])
	}
	// 展示学生成绩
	for i:=0;i<len(scorces);i++{
		fmt.Printf("第%d个学生的成绩为：\t%d\n",i+1,scorces[i])
	}
	fmt.Println(".................................")
	// 用for range遍历数组
	for i,value:=range scorces{
		fmt.Printf("第%d个学生的成绩为：\t%d\n",i+1,value)
	}
}

数组的初始化

定义的时候直接初始化

var arr1 [3]int = [3]int{3,6,8}

var arr2 = [3]int{1,4,5}

var arr3 = [...]int{4,5,6,7,8}

4.指定下标对应值

var arr3 = [...]int{2:4,5:5,20:6,0:7,3:8}

注意事项

1.长度属于类型的一部分

	var scorces [5]int
	fmt.Printf("数组的类型为%T",scorces)

2.在go语言中数组属于值类型，在默认情况下是值传递（进行值的拷贝，不会改变实际的值，要想直接改变实际值要将指数类型作为参数传递如&scorces[i]）

二维数组

声明格式：

var arr  [2][3]int16

赋值操作和一维数组是一样的

初始化操作也是类似的

var  arr [2][3]int = [2][3]int{{1,4,7},{2,5,8}}

二维数组的遍历

	var  arr [3][3]int = [3][3]int{{1,4,7},{2,5,8},{3,6,9}}
	// 遍历二维数组 普通for
	for i:=0;i<len(arr);i++{
		for j:=0;j<len(arr[i]);j++{
			fmt.Print(arr[i][j],"\t")
		}
		fmt.Println()
	}
	fmt.Println(".................................")
	// 遍历二维数组 for range
	for key,value:=range arr{
		for k,v:=range value{
			fmt.Printf("arr=[%v][%v]的值=%v\t",key,k,v)
		}
		fmt.Println()
	}

切片

切片（slice）是一种建立在数组类型上抽象，是对数组一个连续片段的引用，是一个引用类型。这个片段可以是整个数组，也可以是由起始位置索引标识的一些 项的子集，注意终止的索引标识不包括在切片内相关于[ )，切片提供了一个相关数组的动态窗口

声明格式：（因为其建立在数组的基础上，所以创建需要数组）

var intarr [6]int = [6]int{2,5,6,7,3,4}
//切片建立在数组之上
//创建一个切片叫slice，长度是动态的所以不写
var slice []int = intarr[1:3]
//这里int是类型，intarr数字名，1是开始位置索引，3是结束位置，包括了1，不包括3
、、、下面是一样的
slice := intarr[1:3]

内存分析如下：

获取切片的长度和容量

//长度
len(slice)
//容量，用内置函数cap（）
cap(slice)

切片的定义

1.在数组上截取片段

slice := intarr[1:3]

2.通过内置函数make（）来创建切片，基本语法 var 切片名[]Type=make([]Type,len,cap)

slice := make([]int,4,20)

以上三个参数分别是

1.切片的类型

2.切片的长度

3.切片的容量

注意：这种方式是make底层创建一个数组，所以不可以直接操作这个数组，要通过slice去间接的访问各个元素

3.定义一个切片，直接就指定具体数组，类似于make方式

slice2 := []int{1,4,7}

遍历

1.普通for

slice := make([]int,4,20)
slice[0]=44
slice[1]=45
slice[2]=46
slice[3]=47
for i:=0;i<len(slice);i++{
	fmt.Printf("slice[%v]=%v \t",i,slice[i])
}

2.for range

for i,value := range slice{
	fmt.Printf("slice[%v]=%v \t",i,value)
}

注意事项

第四点就将已有切片当成一个数组创建一个新的切片

5，切片可以动态增长

用内置函数append（）

如果是再切片后面追加切片可以这样写

slice := []int{2,3}
slice2 := []int{1,4,7}
slice = sppend(slice,slice2...)
//三个点必写代表追加切片，而且是切片中所有内容

切片的拷贝

用内置函数copy（）

slice := []int{2,3}
slice2 := []int{1,4,7}
copy(slice2,slice)//将slice内容复制到slice2中

注：拷贝互不影响只是低层创建了一个一模一样的新数组