go--time包和文件操做

時間  2019-12-14
標籤 time 文件 简体版
原文   原文鏈接

time包

時間類型

time.Time類型表示時間。緩存

func getTime() {
    now := time.Now()    // 獲取當前時間
    fmt.Printf("current time:%v\n", now)

    year := now.Year()    // 年
    month := now.Month()    // 月
    day := now.Day()    // 日
    hour := now.Hour()    // 小時
    minute := now.Minute()    // 分鐘
    second := now.second()    // 秒
    fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}

時間戳

時間戳是自1970年1月1日（08:00:00GMT）至當前時間的總毫秒數。它也被稱爲Unix時間戳（UnixTimestamp）。app

func getTimestamp () {
    now := time.Now()
    timestamp1 := now.Unix()    // 時間戳
    timestamp2 := now.UnixNano()    // 納秒時間戳
}

使用time.Unix()函數將時間戳轉爲時間格式。函數

func getTimestamp () {
    timeObj := time.Unix(timestamp, 0)
    fmt.Println(timeObj)
}

定時器

使用time.Tick(時間間隔)來設置定時器。命令行

func tickDemo () {
    ticker := time.Tick(time.Second)
    for i := range ticker {
        fmt.Println(i)    // 美妙都會執行的任務
    }
}

時間間隔

Duration類型表明兩個時間點之間通過的時間，以納秒爲單位。可表示的最長時間段大約290年。定義的時間間隔常量以下：code

const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)

例如：time.Duration表示1納秒，time.Second表示1秒orm

時間格式化

時間類型有一個自帶的方法Format進行格式化，須要注意的是Go語言中格式化時間模版不是常見的Y-m-d H:i:s而是使用Go的誕生時間2006年1月2日15點04分05秒。字符串

func formatDemo() {
    now := time.Now()
    // 格式化的模板爲Go的出生時間2006年1月2號15點04分 Mon Jan
    // 24小時制
    fmt.Println(now.Format("2006-01-02 15:04:05.000 Mon Jan"))
    // 12小時制
    fmt.Println(now.Format("2006-01-02 03:04:05.000 PM Mon Jan"))
    fmt.Println(now.Format("2006/01/02 15:04"))
    fmt.Println(now.Format("15:04 2006/01/02"))
    fmt.Println(now.Format("2006/01/02"))
}

文件操做

打開和關閉文件

os.Open()函數可以打開一個文件，返回一個*File和一個err。對獲得的文件實例調用close()方法可以關閉文件。get

package main

import (
    "fmt"
    「os」
)

func main () {
    // 只讀方式打開當前目錄下的main.go文件
    file, err := os.Open("./main.go")
    if err != nil {
        fmt.Println("打開失敗，失敗緣由：", err)
        return
    }

    // 關閉文件
    file.Close()
}

爲了防止文件忘記關閉，咱們一般使用defer註冊文件關閉語句。string

讀取文件file.Read()

基本使用

Read方法定義以下：it

func (f *File) Read(b []byte) (n int, err error)

它接收一個字節切片，返回讀取的字節數和可能的具體錯誤，讀到文件末尾時會返回0和io.EOF。例：

func main () {
    // 只讀方式打開當前目錄下的main.go文件
    file, err := os.Open("./main.go")
    if err != nil {
        fmt.Println("打開失敗，緣由：", err)
        return
    }

    defer file.Close()
    // 使用Read方法讀取數據
    var tmp = make([]byte, 128)
    n, err := file.Read(tmp)
    if err == io.EOF {
        fmt.Println("文件讀完了")
        return 
    }

    if err != nil {
        fmt.Println("讀取失敗，緣由：", err)
        return 
    }
    
    fmt.Printf("讀取了%d字節數據\n", n)
    fmt.Pringln(string(tmp[:n]))
}

循環讀取

使用for循環讀取文件中的全部數據

func main() {
    // 只讀方式打開當前目錄下的main.go文件
    file, err := os.Open("./main.go")
    if err != nil {
        fmt.Println("open file failed!, err:", err)
        return
    }
    defer file.Close()
    // 循環讀取文件
    var content []byte
    var tmp = make([]byte, 128)
    for {
        n, err := file.Read(tmp)
        if err == io.EOF {
            fmt.Println("文件讀完了")
            break
        }
        if err != nil {
            fmt.Println("read file failed, err:", err)
            return
        }
        content = append(content, tmp[:n]...)
    }
    fmt.Println(string(content))
}

bufio讀取文件

bufio是在file基礎上封裝了一層API，支持更多的功能。

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
)

