GO学习之 常用系统函数_字符串相关函数_时间函数_内置函数
一.常用的字符串函数
后面的一些需要导入strings包
//（1）统计字符串的长度，按字节len(str)
package main
import "fmt"
func main() {
// 统计字符串的长度，按字节
// 一个英文字母占用一个字节
// utf8中一个中文编码一个字符三个字节
str := "hello东"
fmt.Println("str len=",len(str)) // 8
}
//（2）字符串变量，同时处理有中文的问题 r :[] rune(str)
str2 := "hello深圳"
// 有中文的话，需要转rune
str3 := []rune(str2)
for i := 0; i < len(str3); i++ {
fmt.Printf("字符=%c\n",str3[i])
}
//（3）字符串转整数： n.err = stronv.Atoi(“123”)
// 字符串转整数：n,err := strconv.Atoi("12")
n, err := strconv.Atoi("123")
if err != nil{
fmt.Println("转换错误",err)
} else {
fmt.Println("转成的结果是",n)
}
//（4）整数转字符串： str = strconv.Itoa(“hello”)
// 整数转字符串
str4 := strconv.Itoa(12345)
fmt.Printf("str=%v, str_type=%T",str4,str4)
//（5）字符串转byte
// 字符串转byte
var bytes = []byte("hello go")
fmt.Printf("bytes=%v\n",bytes)
//（6）byte转字符串
// byte 转字符串
str5 := string([]byte{97, 98, 99})
fmt.Println("str5=", str5)
//（7）10 进制转 2,8,16进制
// 10 进制转 2,8,16进制 返回对应的字符串
str6 := strconv.FormatInt(123, 2)
fmt.Printf("123对应的二进制是=%v\n",str6)
str7 := strconv.FormatInt(123,8)
fmt.Printf("123对应的8进制是=%v\n",str7)
str8 := strconv.FormatInt(123,16)
fmt.Printf("123对应的16进制是=%v\n",str8)
//（8）查找子串是否在指定的字符串中
需要导入strings
// 查找子串是否在指定的字符串中
is_in := strings.Contains("hszllo","llo")
fmt.Println("是否存在",is_in)
//（9）统计一个字符串中有几个指定的子串
// 统计一个字符串中有几个指定的子串
num := strings.Count("hahahahahhahah", "ha")
fmt.Printf("出现%v次",num)
//（10）不区分大小的字符串比较（==是字母大小写的）
// 不区分带小写比较
is_eq := strings.EqualFold("ASD","asd")
fmt.Println("是否相同",is_eq)
//（11）返回子串在字符串中第一个出现的index值，如果没有返回-1
// 返回子串Index值
index := strings.Index("NNN_ABC","ABC")
fmt.Println("返回index=",index)
//（12）返回子串最后一次出现的index,如果没有返回-1
// 返回子串最后一次出现的index,如果没有返回-1
index_02 := strings.LastIndex("go go go goLang","go")
fmt.Println("最后一次出现index=",index_02)
//（13）字符串的替换
strings.Replace(“hello go go go”,”go”,”go 语言”,n)
n 可以指定希望替换几个，如果n=-1表示全部替换
//字符串的替换
rp_str := strings.Replace("hello go go go","go","go 语言",3)
fmt.Println("替换后的结果:",rp_str)
//（14）字符串的分割，才分为字符串数组
// 字符串的分割，才分为字符串数组
strArr := strings.Split("hello,world,ok",",")
fmt.Println("strArr=",strArr)
// 遍历数组
for i := 0 ; i <len(strArr); i++ {
fmt.Println(strArr[i])
}
//（15）字符串中的带小写转换
// 字符串中的带小写转换
// strings.ToLower("GO")
// strings.ToUpper("go")
res1 := strings.ToLower("GO")
fmt.Println("变成小写：",res1)
res2 := strings.ToUpper("go")
fmt.Println("变成大写：",res2)
//（16）字符串左右空格去掉
// 字符串左右空格去掉
new_str_01 := strings.TrimSpace(" hello go ! ")
fmt.Println("去掉空格的:",new_str_01)
//（17）字符串去掉左右两边的字符串
// 去掉左右两边指定的字符串
new_str_02 := strings.Trim("!!hello go !!","!!")
fmt.Println("去掉左右两边指定的！:",new_str_02)
//（18）字符串去掉左边指定字符串
// 去掉左边指定的字符串
new_str_03 := strings.TrimLeft("!!hello go ! ","!!")
fmt.Println("去掉左边指定的！:",new_str_03)
//（19）字符串去掉右边指定的字符串
// 去掉右边指定的字符串
new_str_04 := strings.TrimRight("!!hello go !!","!!")
fmt.Println("去掉右边指定的！:",new_str_04)
//（20）判断字符串是否以指定的字符串开头
// 判断字符串是否以指定的字符串开头
is_start := strings.HasPrefix("ftp://127.0.0.1","ftp")
fmt.Println("是否为ftp开头:",is_start)
//（21）判断字符串是否以指定的字符串结尾
// 判断字符串是否以指定的字符串结尾
is_end := strings.HasSuffix("www.baidu.com","com")
fmt.Println("是否为com结尾:",is_end)
二.常用的时间与日期函数
时间和日期相关函数，需要导入time包
1.time.Time 时间类型
例：
package main
import (
"fmt"
"time"
)
func main() {
// 日期和时间相关函数与方法的使用
// 1.获取当前时间
now := time.Now()
fmt.Printf("当前时间为:now=%v\n时间类型为：time_type=%T\n",now,now)
// 打印结果：
// 当前时间为:now=2020-03-15 17:59:06.3353254 +0800 CST m=+0.002996901
// 时间类型为：time_type=time.Time
// 通过now获取到年月日，时分秒
fmt.Printf("年=%v\n",now.Year())
fmt.Printf("月=%v %v\n",now.Month(),int(now.Month())) // 英文的 数字加int强转
fmt.Printf("日=%v\n",now.Day())
fmt.Printf("时=%v\n",now.Hour())
fmt.Printf("分=%v\n",now.Minute())
fmt.Printf("秒=%v\n",now.Second())
fmt.Printf("周=%v\n",now.Weekday())
}
2.格式化日期和时间
方式一：
例：
port (
"fmt"
"time"
)
func main() {
// 格式化日期时间
now := time.Now()
fmt.Printf("当前年月日 时分秒 %02d-%02d-%02d %02d：%02d：%02d\n",
now.Year(),now.Month(),now.Day(),
now.Hour(),now.Minute(),now.Second())
dateStr := fmt.Sprintf("当前年月日 时分秒 %02d-%02d-%02d %02d：%02d：%02d\n",
now.Year(),now.Month(),now.Day(),
now.Hour(),now.Minute(),now.Second())
fmt.Printf("%v %T",dateStr,dateStr)
}
方式二：使用time.Format("2006/01/02 15:04:05")
例：
package main
import (
"fmt"
"time"
)
func main() {
// 格式化日期时间
now := time.Now()
// "2006/01/02 15:04:05" 这个字符串的各个数字是固定的，必须是这样写
// "2006/01/02 15:04:05" 这个字符串各个数字可以自由的组合，这样可以按程序需求来返回时间和日期
fmt.Println(now.Format("2006/01/02 15:04:05"))
// 只输出年月日
fmt.Println(now.Format("2006/01/02"))
// 只输出时分秒
fmt.Println(now.Format("15:04:05"))
}
3.时间的常量
const(
Nanosecond Duration = 1 // 纳秒
Microsecond = 1000 * Nanosecond Duration // 微秒
Millisecond = 1000* Microsecond // 毫秒
Second = 1000*Millisecond // 秒
Minute = 60 * Second // 分钟
Hour = 60* Minute // 小时
)
常量的作用：在程序中可用于获取指定时间单位的时间，比如想得到100毫秒 100 * time.Millisecond
休眠：
time.Sleep(1000*time*Millisecond) // 休眠100毫秒
例：
i := 0
for {
i ++
fmt.Println(i)
time.Sleep(time.Second)
if i >= 10 {
break
}
}
4.获取unix时间戳和unixnano时间戳
作用是可以获取随机的数字
从1970年1月1日0时0分0秒 到现在的时间
例子：
package main
import "fmt"
import "time"
func main() {
now := time.Now()
// Unix 和 UnixNamo
fmt.Printf("uinx时间戳=%v \nunixnano时间戳=%v",now.Unix(),now.UnixNano())
}
例：计算程序运行时间
package main
import "fmt"
import "strconv"
import "time"
func test() {
str := ""
for i := 0 ; i < 100000; i++ {
str += "hello" + strconv.Itoa(i)
}
}
func main() {
start := time.Now().Unix()
test()
end := time.Now().Unix()
fmt.Printf("执行程序耗费时间为%v秒",end-start)
}
三．内置函数builtin
Golang设计者为了编程方便，提供了一些函数，这些函数可以直接使用，我们称为GO的内置函数。
文档：https://studygolang.com/pkgdoc -> builtin
1.len
用来求长度，比如：string,array,slice,map,channel
2.new
用来分配内存，主要用来分配值类型，比如int,float32,struct...返回的是指针
举例：
package main
import "fmt"
func main() {
//
num1 := 100
fmt.Printf("num1的类型%T,num1的值=%v,num1的地址%v\n",num1,num1,&num1)
num2 := new(int) // num2是指针
// 指针的值是一个地址
// num2 的类型%T => *int
// num2 的值 = 地址 0xc0000540a0
// num2的地址 = 0xc000080020
// 修改num2 指向的的值
*num2 = 100
fmt.Printf("num2的类型%T,num2的值=%v,num2的地址%v 指向的值=%v\n",num2,num2,&num2,*num2)
}
3.make
用来分配内存，主要用来分配引用类型，比如channel、map、slice。
4.错误处理
默认情况下代码逻辑或语法错误，会报错。
如果让报错跳过继续运行就需要使用到错误处理机制。
基本说明：
（1）GO语言追求简洁优雅，所有，GO语言不支持传统的try...catch..finally （java）这种处理
（2）GO中引入的处理方式为：defer,panic,recover
（3）GO中可以抛出一个panic的异常，然后在defer中通过recover捕获这个异常，然后正常处理。
举例：defer + recover
package main
import "fmt"
func test() {
// 使用defer + recover 来捕获和处理异常
defer func() {
err := recover() //内置函数recover可以捕获到异常
if err != nil { // 说明捕获到异常或错误
fmt.Println("err=",err)
}
}()
num1 := 10
num2 := 0
res := num1 / num2
fmt.Println("res=",res)
}
func main() {
//
test()
// 下面的代码正常指向
fmt.Println("test() 后运行的")
}
错误处理的好处：
进行错误处理后，程序不会轻易挂掉，如果加入预警代码，就可以让程序更加的健壮。
自定义错误
GO程序中，也支持自定义错误，使用errors.New和panic内置函数。
（1）errors.New(“错误说明”),会返回一个error类型的值，表示一个错误
（2）panic内置函数，接收一个interface{} 类型的值（也就是任何值），作为参数。可以接收error类型的变量，输出错误信息，并退出程序。
举例：自定义错误
package main
import (
"errors"
"fmt"
)
// 函数去读取以配置文件init.conf的信息
// 如果文件名传入不正确，我们就返回一个自定义的错误
func readConf(name string) (err error) {
if name == "config.ini" {
// 读取
return nil
} else {
// 返回一个自定义错误
return errors.New("读取文件错误...")
}
}
func test() {
err := readConf("config.ini2") // 看传的文件名是否正确，不正确就报错
if err != nil {
// 如果读取文件发送错误，就输出这个错误，并终止程序
panic(err)
}
fmt.Println("test继续执行")
}
func main() {
// 自定义错误的使用
test()
fmt.Println("运行main()后面的代码")
}
