go學習第一課–語法基礎

• 2022 年 4 月 25 日
• 筆記
• Go

一.hello world

新建文件helloworld.go

package main

import "fmt"

func main() {
    fmt.Println(       "Hello world!" )
}

運行代碼

go run helloworld.go

Hello world!

代碼說明

1.每個Go文件都是以package 「包名」 開頭，

package main 這行表示文件中的所有其餘代碼都屬於main 包

2.import “fmt” 語句 導入需要的包

3.func main() main函數比較特殊，當程序運行時首先運行它。

4. fmt.Println(“Hello world!”)

從fmt包調用Println函數實現在終端打印Hello world！ 

附錄： 網頁練習go語言

打開網站：//go.dev/play/

輸入代碼可直接執行

轉載請在文章開頭附上原文鏈接地址：//www.cnblogs.com/Sunzz/p/15956313.html

二 函數

 1.函數調用

要調用函數，需要輸入函數名(本例中為Println)，以及一對圓括號

fmt.Println()

2.函數參數

與其他函數一樣，Println可以接受一個或者多個參數，參數鞋子函數名後面的原括號中

fmt.Println(      "First argument" ,      "Second argument" )

輸出

First argument Second argument

3.Println函數

當我們想要查看程序在做什麼的時候可以使用Println函數。傳遞給它的任何參數都將會在終端打印出來，每個參數用空格分隔。

打印完所有參數後，Println將跳動新的終端行，這就是為什麼”ln”在它名字的末尾。

package main

import "fmt"

func main() {
    fmt.Println(      "First argument" ,       "Second argument" ,       "Third argument" )
    fmt.Println(      "Another line" )
}

輸出如下

First argument Second argument Third argument
Another line

三、使用其它包中的函數

我們第一個helloworld.go程序中的代碼時main包的一部分，但是Println函數在fmt包，為了能夠調用Println，我們必須首先到人包含它的包

import “fmt” 

導入包後，我們可以通過包名、點和我們想要的函數名來訪問它提供的任何函數。

fmt.Println()

1.示例

package main

import (        // import語句的這種替代格式運行一次導入多個包
    "math" //導入math包，這樣就可以使用maht.Floor函數來
    "strings"
)

func main() {
    math.Floor(2.75)       // 調用math包中的Floor函數
    strings.Title(      "Hello world!" )       //調用strings中的Title函數
}

運行代碼

go run example1.      go

你會發現沒有任何輸出，不用擔心，也不要着急

2.函數返回值

調用fmt.Println函數之後，我們不需要和它進一步的通信。我們傳遞一個或者多個值讓Println函數打印,我們相信它會打印出這些值。但是有時候程序需要能夠調用函數並從那兒獲取數據。因此大多數編程語言中的函數都有返回值：函數計算後並返回給調用者的值。

math.Floor和strings.Title都是使用返回值的函數的示例。 math.Floor函數拿到一個浮點數，將其向下取整為最接近的整數，然後返回該整數。strings.Title函數拿到一個字符串，將它的包含的每個單詞的第一個字母大寫(首字母大寫)，並返回大寫後的字符串。

要實際查看這些函數調用的結果，我們需要獲取它們的返回值並將其傳遞給fmt.Println

example2 :

package main

import (
    "fmt"
    "math"
    "strings"
)

func main() {
    fmt.Println(math.Floor(2.75))
    fmt.Println(strings.Title(      "hello world!" ))
}

go run example.go 

輸出

2
Hello World!

說明：

fmt.Println(math.Floor(2.75)) 

math.Floor 取2.75的整數2返回給fmt.Println函數

strings.Title(“hello world”) 取一個字符串，然後將其中的每個單詞首字母大寫後返回給 fmt.Println函數

Go程序模板

對於下面的代碼，想像一下將它們插入到這個完整的Go程序中：

package main


import "fmt"

func main() {
    fmt.Println("xxxxxxxxxxx")    //在這裡插入你的代碼
}

更好的方法是，試着在Go Playground中輸入這個程序，然後一次插入一個片段，看看它們會做什麼！

字符串

我們將字符串作為參數傳遞給Println。字符串是一系列位元組，通常表示文本字符。你可以在代碼中直接使用字符串字面量來定義字符串： 雙引號之間的文本，Go將把它們視為字符串。

