2. 程式人生 > >Go語言7

Go語言7

阿新 • • 發佈：2018-11-11

終端讀寫

操作終端相關檔案控制代碼常量：

  • os.Stdin ： 標準輸入
  • os.Stdout ： 標準輸出
  • os.Stderr ： 標準錯誤

這個是fmt包裡的一個方法，列印到檔案。比平時用的fmt列印多一個引數，這個引數接收的就是檔案控制代碼，一個實現了 io.Winter 的介面：

func Fprint(w io.Writer, a ...interface{}) (n int, err error)

把終端的標準輸出的檔案控制代碼傳入，就是列印到標準輸出，即螢幕：

package main

import (
    "os"
    "fmt"
)

func main(){
    fmt.Fprintln(os.Stdout, "TEST")
}

終端輸入

先列印提示資訊，然後獲取使用者輸入的值，最後打印出來：

package main

import "fmt"

var firstName, lastName string

func main(){
    fmt.Print("Please enter your full name:")
    fmt.Scanln(&firstName, &lastName)
    // fmt.Scanf("%s %s", &firstName, &lastName)  // 和上面那句效果一樣
    fmt.Printf("Hi %s %s.\n", firstName, lastName)
}

把字串作為格式的化輸入

使用 fmt 包裡的 Sscanf()方法：

func Sscanf(str string, format string, a ...interface{}) (n int, err error)

Scanf 掃描實參 string，並將連續由空格分隔的值儲存為連續的實參， 其格式由 format 決定。它返回成功解析的條目數。
不是很好理解的話，參考下下面的例子：

package main

import "fmt"

func main(){
    var (
        input = "12.34 567 Golang"  // 要掃描的字串
        format = "%f %d %s"  // 每段字串的格式
        i float32  // 對應格式的變數，把字串裡的每一段賦值到這些變數裡
        j int
        k string
    )
    fmt.Sscanf(input, format, &i, &j, &k)
    fmt.Println(i)
    fmt.Println(j)
    fmt.Println(k)
}

帶緩衝區的讀寫

不直接操作 io，在緩衝區裡進行讀寫，io的操作交由作業系統處理，主要是解決效能的問題。
這裡要使用 bufio 包，下面是緩衝區進行讀操作的示例：

package main

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

func main() {
    var inputReader *bufio.Reader  // bufio包裡的一個結構體型別
    // 給上面的結構體賦值，包裡提供了建構函式
    inputReader = bufio.NewReader(os.Stdin)  // 生成例項，之後要呼叫裡面的方法
    fmt.Print("請隨意輸入內容: ")
    // 呼叫例項的方法進行讀操作，就是帶緩衝區的操作了
    input, err := inputReader.ReadString('\n')  // 這裡是字元型別
    if err == nil {
        fmt.Println(input)
    }
}

上面是從終端讀取，檔案讀寫下面會講，先來個從檔案讀取的示例：

package main

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

func main() {
    file, err := os.Open("test.txt")
    if err != nil {
        fmt.Println("ERROR:", err)
        return
    }
    defer file.Close()  // 函式返回時關閉檔案
    bufReader := bufio.NewReader(file)
    for {
        line, err := bufReader.ReadString('\n')
        // 最後一行會同時返回 line 和 err，所以先列印
        fmt.Println(strings.TrimSpace(line))
        if err != nil {
            if err == io.EOF {
                fmt.Println("讀取完畢")
                break
            } else {
                fmt.Println("讀取檔案錯誤:", err)
                return
            }
        }
    }
}

檔案讀寫

os.File 是個結構體，封裝了所有檔案相關的操作。之前講的 os.Stdin、os.Stdout、os.Stderr 都是檔案控制代碼，都是 *os.File

讀取整個檔案

"io/ioutil" 可以直接把整個檔案讀取出來，適合檔案不是很大的情況：

package main

import (
    "fmt"
    "io/ioutil"
)

func main() {
    buf, err := ioutil.ReadFile("test.txt")
    if err != nil {
        fmt.Println("ERROR", err)
        return
    }
    fmt.Println(string(buf))  // buf是[]byte型別，要轉字串
    // 寫操作
    err = ioutil.WriteFile("wtest.txt", buf, 0x64)
    if err != nil {
        panic(err.Error())
    }
}

