Golang-基础包

1. math包

fmt.Printf("%#v\n",err) // (*os.PathError)(nil)

fmt.println(math.abs(-19)) // 取绝对值
fmt.Println(math.Floor(3.14)) // 向下取整
fmt.Println(math.Ceil(3.14)) //向上取整
fmt.Println(math.Round(3.3478)) //就近取整
fmt.Println(math.Round(3.3478*100)/100) //四舍五入
fmt.Println(math.Mod(11, 3)) //取余数
fmt.Println(math.Pow(2, 3))  //计算次方
fmt.Println(math.Pow10(2))   //计算10次方
fmt.Println(math.Max(2, 10)) //取较大值
fmt.Println(math.Min(2, 10)) //取较小值

2. strconv包

//整型转字符串
v1 := strconv.Itoa(123)

//字符串转int整型
v2, _ := strconv.Itoa("123")

//字符串转int64整型
v3, _ := strconv.ParseInt("123")

//字符串转bool值
//True: "1", "t", "T", "true", "True", "TRUE"
//False: "0", "f", "F", "false", "False", "FALSE"
//其他报错，返回错误
v4, _ :=  strconv.ParseBool("1")

//布尔转字符串
v5 := strconv.FormatBool(true)

3. strings

常规功能

// 常规功能

//用于比较两个字符串。它用于按字典顺序比较两个字符串,
//如果字符串相等(s1 == s2)，则返回0
//如果字符串1大于字符串2(s1> s2)，则返回1。
//如果字符串1小于字符串2，则返回-1(s1 

字符串切割

//字符串转切片
fmt.Println(strings.Split("a,b,c", ","))    //[ a b c]

fmt.Println(strings.SplitAfter("a,b,c", ","))   //[a, b, c] 

fmt.Println(strings.SplitAfterN("a,b,c", ",", -1))  

// 最后一个参数 n 就是返回的切片元素个数 
fmt.Println(strings.SplitAfterN("a,b,c", ",", 2)) 

// 用 len 可以验证，其实就是将这段 str 分割成多少"段"
fmt.Println(len(strings.SplitAfterN("/usr/local/bin/abs/sdk", "/", 3))) 

获取 substr 索引

//子串sep在字符串s中第一次出现的位置，不存在则返回-1
fmt.Println(strings.Index("ethan,thanks", "than"))   //1

//子串sep在字符串s中最后一次出现的位置，不存在则返回-1。
fmt.Println(strings.LastIndex("ethan,thanks", "than")) //6

字符串拼接

//切片转字符串
//将一系列字符串连接为一个字符串，之间用sep来分隔。
fmt.Println(strings.Join([]string{"usr", "local", "bin"}, "/")) // usr/local/bin

Trim 系列函数

//返回将s前后端所有cutset包含的utf-8码值都去掉的字符串。
fmt.Println(strings.Trim("  abc   ", "a ")) //bc
fmt.Println(strings.TrimSpace("  mysql  ")) //mysql

fmt.Println(strings.TrimLeft("!!!Ethan!!!", "!")) //Ethan!!!
fmt.Println(strings.TrimRight("!!!Ethan!!!", "!")) //!!!Ethan

替换 Replace 函数

// 替换所有
fmt.Println(strings.ReplaceAll("/usr/local/mysql/", "/", "\\"))  // \usr\local\mysql\

// Replace 多了一个传入参数（替换 n 次） 
fmt.Println(strings.Replace("/usr/local/mysql/", "/", "\\", 2)) // \usr\local/mysql/

// 或者创建一个 *strings.Replacer 类型对象（是个结构体），需要传入替换内容    
Replacer := strings.NewReplacer("/", ":")   
splitStr := strings.SplitAfterN("/usr/local/mysql", "/", 2)[1] 
res := Replacer.Replace(splitStr)   
fmt.Println(res)  //usr:local:mysql

4. json包

//序列化(转json)
type Person struct{
    Name string `json : "name"`
    Age int `json : "age"`
}
v1 := []interface{}{
    //字符串
    "zhangsan",
    //整数
    18,
    //bool
    true,
    //浮点数
    4.13,
    //map
    map[string]interface{}{
        "adress" : "beijing",
    },
    //结构体
    Person{
        "zhangsan",
        18
    }
}
res, _ json.Marshal(v1)
data := string(res)
//反序列化
str := `["zhangsan", 18, true, 4.13, {"age":18,"name":"zhangsan"}]`
var value []interface{}
json.Unmarshal([]byte(str), &value)
fmt.Println(value)

5. time包

//获取当前时间
curDate := time.Now() //2022-08-22 12:54:12.507845 +0800 CST m=+0.000176922
//第一种，格式化时间(年月日时分秒)
date := curDate.Format("2006-01-02 15:04:05") // 2022-08-22 12:44:51
//fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
//第二种, 分别获取年月日，时分秒
fmt.Println(
    curDate.YearDay(), int(curDate.Month()), curDate.Day(), 
    curDate.Hour(), curDate.Minute(), curDate.Second()
)
//2023 February 6 19 19 40 //月份不强转的话是英文的月份
//2023 2        6 19 22 52

//用字符串接收
strDate := fmt.Sprintf("当前年月日 %d-%d-%d %d:%d:%d \n", curDate.Year(), int(curDate.Month()), curDate.Day(), curDate.Hour(), curDate.Minute(), curDate.Second())
    fmt.Println(strDate)
//当前年月日 2023-02-06 19:28:41

//utc时间
time.Now().UTC()
//本地时间（东八区）
time.Now().Local()


// 默认UTC  
loc, err := time.LoadLocation("") 
// 服务器设定的时区，一般为CST
loc, err := time.LoadLocation("Local")
// 美国洛杉矶PDT
loc, err := time.LoadLocation("America/Los_Angeles")

// 获取指定时区的时间点
local, _ := time.LoadLocation("America/Los_Angeles")
fmt.Println(time.Date(2018,1,1,12,0,0,0, local))

//字符串类型转换成time类型
time1, err := time.Parse("2006-01-02", "2022-04-05")

//创建一个时间(Time类型)
t2 := time.Date(2022, 8,22,13,01,1,0, time.Local)
fmt.Println(t2)

//获取当前时间戳
t1 := time.Now().Unix() //单位秒  1661145016
t2 := time.Now().UnixNano()// 单位纳秒 1661145251807445000


//时间常量
const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)

//常量的作用：比如需要获取100毫秒(0.1秒)
time.Sleep(time.Millisecond * 100) // 只能用微妙*100， 不可以用1秒/10
//time.Sleep(time.Second/10) 错误的