Golang常用标准库

无泡汽水

已于 2023-08-18 18:48:58 修改

阅读量227

点赞数

分类专栏： Golang 文章标签： golang 开发语言后端

于 2023-08-17 23:00:21 首次发布

本文链接：https://blog.csdn.net/qq_65150735/article/details/132305403

版权

Golang 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一，fmt输入输出

package main

import "fmt"

// fmt，格式化输入输出库
func main() {
	//输出
	//输出字符串
	fmt.Print("hello", "world", "\n")
	fmt.Println("自动换行")
	//格式化输出
	fmt.Printf("姓名：%s,年龄：%d", "alice", 22)
	//格式化占位符
	fmt.Printf("%s %d %t\n", "字符串", 22, true) //字符串，数值，bool
	//浮点型占位符
	fmt.Printf("%f\n", 12.34)
	//指定浮点型精度
	fmt.Printf("%6.1f\n", 12.34) //指定宽度6和精度1
	fmt.Printf("%.1f\n", 12.34)  //指定精度为1

	//输入，获取用户输入的值
	var name string
	var age int
	// fmt.Print("请输入姓名：")
	// fmt.Scan(&name)
	// fmt.Print("请输入年龄：")
	// fmt.Scan(&age)
	// fmt.Println("你输入的姓名是：", name, "，年龄是：", age)
	// //一次输入多个
	// fmt.Print("请输入姓名和年龄：")
	// fmt.Scan(&name, &age)
	// fmt.Println("你输入的姓名是：", name, "，年龄是：", age)
	//格式化输入
	fmt.Print("请输入姓名和年龄：")
	fmt.Scanf("姓名 %s 年龄 %d ", &name, &age) //输入格式：姓名 alice 年龄 22，必须以空格分隔
	fmt.Println("你输入的姓名是：", name, "，年龄是：", age)
}

二，log日志

package main

import (
	"log"
	"os"
)

// log，内置的简单的日志库
func main() {
	//基本用法
	// log.Print("hello")
	// log.Printf("hello %s", "alice") //格式化打印
	// log.Println("hello bob")        //打印并且换行

	//log.Fatalln("hello")//打印日志，退出
	//log.Panicln("hello") //打印日志，及其详细信息，退出

	//配置
	log.SetPrefix("test: ")                                 //设置前缀
	log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds) //设置格式

	f, err := os.OpenFile("./cli.log", os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0755)
	if err != nil {
		log.Fatal(err)
	}
	log.SetOutput(f) //设置日志的输出位置

	log.Println("1234")
}

三，time时间

package main

import (
	"fmt"
	"time"
)

// time 时间处理
func main() {
	//获取当前时间
	now := time.Now()
	fmt.Println(now)

	//时间格式化输出
	layout := "2006-01-02 15:04:05" //时间格式化的模板
	fmt.Println("当前时间：", now.Format(layout))

	//将字符串转化为时间
	ts := "2007-02-03 16:05:06.778899"
	t1, err := time.Parse(layout, ts)
	if err != nil {
		panic(err)
	}
	fmt.Println("字符串转化：", t1)

	//时区
	loc, err := time.LoadLocation("America/New_York")
	if err != nil {
		panic(err)
	}
	fmt.Println("纽约时间：", now.In(loc))

	//指定时区
	loc2, err := time.LoadLocation("Asia/Shanghai")
	if err != nil {
		panic(err)
	}
	fmt.Print("上海时间：")
	fmt.Println(time.ParseInLocation(layout, ts, loc2))

	//时间的运算
	fmt.Println("当前时间+1小时：", now.Add(1*time.Hour))    //当前时间+1小时
	fmt.Println("当前时间-5分钟：", now.Add(-5*time.Minute)) //当前时间-5分钟
	fmt.Println("加一年 一月 减一天：", now.AddDate(1, 1, -1)) //加一年 一月 减一天的时间
	t2 := now.Add(1 * time.Hour)
	fmt.Println("两个时间相减：", now.Sub(t2)) //两个时间相减

	//时间的比较
	fmt.Println("是否相等：", now.Equal(t2))     //是否相等 =
	fmt.Println("是否在t2之后：", now.After(t2))  //是否在t2之后 >
	fmt.Println("是否在t2之前：", now.Before(t2)) //是否在t2之前 <

	//时间戳
	fmt.Println("时间戳 秒：", now.Unix())       //时间戳 秒
	fmt.Println("时间戳 毫秒：", now.UnixMilli()) //时间戳 毫秒
	fmt.Println("时间戳 微秒：", now.UnixMicro()) //时间戳 微秒
	fmt.Println("时间戳 纳秒：", now.UnixNano())  //时间戳 纳秒
}

四，strconv字符串的转换

package main

import (
	"log"
	"math"
	"strconv"
)

