1

A Quick Introduction to Go
Go 快速簡介

• Introducing Go 介紹Go
• When to use Go
  何時使用Go
• Hello World! 你好世界！
• Running Go code 運行 Go 程式碼
• What you should know about Go
  關於 Go 您應該了解的內容
• Developing the which(1) utility in Go
  在 Go 中開發 which(1) 實用程式
• Logging information 記錄資訊
• Developing a statistics application
  開發統計應用程式

Introducing Go 介紹Go

The history of Go
Go的歷史

The advantages of Go
Go的優點

When to use Go
何時使用Go

• Professional web services
  專業網路服務
• Networking tools and servers such as Kubernetes and Istio
  網路工具和伺服器，例如 Kubernetes 和 Istio
• Backend systems 後端系統
• Robust UNIX and Windows system tools
  強大的 UNIX 和 Windows 系統工具
• Servers that work with APIs and clients that interact by exchanging data in myriad formats, including JSON, XML, and CSV
  使用 API 的伺服器和透過多種格式（包括 JSON、XML 和 CSV）交換資料進行互動的用戶端
• WebSocket servers and clients
  WebSocket 伺服器和用戶端
• gRPC (Remote Procedure Call) servers and clients
  gRPC（遠端過程呼叫）伺服器與客戶端
• Complex command line utilities with multiple commands, sub-commands, and command line parameters, such as docker and hugo
  具有多個命令、子命令和命令列參數的複雜命令列實用程序，例如 docker 和 hugo
• Applications that exchange data in the JSON format
  以 JSON 格式交換資料的應用程式
• Applications that process data from relational databases, NoSQL databases, or other popular data storage systems
  處理來自關聯式資料庫、NoSQL 資料庫或其他流行資料儲存系統的資料的應用程式
• Compilers and interpreters for your own programming languages
  適用於您自己的程式語言的編譯器和解釋器
• Database systems such as CockroachDB and key/value stores such as etcd
  資料庫系統（例如 CockroachDB）和鍵/值儲存（例如 etcd）

• This is a personal preference rather than an actual technical shortcoming: Go has no direct and full support for object-oriented programming, which is a popular programming paradigm.
  這是個人偏好，而不是實際的技術缺點：Go沒有對物件導向程式設計的直接和完整支持，這是一種流行的程式範例。
• Although goroutines are lightweight, they are not as powerful as OS threads. Depending on the application you are trying to implement, there might exist some rare cases where goroutines will not be appropriate for the job. The Apache web server creates UNIX processes with fork(2) to serve its clients—Go does not support the functionality of fork(2). However, in most cases, designing your application with goroutines and channels in mind will solve your problems.
  雖然 goroutine 很輕量級，但它們不如作業系統線程強大。根據您嘗試實現的應用程序，可能存在一些罕見的情況，其中 goroutine 不適合該工作。 Apache Web 伺服器使用 fork(2) 建立 UNIX 程序來為其客戶端提供服務 - Go 不支援 fork(2) 的功能。然而，在大多數情況下，在設計應用程式時考慮 goroutine 和通道將解決您的問題。
• Although garbage collection is fast enough most of the time, and for almost all kinds of applications, there are times when you need to handle memory allocation manually, such as when developing an operating system or working with large chunks of memory and want to avoid fragmentation—Go cannot do that. In practice, this means that Go will not allow you to perform any memory management manually.
  雖然垃圾收集在大多數情況下都足夠快，並且對於幾乎所有類型的應用程式來說，但有時您需要手動處理記憶體分配，例如在開發作業系統或使用大塊記憶體並希望避免碎片時—<b1001 ></b1001> 不能這樣做。實際上，這意味著 Go 不允許您手動執行任何記憶體管理。
• Go does not offer the full functionality of a functional programming language.
  Go 不提供函數式程式語言的全部功能。
• Go is not good at developing systems with high availability guarantees. In such cases, use Erlang or Elixir instead.
  Go不擅長開發具有高可用性保證的系統。在這種情況下，請改用 Erlang 或 Elixir。