上面還有整個檔案寫入的操作。

讀取壓縮檔案

下面的程式碼是解壓讀取一個 .gz 檔案，注意不是 .tar.gz 。打了tar包應該是不行的：

package main

import (
    "compress/gzip"
    "os"
    "fmt"
    "bufio"
    "io"
    "strings"
)

func main() {
    fileName := "test.gz"
    var reader *bufio.Reader
    file, err := os.Open(fileName)
    if err != nil {
        fmt.Println("Open ERROE:", err)
        os.Exit(1)
    }
    defer file.Close()  // 記得關檔案
    gzFile, err := gzip.NewReader(file)
    if err != nil {
        fmt.Println("gz ERROR:", err)
        return
    }
    reader = bufio.NewReader(gzFile)
    for {
        line, err := reader.ReadString('\n')
        fmt.Println(strings.TrimSpace(line))
        if err != nil {
            if err == io.EOF {
                fmt.Println("讀取完畢")
                break
            } else {
                fmt.Println("Read ERROR:", err)
                os.Exit(0)
            }
        }
    }
}

檔案寫入

寫入檔案的命令：

os.OpenFile("output.dat", os.O_WRONLY|os.O_CREATE, 0666)

第二個引數是檔案開啟模式：

  • os.O_WRONLY ： 只寫
  • os.O_CREATE ： 建立檔案
  • os.O_RDONLY ： 只讀
  • os.O_RDWR ： 讀寫
  • os.O_TRUNC ： 清空

第三個引數是許可權控制，同Linux的ugo許可權。
檔案寫入的示例：

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
)

func main() {
    outputFile, err := os.OpenFile("test.txt", os.O_WRONLY|os.O_CREATE, 0666)
    if err != nil {
        fmt.Println("ERROR", err)
        return
    }
    defer outputFile.Close()
    outputWriter := bufio.NewWriter(outputFile)
    outputString := "Hello World! "
    for i := 0; i < 10; i++ {
        outputWriter.WriteString(outputString + strconv.Itoa(i) + "\n")
    }
    outputWriter.Flush()  // 強制重新整理，儲存到磁碟
}

拷貝檔案

首先分別開啟2個檔案，然後拷貝檔案只要一次呼叫傳入2個檔案控制代碼就完成了：

package main

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

func CopyFile(dstName, srcName string) (written int64, err error) {
    src, err := os.Open(srcName)
    if err != nil {
        fmt.Println("Open ERROR", err)
        return
    }
    defer src.Close()
    dst, err := os.OpenFile(dstName, os.O_WRONLY|os.O_CREATE, 0644)
    if err != nil {
        fmt.Println("OpenFile ERROR", err)
        return
    }
    defer dst.Close()
    // 先依次把2個檔案都開啟，然後拷貝只要下面這一句
    return io.Copy(dst, src)
}

func main() {
    CopyFile("test_copy.txt", "test.txt")
    fmt.Println("檔案拷貝完成")
}

命令列引數

os.Args 是一個 string 的切片，用來儲存所有的命令列引數。

package main

import (
    "os"
    "fmt"
)

func main() {
    fmt.Println(len(os.Args))
    for i, v := range os.Args {
        fmt.Println(i, v)
    }
}

/* 執行結果
PS H:\Go\src\go_dev\day7\args\beginning> go run main.go arg1 arg2 arg3
4
0 [省略敏感資訊]\main.exe
1 arg1
2 arg2
3 arg3
PS H:\Go\src\go_dev\day7\args\beginning>
*/

os.Args 至少有一個元素，如果一個引數也不打，第一個元素就是命令本身。之後的命令列引數從下標1開始儲存。

解析命令列引數

flag 包實現命令列標籤解析。

func BoolVar(p *bool, name string, value bool, usage string)
func StringVar(p *string, name string, value string, usage string)
func IntVar(p *int, name string, value int, usage string)

第一個引數是個指標，指向要接收的引數的值
第二個引數是指定的名字
第三個引數是預設值
第四個引數是用法說明
用法示例：

package main

import (
    "fmt"
    "flag"
)

