Golang 学习笔记 - 常用包

最新推荐文章于 2022-10-28 14:48:25 发布

起个网名有何难

最新推荐文章于 2022-10-28 14:48:25 发布

阅读量318

点赞数 1

文章标签： golang go

本文链接：https://blog.csdn.net/qq_35953955/article/details/116755255

版权

json

结构体序列化

package main

import (
	"encoding/json"
	"fmt"
)

type Person struct{
	Name string `json:"name"`
	Age int `json:"age"`
	Gender string `json:gender`
}

func main(){
	person := Person{
		Name:   "Tom",
		Age:    18,
		Gender: "男",
	}

	data, err := json.Marshal(person)

	if err == nil{
		fmt.Println(string(data)) // {"name":"Tom","age":18,"Gender":"男"}
	}
}

切片序列化

package main

import (
	"encoding/json"
	"fmt"
)

func main(){
	var person []map[string]interface{}

	p1 := make(map[string]interface{})

	p1["name"] = "Tom"
	p1["age"] = 18
	p1["gender"] = "男"

	person = append(person, p1)

	data, err := json.Marshal(person)

	if err == nil{
		fmt.Println(string(data)) // [{"age":18,"gender":"男","name":"Tom"}]
	}
}

json 反序列化

package main

import (
	"encoding/json"
	"fmt"
)

func main(){
	str := "{\"name\":\"Tom\",\"age\":18,\"gender\":\"男\"}"

	var person map[string]interface{}

	err := json.Unmarshal([]byte(str), &person)
	if err == nil {
		fmt.Println(person) // map[age:18 gender:男 name:Tom]
	}

}

time

获取当前时间戳

package main

import (
	"fmt"
	"time"
)

func main(){
	timeUnix:=time.Now().Unix()
	fmt.Println(timeUnix) // 1598794757
}

获取年月日时分秒

package main

import (
	"fmt"
	"time"
)

func main(){
	year:=time.Now().Year()        //年
	month:=time.Now().Month()       //月
	day:=time.Now().Day()         //日
	hour:=time.Now().Hour()        //时
	minute:=time.Now().Minute()      //分钟
	second:=time.Now().Second()      //秒
	fmt.Println(year, month, day, hour, minute, second) // 2020 August 30 21 49 10
}

当前时间格式化

package main

import (
	"fmt"
	"time"
)

func main(){
	timeStr:=time.Now().Format("2006-01-02 15:04:05") // 2006-01-02 15:04:05据说是golang的诞生时间，固定写法
	fmt.Println(timeStr) // 2020-08-30 21:40:30
}

时间戳格式化

package main

import (
	"fmt"
	"time"
)

func main(){
	timeUnix:=time.Now().Unix()
	formatTimeStr:=time.Unix(timeUnix,0).Format("2006-01-02 15:04:05")
	fmt.Println(formatTimeStr) // 2020-08-30 21:42:13
}

格式化时间转时间戳

package main

import (
	"fmt"
	"time"
)

func main(){
	formatTime, err := time.ParseInLocation("2006-01-02 15:04:05", "2020-02-02 20:20:20", time.Local)

	if err == nil{
		timeUnix := formatTime.Unix()
		fmt.Println(timeUnix) // 1580674820
	}
}

strings

判断前缀、后缀

// HasPrefix 判断字符串 str 是否以 prefix 开头：
strings.HasPrefix(str, prefix string) bool

package main

import (
	"fmt"
	"strings"
)

func main() {
	str := "hello world"
	res := strings.HasPrefix(str, "he")
	fmt.Println(res) // true
}

// HasSuffix 判断字符串 str 是否以 suffix 结尾：
strings.HasSuffix(str, suffix string) bool

func main() {
	str := "hello world"
	res := strings.HasSuffix(str, "wo")
	fmt.Println(res) // false
}

判断是否包含字符串

// Contains 判断字符串 str 是否包含 substr：
strings.Contains(str, substr string) bool

func main() {
	str := "hello world"
	res := strings.Contains(str, " ")
	fmt.Println(res) // true
}

判断子字符串或字符在父字符串中出现的位置（索引）

// Index 返回字符串 s 在字符串 str 中的索引，-1 表示字符串 str 不包含字符串 s：
strings.Index(str, s string) int

func main() {
	str := "hello world"
	res := strings.Index(str, "o")
	fmt.Println(res) // 4
}

// LastIndex 返回字符串 s 在字符串 str 中最后出现位置的索引，-1 表示字符串 str 不包含字符串 s：
strings.LastIndex(s, str string) int

func main() {
	str := "hello world"
	res := strings.LastIndex(str, "o")
	fmt.Println(res) // 7
}

字符串替换

Replace 用于将字符串 str 中的前 n 个字符串 old 替换为字符串 new，并返回一个新的字符串，如果 n = -1 则替换所有字符串 old 为字符串 new：
strings.Replace(str, old, new, n) string

func main() {
	str := "hello world"
	res := strings.Replace(str, " ", "-", 1)
	fmt.Println(res) // hello-world
}