」hello world!「

在字符串中，換行符、製表符和其他難以包含在程序代碼中的字符可以用轉義序列來表示：反斜杠後跟表示另一個字符的字符。

符文

字符串通常用於表示一些列文本字符，而Go的符文（rune）則用於表示單個字符。

字符串字面量由雙引號（」）包圍，但rune字面量由單引號（『）包圍。

Go程序幾乎可以使用地球上任何語言的任何字符，因為Go使用Unicode標準來存儲runes。runes被保存未數字代碼，而不是字符本身，如果你把runes傳遞給fmt.Println，你會在輸出中看到數字代碼，而不是原始字符。

package main

import "fmt"

func main() {
        fmt.Println('A')
        fmt.Println('B')
        fmt.Println('Z')
}

65
66
90

與字符串字面量一樣，轉義虛了也可以用在runes字面量中，用來表示程序代碼中難以包含的字符：

func main() {
        fmt.Println('\t')
        fmt.Println('\n')
        fmt.Println('\\')
}

9
10
92

布爾值

布爾值只能是兩個值中的一個：true或false。它們對於條件語句特別有用，條件語句只在條件未true或者false時才會導致代碼段運行。

func main() {
        fmt.Println(true)
        fmt.Println(false)
}

true
false

數字

你可以直接在代碼中定義數字，它甚至比字符串字面量更簡單：只需輸入數字即可：

func main() {
        fmt.Println(42)
        fmt.Println(3.14159265)
}

42
3.14159265

稍後我們將看到，Go將整數和浮點數視為不同的數據類型，因此請記住，可以使用小數點來區分整數和浮點數。

數學運算與比較

Go的基本數學運算符的工作方式與大多數其他語言一樣。符號+表示加法，-表示減法，*表示乘法，/表示除法。

可以使用<和>來比較兩個值，看看其中一個值是否小於或者大於另一個值，可以使用==來查看兩個值是否相等，已經!=來查看兩個值是否不相等。<=測試第二個值是否大於或者等於第一個值，>=測試第二個值是否小於或者等於第一個值。

比較結果是一個布爾值，要麼true，要麼false

類型

在前面的代碼示例中，我們看到了math.Floor函數，它將浮點數向下取捨為最接近的整數，已經strings.Title函數，它將字符串轉換為首字母大寫。將數字轉換為參數傳遞給Floor函數，將字符串作為參數傳遞給Title函數，也是有意義的，但是如果將字符串傳遞給Floor，將數字傳遞給Title，會發生什麼呢？

package main

import (
        "fmt"
        "math"
        "strings"
)

func main() {
        fmt.Println(math.Floor("head first go"))
        fmt.Println(strings.Title(2.75))
}

 cannot use "head first go" (type untyped string) as type float64 in argument to math.Floor
 cannot use 2.75 (type untyped float) as type string in argument to strings.Title

Go會打印兩天錯誤信息，一個函數調用有一條，程序甚至不能運行！

你周圍的事物通常可以根據它們的用途分為不同的類型，早餐不吃汽車或者卡車（因為它們是交通工具）。也不會開着煎蛋卷或者一碗麥片去上班（因為它們是早餐食品）。

同樣，Go中的值都被劃分為不同的類型，這些類型指定了這些值的用途，整數可以用在數學運算符中，但字符串不行，字符串可以大寫，但是數字不行，等等這些。。。

Go是靜態類型的，這意味着它甚至在程序運行之前就知道值得類型是什麼，函數期望它的參數具有特定得類型，它們的返回值也具有類型（可能與參數類型相同，也肯定不同）。如果你不小心在錯誤的地方使用了錯誤類型的值，Go會給你一個錯誤消息。這是一件好事：它讓你在用戶發現問題之前就發現了問題！

可以通過將任何值傳遞給reflect包的TypeOf函數，來查看它們的類型，讓我們看看對於已經看到的一些值，它們的類型是什麼：

package main

import (
        "fmt"
        "reflect"    //導入reflect包以便使用TypeOf函數
)

