golang文件操作及time、strconv、log等包使用time strconv标准库 log库 Strings标

time

func main() {
    // 当前时间
    var now time.Time =time.Now()
    fmt.Println(now)
    // 取出时间年、月、日、时、分、秒
    fmt.Println(now.Hour())
    fmt.Println(now.Month())
    fmt.Println(now.Day())
    fmt.Println(now.Minute())
    fmt.Println(now.Second())
    // 实践对象转为时间戳
    miaocuo :=now.Unix()
    fmt.Println(now.Unix())
    // 时间戳转为时间对象,不同时间戳使用不同方法
    fmt.Println(time.Unix(miaocuo, 0))  // 时间戳是秒单位的

    // 时间运算
    now1 :=time.Now()
    lastNowHour :=now1.Add(1*time.Hour)  // 时间相加
    fmt.Println(lastNowHour)

    jianTime :=now.Sub(now1)  // 时间相减
    fmt.Println(jianTime)

    // 时间是否相等
    fmt.Println(now.Equal(now1))  // false

    // Before、After
    fmt.Println(now.Before(now1))
    fmt.Println(now1.After(now))

    // 时间格式化   把Time对象转成字符串时间
    /*其他语言Y-m-d H:m:s  go中：2006  01
    - 2006代指年（Y）
    - 01代指月（m）
    - 02代指日（d）
    - 15代指时（H）
    - 04代指分（M）
    - 05代指秒（S）
    */
    var now2 time.Time = time.Now()  // 转成字符串格式
    strTime:=now2.Format("2006年01月02日 15时-04分-05秒\n")  // 正确写法
    str1Time:=now2.Format("2006-01-02 15:04:05")  // 正确写法
    fmt.Println(now2.Format("15:04:05"))  // 只要时分秒
    fmt.Println(strTime, str1Time)

    // 把字符串时间转成time
    //小数部分想保留指定位数就写0，如果想省略末尾可能的0就写 9
    //timeObj,err:=time.Parse("2006-01-02 15:04:05.9999","2022-03-19 00:10:42.96")
    timeObj,err:=time.Parse("2006年01月02日 15:04:05","2023年04月19日 2:10:42")
    if err != nil {
        fmt.Println("转换出错",err)
    }
    fmt.Println(timeObj)
}

strconv标准库

// strconv包实现了基本数据类型与其字符串表示的转换，主要有以下常用函数： Atoi()、Itoa()、parse系列、format系列、append系列
// Atoi将字符串类型的整数转化为int类型
strNum := "321"
num, err :=strconv.Atoi(strNum)
if err != nil{
    fmt.Printf("转换出错，错误%v\n", err)
    return
}
fmt.Println(num)

// Itoa将int类型转化为字符串
a :=99
fmt.Println(strconv.Itoa(a))

// Parse系列:把字符串转为相应的类型
// ParseBool
b, errb :=strconv.ParseBool("true")
if errb != nil{
    fmt.Println("转换错误")
    return
}
fmt.Println(b)

// ParseInt
// 第一个参数表示要转化的字符串，第二个参数表示几进制，第三个参数int类型0代表int，8代表int8,16代表int16
num1, _ :=strconv.ParseInt("99",10,32)
fmt.Println(num1)

// ParseUint类似ParseInt但不接受正负号，用于无符号整型
// ParseFloat
f, _:=strconv.ParseFloat("32.89", 64)
fmt.Println(f)

// format类型，把其他数字类型转化为字符串
s:=strconv.FormatBool(true)
fmt.Println(s)

// formatfloat函数将浮点数表示为字符串并返回。

log库