• The Go compiler catches a large set of silly errors that might end up being bugs. This includes imported Go packages and variables that are not being used in the code.
  Go 編譯器捕捉大量愚蠢的錯誤，這些錯誤最終可能會成為錯誤。這包括導入的 Go 套件和程式碼中未使用的變數。
• Go uses fewer parentheses than C, C++, or Java, and no semicolons, which makes Go source code more human-readable and less error-prone.
  Go 使用的括號比 C、C++ 或 Java 少，且不使用分號，這使得 Go 原始碼更容易閱讀且不易出錯。
• Go comes with a rich and reliable standard library that keeps improving.
  Go 配備了豐富且可靠且不斷改進的標準庫。
• Go has support for concurrency out of the box through goroutines and channels.
  Go 透過 goroutine 和通道支援開箱即用的並發。
• Goroutines are lightweight. You can easily run thousands of goroutines on any modern machine without any performance issues.
  Goroutines 是輕量級的。您可以在任何現代機器上輕鬆運行數千個 goroutine，而不會出現任何效能問題。
• Unlike C, Go considers functions as first-class citizens.
  與 C 不同，Go 將函數視為一等公民。
• Go code is backward compatible, which means that newer versions of the Go compiler accept programs that were created using a previous version of the language without any modifications. This compatibility guarantee is limited to major versions of Go. For example, there is no guarantee that a Go 1.x program will compile with Go 2.x.
  Go 程式碼向後相容，這意味著較新版本的 Go 編譯器接受使用該語言的早期版本建立的程序，無需任何修改。此相容性保證僅限於 Go 的主要版本。例如，不能保證 Go 1.x 程式可以用 Go 2.x 進行編譯。

My personal Go journey
我個人的Go旅程

The go doc and godoc utilities
go doc 和 godoc 實用程序

$ go doc fmt.Printf

$ go doc fmt

$ ~/go/bin/godoc -http=:8001

$ ~/go/bin/godoc -http :8001

Hello World! 你好世界！

package main
import (
    "fmt"
)
func main() {
    fmt.Println("Hello World!")
}

Introducing functions 功能介紹

Introducing packages 介紹套餐

Running Go code 運行 Go 程式碼

Compiling Go code 編譯 Go 程式碼

$ go build hw.go
$ ./hw
Hello World!

Using Go like a scripting language
像腳本語言一樣使用 Go

$ go run hw.go
Hello World!

Important formatting and coding rules
重要的格式和編碼規則

• Go code is delivered in packages, and you are free to use the functionality found in existing packages. There is a Go rule that says that if you import a package, you should use it in some way (call a function or use a datatype), or the compiler is going to complain. There exist exceptions to this rule that mainly have to do with packages that initialize connections with database and TCP/IP servers, but they are not important for now. Packages are covered in Chapter 6, Go Packages and Functions.
  Go 程式碼以軟體包形式提供，您可以自由使用現有軟體包中的功能。有一條 Go 規則，規定如果導入包，則應該以某種方式使用它（調用函數或使用資料類型），否則編譯器會抱怨。此規則存在一些例外情況，主要與初始化與資料庫和 TCP/IP 伺服器的連接的包有關，但目前它們並不重要。包在第 6 章 Go 包和函數中介紹。
• You either use a variable or you do not declare it at all. This rule helps you avoid errors such as misspelling an existing variable or function name.
  您要么使用變量，要么根本不聲明它。此規則可協助您避免錯誤，例如拼字錯誤現有變數或函數名稱。
• There is only one way to format curly braces in Go.
  Go 中只有一種格式花括號的方法。
• Coding blocks in Go are embedded in curly braces, even if they contain just a single statement or no statements at all.
  Go 中的編碼區塊嵌入在花括號中，即使它們只包含單一語句或根本不包含任何語句。
• Go functions can return multiple values.
  Go 函數可以傳回多個值。
• You cannot automatically convert between different data types, even if they are of the same kind. As an example, you cannot implicitly convert an integer to a floating point.
  您無法在不同資料類型之間自動轉換，即使它們屬於同一類型。例如，您不能將整數隱式轉換為浮點數。

package main
import (
    "fmt"
)
func main() 
{
    fmt.Println("Go has strict rules for curly braces!")
}