func main() {
        fmt.Println(reflect.TypeOf(42))
        fmt.Println(reflect.TypeOf(3.1459265))
        fmt.Println(reflect.TypeOf(true))
        fmt.Println(reflect.TypeOf("Hello, world!"))
}

int
float64
bool
string

以下是這些類型的用途：

聲明變量

在Go中，變量是包含值得一塊存儲，可以使用變量聲明為變量命名，只需使用var關鍵字，後面跟所需得名稱以及變量將保存得值的類型。

var quantity int    //quantity為變量名，int為變量將保存的值的類型。
var length, width float64    //可以一次聲明同一類型的多個變量
var customerName string

一旦聲明了一個變量，就可以用=（這是一個等號）為它分配該類型的任何值：

quantity = 2
customerName = "Damon cloe"

可以在同一語句中為多個變量賦值，只需將多個變量名放在=的左側，將數量相同的值放在右側，並使用逗號分隔。

 lenth, width = 1.2, 2.4

一旦給變量賦了值，就可以在任何要使用原始值的上下文中使用它們：

package main

import "fmt"

func main() {
        var quantity int
        var length, width float64
        var customerName string
        quantity = 2
        length, width = 1.2, 2.4
        customerName = "Damon cloe"

        fmt.Println(customerName)
        fmt.Println("has ordered", quantity, "sheets")
        fmt.Println("echo with an area of")
        fmt.Println(length*width, "square meters")
}

Damon cloe
has ordered 2 sheets
echo with an area of
2.88 square meters

如果事先知道變量的值是什麼，可以什麼變量並在同一行賦值：

var quantity int = 4
var length, width float64 = 1.2, 2.4
var customerName string = "Damon Coie"

可以為現有的變量分配心值，但它們必須是相同類型的值。Go的靜態類型確保你不會意外第將錯誤類型的值賦給變量。

var quantity int = 4
var customerName string = "Damon Cole"
quantity = "Damon Cole"
customerName = 4

cannot use "Damon Cole" (type untyped string) as type int in assignment
cannot use 4 (type untyped int) as type string in assignment

如果在聲明變量的同時為其賦值，通常可以在聲明中省略變量類型，這個分配給變量的值的類型將作為該變量的類型。

func main() {
        var quantity = 4
        var length, width = 1.2, 2.4
        var customerName = "Damon cloe"

        fmt.Println(reflect.TypeOf(quantity))
        fmt.Println(reflect.TypeOf(length))
        fmt.Println(reflect.TypeOf(width))
        fmt.Println(reflect.TypeOf(customerName))
}

int
float64
float64
string

零值

如果聲明一個變量而沒有給它賦值，該變量將包含其類型的零值。對於數值類型，零值實際上就是0：

var myInt int
var MyFloat float64
fmt.Println(myInt, MyFloat)

0 0

但是對於其他類型來說，0值是無效的，因此該類型的零值可能是其他的值。例如，字符串變量的零值是空字符串，布爾值變量的零值是false。

var myString string
var myBool bool
fmt.Println(myString, myBool)

string變量的零值是空字符串，bool變量的零值是false

 false

段變量聲明

我們提到過，可以聲明變量並在同一行上為其賦值：

 var quantity = 4
var length, width = 1.2, 2.4
var customerName = "Damon cloe"

但是，如果你聲明變量時就知道它的初始值時什麼，那麼更有代表性的時使用短變量聲明。不必很明確地聲明變量的類型並在之後使用=為其賦值，而是同時使用 “:=”。

package main

import "fmt"

func main() {
        quantity := 4
        length, width := 1.2, 2.4
        customerName := "Damon Cole"

        fmt.Println(customerName)
        fmt.Println("has ordered", quantity, "sheets")
        fmt.Println("each with an area of")
        fmt.Println(length*width, "square meters")
}

Damon Cole
has ordered 4 sheets
each with an area of
2.88 square meters

不需要明確地聲明變量的類型；賦給變量的值的類型稱為該變量的類型。由於短變量聲明非常方便和簡潔，因此它們比常規聲明更常用。不過，仍然會偶爾看到這兩種形式，因此熟悉這兩種形式很重要。

命名規則

Go有一天簡單的規則，適用於變量、函數和類型的名稱：