/*
log包定义了Logger类型，该类型提供了一些格式化输出的方法。本包也提供了一个预定义的“标准”logger，可以通过调用函数Print系列(Print|Printf|Println）、Fatal系列（Fatal|Fatalf|Fatalln）、和Panic系列（Panic|Panicf|Panicln）来使用，比自行创建一个logger对象更容易使用
*/
// 快速使用
//log.Println("普通日志")  // 普通日志输出
//log.Printf("普通日志%v","cuw")  // 普通日志输出
//log.Fatalln("错误日志")  // 输出日志后结束程序
//log.Panicln("触发错误日志")  // 输出日志后抛出异常

// 修改日志格式：只能设置日志输出的字段，不能改变输出字段位置
log.Flags()  // 获取日志配置
/*
    flag参数
    const (
        // 控制输出日志信息的细节，不能控制输出的顺序和格式。
        // 输出的日志在每一项后会有一个冒号分隔：例如2009/01/23 01:23:23.123123 /a/b/c/d.go:23: message
        Ldate         = 1 << iota     // 日期：2009/01/23
        Ltime                         // 时间：01:23:23
        Lmicroseconds                 // 微秒级别的时间：01:23:23.123123（用于增强Ltime位）
        Llongfile                     // 文件全路径名+行号： /a/b/c/d.go:23
        Lshortfile                    // 文件名+行号：d.go:23（会覆盖掉Llongfile）
        LUTC                          // 使用UTC时间
        LstdFlags     = Ldate | Ltime // 标准logger的初始值
    )
    */
log.SetFlags(log.Llongfile | log.Lmicroseconds | log.Ldate)  // 设置日志格式方式一：通过flag参数名配置
//log.SetFlags(13)  // 设置日志格式方式二：通过不同配置的二进制数位运算得到13
log.Println("普通日志")  // 2022/12/17 13:37:30.967962 D:/go_road/pro/go_code/pro6/test_log.go:15: 普通日志

// 配置日志前缀
fmt.Println()
log.SetPrefix("设置我的日志前缀")  // 设置日志前缀
log.Println("普通错误")  // 设置我的日志前缀2022/12/17 13:46:12.518255 D:/go_road/pro/go_code/pro6/test_log.go:38: 普通错误
fmt.Println(log.Prefix())  // 打印日之前缀

// 修改日志的打印位置
//log.SetOutput()修改日志打印位置
// 创建文件把日志写入文件中
file, err :=os.OpenFile("log.log", os.O_CREATE|os.O_APPEND|os.O_WRONLY,04464)
if err != nil{
    fmt.Println("创建文件错误")
    return
}
log.SetOutput(file)
log.Println("普通错误")

// 通常将日志的配置放在init函数中，此后包中打印日志掉用此包的log
func init()  {  // 导入包自动执行没有参数没有返回值
    log.SetFlags(log.Llongfile | log.Lmicroseconds | log.Ldate)
    log.SetPrefix("错误前缀设置：")
    file, err :=os.OpenFile("log.log", os.O_CREATE|os.O_APPEND|os.O_WRONLY,04464)
    if err != nil{
        fmt.Println("创建文件错误")
        return
    }
    log.SetOutput(file)
}

// 通过new的方式创建一个logger对象
logger :=log.New(os.Stdout, "日志前缀", log.Llongfile | log.Lmicroseconds | log.Ldate)
logger.Println("通过new创建的logger对象")

Strings标准库

// 打包字符串实现简单的函数来操纵 UTF-8 编码的字符串。

// Compare 按字典顺序返回一个比较两个字符串的整数。如果 a == b，结果将为0，如果 a <b 则返回-1，如果 a> b 则返回+1
s, s1 := "hello", "nihao"
fmt.Println(strings.Compare(s, s1))

// Contains  是否包含
fmt.Println(strings.Contains("hello world nihao", "ni"))

// ToUpper  ToLower
fmt.Println(strings.ToLower(`BILIIL`))
fmt.Println(strings.ToUpper("chenxia"))

//4 Count  ,统计子字符串出现的次数
fmt.Println(strings.Count("where is there,there is way", "is"))

