日期和时间函数
获取当前日期和时间
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中
注：拷贝互不影响只是低层创建了一个一模一样的新数组
标签：切片,slice,int,fmt,基础,Golang,数组,var From： https://www.cnblogs.com/qwerty-wy/p/16659430.html