• 名稱必須以字面開通，並且可以有任意熟悉的額外的字面和數字。
• 如果變量、函數或者類型的名稱以大寫字面開頭，則認為它是導出的，可以從當前包之外的包訪問。（這就是為什麼fmt.Println中的P時大寫的：這樣它就可以在main包或者任何其他包中使用。如果變量/函數/類型阿名稱是以小寫字面開頭的，則認為該名稱是未導出的，只能在當前包中使用。）

這些是該語言強制執行的唯一規則。但是Go社區還遵循一些額外的約定：

• 如果一個名稱由多個單詞組成，那麼第一個單詞之後的每個單詞都應該首字面大寫，並且它們應該連接在一起，中間沒有空格，比如toPrice、RetryConnection,等等。（名稱的第一個字面只有在你想從包中導出時才大寫）。這種樣式通常稱為駝峰大小寫，因為大寫字母看起來像駝峰。
• 當名稱的含義在上下文種很明顯時，Go社區的慣例是縮寫它：用i代替index，用max代替maximum，等等。

只有名稱是以大寫字面開頭的變量、函數或類型才被認為是可導出的：可以從當前包之外的包訪問。

轉換

Go中的數學運算和比較運算要求包含的值具有相同的類型。如果不是的話，則在嘗試運行代碼時會報錯。

var length float64 = 1.2
var width int = 2
fmt.Println("Area is", length*width)    //如果我們在數學運算中同時使用float64浮點數和整型數...
fmt.Println("length > width?", length > width)

invalid operation: length * width (mismatched types float64 and int)
invalid operation: length > width (mismatched types float64 and int)

為變量分配新值也是如此，如果所賦值的類型與變量的聲明類型不匹配，也會報錯。

var length float64 = 1.2
var width int = 2
length = width
fmt.Println("Area is", length)

 cannot use width (type int) as type float64 in assignment

解決方法是使用轉換，它允許你將值從一種類型轉換為另一種類型，只需要提供將值轉換的類型，後面緊接着是在圓括號中的要轉換的值。

var myInt int =2 

float(myInt)   float64 為需要轉換的類型，myInt為要轉換的值

結果是所需類型的新值。下面是我們對整型變量中的值調用TypeOf，以及在轉換為float64後對相同的值再次調用TypeOf時得到的結果：

var myInt int = 2
fmt.Println(reflect.TypeOf(myInt))    //沒做轉換
fmt.Println(reflect.TypeOf(float64(myInt)))    //做了轉換

int
float64

讓我們更新失敗的代碼示例，在任何數學運算中，或者與其他float64值進行比較前，先將int值轉換為float64值。

var length float64 = 1.2
var width int = 2
fmt.Println("Area is", length*float64(width))    //在講int數與另一個float64數相乘之前，先將其轉換為float64.
fmt.Println("length > width?", length > float64(width))

Area is 2.4
length > width? false

數學運算和比較現在都能正常工作！

現在讓我們嘗試在將一個int值轉換為float64之前，先把它賦值給float64變量：

var length float64 = 1.2
var width int = 2
length = float64(width)    //在講int數賦值給float64變量之前，先將其轉換為float64。
fmt.Println(length)

同樣，轉換就緒後，賦值成功了。

在進行轉換時，請注意它們可能會如何更改結果值。例如，float64變量可以存儲小數值，但是int變量不能，當你float64轉換為int時，小數部分會被簡單的刪除！這可能會拋棄用結果執行的任何操作。

var length float64 = 3.75
var width int = 5
width = int(length)
fmt.Println(width)

3

不過只有你保存謹慎，你就會反省轉換在使用Go時時必不可少的，它們允許不兼容的類型一起工作。

在你的計算機上安裝Go

Go Playgroud時一種很好的嘗試語言的方法，但它的實際用途是有限的，例如，你不能使用它來處理文件，它沒有辦法從終端獲取用戶的輸入，而這些都是我們在即將推出的程序中所需要的。

所以，為了圓滿完成這一章，請在你的計算機上下載並安裝Go。

別擔心，Go團隊以及讓這項工作變得很容易了！對於大多數操作系統，只需要運行一個安裝程序就可以了。

1.在Web瀏覽器上訪問  //go.dev

2.點擊下載鏈接

