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")
}
个人微信公众号上有最新文章: 欢迎大家关注一同学习交流
每天进步一点点！加油
