Go語言基礎學習 - 包、變量、函數

Go is an open source programming language that makes it easy to build?simple, reliable,?and?efficient?software.

- golang.org

跟隨golang官網教程，學習Go語言基礎知識 - 包、變量和函數，參考鏈接https://tour.go-zh.org/list。Let's go!

包

每個 Go 程序都是由包構成的。

程序從?main?包開始運行。

本程序通過導入路徑?"fmt"?和?"math/rand"?來使用這兩個包。

按照約定，包名與導入路徑的最后一個元素一致。例如，"math/rand"?包中的源碼均以?package rand?語句開始。

*注意：* 此程序的運行環境是固定的，因此?rand.Intn?總是會返回相同的數字。 （要得到不同的數字，需為生成器提供不同的種子數，參見?rand.Seed。 練習場中的時間為常量，因此你需要用其它的值作為種子數。）

package?main import?( "fmt" "math/rand" ) func?main()?{ rand.Seed(2) fmt.Println("My?favorite?number?is",?rand.Intn(10)) } //?output My?favorite?number?is?6

導入

此代碼用圓括號組合了導入，這是“分組”形式的導入語句。

當然你也可以編寫多個導入語句，例如：

import?"fmt" import?"math"

不過使用分組導入語句是更好的形式。

package?main import?( "fmt" "math" ) func?main()?{ fmt.Printf("Now?you?have?%g?problems.\n",?math.Sqrt(7)) } //?output Now?you?have?2.6457513110645907?problems.

導出名

在 Go 中，如果一個名字以大寫字母開頭，那么它就是已導出的。例如，Pizza?就是個已導出名，Pi?也同樣，它導出自?math?包。

pizza?和?pi?并未以大寫字母開頭，所以它們是未導出的。

在導入一個包時，你只能引用其中已導出的名字。任何“未導出”的名字在該包外均無法訪問。

package?main import?( "fmt" "math" ) func?main()?{ fmt.Println(math.Pi) } //?output 3.141592653589793

函數

函數可以沒有參數或接受多個參數。

在本例中，add?接受兩個?int?類型的參數。

注意類型在變量名?之后。好處：當類型聲明變得很復雜時，可以增加可讀性。

package?main import?"fmt" func?add(x?int,?y?int)?int?{ return?x?+?y } func?main()?{ fmt.Println(add(42,?13)) } //?output?55

當連續兩個或多個函數的已命名形參類型相同時，除最后一個類型以外，其它都可以省略。

在本例中，

x?int,?y?int

被縮寫為

x,?y?int

package?main import?"fmt" //?函數參數屬于同一個類型，可只保留一個類型 func?add(x,?y?int)?int?{ return?x?+?y } func?main()?{ fmt.Println(add(42,?13)) }

多值返回

函數可以返回任意數量的返回值。

swap?函數返回了兩個字符串。

package?main import?"fmt" func?swap(x,?y?string)?(string,?string)?{ return?y,?x } func?main()?{ a,?b?:=?swap("hello",?"world") fmt.Println(a,?b) } //?output world?hello

命名返回值

Go 的返回值可被命名，它們會被視作定義在函數頂部的變量。

返回值的名稱應當具有一定的意義，它可以作為文檔使用。

沒有參數的?return?語句返回已命名的返回值。也就是?直接?返回。

直接返回語句應當僅用在下面這樣的短函數中。在長的函數中它們會影響代碼的可讀性。

package?main import?"fmt" func?split(sum?int)?(x,y?int){ x?=?sum?*?4?/?9 y?=?sum?-?x return?x,y } func?main()?{ fmt.Println(split(17)) } //?output 7?10

變量

var?語句用于聲明一個變量列表，跟函數的參數列表一樣，類型在最后。

就像在這個例子中看到的一樣，var?語句可以出現在包或函數級別。

package?main import?"fmt" var?c,?python,?java?bool func?main()?{ var?i?int fmt.Println(i,?c,?python,?java) } //?output 0?false?false?false

初始化

變量聲明可以包含初始值，每個變量對應一個。

如果初始化值已存在，則可以省略類型；變量會從初始值中獲得類型。

package?main import?"fmt" var?i,?j?int?=?1,?2 func?main()?{ var?c,?python,?java?=?true,?false,?"no!" fmt.Println(i,?j,?c,?python,?java) } //??output 1?2?true?false?no!

短變量聲明

在函數中，簡潔賦值語句?:=?可在類型明確的地方代替?var?聲明。

函數外的每個語句都必須以關鍵字開始（var,?func?等等），因此?:=?結構不能在函數外使用。

package?main import?"fmt" func?main()?{ var?i,?j?int?=?1,?2 k?:=?3 c,?python,?java?:=?true,?false,?"no!" fmt.Println(i,?j,?k,?c,?python,?java) } //?output 1?2?3?true?false?no!

基本類型

Go 的基本類型有

bool string int??int8??int16??int32??int64 uint?uint8?uint16?uint32?uint64?uintptr byte?//?uint8?的別名 rune?//?int32?的別名 ????//?表示一個?Unicode?碼點 float32?float64 complex64?complex128

