Go 常用函数

#### Go 常用函数,错误处理
这一节我们来学习一下Go 常用的函数,这些函数有些是内置的,有些是官方标准库内的, 熟悉这些函数对程序开发来讲还是很重要的;  
1. len("abc") 统计字符串的字节长度

fmt.Println(len("abc,我")) // 4 + 3 = 7 中文字符占三个字节

　　

2. strconv.Atoi("11") 将字符串转为整数

    var str = "11"
   s,err := strconv.Atoi(str)
   fmt.Println(s,err) // 11 nil , 默认如果没有错误,返回nil

　　

3. strconv.Itoa(11) 将整数转为字符串

    var a = 11
   s := strconv.Itoa(a)
   fmt.Println(s) // 11,默认情况下,如果转换不成功返回空字符串

　　

4. strconv.FormatInt(11,2) 将int64 类型的整数转为2,8,16 进制的字符串

   var a int64 = 11
   fmt.Println(strconv.FormatInt(a,10)) // 11
   fmt.Println(strconv.FormatInt(a,2)) // 1011
   fmt.Println(strconv.FormatInt(a,8)) // 13
   fmt.Println(strconv.FormatInt(a,16)) // b

　　

5. []byte("abc") 将字符串转为字节切片

    var a = "abc"
   fmt.Println([]byte(a)) // [97 98 99]

　　

6. []rune("你好") 将包含中文或其它语言的字符串转为rune 字节切片 

    var a = "你好"
       fmt.Println([]rune(a)) // [20320 22909] unicode 编码

　　

7. strings.Contains("abc","a") 判断字符串是否包含目标字符

    fmt.Println(strings.Contains("abc","a")) // true

　　

8. strings.Count("abc","a") 统计字符串中出现目标字符的个数

    fmt.Println(strings.Count("abaac","a")) // 3

　　

9. strings.EqualFold("abc","ABC") 不区分大小写的字符串比较

    fmt.Println(strings.EqualFold("abc","ABC")) // true

　　

10. strings.Index("aabbcc","a") 查询目标字符中字符串中首次出现的索引(下标)值 

    fmt.Println(strings.Index("aabbcc","a")) // 0

　　

11. strings.LastIndex("aabbcc","a") 查询目标字符中字符串中最后一次出现的索引(下标)值 

    fmt.Println(strings.LastIndex("aabbcc","a")) // 1

　　

12. strings.Replace("aabbcc","a","d",-1) 将指定的字符串替换为另一个字符串,可以指定替换个数

    // -1 表示替换所有的目标字符
    fmt.Println(strings.Replace("aabbcc","a","d",-1)) // ddbbcc

　　

13. strings.Split("aa,bb,cc",",") 将字符串按指定的字符转换成***字符串切片***

    fmt.Println(strings.Split("aa,bb,cc",",")) // [aa bb cc]

　　

14. strings.ToUpper("aa") 将字符串转为大写

    fmt.Println(strings.ToUpper("aa")) // AA

　　

15. strings.ToLower("AA") 将字符串转为小写

    fmt.Println(strings.ToUpper("AA")) // aa

　　

16. strings.TrimSpace(" aa bb cc ") 将字符串左右两边的空格去掉

    fmt.Println(strings.TrimSpace(" aa bb cc ")) // aa bb cc

　　

17. strings.Trim(",aa,bb,cc,",",") 将字符串左右两边指定的字符去掉

    fmt.Println(strings.Trim(",aa,bb,cc,",",")) // aa,bb,cc

　　

18. strings.TrimLeft(",aa,bb,cc,",",") 将字符串左边指定的字符去掉

    fmt.Println(strings.TrimLeft(",aa,bb,cc,",",")) // aa,bb,cc,

　　

19. strings.TrimRight(",aa,bb,cc,",",") 将字符串右边指定的字符去掉

    fmt.Println(strings.TrimRight(",aa,bb,cc,",",")) // ,aa,bb,cc

　　

20. strings.HasPrefix("http://127.0.0.1","http") 判断字符串是否以指定的字符开头

    fmt.Println(strings.HasPrefix("http://127.0.0.1","http")) // true

　　

21. strings.HasSuffix("abc.jpg","jpg") 判断字符串是否以指定的字符结尾

    fmt.Println(strings.HasSuffix("abc.jpg","jpg")) // true

　　

---
##### 时间和日期相关的函数
时间和日期相关的函数需要导入time 包  
时间的类型为: time.Time 
时间常量:

const (
   Nanosecond  Duration = 1                   // 纳秒
   Microsecond          = 1000 * Nanosecond   // 微秒
   Millisecond          = 1000 * Microsecond  // 毫秒
   Second               = 1000 * Millisecond  // 秒
   Minute               = 60 * Second         // 分
   Hour                 = 60 * Minute         // 小时
)

　　