//5 HasPrefix HasSuffix 是否以xx开头， 以 xx结尾
fmt.Println(strings.HasSuffix("where is there,there is way", "way"))
fmt.Println(strings.HasPrefix("where is there,there is way", "where"))

// 6 Split,结果返回切片类型
res := strings.Split("where is there,there is way", " ")
fmt.Println(res)
fmt.Printf("%T\n", res)

// 7 Join
qie := []string{"where", "is", "there,there", "is", "way"}
fmt.Println(strings.Join(qie, "-"))  // where-is-there,there-is-way

// 8 Index  返回索引位置-->从0开始
fmt.Println(strings.Index("where is there,there is way", ","))

// 9 去除前后空格，特殊字符
var str1 string = "   where is Nb  "
var str2 string = "***where is Nb***"
fmt.Println(strings.Trim(str1, " "))
fmt.Println(strings.Trim(str2, "*"))
// 专门用来清除两端空格的函数
fmt.Println(strings.TrimSpace(str1))
fmt.Println(strings.TrimRight(str1," "))
fmt.Println(strings.TrimLeft(str2,"*"))

//10 替换
var str3 string = "www.baidu.com"
newReplacer1 := strings.NewReplacer(".","-")
fmt.Println(newReplacer1.Replace(str3))  // www-baidu-com

path/filepath

// 对路径处理的标准库
// 1、pat库
func IsAbs(path string) bool // 判断是否是一个绝对路径,相对路径false
// file:="/Users/liuqingzheng/go/src/go_day08/go.mod"  //true
// isABS := path.IsAbs(file)
// fmt.Println(isABS)

func Split(path string) (dir, file string) // 将路径分割为路径和文件名
//dir:="/Users/liuqingzheng/go/src/go_day08/s1.go"
//dir, file := path.Split(dir)
//fmt.Println(dir, file) // /Users/liuqingzheng/go/src/go_day08/       s1.go

func Join(elem ...string) string // 将多个字符串合并为一个路径
// dirJoin := path.Join("/Users/liuqingzheng/go/", "src", "go_day08","go.mod")
// fmt.Println(dirJoin) // /Users/liuqingzheng/go/src/go_day08/go.mod

func Ext(path string) string // 返回路径中扩展部分，判断文件类型
//pf:="/Users/liuqingzheng/go/src/go_day08/s4.go"
// fileExt := path.Ext(pf)
// fmt.Println(fileExt) // .go

func Base(path string) string // 返回路径的最后一个元素
// pf:="Users/liuqingzheng/go/src/gin_test/static/css/common.css"
// dirBase := path.Base(pf)
// fmt.Println(dirBase)  //common.css

func Dir(path string) string // 返回路径中目录部分
// pf:="Users/liuqingzheng/go/src/gin_test/static/css/"
// dir := path.Dir(pf)
// fmt.Println(dir) // Users/liuqingzheng/go/src/gin_test/static/css

func Clean(path string) string // 返回同目录的最短路径
func Match(pattern, name string) (matched bool, err error) // 正则是否匹配路径（shell 文件名匹配）

// filepath库
filepath.Separator // 预定义变量，表示路径分隔符 /
filepath.ListSeparator // 预定义变量，表示环境变量分隔符 :
func Abs(path string) (string, error) // 返回path 相对当前路径的绝对路径
func Clean(path string) string // 返回path 的最短路径
func Rel(basepath, targpath string) (string, error) // 返回targpath 相对 basepath路径
func EvalSymlinks(path string) (string, error) // 返回软链指向的路径
func VolumeName(path string) string // 返回路径最前面的卷名
func ToSlash(path string) string // 路径分隔符替换为 /
func FromSlash(path string) string // / 替换为路径分隔符
func SplitList(path string) []string // 分隔环境变量里面的路径
func Walk(root string, walkFn WalkFunc) error // 遍历 root 目录下的文件树，并调用 walkFunc

文件操作

