字符串函数
常用方法
统计字符串的长度，按字节len(str)
字符串遍历，同时处理有中文的问题
字符串转整数
整数转字符串
字符串 转 []byte
[]byte 转字符串
10 进制转 2, 8, 16 进制
查找子串是否在指定的字符串中
统计一个字符串有几个指定的子串
不区分大小写的字符串比较(== 是区分字母大小写的
返回子串在字符串第一次出现的 index 值，如果没有返回-1
返回子串在字符串最后一次出现的 index，如没有返回-1
将指定的子串替换成 另外一个子串， n 可以指定你希望替换几个，如果 n=-1 表示全部替换
按 照 指 定 的 某 个 字 符 ， 为 分 割 标 识 ， 将 一 个 字 符 串 拆 分 成 字 符 串 数 组
将字符串的字母进行大小写的转换
将字符串左右两边的空格去掉
将字符串左右两边指定的字符去掉
将字符串左边指定的字符去掉
将字符串右边指定的字符去掉
判断字符串是否以指定的字符串开头
判断字符串是否以指定的字符串结束
package main
import (
"fmt"
"strconv"
"strings"
)
func main() {
// 统计字符串的长度
// go编码是utf-8 英文字母占一个字节，一个汉字占三个字节
str := "hello北"
fmt.Println("str len = ", len(str))
// 遍历字符串，同时处理中文乱码问题
r := []rune(str)
for i := 0; i < len(r); i++ {
fmt.Printf("字符便利%c \n", r[i])
}
// 字符串转整数
// Atoi是ParseInt(s, 10, 0)的简写
//n, err := strconv.Atoi("hello")
n, err := strconv.Atoi("12")
if err != nil {
fmt.Println("转换错误", err)
} else {
fmt.Println("转换结果", n)
}
// 整数转字符串
// Itoa是FormatInt(i, 10) 的简写。
numStr := strconv.Itoa(1)
fmt.Println("整数传唤字符串", numStr)
// 字符串 转 []byte
var bytes = []byte("hello byte")
fmt.Printf("byte %v \n", bytes)
// []byte 转 字符串
byteStr := string([]byte{97, 96, 98})
fmt.Printf("str %v \n", byteStr)
// 10 进制转 2, 8, 16 进制,也可以进行整数转10进制的字符串
str2 := strconv.FormatInt(123, 2)
fmt.Println("10进制转2进制", str2)
str8 := strconv.FormatInt(123, 8)
fmt.Println("10进制转8进制", str8)
// 查找子串是否在指定的字符串中
con := strings.Contains(str, "ll")
fmt.Println("是否存在", con)
// 统计一个字符串有几个指定的子串
cou := strings.Count(str, "l")
fmt.Println("一共有几个l", cou)
// 不区分大小写的字符串比较
fmt.Println("是否相等", strings.EqualFold("hr", "HR"))
// 返回子串在字符串第一次出现的 index 值，如果没有返回-1
fmt.Println("返回第一次出现的index", strings.Index(str, "h"))
// 返回子串在字符串最后一次出现的 index，如没有返回-1
fmt.Println("返回最后一次出现的index", strings.LastIndex(str, "l"))
// 将指定的子串替换成 另外一个子串 n 可以指定你希望替换几个，如果 n=-1 表示全部替换
rep := strings.Replace("hello", "l", "e", -1)
fmt.Println("替换后的值", rep)
// 按 照 指 定 的 某 个 字 符 ， 为 分 割 标 识 ， 将 一 个 字 符 串 拆 分 成 字 符 串 数 组
strArr := strings.Split("hello,word你", "w")
for i := 0; i < len(strArr); i++ {
fmt.Printf("遍历str[%v]=%v \n", i, strArr[i])
}
// 将字符串的字母进行大小写的转换
str3 := " Hello "
lower := strings.ToLower(str3) // 小写
upper := strings.ToUpper(str3) // 大写
fmt.Printf("小写=%v;大写=%v \n", lower, upper)
// 将字符串左右两边的空格去掉
space := strings.TrimSpace(str3)
fmt.Println(space)
// 将字符串左右两边指定的字符去掉
str4 := "!wwww!"
fmt.Println("替换指定字符串", strings.Trim(str4, "!"))
// 将字符串左边指定的字符去掉
fmt.Println("替换左边", strings.TrimLeft(str4, "!"))
// 将字符串右边指定的字符去
fmt.Println("替换右边", strings.TrimRight(str4, "!"))
// 判断字符串是否以指定的字符串开头
prefix := strings.HasPrefix(str4, "!")
fmt.Println("左边开头", prefix)
suffix := strings.HasSuffix(str4, "w")
fmt.Println("右边开头", suffix)
}
时间函数
常用方法
获取当前时间
获取时间的其他信息
格式化日期时间
"2006/01/02 15:04:05" 这个字符串的各个数字是固定的，必须是这样写。
"2006/01/02 15:04:05" 这个字符串各个数字可以自由的组合，这样可以按程序需求来返回时间
Unix将t表示为Unix时间，即从时间点January 1, 1970 UTC到时间点t所经过的时间（单位秒）
UnixNano将t表示为Unix时间，即从时间点January 1, 1970 UTC到时间点t所经过的时间（单位纳秒）。如果纳秒为单位的unix时间超出了int64能表示的范围，结果是未定义的。注意这就意味着Time零值调用UnixNano方法的话，结果是未定义的。
package main
import (
"fmt"
"time"
)
func main() {
// 获取当前时间
now := time.Now()
fmt.Printf("now = %v; type = %T \n", now, now)
// 获取时间的其他信息
fmt.Printf("年=%v\n", now.Year())
fmt.Printf("月=%v\n", now.Month())
fmt.Printf("月=%v\n", int(now.Month())) // 转为数字
fmt.Printf("日=%v\n", now.Day())
fmt.Printf("时=%v\n", now.Hour())
fmt.Printf("分=%v\n", now.Minute())
fmt.Printf("秒=%v\n", now.Second())
// 格式化日期时间 方式1 使用 Printf 或者 SPrintf
fmt.Printf("当前时间%d-%d-%d %d:%d:%d", now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second())
sprintf := fmt.Sprintf("当前时间%d-%d-%d %d:%d:%d", now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second())
fmt.Println("\n", sprintf)
// 格式化日期时间 方式2 使用 time.Format() 方法完成
fmt.Println(now.Format("2006-01-02 15:04:05"))
fmt.Println(now.Format("2006-01-02"))
fmt.Println(now.Format("15:04:05"))
// 获取当前时间戳
fmt.Println("时间戳", now.Unix())
// 获取当前时间戳纳秒
fmt.Println("时间戳", now.UnixNano())
}
时间常量
const (
Nanosecond Duration = 1
Microsecond = 1000 * Nanosecond
Millisecond = 1000 * Microsecond
Second = 1000 * Millisecond
Minute = 60 * Second
Hour = 60 * Minute
)练习：
每隔0.1秒打印一个数字，直到20结束
package main
import (
"fmt"
"time"
)
func main() {
var count = 0
for true {
fmt.Println(count)
count++
time.Sleep(time.Millisecond * 100)
if count > 20 {
return
}
}
}练习
编写一段代码来统计 函数 test03 执行的时间
package main
import (
"fmt"
"strconv"
"time"
)
func test3() {
str := "hello"
for i := 0; i < 100000; i++ {
str += strconv.Itoa(i)
}
}
func main() {
startTime := time.Now().Unix()
test3()
endTime := time.Now().Unix()
fmt.Println("test3()执行时间", endTime-startTime)
}
内置函数
基本说明
Golang 设计者为了编程方便，提供了一些函数，这些函数可以直接使用，我们称为 Go 的内置函数。
文档：https://studygolang.com/pkgdoc -> builtin
常用方法
len：用来求长度，比如 string、array、slice、map、channel
new：用来分配内存，主要用来分配值类型，比如 int、float32,struct...返回的是指针
make：用来分配内存，主要用来分配引用类型，比如 channel、map、slice
package main
import "fmt"
func main() {
num1 := 100
fmt.Printf("num1的类型=%T;num1的值=%v;num1的地址=%v \n", num1, num1, &num1)
num2 := new(int)
fmt.Printf("num2的类型=%T;num2的值=%v;num2的地址=%v;num2这个指针执行的值%v \n", num2, num2, &num2, *num2)
}
内存分析图
异常处理
基本介绍
Go 语言追求简洁优雅，所以，Go 语言不支持传统的 try…catch…finally 这种处理。
Go 中引入的处理方式为：defer, panic, recover
这几个异常的使用场景可以这么简单描述：Go 中可以抛出一个 panic 的异常，然后在 defer 中通过 recover 捕获这个异常，然后正常处理
使用defer+recover 来处理错误
package main
import "fmt"
func test() {
defer func() {
err := recover() // 使用recover()内置函数 捕获异常
if err != nil {
fmt.Println("err=", err)
}
}()
num1 := 10
num2 := 0
num3 := num1 / num2
fmt.Println("num3=", num3)
}
func main() {
test()
fmt.Println("这里执行了")
}
自定义异常errors.New 和 panic
Go 程序中，也支持自定义错误， 使用 errors.New 和 panic 内置函数。
errors.New("错误说明") , 会返回一个 error 类型的值，表示一个错误
panic 内置函数 ,接收一个 interface{}类型的值（也就是任何值了）作为参数。可以接收 error 类型的变量，输出错误信息，并退出程序.
package main
import (
"errors"
"fmt"
"strings"
)
func errTest(name string) error {
if strings.EqualFold(name, "init") {
return nil
} else {
// 返回一个自定义错误
return errors.New("名称错误")
}
}
func test1(name string) {
err := errTest(name)
if err != nil {
// 这里出现错误，程序就终止了
panic(err)
}
fmt.Println("test1后面执行了")
}
func main() {
test1("in")
fmt.Println("main后面执行了")
}
评论区