// strconv，字符串和基本数据类型之间的转换
func main() {

	//字符串和int类型转换
	//字符串转int
	i, err := strconv.Atoi("101")
	if err != nil {
		log.Fatalln(err)
	}
	log.Printf("%v,%T", i, i) //打印值和类型

	//int转字符串
	log.Println(strconv.Itoa(102))



	//字符串和bool的转换
	//字符串转bool
	b, err := strconv.ParseBool("false")
	if err != nil {
		log.Fatalln(err)
	}
	log.Printf("%v,%T", b, b) //打印值和类型

	//bool转字符串
	log.Println(strconv.FormatBool(true)) //true



	//字符串和float 类型的转换
	f, err := strconv.ParseFloat("3.1415926", 64) //32:float32,64:float64
	if err != nil {
		log.Println(err)
	}
	log.Printf("%v,%T", f, f)

	//float转换为字符串
	log.Println(strconv.FormatFloat(math.Pi, 'f', 2, 64)) //值，格式，精度，大小



	//字符串和int64 int32 int16 int8之间的转换
	//字符串转换为 int64
	i2, err := strconv.ParseInt("123", 10, 64) //值，进制，大小
	if err != nil {
		log.Println(err)
	}
	log.Printf("%v,%T", i2, i2)

	//int64转换为字符串
	log.Println(strconv.FormatInt(456, 10))

	//字符串转换为 uint64
	ui, err := strconv.ParseUint("123", 10, 64) //值，进制，大小
	if err != nil {
		log.Println(err)
	}
	log.Printf("%v,%T", ui, ui)

	//uint64转换为字符串
	log.Println(strconv.FormatUint(456, 10))
}

五，flag命令行参数解析

package main

import (
	"flag"
	"fmt"
	"strings"
)

// 实现接口
//
//	type Value interface{
//		String() string
//		Set(string) error
//	}
type Hobby []string

func (h *Hobby) String() string {
	return strings.Join(*h, ",")
}
func (h *Hobby) Set(s string) error {
	for _, v := range strings.Split(s, ",") {
		*h = append(*h, v)
	}
	return nil
}

// flag 命令行参数解析
func main() {
	name := flag.String("name", "", "姓名") //名字，默认值，用法说明
	age := flag.Int("age", 22, "年龄")

	var gender string
	flag.StringVar(&gender, "gender", "", "性别") //值 地址，名字，默认值，说明

	//将参数值绑定到结构体
	var hobby Hobby
	flag.Var(&hobby, "hobby", "爱好") //值，名字，说明

	//测试：命令行：./client -name "alice" -age 22 -gender M -hobby "sing,dance,play games" aa bb cc
	flag.Parse()
	fmt.Println(*name, *age)
	fmt.Println(gender)
	fmt.Println(hobby)

	fmt.Println(flag.Args())  //获取后面多余的参数
	fmt.Println(flag.NArg())  //获取后面多余参数的个数
	fmt.Println(flag.NFlag()) //获取flag参数的个数
}

六，strings字符串处理

package main

import (
	"fmt"
	"strings"
)

// strings 字符串处理
func main() {
	s1 := "hello world myworld"
	//字符串替换
	fmt.Println(strings.Replace(s1, "world", "golang", -1)) //需要替换的字符串，被替换的，替换为，替换次数 -1次数不限
	fmt.Println(strings.ReplaceAll(s1, "world", "golang"))  //等同于上一行代码

	//字符串查找
	fmt.Println(strings.Index(s1, "w")) //某个字符在字符串中（首次）存在的位置

	//判断字符串是否包含某个字符串
	fmt.Println(strings.Contains(s1, "wo")) //返回bool

	//字符串的填充
	fmt.Println(strings.Repeat("*", 10)) //10个*

	//字符串分割为切片
	fmt.Println(strings.Split(s1, " ")) //以空格分隔

	//将切片组合为字符串
	names := []string{"alice", "bob"}
	fmt.Println(strings.Join(names, ", ")) //以, （逗号+空格）分隔

	//字符串大小写转换
	fmt.Println(strings.ToLower(s1)) //转小写
	fmt.Println(strings.ToUpper(s1)) //转大写

	//字符串去除
	s2 := "  hello everybody"
	fmt.Println(strings.Trim(s2, " ")) //去除空格
	fmt.Println(strings.TrimSpace(s2))
	fmt.Println(strings.TrimPrefix("a_alice_a", "a_")) //去除前缀
	fmt.Println(strings.TrimSuffix("a_alice_a", "_a")) //去除后缀

	//是否存在前后缀
	fmt.Println(strings.HasPrefix("a_alice_a", "a_")) //是否存在前缀，返回bool
	fmt.Println(strings.HasSuffix("a_alice_a", "_a")) //是否存在后缀
}

七，math数学常量和数学运算

package main

import (
	"fmt"
	"math"
)