$ go run curly.go
# command-line-arguments
./curly.go:7:6: missing function body
./curly.go:8:1: syntax error: unexpected semicolon or newline before {

package main
import (
    "fmt"
)
func main() {
    fmt.Println("Go has strict rules for curly braces!")
}

What you should know about Go
關於 Go 您應該了解的內容

Defining and using variables
定義和使用變數

Constants 常數

Global variables 全域變數

Printing variables 列印變數

package main
import (
    "fmt"
    "math"
)
var Global int = 1234
var AnotherGlobal = -5678
func main() {
    var j int
    i := Global + AnotherGlobal
    fmt.Println("Initial j value:", j)
    j = Global
    // math.Abs() requires a float64 parameter
    // so we type cast it appropriately
    k := math.Abs(float64(AnotherGlobal))
    fmt.Printf("Global=%d, i=%d, j=%d k=%.2f.\n", Global, i, j, k)
}

• A global int variable named Global.
  名為 Global 的全域 int 變數。
• A second global variable named AnotherGlobal—Go automatically infers its data type from its value, which in this case is an integer.
  第二個名為 AnotherGlobal —Go 的全域變數會自動從其值推斷其資料類型，在本例中為整數。
• A local variable named j of type int, which, as you will learn in the next chapter, is a special data type. j does not have an initial value, which means that Go automatically assigns the zero value of its data type, which in this case is 0.
  名為 j 且類型為 int 的局部變量，正如您將在下一章中了解到的那樣，它是一種特殊的資料類型。 j 沒有初始值，這表示 Go 自動分配其資料類型的零值，在本例中為 0 。
• Another local variable named i—Go infers its data type from its value. As it is the sum of two int values, it is also an int.
  另一個名為 i - Go 的局部變數根據其值推斷其資料型態。由於它是兩個 int 值的總和，因此它也是一個 int 。
• As math.Abs() requires a float64 parameter, you cannot pass AnotherGlobal to it because AnotherGlobal is an int variable. The float64() type cast converts the value of AnotherGlobal to float64. Note that AnotherGlobal continues to have the int data type.
  由於 math.Abs() 需要 float64 參數，因此您無法將 AnotherGlobal 傳遞給它，因為 AnotherGlobal 是 int 變量。 float64() 型別轉換將 AnotherGlobal 的值轉換為 float64 。請注意， AnotherGlobal 仍然具有 int 資料類型。
• Lastly, fmt.Printf() formats and prints the output.
  最後， fmt.Printf() 格式化並列印輸出。

Initial j value: 0
Global=1234, i=-4444, j=1234 k=5678.00.

Controlling program flow
控製程序流程

err := anyFunctionCall()
if err != nil {
    // Do something if there is an error
}

package main
import (
    "fmt"
    "os"
    "strconv"
)

func main() {
    if len(os.Args) != 2 {
        fmt.Println("Please provide a command line argument")
        return
    }
    argument := os.Args[1]

    // With expression after switch
    switch argument {
    case "0":
        fmt.Println("Zero!")
    case "1":
        fmt.Println("One!")
    case "2", "3", "4":
        fmt.Println("2 or 3 or 4")
        fallthrough
    default:
        fmt.Println("Value:", argument)
    }

    value, err := strconv.Atoi(argument)
    if err != nil {
        fmt.Println("Cannot convert to int:", argument)
        return
    }

    // No expression after switch
    switch {
    case value == 0:
        fmt.Println("Zero!")
    case value > 0:
        fmt.Println("Positive integer")
    case value < 0:
        fmt.Println("Negative integer")
    default:
        fmt.Println("This should not happen:", value)
    }
}

$ go run control.go 10
Value: 10
Positive integer
$ go run control.go 0
Zero!
Zero!

Iterating with for loops and range
使用 for 迴圈和範圍進行迭代

package main
import "fmt"
func main() {
    // Traditional for loop
    for i := 0; i < 10; i++ {
        fmt.Print(i*i, " ")
    }
    fmt.Println()
}

    i := 0
    for ok := true; ok; ok = (i != 10) {
        fmt.Print(i*i, " ")
        i++
    }
    fmt.Println()

    // For loop used as while loop
    i = 0
    for {
        if i == 10 {
            break
        }
        fmt.Print(i*i, " ")
        i++
    }
    fmt.Println()

    // This is a slice but range also works with arrays
    aSlice := []int{-1, 2, 1, -1, 2, -2}
    for i, v := range aSlice {
        fmt.Println("index:", i, "value: ", v)
    }

$ go run forLoops.go
0 1 4 9 16 25 36 49 64 81
0 1 4 9 16 25 36 49 64 81
0 1 4 9 16 25 36 49 64 81
index: 0 value:  -1
index: 1 value:  2
index: 2 value:  1
index: 3 value:  -1
index: 4 value:  2
index: 5 value:  -2

Getting user input 取得用戶輸入

Reading from standard input
從標準輸入讀取

package main
import (
    "fmt"
)
func main() {
    // Get User Input
    fmt.Printf("Please give me your name: ")
    var name string
    fmt.Scanln(&name)
    fmt.Println("Your name is", name)
}

$ go run input.go
Please give me your name: Mihalis
Your name is Mihalis

Working with command line arguments
使用命令列參數

package main
import (
    "fmt"
    "os"
    "strconv"
)

func main() {
    arguments := os.Args
    if len(arguments) == 1 {
        fmt.Println("Need one or more arguments!")
        return
    }

    var min, max float64
    var initialized = 0
    for i := 1; i < len(arguments); i++ {
        n, err := strconv.ParseFloat(arguments[i], 64)
        if err != nil {
            continue
        }

        if initialized == 0 {
            min = n
            max = n
            initialized = 1
            continue
        }

        if n < min {
            min = n
        }
        if n > max {
            max = n
        }
    }
    fmt.Println("Min:", min)
    fmt.Println("Max:", max)
}

$ go run cla.go a b 2 -1
Min: -1
Max: 2

$ go run cla.go a 0 b -1.2 10.32
Min: -1.2
Max: 10.32

$ go run cla.go
Need one or more arguments!

Using error variables to differentiate between input types
使用錯誤變數來區分輸入類型

package main
import (
    "fmt"
    "os"
    "strconv"
)
func main() {
    arguments := os.Args
    if len(arguments) == 1 {
        fmt.Println("Not enough arguments")
        return
    }

    var total, nInts, nFloats int
    invalid := make([]string, 0)
    for _, k := range arguments[1:] {
        // Is it an integer?
        _, err := strconv.Atoi(k)
        if err == nil {
            total++
            nInts++
            continue
        }

        // Is it a float
        _, err = strconv.ParseFloat(k, 64)
        if err == nil {
            total++
            nFloats++
            continue
        }

        // Then it is invalid
        invalid = append(invalid, k)
    }

    fmt.Println("#read:", total, "#ints:", nInts, "#floats:", nFloats)
    if len(invalid) > total {
        fmt.Println("Too much invalid input:", len(invalid))
        for _, s := range invalid {
            fmt.Println(s)
        }
    }
}

$ go run process.go 1 2 3
#read: 3 #ints: 3 #floats: 0

$ go run process.go 1 2.1 a    
#read: 2 #ints: 1 #floats: 1

$ go run process.go a 1 b
#read: 1 #ints: 1 #floats: 0
Too much invalid input: 2
a
b

Understanding the Go concurrency model
了解Go並發模型

package main
import (
    "fmt"
    "time"
)
func myPrint(start, finish int) {
    for i := start; i <= finish; i++ {
        fmt.Print(i, " ")
    }
    fmt.Println()
    time.Sleep(100 * time.Microsecond)
}
func main() {
    for i := 0; i < 4; i++ {
        go myPrint(i, 5)
    }
    time.Sleep(time.Second)
}

$ go run goRoutines.go
2 3 4 5
0 4 1 2 3 1 2 3 4 4 5
5
3 4 5
5

1 2 3 4 5 
4 2 5 3 4 5 
3 0 1 2 3 4 5 
4 5

Developing the which(1) utility in Go
在Go中開發which(1)實用程序

package main
import (
    "fmt"
    "os"
    "path/filepath"
)

func main() {
    arguments := os.Args
    if len(arguments) == 1 {
        fmt.Println("Please provide an argument!")
        return
    }
    file := arguments[1]
    path := os.Getenv("PATH")
    pathSplit := filepath.SplitList(path)
    for _, directory := range pathSplit {

        fullPath := filepath.Join(directory, file)
        // Does it exist?
        fileInfo, err := os.Stat(fullPath)
        if err != nil {
            continue
        }
        mode := fileInfo.Mode()
        // Is it a regular file?
        if !mode.IsRegular() {
            continue
        }
        // Is it executable?
        if mode&0111 != 0 {
            fmt.Println(fullPath)
            return
        }
    }
}

$ go run which.go which
/usr/bin/which
$ go run which.go doesNotExist

Logging information 記錄資訊

package main
import (
    "log"
    "log/syslog"
)
func main() {
    sysLog, err := syslog.New(syslog.LOG_SYSLOG, "systemLog.go")
    if err != nil {
        log.Println(err)
        return
    } else {
        log.SetOutput(sysLog)
        log.Print("Everything is fine!")
    }
}

Jun 08 20:46:05 thinkpad systemLog.go[4412]: 2023/06/08 20:46:05 Everything is fine!
Jun 08 20:46:51 thinkpad systemLog.go[4822]: 2023/06/08 20:46:51 Everything is fine!

log.Fatal() and log.Panic()
log.Fatal() 和 log.Panic()

package main
import (
    "log"
    "os"
)
func main() {
    if len(os.Args) != 1 {
        log.Fatal("Fatal: Hello World!")
    }
    log.Panic("Panic: Hello World!")
}

$ go run logs.go
2023/06/08 20:48:42 Panic: Hello World!
panic: Panic: Hello World!
goroutine 1 [running]:
log.Panic({0xc000104f60?, 0x0?, 0x0?})
    /usr/lib/go/src/log/log.go:384 +0x65
main.main()
    /home/mtsouk/code/mGo4th/ch01/logs.go:12 +0x85
exit status 2
$ go run logs.go 1
2023/06/08 20:48:59 Fatal: Hello World!
exit status 1

Writing to a custom log file
寫入自訂日誌文件

package main
import (
    "fmt"
    "log"
    "os"
    "path"
)
func main() {
    LOGFILE := path.Join(os.TempDir(), "mGo.log")
    fmt.Println(LOGFILE)
    f, err := os.OpenFile(LOGFILE, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
// The call to os.OpenFile() creates the log file for writing, 
// if it does not already exist, or opens it for writing 
// by appending new data at the end of it (os.O_APPEND)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer f.Close()

    iLog := log.New(f, "iLog ", log.LstdFlags)
    iLog.Println("Hello there!")
    iLog.Println("Mastering Go 4th edition!")
}

$ go run customLog.go
/tmp/mGo.log

$ cat /tmp/mGo.log
iLog 2023/11/27 22:15:10 Hello there!
iLog 2023/11/27 22:15:10 Mastering Go 4th edition!

Printing line numbers in log entries
列印日誌條目中的行號

package main
import (
    "fmt"
    "log"
    "os"
    "path"
)
func main() {
    LOGFILE := path.Join(os.TempDir(), "mGo.log")
    fmt.Println(LOGFILE)
    f, err := os.OpenFile(LOGFILE, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer f.Close()
    LstdFlags := log.Ldate | log.Lshortfile
    iLog := log.New(f, "LNum ", LstdFlags)
    iLog.Println("Mastering Go, 4th edition!")
    iLog.SetFlags(log.Lshortfile | log.LstdFlags)
    iLog.Println("Another log entry!")
}

$ go run customLogLineNumber.go
/var/folders/sk/ltk8cnw50lzdtr2hxcj5sv2m0000gn/T/mGo.log

$ cat /var/folders/sk/ltk8cnw50lzdtr2hxcj5sv2m0000gn/T/mGo.log
LNum 2023/06/08 customLogLineNumber.go:25: Mastering Go, 4th edition!
LNum 2023/06/08 20:58:09 customLogLineNumber.go:28: Another log entry!

Writing to multiple log files
寫入多個日誌文件

package main
import (
    "fmt"
    "io"
    "log"
    "os"
)
func main() {
    flag := os.O_APPEND | os.O_CREATE | os.O_WRONLY
    file, err := os.OpenFile("myLog.log", flag, 0644)
    if err != nil {
        fmt.Println(err)
        os.Exit(0)
    }
    defer file.Close()
    w := io.MultiWriter(file, os.Stderr)
    logger := log.New(w, "myApp: ", log.LstdFlags)
    logger.Printf("BOOK %d", os.Getpid())
}

$ go run multipleLogs.go
myApp: 2023/06/24 21:02:55 BOOK 71457

$ at myLog.log
myApp: 2023/06/24 21:02:55 BOOK 71457

Developing a statistics application
開發統計應用程式

package main
import (
    "fmt"
    "math"
    "os"
    "strconv"
)
func main() {
    arguments := os.Args
    if len(arguments) == 1 {
        fmt.Println("Need one or more arguments!")
        return
    }

    var min, max float64
    var initialized = 0
    nValues := 0
    var sum float64
    for i := 1; i < len(arguments); i++ {
        n, err := strconv.ParseFloat(arguments[i], 64)
        if err != nil {
            continue
        }
        nValues = nValues + 1
        sum = sum + n
        if initialized == 0 {
            min = n
            max = n
            initialized = 1
            continue
        }
        if n < min {
            min = n
        }
        if n > max {
            max = n
        }
    }
    fmt.Println("Number of values:", nValues)
    fmt.Println("Min:", min)
    fmt.Println("Max:", max)

    // Mean value
    if nValues == 0 {
        return
    }
meanValue := sum / float64(nValues)
    fmt.Printf("Mean value: %.5f\n", meanValue)
    // Standard deviation
    var squared float64
for i := 1; i < len(arguments); i++ {
        n, err := strconv.ParseFloat(arguments[i], 64)
        if err != nil {
            continue
        }
        squared = squared + math.Pow((n-meanValue), 2)
    }
    standardDeviation := math.Sqrt(squared / float64(nValues))
    fmt.Printf("Standard deviation: %.5f\n", standardDeviation)
}

$ go run stats.go 1 2 3
Number of values: 3
Min: 1
Max: 3
Mean value: 2.00000
Standard deviation: 0.81650

Summary 概括

Exercises 練習

• Read the documentation of the fmt package using go doc.
  使用 go doc 閱讀 fmt 套件的文件。
• In UNIX, an exit code of 0 means success, whereas a non-zero exit code usually means failure. Try to modify which.go to do so with the help of os.Exit().
  在 UNIX 中，退出代碼 0 表示成功，而非零退出代碼通常表示失敗。嘗試在 os.Exit() 的幫助下修改 which.go 來執行此操作。
• The current version of which(1) stops after finding the first occurrence of the desired executable. Make the necessary code changes to which.go in order to find all possible occurrences of the desired executable.
  which(1) 的當前版本在找到第一次出現的所需執行檔後停止。對 which.go 進行必要的程式碼更改，以便找到所需執行檔的所有可能出現位置。

Additional resources 其他資源

• The official Go website: https://go.dev/
  官方Go網址：https://go.dev/
• The Go Playground: https://go.dev/play/
  Go 遊樂場：https://go.dev/play/
• The log package: https://pkg.go.dev/log
  log 套件：https://pkg.go.dev/log
• Elasticsearch Beats: https://www.elastic.co/beats/
  Elasticsearch 節拍：https://www.elastic.co/beats/
• Grafana Loki: https://grafana.com/oss/loki/
  Grafana Loki：https://grafana.com/oss/loki/
• Standard deviation: https://en.wikipedia.org/wiki/Standard_deviation
  標準差：https://en.wikipedia.org/wiki/Standard_deviation
• Microsoft Visual Studio: https://visualstudio.microsoft.com/
  微軟 Visual Studio：https://visualstudio.microsoft.com/
• The Standard Go library: https://pkg.go.dev/std
  標準 Go 函式庫：https://pkg.go.dev/std
• The godoc utility: https://pkg.go.dev/golang.org/x/tools/cmd/godoc
  godoc 實用程式：https://pkg.go.dev/golang.org/x/tools/cmd/godoc

Leave a review! 留下評論！