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語言

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

輸入代碼可直接執行

轉載請在文章開頭附上原文鏈接地址：https://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瀏覽器上訪問  https://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命令編譯并運行一個程式，而不將可執行檔案保存在當前目錄中，

標籤：Go

上一篇：go-micro使用Consul做服務發現的方法和原理

下一篇：Halo 開源專案學習（三）：注冊與登錄