// math提供基本的数学常数和函数
func main() {
	//数学常数
	fmt.Println(math.Pi)
	fmt.Println(math.Sqrt2)

	//数学函数
	math.Abs(-10)  //绝对值
	math.Max(1, 2) //返回最大值
	math.Min(1, 2) //返回最小值

	math.Ceil(5.1)  //6，向上取整
	math.Floor(5.1) //5，向下取整
	math.Round(5.1) //5，四舍五入

	math.Mod(3, 2) //1，求余数
	math.Sqrt(2)   //平方根
	math.Pow(2, 3) //8，二的三次方

	//三角函数
	fmt.Println(math.Sin(45))
	fmt.Println(math.Cos(45))
	fmt.Println(math.Tan(45))
}

八，sort排序

package main

import (
	"fmt"
	"sort"
)

type User struct {
	Name string
	Age  int
}
type Users []User

func (users Users) Len() int {
	return len(users)
}
func (users Users) Less(i, j int) bool {
	return users[i].Age < users[j].Age
}
func (users Users) Swap(i, j int) {
	users[i], users[j] = users[j], users[i]
}

// sort 排序
func main() {
	numbers := []int{6, 3, 1, 6, 8, 9, 2, 0, -5}
	fmt.Println("未排序：", numbers)

	//升序
	sort.Ints(numbers)
	fmt.Println("升序：", numbers)
	//降序
	sort.Sort(sort.Reverse(sort.IntSlice(numbers)))
	fmt.Println("降序：", numbers)

	//用法与上述一致
	//sort.Strings()对字符串排序
	//sort.Float64s()对浮点型排序

	//自定义结构的排序
	//方法一
	users := []User{
		{Name: "alice", Age: 20},
		{"bob", 22},
		{"eve", 18},
	}
	sort.Slice(users, func(i, j int) bool {
		return users[i].Age < users[j].Age
	})
	fmt.Println(users)

	//方法二
	usersByAge := Users(users)
	sort.Sort(usersByAge) //实现接口 自定义排序
	fmt.Println(usersByAge)
}

九，os系统相关函数

package main

import (
	"fmt"
	"os"
)

// os 操作系统相关函数
func main() {
	//环境变量
	envs := os.Environ()
	fmt.Println(envs[0])
	//获取单个环境变量
	fmt.Println(os.Getenv("GOPATH"))


	//文件和目录的相关操作
	//获取当前目录
	fmt.Println(os.Getwd())

	//切换目录
	os.Chdir("/tmp")
	fmt.Println(os.Getwd())

	//递归创建目录，相当于mkdir -p /tmp/gotest/test1
	err := os.MkdirAll("/tmp/gotest/test1", 0666) //目录，权限
	if err != nil {
		panic(err)
	}

	//删除目录
	os.RemoveAll("/tmp/gotest/") //递归删除当前及其子目录


	//文件操作
	//创建文件
	f, err := os.Create("/tmp/1.txt")
	if err != nil {
		panic(err)
	}
	fmt.Println(f.Name())

	//文件写入
	n, err := f.WriteString("hello world!")
	if err != nil {
		panic(err)
	}
	fmt.Println("成功写入", n, "个字节") //写入的字节数
	defer f.Close()               //关闭文件

	//文件的打开
	f, err = os.OpenFile("/tmp/1.txt", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666) //文件，打开方式，权限
	if err != nil {
		panic(err)
	}

	//文件的读取
	content := make([]byte, 1024)
	n, err = f.Read(content)
	if err != nil {
		panic(err)
	}
	fmt.Println("成功读到", n, "个字节：", string(content))

	//获取文件信息
	fi, err := os.Stat("/tmp/1.txt")
	if err != nil {
		panic(err)
	}
	fmt.Println("文件名：", fi.Name(), "  大小：", fi.Size())
}

十，path路径相关操作

package main

import (
	"fmt"
	"path"
)

// path 路径相关操作
func main() {
	//路径信息获取
	fmt.Println(path.Base("/a/b/c.txt"))  //获取路径的最后一个元素
	fmt.Println(path.Dir("/a/b/c.txt"))   //获取路径的目录
	fmt.Println(path.Ext("/a/b/c.txt"))   //路径后缀

	dir, file := path.Split("/a/b/c.txt") //分隔路径的目录和文件名，返回目录 路径
	fmt.Println(dir, file)

	fmt.Println(path.IsAbs("/a/b/c.txt")) //true 判断是否是绝对路径
	fmt.Println(path.IsAbs("a/b/c.txt"))  //false

	fmt.Println(path.Join("a","b","c.txt"))//路径的拼接

	fmt.Println(path.Match("/a/b/*.txt","/a/b/c.txt"))//true路径的匹配
	fmt.Println(path.Match("/a/*.txt","/a/b/c.txt"))//false

	//建议使用filepath 区分操作系统，大多方法和path类似
}