/*
Go中常见的读文件操作：
1 使用File自带的Read方法，使用os.Open()或os.OpenFile()打开文件（Open本质还是调用了OpenFile）
2 使用bufio库的Read方法，使用bufio.NewReader(文件对象),也需要先打开文件
3 使用io/ioutil库的ReadAll(),使用ioutil.ReadFile(文件路径)，本质还是调用了os.OpenFile
速度比较：bufio > ioutil.ReadAll > File自带Read
*/
// 打开文件的方式
// 方式一：open()是只读模式，本质是OpenFile(name, O_RDONLY, 0),函数中O_RDONLY
file, err :=os.Open("./log.log")
if err != nil{
    fmt.Println("文件打开错误")
    return
}
defer file.Close()
// 处理文件代码

// 方式二:OpenFile(文件路径，文件操作，文件权限)
/*
    os.O_WRONLY 只写
    os.O_CREATE 创建文件
    os.O_RDONLY 只读
    os.O_RDWR   读写
    os.O_TRUNC  清空
    os.O_APPEND 追加
    */
file1, err1 :=os.OpenFile("./test.log", os.O_RDONLY|os.O_CREATE, 0666)
if err1 != nil{
    fmt.Println("文件打开错误",err)
    return
}
defer file1.Close()
// 处理文件代码

// 读取文件
file, err :=os.Open("./log.log")
if err != nil{
    fmt.Println("打开文件出现错误", err)
    return
}
defer file.Close()

// 按字节读取,只要切片够大就能读取
var buffer = make([]byte, 3)
n, err1:=file.Read(buffer)
if err1 != nil{
    fmt.Println("读取文件出错", err)
    return
}
fmt.Printf("读取了多少字节%v\n", n)
fmt.Println(string(buffer))

// 使用for循环读取文中所有内容(io.EOF表示读取到文件的末尾)
var content []byte
var buf = make([]byte, 10)
for {
    _, err2 :=file.Read(buf)
    if err2 == io.EOF{
        fmt.Println("文件读取完成")
        break
    }
    if err2 != nil{
        fmt.Println("读取文件出错", err)
        return
    }
    content=append(content, buf...)
}
fmt.Println(string(content))

// io/ioutil读取, 使用与小文件一次性读出
content, err2 :=ioutil.ReadFile("./log.log")
if err2 != nil{
    fmt.Println("读取文件错误", err2)
    return
}
fmt.Println(string(content))

// bufio包读取文件,按行读取ReadLine()，按块读取Read()
file, err :=os.Open("./log.log")
if err != nil{
    fmt.Println("打开文件出错", err)
    return
}
defer file.Close()
reader:=bufio.NewReader(file)  // 传入一个实现了io.Reader的变量
// 按行读取, 一次读取一行使用for循环读取
var content []byte
for {
    line, _, errlin :=reader.ReadLine()
    if errlin == io.EOF{
        fmt.Println("文件读取结束")
        break
    }
    if errlin != nil{
        fmt.Println("读取一行数据错误", errlin)
        return
    }
    content = append(content, line...)
}
fmt.Println(string(content))

// 写入文件，存在则追加写入，不存在则创建写入
str2 := "fsufdsggw\nfrsg方法发给他人文化\n个人给他扔给我"
var xie = []byte(str2)
file, err := os.OpenFile("./test", os.O_CREATE|os.O_APPEND|os.O_RDWR, 0666)
if err != nil {
    log.Fatal(err)
}
n, err := file.Write(xie)  // 方式一通过二进制切片写入
file.WriteString(str2)  // 方式二字符串直接写入
fmt.Println(n)

// ioutil写入，不是追加写入，会覆盖原有的内容
err1 :=ioutil.WriteFile("./go.log", []byte("osafds"), 0666)
if err1 != nil{
    fmt.Println("ioutil写入错误",err1)
}

// bufio NewWrite,bufio缓冲写入一定要flush刷到硬盘上
write :=bufio.NewWriter(file)
write.WriteString("bili")
write.Flush()