func main() {
    var (
        enable bool
        conf string
        num int
    )
    flag.BoolVar(&enable, "b", false, "是否啟用")
    flag.StringVar(&conf, "s", "test.conf", "配置檔案")
    flag.IntVar(&num, "i", 0, "數量")
    flag.Parse()  // 讀取命令列引數進行解析
    fmt.Println(enable, conf, num)
}

/* 執行結果
PS H:\Go\src\go_dev\day7\args\flag_var> go run main.go
false test.conf 0
PS H:\Go\src\go_dev\day7\args\flag_var> go run main.go -b -s default.conf -i 10
true default.conf 10
PS H:\Go\src\go_dev\day7\args\flag_var>
*/

Json資料協議

匯入包

import "encoding/json"

序列化

json.Marshal(data interface{})

示例：

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    UserName string  `json:"username"`
    NickName string  `json:"nickname"`
    Age int  `json:"age"`
    Vip bool  `json:"vip"`
}

func main() {
    u1 := &User{
        UserName: "Sara",
        NickName: "White Canary",
        Age: 29,
        Vip: true,
    }
    if data, err := json.Marshal(u1); err == nil{
        fmt.Println(string(data))
    }
}

反序列化

json.Unmarshal(data []byte, v interface{})

示例：

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    UserName string  `json:"username"`
    NickName string  `json:"nickname"`
    Age int  `json:"age"`
    Vip bool  `json:"vip"`
}

func main() {
    var jsonStr = `{
        "username": "Kara",
        "nickname": "Supergirl",
        "age": 20,
        "vip": false
        }`
    var jsonByte = []byte(jsonStr)
    var u2 User
    if err := json.Unmarshal(jsonByte, &u2); err == nil {
        fmt.Println(u2)
    } else {
        fmt.Println("ERROR:", err)
    }
}

錯誤處理

error 型別是在 builtin 包裡定義的。error 是個介面，裡面實現了一個 Error() 的方法，返回一個字串：

type error interface {
    Error() string
}

所以其實 error 也就是個字串資訊。

定義錯誤

error 包實現了用於錯誤處理的函式。
New 返回一個按給定文字格式化的錯誤：

package main

import (
    "errors"
    "fmt"
)

var errNotFound error = errors.New("Not found error")

func main() {
    fmt.Println("ERROR:", errNotFound)
}

平時簡單這樣用用就可以了，也很方便。不過學習嘛，下面稍微再深入點。

自定義錯誤

主要是學習，上面的 New() 函式用起來更加方便。
使用自定義錯誤返回：

package main

import (
    "fmt"
    "os"
)

type PathError struct {
    Op string
    Path string
    err string  // 把這個資訊隱藏起來，所以是小寫
}

// 實現error的介面
func (e *PathError) Error() string {
    return e.Op + " " + e.Path + " 路徑不存在\n原始錯誤資訊: " + e.err
}

func Open(filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return &PathError{
            Op: "read",
            Path: filename,
            err: err.Error(),
        }
    }
    defer file.Close()
    return nil
}

func main() {
    err := Open("test.txt")
    if err != nil {
        fmt.Println(err)
    }
}

/* 執行結果
PS H:\Go\src\go_dev\day7\error\diy_error> go run main.go
read test.txt 路徑不存在
原始錯誤資訊: open test.txt: The system cannot find the file specified.
PS H:\Go\src\go_dev\day7\error\diy_error>
*/

判斷自定義錯誤

這裡用 switch 來判斷：

switch err := err.(type) {
case ParseError:
    PrintParseError(err)
case.PathError:
    PrintPathError(err)
default:
    fmt.Println(err)
}

異常和捕捉

首先呼叫 panic 來丟擲異常：

package main

func badCall() {
    panic("bad end")
}

func main() {
    badCall()
}

/* 執行結果
PS H:\Go\src\go_dev\day7\error\panic> go run main.go
panic: bad end

goroutine 1 [running]:
main.badCall()
        H:/Go/src/go_dev/day7/error/panic/main.go:4 +0x40
main.main()
        H:/Go/src/go_dev/day7/error/panic/main.go:8 +0x27
exit status 2
PS H:\Go\src\go_dev\day7\error\panic>
*/

