1. hello-world

package main import "fmt"func main(){ fmt.Println("Hello world, Go Go!"); fmt.Printf("type of Hello is %T\n", "Hello") }

package main--每一個Go文件都應(yīng)該在開頭進行package name的聲明（注：只有可執(zhí)行程序的包名為main）。包用于代碼的封裝與重用，這里包名為main。位于第一行。

import "fmt"--導(dǎo)入fmt包，下面代碼要使用。

2. 注釋

單行注釋：//

多行注釋：/* */

3. 空白符

_在Go中被用作空白符，可以表示任何類型的任何值。

4. 類型

布爾：bool??? // true，false

字符串：string

數(shù)字類型：int8，int16，int32，int64，int

uint8，uint16，uint32，uint64，uint

float32，float64

complex64，complex128

byte

rune

注：int，根據(jù)不同的底層平臺，表示32或64位整型。除非對整形的大小有特定的需求，否則通常應(yīng)該使用int表示整型。

注：byte是uint8的別名，rune是int32的別名。

注：+操作符用于拼接字符串。

5. 類型轉(zhuǎn)換

Go有著非常嚴(yán)格的強類型特征，沒有自動類型提升或類型轉(zhuǎn)換，不允許將一種類型的變量賦值給另一種類型的變量。

若要類型轉(zhuǎn)換，需要顯式類型裝換，如int(f)等。

i := 60.5 j := 50 sum := i + float64(j)

自聲明類型也不能和相同原類型混合使用：

var str string = "Hello"type myString stringvar customName myString = "world"customName = str // 不允許

6. 格式說明符

%T：打印變量的類型

%v：打印變量的值

fmt.Printf("type of sum is %T\n", sum)

7. sizeof

Go的unsafe包提供一個Sizeof函數(shù)，該函數(shù)接收變量并返回它的字節(jié)大小。unsafe包應(yīng)該小心使用，因為使用unsafe包可能帶來可移植性問題。

8. 變量

var name type name = initalvalue var name type = initalvalue var name = initalvalue // 類型推斷 var name1, name2 type = initalvalue1, initalvalue2 var ( name1 = initalvalue1 name2 = initalvalue2 ) // 一條語句聲明不同類型變量 name := initalvalue // 簡短聲明用:=

注：簡短聲明要求:=操作符左邊的所有變量都要有初始值；要求:=操作符的左邊至少有一個變量是尚未聲明的。

注意：go語言中定義的變量必須被用到，否則會報錯。

9. 常量

雙引號中的任何值都是Go中的字符串常量。

無類型的常量有一個與它們相關(guān)聯(lián)的默認(rèn)類型，并且當(dāng)且僅當(dāng)一行代碼需要時才提供它。在聲明中?var name = "Sam"?，?name需要一個類型，它從字符串常量?Sam?的默認(rèn)類型中獲取。

const a = 5 var intVar int = a var int32Var int32 = a var float64Var float64 = a var complex64Var complex64 = a fmt.Println("intVar", intVar, "\nint32Var", int32Var, "\nfloat64Var", float64Var, "\ncomplex64Var", complex64Var)

a?的值是?5?，a?的語法是通用的（它可以代表一個浮點數(shù)、整數(shù)甚至是一個沒有虛部的復(fù)數(shù)），因此可以將其分配給任何兼容的類型。這些常量的默認(rèn)類型可以被認(rèn)為是根據(jù)上下文在運行中生成的。?var intVar int = a?要求?a?是?int，所以它變成一個?int?常量。?var complex64Var complex64 = a?要求?a?是?complex64，因此它變成一個復(fù)數(shù)類型。

10. 函數(shù)