统计字符串出现次数

//Count 用于计算字符串 s 在字符串 str 中出现的非重叠次数：
strings.Count(str, s string) int

func main() {
	str := "hello world"
	res := strings.Count(str, "o")
	fmt.Println(res) // 2
}

重复字符串

// Repeat 用于重复 count 次字符串 str 并返回一个新的字符串：
strings.Repeat(s, count int) string

func main() {
	str := "hello world"
	res := strings.Repeat(str, 2)
	fmt.Println(res) // hello worldhello world
}

修改字符串大小写

// ToLower 将字符串中的 Unicode 字符全部转换为相应的小写字符：
strings.ToLower(str) string

func main() {
	str := "Hello WORLD"
	res := strings.ToLower(str)
	fmt.Println(res) // hello world
}

// ToUpper 将字符串中的 Unicode 字符全部转换为相应的大写字符：
strings.ToUpper(str) string

func main() {
	str := "Hello world"
	res := strings.ToUpper(str)
	fmt.Println(res) // HELLO WORLD
}

修剪字符串

// 你可以使用 strings.TrimSpace(str) 来剔除字符串开头和结尾的空白符号；如果你想要剔除指定字符，则可以使用 strings.Trim(str, "cut") 来将开头和结尾的 cut 去除掉。该函数的第二个参数可以包含任何字符，如果你只想剔除开头或者结尾的字符串，则可以使用 TrimLeft 或者 TrimRight 来实现。区分大小写

func main() {
	str := "Hello world"
	res := strings.Trim(str, "He")
	fmt.Println(res) // llo world
}

分割字符串

// strings.Fields(str) 利用空白作为分隔符将字符串分割为若干块，并返回一个 slice 。如果字符串只包含空白符号，返回一个长度为 0 的 slice 。



// strings.Split(str, sep) 自定义分割符号 sep 对字符串分割，返回 slice 。

拼接 slice 到字符串

// Join 用于将元素类型为 string 的 slice 使用分割符号来拼接组成一个字符串：
strings.Join(sl []string, sep string) string

func main() {
	str := "H-e-l-l-o world"
	s2 := strings.Split(str, "-")
	res := strings.Join(s2, "|")
	fmt.Printf("%q", res) // "H|e|l|l|o world"
}

strconv

ParseBool

func ParseBool(str string) (bool, error)

ParseBool 将字符串转换为布尔值
它接受真值：1, t, T, TRUE, true, True
它接受假值：0, f, F, FALSE, false, False.
其它任何值都返回一个错误

示例

package main

import (
   "fmt"
   "strconv"
)

func main() {

   b, err := strconv.ParseBool("t")
   if err == nil{
      fmt.Println(b)
   }else{
      fmt.Println(err)
   }
}

FormatBool

将布尔值转换为字符串 “true” 或 "false"

res := strconv.FormatBool(0 > 1)
fmt.Println(res)

ParseFloat

func ParseFloat(s string, bitSize int) (f float64, err error)

ParseFloat 将字符串转换为浮点数
s：要转换的字符串
bitSize：指定浮点类型（32:float32、64:float64）
如果 s 是合法的格式，而且接近一个浮点值，
则返回浮点数的四舍五入值（依据 IEEE754 的四舍五入标准）
如果 s 不是合法的格式，则返回“语法错误”
如果转换结果超出 bitSize 范围，则返回“超出范围”

s := "3.1415926"

f, err := strconv.ParseFloat(s, 64)
if err == nil{
   fmt.Println(f) // 3.1415926
}else{
   fmt.Println(err)
}

ParseInt

func ParseInt(s string, base int, bitSize int) (i int64, err error)

ParseInt 将字符串转换为 int 类型
s：要转换的字符串
base：进位制（2 进制到 36 进制）
bitSize：指定整数类型（0:int、8:int8、16:int16、32:int32、64:int64）
返回转换后的结果和转换时遇到的错误
如果 base 为 0，则根据字符串的前缀判断进位制（0x:16，0:8，其它:10）

s := "0101"
i, err := strconv.ParseInt(s, 2, 0)
fmt.Println(err, i)  // 5

s = "233"
i, err = strconv.ParseInt(s, 0, 0)
fmt.Println(err, i) // 233

ParseUint

func ParseUint(s string, base int, bitSize int) (n uint64, err error)

ParseUint 功能同 ParseInt 一样，只不过返回 uint 类型整数

fmt.Println(strconv.ParseUint("FF", 16, 8)) // 255 <nil>

Atoi

func Atoi(s string) (int, error)

Atoi 相当于 ParseInt(s, 10, 0)
通常使用这个函数，而不使用 ParseInt

fmt.Println(strconv.Atoi("518")) // 518 <nil>

FormatFloat

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

FormatFloat 将浮点数 f 转换为字符串值

f：要转换的浮点数
fmt：格式标记（b、e、E、f、g、G）
prec：精度（数字部分的长度，不包括指数部分）
bitSize：指定浮点类型（32:float32、64:float64）