package main

import (
   "fmt"
   "math"
   "time"
)

func main() {
   now := time.Now()
   fmt.Printf("now value is %v,now type is %T\n", now, now)
   // 获得到具体的时间
   fmt.Println(now.Year())   // 年
   fmt.Println(now.Month())  // 月
   fmt.Println(now.Day())    // 日
   fmt.Println(now.Hour())   // 时
   fmt.Println(now.Minute()) // 分
   fmt.Println(now.Second()) // 秒
   fmt.Println(now.Date())   // 日期
   // 格式化日期
   // 2006-01-02 15:04:05  这6个数字是固定的,必须这样写, 位置可以随意更改,其中15,也可以写成03,代表24时制和12小时制
   fmt.Println(now.Format("2006-01-02 15:04:05"))
   fmt.Println(now.Unix())  // 从1970-01-01 到现在经过的的时间: 秒
   fmt.Println(now.UnixNano()) // 从1970-01-01 到现在经过的的时间: 纳秒, 如果超过int64 表示的范围,结果将溢出
   fmt.Println(math.MaxInt64) // int64 能表示的最大范围
}

　　

---
###### 内置函数
Go 中提供了一些函数, 这些函数可以直接使用,称为内置函数
1. len: 用来求长试, 如: string,array,slice,map,channel ;  
2. new: 用来分配内存主要用来分配值类型的,如: int,float64,struct 等, 返回的是对应值类型的指针;  
3. make: 用来分配内存,主要用来分配引用类型,如: channel,map,slice.
4. make 的作用,稍后学习到复合数据类型时再详细学习,这里先学习一下用法

package main

import "fmt"
func main(){
   var a *int  // 定义变量a 的类型为 *int , int 类型的指针
   a = new(int) // 用new 来分配内存
   fmt.Printf("a value is %p\n",a) // 变量的a 的值, 实际是上一步new 出来的地址: 0xc000010098
   fmt.Printf("a address is %p\n",&a) // 变量a 的地址, 变量a 本身的自己的地址:  0xc000006028
   *a = 100   // 将a 的地址指向值100
   fmt.Println(*a)
   // 对比一下传统的变量声明
   var b int
   b = 100
   fmt.Printf("b value is %d\n",b)
   fmt.Printf("b address is %p\n",&b)
   // 用new 方式
   // a --> 0xc000010098 --> 100
   // 用普通方式
   // b --> 100
   //
   // make
   var c []int
   c = make([]int,1) // 为引用类型c(切片),分配内存,如果不分配内存(声明的方式)是不可以使用的
   // 这里重新强调一下变量的几种声明方式
   // 1. 显示声明变量的类型,再赋值,var b int , b = 100 ;此种方式声明的引用类型的变量必须make,否则变量无法使用
   // 2. 直接为变量赋值, 编译器为推断变量的类型, var b = 100; 此种方式声明的引用类型的变量也必须make,否则变量无法使用
   // 3. 短变量声明,只适用为函数内部, b := 100
   c[1] = 10
   fmt.Println(c)
}

　　

--- 
##### 错误处理
1. 默认情况下,当程序发生panic 错误后,程序就会退出;  
2. 实际上有的错误并不需要退出,为了保证程序能正常的运行,我们可以捕捉错误,并进行错误处理;  
3. Go 中不支持传统的try...catch...finally 这种语法, 它的错误捕捉处理方式为: defer panic,recover;  

package main

import "fmt"

func test01(){
   // 使用defer recover 来捕捉错误
   defer func() {
      r := recover()
      if r != nil {
         fmt.Println("捕捉到了错误,需要处理")
         fmt.Println(r)
      }
   }()
   a := 10
   var b int
   res := a / b // 除数不能为0, 所以这个地方会导致程序panic , 也就是崩溃,加入错误处理机制后可保证程序正常运行
   // 如果没有defer recover 程序到这里就退出了;
   fmt.Println(res)

}
func main(){
   test01()
   fmt.Println("错误处理后,还能正常运行")
}

　　

---
##### 自定义错误 
自定义错误,需要用来errors 包和panic 函数;  
errors.New("string") 返回一个错误类型的值,表示一个错误   
panic 是一个内置函数,接收一个interface 的值(可以接收任意值),输出错误信息,并退出程序;  

package main

import (
   "errors"
   "fmt"
)

func test01()(err error){
   defer func() {
      r := recover()
      if r != nil {
         // 自定义错误
         err = errors.New("something is wrong")
         return
      }
   }()
   var a = 10
   var b int
   res := a / b
   fmt.Println(res)
   return nil
}
func main()  {
   err := test01()
   if err != nil {
      panic("test01 is wrong") // 报出错误,并退出程序
   }
   fmt.Println("main is running")
}

　　个人微信公众号上有最新文章: 欢迎大家关注一同学习交流