func functionname(parametername1 type, parametername1 type) returntype { // 函數(shù)體（具體實現(xiàn)的功能） }

如果有連續(xù)若干個參數(shù)，它們的類型一致，那么我們無須一一羅列，只需在最后一個參數(shù)后添加該類型。

從函數(shù)中可以返回一個命名值。一旦命名了返回值，可以認(rèn)為這些值在函數(shù)第一行就被聲明為變量了。

func rectProps(length, width float64)(area, perimeter float64) { area = length * widthperimeter = (length + width) * 2return // 不需要明確指定返回值，默認(rèn)返回 area, perimeter 的值 }

11. 包

包用于組織Go源代碼，提供了更好的可重用性和可讀性。

屬于某一個包的源文件都應(yīng)該放置于一個單獨命名的文件夾里。按照 Go 的慣例，應(yīng)該用包名命名該文件夾。

導(dǎo)出名字

在 Go 中，任何以大寫字母開頭的變量或者函數(shù)都是被導(dǎo)出的名字。其它包只能訪問被導(dǎo)出的函數(shù)和變量。

同一個包中，所有變量和函數(shù)都可調(diào)用，無論首字母是否大小寫。

init函數(shù)

所有包都可以包含一個?init?函數(shù)。init 函數(shù)不應(yīng)該有任何返回值類型和參數(shù)，在我們的代碼中也不能顯式地調(diào)用它。init 函數(shù)的形式如下：

func init() { }

init 函數(shù)可用于執(zhí)行初始化任務(wù)，也可用于在開始執(zhí)行之前驗證程序的正確性。

包的初始化順序

首先初始化包級別（Package Level）的變量

緊接著調(diào)用 init 函數(shù)。包可以有多個 init 函數(shù)（在一個文件或分布于多個文件中），它們按照編譯器解析它們的順序進行調(diào)用。

如果一個包導(dǎo)入了另一個包，會先初始化被導(dǎo)入的包。盡管一個包可能會被導(dǎo)入多次，但是它只會被初始化一次。

空白標(biāo)識符

導(dǎo)入了包，卻不在代碼中使用它，這在 Go 中是非法的。有兩種處理方法：

1）錯誤屏蔽器。在導(dǎo)入包后，用空白符引用包的變量。var _ = rectangle.Area

2）導(dǎo)入包語句前使用空白符。_"geometry/rectangle"

12. 條件判斷

if condition { } else if condition { } else { }

或

if statement; condition { }

注：else?語句應(yīng)該在?if?語句的大括號?}?之后的同一行中。如果不是，編譯器會不通過。

13. 循環(huán)

for是Go語言中唯一的循環(huán)語句。Go中沒有while和do while循環(huán)。

for initialisation; condition; post { }

其中initialization和post可以省略，而只使用condition

for i <= 10 { //semicolons are ommitted and only condition is presentfmt.Printf("%d ", i)i += 2 }

若condition也省略則表示無限循環(huán)。

14. switch

基礎(chǔ)用法和C語言相似，包含switch…case…case…default。

通過用逗號分隔，可以在一個 case 中包含多個表達式。 case 1,2, 3, 4, 5:

switch中表達式可省略。如果省略表達式，則表示這個 switch 語句等同于?switch true，并且每個?case?表達式都被認(rèn)定為有效，相應(yīng)的代碼塊也會被執(zhí)行。

num := 75switch { // 表達式被省略了case num >= 0 && num <= 50:fmt.Println("num is greater than 0 and less than 50")case num >= 51 && num <= 100:fmt.Println("num is greater than 51 and less than 100")case num >= 101:fmt.Println("num is greater than 100")}

在 Go 中，每執(zhí)行完一個 case 后，會從 switch 語句中跳出來，不再做后續(xù) case 的判斷和執(zhí)行。使用?fallthrough?語句可以在已經(jīng)執(zhí)行完成的 case 之后，把控制權(quán)轉(zhuǎn)移到下一個 case 的執(zhí)行代碼中。

switch num := number(); { // num is not a constantcase num < 50:fmt.Printf("%d is lesser than 50\n", num)fallthroughcase num < 100:fmt.Printf("%d is lesser than 100\n", num)fallthroughcase num < 200:fmt.Printf("%d is lesser than 200", num)}

fallthrough?語句應(yīng)該是 case 子句的最后一個語句。如果它出現(xiàn)在了 case 語句的中間，編譯器將會報錯：fallthrough statement out of place

15. 數(shù)組

Go語言不允許混合不同類型的元素。

[n]T，n表示數(shù)組中元素的數(shù)量，T代表每個元素的類型。

var a [3]int聲明了一個長度為3的整型數(shù)組。數(shù)組中的所有元素都被自動賦值為數(shù)組類型的零值。

數(shù)組的索引從0開始到length-1結(jié)束，長度用函數(shù)len()計算。

a := [3]int{10, 11, 12} //簡略聲明

a := [3]int{10}

a := […]int{10, 11, 12} //忽略數(shù)組長度，用…代替

數(shù)組的大小是類型的一部分，因此[5]int和[20]int是不同類型。

Go中的數(shù)組是值類型而不是引用類型。這意味著當(dāng)數(shù)組賦值給一個新的變量時，該變量會得到一個原始數(shù)組的一個副本。對新變量的更改，不會影響原始數(shù)組。

for i, v := range arr {} // range方法遍歷數(shù)組

for _, v := range arr {} //忽略索引

a := [3][2]string{{"lion", "tiger"},{"cat", "dog"},{"pigeon", "peacock"}, // this comma is necessary. The compiler will complain if you omit this comma}

多維數(shù)組最后一組末尾要加逗號，否則根據(jù)Go語言的規(guī)則會自動插入分號。

16. 切片

切片是由數(shù)組簡歷的一種方便、靈活且功能強大的包裝（wrapper）。切片本身不擁有任何數(shù)據(jù)，只是對現(xiàn)有數(shù)組的引用。對切片的所有修改都會反映到底層數(shù)組上。

切片用[]T表示。

a[start:end]創(chuàng)建一個從a數(shù)組索引start開始到end-1結(jié)束的切片。

numa := [3]int{78, 79 ,80} nums1 := numa[:] // creates a slice which contains all elements of the array

numa[:]缺少開始和結(jié)束值，開始和結(jié)束默認(rèn)值分別是0和len(numa)。

切片的長度是切片中的元素數(shù)。切片的容量是從創(chuàng)建切片索引開始的底層數(shù)組中元素數(shù)。

func make（[]T，len，cap）[]T 通過傳遞類型，長度和容量來創(chuàng)建切片。容量是可選參數(shù), 默認(rèn)值為切片長度。make 函數(shù)創(chuàng)建一個數(shù)組，并返回引用該數(shù)組的切片。

func append（s[]T，x ... T）[]T用于向切片追加元素。

如果切片由數(shù)組支持，并且數(shù)組本身的長度是固定的，那么切片如何具有動態(tài)長度，以及內(nèi)部發(fā)生了什么？當(dāng)新的元素被添加到切片時，會創(chuàng)建一個新的數(shù)組?，F(xiàn)有數(shù)組的元素被復(fù)制到這個新數(shù)組中，并返回這個新數(shù)組的新切片引用。現(xiàn)在新切片的容量是舊切片的兩倍。

切片類型的零值為?nil。一個?nil?切片的長度和容量為 0。

veggies := []string{"potatoes", "tomatoes", "brinjal"}fruits := []string{"oranges", "apples"}food := append(veggies, fruits...)

可以使用?...?運算符將一個切片添加到另一個切片。

值傳遞

切片在內(nèi)部可看作由一個結(jié)構(gòu)體類型表示：

type slice struct { Length intCapacity intZerothElement *byte }

切片包含長度、容量和指向數(shù)組第零個元素的指針。當(dāng)切片傳遞給函數(shù)時，即使它通過值傳遞，指針變量也將引用相同的底層數(shù)組。因此，當(dāng)切片作為參數(shù)傳遞給函數(shù)時，函數(shù)內(nèi)所做的更改也會在函數(shù)外可見。

內(nèi)存優(yōu)化

切片持有對底層數(shù)組的引用。只要切片在內(nèi)存中，數(shù)組就不能被垃圾回收。這里需要重點注意的是，在切片引用時數(shù)組仍然存在內(nèi)存中。

一種解決方法是使用?copy?函數(shù)?func copy(dst，src[]T)int?來生成一個切片的副本。這樣我們可以使用新的切片，原始數(shù)組可以被垃圾回收。

17. 可變參數(shù)的函數(shù)

如果函數(shù)最后一個參數(shù)被記作?...T?，這時函數(shù)可以接受任意個?T?類型參數(shù)作為最后一個參數(shù)。請注意只有函數(shù)的最后一個參數(shù)才允許是可變的。

可變參數(shù)函數(shù)的工作原理是把可變參數(shù)轉(zhuǎn)換為一個新的切片。?

func find(num int, nums ...int) {for i, v := range nums {if v == num {fmt.Println(num, "found at index", i, "in", nums)}} } find(30, 10, 20, 30, 40)

find(30)也是合法的，此時?nums?是一個長度和容量為 0 的?nil?切片。

有一個可以直接將切片傳入可變參數(shù)函數(shù)的語法糖，你可以在在切片后加上?...?后綴。如果這樣做，切片將直接傳入函數(shù)，不再創(chuàng)建新的切片。

find(89, nums…) // true

一個易錯例程：?

package mainimport ("fmt" )func change(s ...string) {s[0] = "Go"s = append(s, "playground")fmt.Println(s) }func main() {welcome := []string{"hello", "world"}change(welcome...)fmt.Println(welcome) } output： [Go world playground] [Go world]

18. 鍵值對map

map將鍵值關(guān)聯(lián)的內(nèi)置類型，通過相應(yīng)的鍵可以獲取到值。

make(map[type of key]type of value)：創(chuàng)建map。

map 的零值是?nil。如果你想添加元素到 nil map 中，會觸發(fā)運行時 panic。因此 map 必須使用?make?函數(shù)初始化。

鍵不一定只能是 string 類型。所有可比較的類型，如 boolean，interger，float，complex，string 等，都可以作為鍵。關(guān)于可比較的類型，如果你想了解更多，請訪問?http://golang.org/ref/spec#Comparison_operators。

獲取map中元素

訪問map中不存在的元素，map會返回該元素類型的零值。

可通過如下語法判斷key是否存在，如果ok是true，表示key存在，key對應(yīng)的值就是value，反之key不存在。?

value, ok := map[key]

for range遍歷map

personSalary := map[string]int{"steve": 12000,"jamie": 15000,}personSalary["mike"] = 9000for key, value := range personSalary {fmt.Printf("personSalary[%s] = %d\n", key, value)}

注意，當(dāng)使用?for range?遍歷 map 時，不保證每次執(zhí)行程序獲取的元素順序相同。

delete(map, key)：刪除?map?中?key?，這個函數(shù)沒有返回值。

len(man)：獲取map長度。

Map是引用類型，當(dāng) map 被賦值為一個新變量的時候，它們指向同一個內(nèi)部數(shù)據(jù)結(jié)構(gòu)。因此，改變其中一個變量，就會影響到另一變量。

map 之間不能使用?==?操作符判斷，==?只能用來檢查 map 是否為?nil。判斷兩個 map 是否相等的方法是遍歷比較兩個 map 中的每個元素。map類型是不可比較的。

19. 字符串

字符串就是一個字節(jié)切片。Go 中的字符串是兼容 Unicode 編碼的，并且使用 UTF-8 進行編碼。

len(s)返回字符串中字節(jié)的數(shù)量。

在 UTF-8 編碼中，一個代碼點可能會占用超過一個字節(jié)的空間。需要使用rune。

rune 是 Go 語言的內(nèi)建類型，它也是 int32 的別稱。在 Go 語言中，rune 表示一個代碼點。代碼點無論占用多少個字節(jié)，都可以用一個 rune 來表示。

func printChars(s string) {runes := []rune(s)for i:= 0; i < len(runes); i++ {fmt.Printf("%c ",runes[i])} } // rune切片構(gòu)造字符串 runeSlice := []rune{0x0053, 0x0065, 0x00f1, 0x006f, 0x0072}

func RuneCountInString(s string) (n int)：獲取字符串長度，需導(dǎo)入包unicode/utf8。

字符串是不可變得。為了修改字符串，可以把字符串轉(zhuǎn)化為一個 rune 切片。然后這個切片可以進行任何想要的改變，然后再轉(zhuǎn)化為一個字符串。?

func mutate(s []rune) string { s[0] = 'a' return string(s) } fmt.Println(mutate([]rune(h)))

20. 指針

*T指向一個T類型的變量。

指針的零值時nil。?

var a int = 25 var b *int = &a*b++ fmt.Printf("Type of b is %T\n", b) fmt.Println("b is", b) output： Type of b is *int b is 0xc420072010 a is 26?

不要向函數(shù)傳遞數(shù)組的指針，而應(yīng)該使用切片。

對于數(shù)組：(*arr)[x]與arr[x]等價，arr是數(shù)組指針。

var arr *[3]int = [3]int{90, 100, 110}

Go 并不支持其他語言（例如 C）中的指針運算，如b++，但支持*b++。

21. 結(jié)構(gòu)體

type Employee struct {firstName, lastName stringage, salary int }

Employee被稱為命名結(jié)構(gòu)體。

當(dāng)定義好的結(jié)構(gòu)體并沒有被顯式地初始化時，該結(jié)構(gòu)體的字段將默認(rèn)賦為零值。僅為某些字段指定初始值時，忽略的字段會賦值為零值。

對于結(jié)構(gòu)體指針，?emp8.firstName?與?(*emp8).firstName等價。

匿名字段的名稱就默認(rèn)為它的類型。?

type Person struct { stringint }var p1 Personp1.string = "naveen"p1.int = 50fmt.Println(p1)

提升字段（Promoted Fields）

如果是結(jié)構(gòu)體中有匿名的結(jié)構(gòu)體類型字段，則該匿名結(jié)構(gòu)體里的字段就稱為提升字段。這是因為提升字段就像是屬于外部結(jié)構(gòu)體一樣，可以用外部結(jié)構(gòu)體直接訪問。

type Address struct {city, state string } type Person struct {name stringage intAddress }var p Personp.name = "Naveen"p.age = 50p.Address = Address{city: "Chicago",state: "Illinois",}fmt.Println("Name:", p.name)fmt.Println("Age:", p.age)fmt.Println("City:", p.city) //city is promoted fieldfmt.Println("State:", p.state) //state is promoted field

導(dǎo)出結(jié)構(gòu)體和字段

如果結(jié)構(gòu)體名稱以大寫字母開頭，則它是其他包可以訪問的導(dǎo)出類型（Exported Type）。同樣，如果結(jié)構(gòu)體里的字段首字母大寫，它也能被其他包訪問到。

結(jié)構(gòu)體相等性（Structs Equality）

結(jié)構(gòu)體是值類型。如果它的每一個字段都是可比較的，則該結(jié)構(gòu)體也是可比較的。如果兩個結(jié)構(gòu)體變量的對應(yīng)字段相等，則這兩個變量也是相等的。如果結(jié)構(gòu)體包含不可比較的字段，則結(jié)構(gòu)體變量也不可比較。

type name struct { firstName stringlastName string }name1 := name{"Steve", "Jobs"}name2 := name{"Steve", "Jobs"}if name1 == name2 {fmt.Println("name1 and name2 are equal")}

?22. defer

含有defer語句的函數(shù)，會在該函數(shù)將要返回之前，調(diào)用另一個函數(shù)。

在 Go 語言中，并非在調(diào)用延遲函數(shù)的時候才確定實參，而是當(dāng)執(zhí)行?defer?語句的時候，就會對延遲函數(shù)的實參進行求值。

package main import ("fmt""time" )func finished(v int){fmt.Printf("Finished something:%d\n", v) }func process(v int){defer finished(v)fmt.Printf("Start processing...%d\n", v)time.Sleep(2*time.Second)v = 3fmt.Printf("End processing...%d\n", v) }func main(){process(5) } output： Start processing...5 End processing...3 Finished something:5

當(dāng)一個函數(shù)內(nèi)多次調(diào)用?defer?時，Go 會把?defer?調(diào)用放入到一個棧中，隨后按照后進先出（Last In First Out, LIFO）的順序執(zhí)行。

23.?時間

time包提供時間相關(guān)處理函數(shù)。

now := time.Now()? time.Now().Day() time.Now().Minute() time.Now().Month()

func Now() Time func (t Time) Nanosecond() int func (t Time) Second() int func (t Time) Minute() int func (t Time) Day() int func (t Time) Month() Month func (t Time) String() string const (Nanosecond Duration = 1Microsecond = 1000 * NanosecondMillisecond = 1000 * MicrosecondSecond = 1000 * MillisecondMinute = 60 * SecondHour = 60 * Minute )

A Duration represents the elapsed time between two instants as an int64 nanosecond count.?

type Duration int64

24. strings和strconv

strings

strings.HasPrefix(s string, preffix string) bool:

判斷字符串s是否以prefix開頭

stirngs.HasSuffix(s string, suffix string) bool:

判斷字符串s是否以suffix結(jié)尾

strings.Index(s string, str string) int:

判斷str在s中首次出現(xiàn)的位置，如果沒有出現(xiàn)，則返回-1

strings.LastIndex(s string,str string) int:

判斷str在s中最后出現(xiàn)的位置，如果沒有出現(xiàn)，則返回-1

strings.Replace(str string,old string,new string,n int):

字符串替換

strings.Count(str string,count int)string:

字符串計數(shù)

strings.Repeat(str string,count int) string:

重復(fù)count次str

strings.ToLower(str string)

轉(zhuǎn)換為小寫

strings.ToUpper(str string)string:

轉(zhuǎn)換為大寫

strings.TrimSpace(str string):

去掉字符串首位空白字符

strings.Trim(str string,cut string):

去掉字符串首尾cut字符

strings.TrimLeft(str string,cut string):

去掉字符串首部cut字符

strings.TrimRight(str string,cunt string):

去掉字符串尾部cut字符

strings.Field(str string):

返回str空格分隔的所有子串的slice

string.Split(str string,split string):

返回str split分割的所有子串的slice

strings.Join(s1 []string,sep string):

用sep把s1中的所有元素連接起來

strconv

strconv.Itoa(i int):把一個整數(shù)轉(zhuǎn)換成字符串

strconv.Atoi (str string)(int,errror): 把一個字符串轉(zhuǎn)換成整數(shù)

25. 終端操作

os.Stdin：標(biāo)準(zhǔn)輸入

os.Stdout:標(biāo)準(zhǔn)輸出

os.Stderr:標(biāo)準(zhǔn)錯誤輸出

?

參考：

1．?How to write Go Code??https://golang.google.cn/doc/code.html

2．?https://golang.google.cn/?提供go在線測試環(huán)境和文檔

3．?https://golang.google.cn/doc/?go相關(guān)文檔

4．?https://golang.google.cn/pkg/?go標(biāo)準(zhǔn)庫

5.? ?https://godoc.org/?go實用庫搜索

6．?go基礎(chǔ)學(xué)習(xí) coder python修行路

7． Go 系列教程（Golang tutorial series） go語言中文網(wǎng)

8.??go基礎(chǔ)學(xué)習(xí) coder python修行路

轉(zhuǎn)載于:https://www.cnblogs.com/embedded-linux/p/11025159.html

總結(jié)

以上是生活随笔為你收集整理的golang基础归纳的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。