執行後就丟擲異常了，但是這樣程式也崩潰了。
下面來捕獲異常，go裡沒有try之類來捕獲異常，所以panic了就是真的異常了，但是還不會馬上就崩潰。panic的函式並不會立刻返回，而是先defer，再返回。如果有辦法將panic捕獲到，並阻止panic傳遞，就正常處理，如果沒有沒有捕獲，程式直接異常終止。這裡並不是像別的語言裡那樣捕獲異常，因為即使捕獲到了，也只是執行defer，之後還是要異常終止的，而不是繼續在錯誤的點往下執行。
注意：就像上面說的，在go裡panic了就是真的異常了。recover之後，邏輯並不會恢復到panic那個點去，函式還是會在defer之後返回。
下面是使用 defer 處理異常的示例：

package main

import "fmt"

func badCall() {
    panic("bad end")
}

func test() {
    // 用defer在最後捕獲異常
    defer func() {
        if e := recover(); e != nil {
            fmt.Println("Panic", e)
        }
    }()
    badCall()
}

func main() {
    test()
}

所以像 python 裡的 try except 那樣捕獲異常，在go裡，大概就是返回個 err(error型別) ，然後判斷一下 err 是不是 nil。

課後作業

實現一個圖書管理系統v3，增加一下功能：

  • 增加持久化儲存的功能
  • 增加日誌記錄的功能

相關推薦

Go語言7

終端讀寫 操作終端相關檔案控制代碼常量： os.Stdin ： 標準輸入 os.Stdout ： 標準輸出 os.Stderr ： 標準錯誤 這個是fmt包裡的一個方法，列印到檔案。比平時用的fmt列印多一個引數，這個引數接收的就是檔案控制代碼，一個實現了 io.Winter 的介面：

GO語言————7.5 切片的複製與追加