格式标记：
‘b’ (-ddddp±ddd，二进制指数)
‘e’ (-d.dddde±dd，十进制指数)
‘E’ (-d.ddddE±dd，十进制指数)
‘f’ (-ddd.dddd，没有指数)
‘g’ (‘e’:大指数，‘f’:其它情况)
‘G’ (‘E’:大指数，‘f’:其它情况)

如果格式标记为 ‘e’，‘E’和’f’，则 prec 表示小数点后的数字位数
如果格式标记为 ‘g’，‘G’，则 prec 表示总的数字位数（整数部分+小数部分）

f := 100.123456789

fmt.Println(strconv.FormatFloat(f, 'g', 5, 64))
// 100.12
fmt.Println(strconv.FormatFloat(f, 'G', 5, 64))
// 100.12
fmt.Println(strconv.FormatFloat(f, 'f', 5, 64))
// 100.12346
fmt.Println(strconv.FormatFloat(f, 'e', 5, 64))
// 1.00123e+02
fmt.Println(strconv.FormatFloat(f, 'E', 5, 64))
// 1.00123E+02

FormatInt

func FormatInt(i int64, base int) string

FormatInt 将 int 型整数 i 转换为字符串形式
base：进位制（2 进制到 36 进制）
大于 10 进制的数，返回值使用小写字母 ‘a’ 到 ‘z’

i := int64(100)

fmt.Println(strconv.FormatInt(i, 10))
// 100
fmt.Println(strconv.FormatInt(i, 2))
// 1100100
fmt.Println(strconv.FormatInt(i, 16))
// 64

Itoa

func Itoa(i int) string

**Itoa 相当于 FormatInt(i, 10) **

func main() {
	fmt.Println(strconv.Itoa(-2048)) // -2048
	fmt.Println(strconv.Itoa(2048))  // 2048
}

FormatUint

func FormatUint(i uint64, base int) string

FormatUint 将 uint 型整数 i 转换为字符串形式
base：进位制（2 进制到 36 进制）
大于 10 进制的数，返回值使用小写字母 ‘a’ 到 ‘z’

func main() {
   i := uint64(2048)
   fmt.Println(strconv.FormatUint(i, 2))  // 100000000000
   fmt.Println(strconv.FormatUint(i, 8))  // 4000
   fmt.Println(strconv.FormatUint(i, 10)) // 2048
   fmt.Println(strconv.FormatUint(i, 16)) // 800
   fmt.Println(strconv.FormatUint(i, 36)) // 1kw
}

math

Ceil

向上取整

func Ceil(x float64) float64

f := 3.14
fmt.Println(math.Ceil(f))
// 4

Floor

向下取整

func Floor(x float64) float64

f := 3.14
fmt.Println(math.Floor(f))
// 3

IsNaN

判断 f 是否表示一个NaN（Not A Number）值

func IsNaN(f float64) (is bool)

f := 3.14
fmt.Println(math.IsNaN(f))
// false

Trunc

返回浮点数的整数部分

func Trunc(x float64) float64

f := 3.9
fmt.Println(math.Trunc(f))
// 3

Abs

获取绝对值

func Abs(x float64) float64

f := -996.007
fmt.Println(math.Abs(f))
// 996.007

Max

返回两个浮点数中的最大值

func Max(x, y float64) float64

fmt.Println(math.Max(3.1415926, 3.1414))
// 3.1415926

Min

返回两个浮点数中的最小值

func Min(x, y float64) float64

fmt.Println(math.Min(3.1415926, 3.1414))
// 3.1414

Dim

如果x-y大于0，则返回差值，否则返回0

func Dim(x, y float64) float64

fmt.Println(math.Dim(3.1415926, 3.1414)) // 0.00019260000000009825
fmt.Println(math.Dim(3.1415926, 3.1416)) // 0

Mod

取余

func Mod(x, y float64) float64

fmt.Println(math.Mod(9, 4))
// 1

Sqrt

返回x的二次方根

func Sqrt(x float64) float64

fmt.Println(math.Sqrt(9))
// 3

Cbrt

返回x的三次方根

func Cbrt(x float64) float64

fmt.Println(math.Cbrt(8))
// 2

Pow

返回 x 的 y 次方

func Pow(x, y float64) float64

fmt.Println(math.Pow(9, 2))
// 81

起个网名有何难

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Golang 学习笔记 - 常用包

常用包json结构体序列化切片序列化json 反序列化time获取当前时间戳获取年月日时分秒当前时间格式化时间戳格式化格式化时间转时间戳strings判断前缀、后缀判断是否包含字符串判断子字符串或字符在父字符串中出现的位置（索引）字符串替换统计字符串出现次数重复字符串修改字符串大小写修剪字符串分割字符串拼接 slice 到字符串strconvParseBoolFormatBoolParseFloatParseIntParseUintAtoiFormatFloatFormatIntItoaFormatUint
复制链接

扫一扫