3.選擇合適你的操作系統(OS)的安裝包。下載應該自動開始。

4.訪問適合你操作系統的「安裝說明」頁面（下載開始後，你可能會被自動帶到那裡），並按照那裡的說明進行操作。

5.打開一個新的終端或命令提升窗口

6.在提示符處輸入go version並按下enter鍵，確認Go安裝好了，應該能開到一條包含了所安裝的Go的版本信息的信息

編譯Go代碼

我們與Go Playground的互動包括了輸入代碼並神秘地運行它們，既然我們以及在你的電腦上安裝了Go，現在是時候仔細看看它是如何工作的了。

計算機實際上是不能直接運行Go代碼的，在此之前，我們需要獲取源代碼文件並進行編譯：將其轉換為CPU可以執行的二進制格式。

讓我們嘗試使用新安裝的Go來編譯和運行我們之前的例子「Hello, world!”

package main

import "fmt"

func main() {
        fmt.Println("Hello world!")
}

1.使用你喜歡的文本編輯器，寫入以上代碼並命名為hello.go的存文本文件。

2.打開一個新的終端或者命令提示窗口

3.在終端上，切換到保存hello.go的目錄

4.運行go fmt hello.go整理代碼格式（這一步不是必需的，但無論如何這是個好主意）

5.運行go build hello.go編譯源代碼。這將向當前目錄添加一個可執行文件。在macOS或者Linux上，可執行文件將命名為hello，在window上，可執行文件將命名為hello.exe

6.運行可執行文件，在macOS或者Linux上，輸入./hello即可，在Windows上，輸入hello.exe。

go build hello.go

$ ./hello.exe
Hello world!

Go工具

當你安裝Go時，它會將一個名為go的可執行文件添加到命令提示符中，go可執行文件運訓訪問各種命令，包括：

我們剛剛嘗試了go fmt命令，它將你的代碼重新格式化為標準的Go格式，相當於Go Playground網站上的Format按鈕，我們建議對創建的每個源文件都運行go fmt。

我們還使用go build命令將代碼編譯成可執行文件，這樣的可執行文件可以分發給用戶，即使用戶沒有安裝Go，也可以運行它們。

但是我們還沒有嘗試go run命令，讓我們現在開始吧。

使用Go run快速嘗試代碼

go run 命令編譯並運行源文件，而不將可執行文件保存到當前目錄。非常適合快速嘗試簡單的程序，讓我們用它來運行hello.go示例。

1.打開一個新的終端或命令提示窗口

2.在終端上，切換到保存hello.go的目錄

3.輸入go run hello.go，然後按回車鍵，

你將看到程序輸出。如果對源碼進行更改，則不必執行單獨的編譯步驟，只需使用go run運行代碼，即可立即看到結果。當你在處理小程序時，go run 是一個很方便的工具！

函數調用

函數是一段代碼，你可以從程序的其他位置調用它。

調用函數時，可以使用參數向函數提供數據。

類型

Go中的值被分為不同的類型，這些類型指定了值得用途。

不同類型直接進行數學運算和比較是不允許的，但如果需要，可以將值轉換為新類型。

Go變量只能存儲其聲明的類型

要點

• 包是一組相關函數和其他代碼的組合
• 在Go文件中使用包的函數之前，需要先導入該包。
• string是一系列位元組，通常表示文本字符。
• runes表示單個文本字符。
• Go最常見的兩種數字類型是int（保存整數）和float64（保存浮點數）。
• bool類型保存布爾值，這些值要麼為true，要麼為false。
• 變量是一段可以包含指定類型值的存儲
• 如果沒有給變量賦值，它將包含其類型的零值。零值的示例包括對int或float64變量來說是0，對string變量來說是「」（空字符串）。
• 你可以使用 := 短變量聲明來聲明一個變量，並同時為其賦值。
• 如果變量、函數或類型的名稱以大寫字面開頭，則只能從其他包的代碼中訪問它們。
• go fmt命令自動重新格式化源文件以使用Go標準格式，如果你打算與其他人共享任何代碼，你應該歲它們運行go fmt。
• go build 命令將Go源代碼編譯成計算機可以執行的二進制格式。
• go run命令編譯並運行一個程序，而不將可執行文件保存在當前目錄中。