7.5 切片的複製與追加如果想增加切片的容量，我們必須建立一個新的更大的切片並把原分片的內容都拷貝過來。下面的程式碼描述了從拷貝切片的 copy 函式和向切片追加新元素的 append 函式。package main import "fmt" func main() {

GO語言環境在Red Hat Linux 7.5上的配置

load F12 jpg 如圖所示 ado ins linux版本 ipo 語言 這篇文章是我根據goland的官方文檔及自己的實踐總結出來的一份基礎向GO語言環境在Linux系統上的配置教程，使用的Linux版本：Red Hat Enterprise Linux Serv

《快學 Go 語言》第 7 課 —— 字串

字串通常有兩種設計，一種是「字元」串，一種是「位元組」串。「字元」串中的每個字都是定長的，而「位元組」串中每個字是不定長的。Go 語言裡的字串是「位元組」串，英文字元佔用 1 個位元組，非英文字元佔多個位元組。這意味著無法通過位置來快速定位出一個完整的字元來，而必須通過遍歷的方式來逐個獲取單個字元。

易學筆記-Go語言-第4章：基本結構和基本資料型別/4.4 變數/4.4.7 變數的作用域

變數的作用域 變數的作用域有幾種： 包間變數：也是在函式外宣告的變數，而且第一個字母是大寫，所有本包函式或者包外函式都可見 全域性變數：在函式外宣告的變數，所有函式都可見 區域性變數：在本函式內部都可見 塊變數：僅僅在某個塊中可見，

《快學 Go 語言》第 7 課 —— 誘人的烤串

字串通常有兩種設計，一種是「字元」串，一種是「位元組」串。「字元」串中的每個字都是定長的，而「位元組」串中每個字是不定長的。Go 語言裡的字串是「位元組」串，英文字元佔用 1 個位元組，非英文字元佔多個位元組。這意味著無法通過位置來快速定位出一個完整的字元來，而必須通過遍歷的方式來逐個獲取單個

go語言漸入佳境[7]-if判斷條件

if條件語句的表現形式： 1234567891011121314151617 //第一種最基本num := 26if(num %2==0){ fmt.Printf("num是偶數\n") }  //第二種 初始化：  if  str:="j

CentOS 7 安裝 go 語言開發環境

安裝 VSCode 編輯器 安裝 golang 安裝 使用系統包管理工具安裝：sudo yum install golang 檢視安裝到哪個目錄：rpm -ql golang |more 測試安裝是否成功：go version（若出現 go 版本資訊，則安裝

7. Reverse Integer Go語言

Given a 32-bit signed integer, reverse digits of an integer. Example 1: Input: 123 Output: 321 Example 2: Input: -123 Output: -321

7 Go 語言運算子

運算子用於在程式執行時執行數學或邏輯運算。 Go 語言內建的運算子有： 算術運算子 關係運算符 邏輯運算子 位運算子 賦值運算子 其他運算子 接下來讓我們來詳細看看各個運算子的介紹。 算術運算子 下表列出了所有Go語言的算術運算子。假定 A 值為 10，B

7.1 介面摘自《go語言學習筆記》

1，介面實現機制：只要目標方法集內包含介面宣告的全部方法，就被視為實現了該介面，無需做顯示宣告。目標型別可以實現多個介面。 2，內部實現，介面自身也是一種結構型別 type iface struct { tab *itab data unsafe.Pointer }

go語言實現最小區塊鏈教程7-網路

1 介紹 Introduction到目前為止，我們構建了一個含有以下特徵的區塊鏈：匿名、安全、以及隨機產生地址；區塊鏈資料儲存；PoW系統；可靠的交易記錄儲存方式。這些特徵都非常關鍵，但是這還不夠。能夠讓這些特徵昇華的，並且讓加密貨幣變得可能的，是網路（network）。這樣

易學筆記-Go語言-第4章：基本結構和基本資料型別/4.5 基本型別/4.5.7 隨機數

易學筆記 十年IT經驗個人學習筆記分享: 開發語言：C/C++/JAVA/PYTHON/GO/JSP WEB架構：Servlets/springMVC/springBoot/springClound 容器架構:Docker容器/Docker叢集/Docker與微服務整合/

Go語言學習筆記7: jsoniter 解碼json 使用指南

範例： var jsonIterator = jsoniter.ConfigCompatibleWithStandardLibrary     //例項化工具類 var response struct {    //

《Go語言核心36講》筆記7:程式實體的那些事兒（下）

回顧 在上一節中，我們著重講述了程式碼塊與程式實體的作用域和訪問許可權控制之間的關係，並圍繞著可重名變數和變數重宣告進行了討論。 前言 如果可重名變數的型別不同，那麼它們之間就可能會存在“遮蔽”的現象，必要時，我們在使用它們之前需要先行檢查型別。 問題：怎樣判斷一個變

go 基礎7 函數語言程式設計

go 基礎7 更多幹貨 程式碼地址： 概述 函數語言程式設計 閉包 資源管理出錯處理 defer呼叫 確保在函式結束時呼叫 def

Go語言之嵌入類型

go 類型 嵌入類型，或者嵌套類型，這是一種可以把已有的類型聲明在新的類型裏的一種方式，這種功能對代碼復用非常重要。在其他語言中，有繼承可以做同樣的事情，但是在Go語言中，沒有繼承的概念。Go提倡的代碼復用的方式是組合，所以這也是嵌入類型的意義所在。組合而不是繼承，所以Go才會更靈活。type Rea

go語言的優點

程序編寫 執行文件 語言培訓 多線程 老男孩 老男孩教育go語言培訓是國內首家go語言培訓機構，主講老師是小米架構資深架構師，有多年go開發經驗。小編現將go語言優點整理如下，希望能幫到你們 1.部署簡單Go 編譯生成的是一個靜態可執行文件，除了 glibc 外沒有其他外部依賴。這讓部署變

go語言筆記——append是內置的函數！！！new是一個函數！！！調試可以使用閉包，本質上是print調試，尼瑪！

... -c map blob 名稱 ebo bsp 處理機制 它的 內置函數 Go 語言擁有一些不需要進行導入操作就可以使用的內置函數。它們有時可以針對不同的類型進行操作，例如：len、cap 和 append，或必須用於系統級的操作，例如：panic。因此，它們需要直接

go語言筆記——切片函數常見操作，增刪改查和搜索、排序

通過 學習 strings 完整 官方文檔 二分 func fun 必須 7.6.6 搜索及排序切片和數組 標準庫提供了 sort 包來實現常見的搜索和排序操作。您可以使用 sort 包中的函數 func Ints(a []int) 來實現對 int 類型的切片排序。例如