本例展示了幾種類型的變量。 同導入語句一樣，變量聲明也可以“分組”成一個語法塊。

int,?uint?和?uintptr?在 32 位系統上通常為 32 位寬，在 64 位系統上則為 64 位寬。 當你需要一個整數值時應使用?int?類型，除非你有特殊的理由使用固定大小或無符號的整數類型。

格式占位符參考https://studygolang.com/articles/2644。

package?main import?( "fmt" "math/cmplx" ) var?( ToBe???bool???????=?false MaxInt?uint64?????=?1<<64?-?1 z??????complex128?=?cmplx.Sqrt(-5?+?12i) ) func?main()?{ fmt.Printf("Type:?%T?Value:?%v\n",?ToBe,?ToBe) fmt.Printf("Type:?%T?Value:?%v\n",?MaxInt,?MaxInt) fmt.Printf("Type:?%T?Value:?%v\n",?z,?z) } //?output Type:?bool?Value:?false Type:?uint64?Value:?18446744073709551615 Type:?complex128?Value:?(2+3i)

零值

沒有明確初始值的變量聲明會被賦予它們的?零值。

零值是：

數值類型為?0，

布爾類型為?false，

字符串為?""（空字符串）。

package?main import?"fmt" func?main()?{ var?i?int var?f?float64 var?b?bool var?s?string fmt.Printf("%v?%v?%v?%q\n",?i,?f,?b,?s) } //?output 0?0?false?""

類型轉換

表達式?T(v)?將值?v?轉換為類型?T。

一些關于數值的轉換：

var?i?int?=?42 var?f?float64?=?float64(i) var?u?uint?=?uint(f)

或者，更加簡單的形式：

i?:=?42 f?:=?float64(i) u?:=?uint(f)

與 C 不同的是，Go 在不同類型的項之間賦值時需要顯式轉換。試著移除例子中?float64?或?uint?的轉換看看會發生什么。

package?main import?( "fmt" "math" ) func?main()?{ var?x,?y?int?=?3,?4 var?f?float64?=?math.Sqrt(float64(x*x?+?y*y)) var?z?uint?=?uint(f) fmt.Println(x,?y,?z) } //?output 3?4?5

類型推導

在聲明一個變量而不指定其類型時（即使用不帶類型的?:=?語法或?var =?表達式語法），變量的類型由右值推導得出。

當右值聲明了類型時，新變量的類型與其相同：

var?i?int j?:=?i?//?j?也是一個?int

不過當右邊包含未指明類型的數值常量時，新變量的類型就可能是?int,?float64?或?complex128?了，這取決于常量的精度：

i?:=?42???????????//?int f?:=?3.142????????//?float64 g?:=?0.867?+?0.5i?//?complex128

嘗試修改示例代碼中?v?的初始值，并觀察它是如何影響類型的。

package?main import?"fmt" func?main()?{ v?:=?4.221341234121234122?//?修改這里！ fmt.Printf("v?is?of?type?%T\n",?v) } //?output v?is?of?type?float64

常量

常量的聲明與變量類似，只不過是使用?const?關鍵字。

常量可以是字符、字符串、布爾值或數值。

常量不能用?:=?語法聲明。

package?main import?"fmt" const?Pi?=?3.14 func?main()?{ const?World?=?"世界" fmt.Println("Hello",?World) fmt.Println("Happy",?Pi,?"Day") const?Truth?=?true fmt.Println("Go?rules?",?Truth) } //?output Hello?世界 Happy?3.14?Day Go?rules??true

數值常量

數值常量是高精度的?值。

一個未指定類型的常量由上下文來決定其類型。

再嘗試一下輸出?needInt(Big)?吧。

（int?類型最大可以存儲一個 64 位的整數，有時會更小。）

（int?可以存放最大64位的整數，根據平臺不同有時會更少。）

package?main import?"fmt" const?( //?將?1?左移?100?位來創建一個非常大的數字 //?即這個數的二進制是?1?后面跟著?100?個?0 Big?=?1?<>?99 ) func?needInt(x?int)?int?{?return?x*10?+?1?} func?needFloat(x?float64)?float64?{ return?x?*?0.1 } func?main()?{ fmt.Println(needInt(Small)) //?fmt.Println(needInt(Big)) fmt.Println(needFloat(Small)) fmt.Println(needFloat(Big)) } //?output 21 0.2 1.2676506002282295e+29

Go語言

版權聲明：本文內容由網絡用戶投稿，版權歸原作者所有，本站不擁有其著作權，亦不承擔相應法律責任。如果您發現本站中有涉嫌抄襲或描述失實的內容，請聯系我們jiasou666@gmail.com 處理，核實后本網站將在24小時內刪除侵權內容。

版權聲明：本文內容由網絡用戶投稿，版權歸原作者所有，本站不擁有其著作權，亦不承擔相應法律責任。如果您發現本站中有涉嫌抄襲或描述失實的內容，請聯系我們jiasou666@gmail.com 處理，核實后本網站將在24小時內刪除侵權內容。