// bufio按行讀取示例
func main() {
    file, err := os.Open("./main.go")
    if err != nil {
        fmt.Println("open file failed, err:", err)
        return
    }
    defer file.Close()
    reader := bufio.NewReader(file)
    for {
        line, err := reader.ReadString('\n') //注意是字符
        if err == io.EOF {
            fmt.Println("文件讀完了")
            break
        }
        if err != nil {
            fmt.Println("read file failed, err:", err)
            return
        }
        fmt.Print(line)
    }
}

ioutil讀取整個文件

io/ioutil包的ReadFile方法可以讀取完整的文件，只須要將文件名做爲參數傳入。

package main

import (
    "fmt"
    "io/ioutil"
)

// ioutil.ReadFile讀取整個文件
func main() {
    content, err := ioutil.ReadFile("./main.go")
    if err != nil {
        fmt.Println("read file failed, err:", err)
        return
    }
    fmt.Println(string(content))
}

文件的寫入操做

os.OpenFile()函數可以以指定模式打開文件，從而實現文件寫入相關功能。

func OpenFile(name string, flag int, perm FileMode) (*File, error) {
    ...
}

name：要打開的文件名 flag：打開文件的模式。 模式有如下幾種：

模式 含義
os.O_WRONLY 只寫
os.O_CREATE 建立文件
os.O_RDONLY 只讀
os.O_RDWR 讀寫
os.O_TRUNC 清空
os.O_APPEND 追加

perm：文件權限，一個八進制數。r（讀）04，w（寫）02，x（執行）01。

Write和WriteString

func main() {
    file, err := os.OpenFile("xx.txt", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
    if err != nil {
        fmt.Println("open file failed, err:", err)
        return
    }
    defer file.Close()
    str := "hello 沙河"
    file.Write([]byte(str))       //寫入字節切片數據
    file.WriteString("hello 小王子") //直接寫入字符串數據
}

bufio.NewWriter

func main() {
    file, err := os.OpenFile("xx.txt", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
    if err != nil {
        fmt.Println("open file failed, err:", err)
        return
    }
    defer file.Close()
    writer := bufio.NewWriter(file)
    for i := 0; i < 10; i++ {
        writer.WriteString("hello沙河\n") //將數據先寫入緩存
    }
    writer.Flush() //將緩存中的內容寫入文件
}

ioutil.WriteFile

func main() {
    str := "hello 沙河"
    err := ioutil.WriteFile("./xx.txt", []byte(str), 0666)
    if err != nil {
        fmt.Println("write file failed, err:", err)
        return
    }
}

copyFile

藉助io.Copy()實現一個拷貝文件函數。

// CopyFile 拷貝文件函數
func CopyFile(dstName, srcName string) (written int64, err error) {
    // 以讀方式打開源文件
    src, err := os.Open(srcName)
    if err != nil {
        fmt.Printf("open %s failed, err:%v.\n", srcName, err)
        return
    }
    defer src.Close()
    // 以寫|建立的方式打開目標文件
    dst, err := os.OpenFile(dstName, os.O_WRONLY|os.O_CREATE, 0644)
    if err != nil {
        fmt.Printf("open %s failed, err:%v.\n", dstName, err)
        return
    }
    defer dst.Close()
    return io.Copy(dst, src) //調用io.Copy()拷貝內容
}
func main() {
    _, err := CopyFile("dst.txt", "src.txt")
    if err != nil {
        fmt.Println("copy file failed, err:", err)
        return
    }
    fmt.Println("copy done!")
}

實現一個cat命令

package main

import (
    "bufio"
    "flag"
    "fmt"
    "io"
    "os"
)

// cat命令實現
func cat(r *bufio.Reader) {
    for {
        buf, err := r.ReadBytes('\n') //注意是字符
        if err == io.EOF {
            break
        }
        fmt.Fprintf(os.Stdout, "%s", buf)
    }
}

func main() {
    flag.Parse() // 解析命令行參數
    if flag.NArg() == 0 {
        // 若是沒有參數默認從標準輸入讀取內容
        cat(bufio.NewReader(os.Stdin))
    }
    // 依次讀取每一個指定文件的內容並打印到終端
    for i := 0; i < flag.NArg(); i++ {
        f, err := os.Open(flag.Arg(i))
        if err != nil {
            fmt.Fprintf(os.Stdout, "reading from %s failed, err:%v\n", flag.Arg(i), err)
            continue
        }
        cat(bufio.NewReader(f))
    }
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程