本教程全面涵蓋了Go語言基礎的各個方面。一共80個例子，每個例子對應一個語言特性點，非常適合新人快速上手。
教程代碼示例來自go by example，文字部分來自本人自己的理解。

創新互聯公司服務項目包括白沙黎族網站建設、白沙黎族網站制作、白沙黎族網頁制作以及白沙黎族網絡營銷策劃等。多年來，我們專注于互聯網行業，利用自身積累的技術優勢、行業經驗、深度合作伙伴關系等，向廣大中小型企業、政府機構等提供互聯網行業的解決方案，白沙黎族網站推廣取得了明顯的社會效益與經濟效益。目前，我們服務的客戶以成都為中心已經輻射到白沙黎族省份的部分城市，未來相信會繼續擴大服務區域并繼續獲得客戶的支持與信任！

本文是教程系列的第一部分，共計20個例子、約1萬字。

目錄

• 1. Hello World
• 2. Values
• 3. Variables
• 4. Constants
• 5. For
• 6. If/Else
• 7. Switch
• 8. Arrays
• 9. Slices
• 10. Maps
• 11. Range
• 12. Functions
• 13. Multiple Return Values
• 14. Variadic Functions
• 15. Closures
• 16. Recursion
• 17. Pointers
• 18. Strings and Runes
• 19. Structs
• 20. Methods

1. Hello World

下面的例子演示了如何打印經典的“Hello world”語句，以及運行和編譯go代碼的方法。

package main
import "fmt"

func main() {// 打印語句并換行
    fmt.Println("hello world")
}

// 可以通過go run命令直接從代碼運行
$ go run hello-world.go
hello world

// 也可以先通過go build先編譯成可執行文件
$ go build hello-world.go
$ ls
hello-world    hello-world.go

// 再運行可執行文件
$ ./hello-world
hello world

2. Values

下面的代碼演示了打印不同類型變量的方法。

package main

import "fmt"

func main() {// 支持字符串通過加號拼接 
    fmt.Println("go" + "lang")
    
	// Println支持多個不同類型參數，參數之間會用空格拼接起來輸出
    fmt.Println("1+1 =", 1+1)
    fmt.Println("7.0/3.0 =", 7.0/3.0)
    
	// 支持輸出bool類型變量
    fmt.Println(true && false)
    fmt.Println(true || false)
    fmt.Println(!true)
}

$ go run values.go
golang
1+1 = 2
7.0/3.0 = 2.3333333333333335
false
true
false

3. Variables

下面的例子演示了定義和初始化變量的方法。Go的編譯器可以做類型推導，無需顯示指定類型。若對變量不做顯式初始化，則會自動賦值為零值。

package main

import "fmt"

func main() {// 定義并初始化一個變量（類型會被自動推導為string）
    var a = "initial"
    fmt.Println(a)
    
	// 可以一次定義多個變量
    var b, c int = 1, 2
    fmt.Println(b, c)
    
  // 定義并初始化一個bool變量
    var d = true
    fmt.Println(d)

	// 定義變量并指定類型，但不顯式初始化（自動初始化為零值，0）
    var e int
    fmt.Println(e)
    
	// 更簡潔的變量定義語法，推薦
    f := "apple"
    fmt.Println(f)
}

$ go run variables.go
initial
1 2
true
0
apple

附：Go中的類型分類及零值大全

Go中的變量類型分為值類型、指針類型和引用類型三類。它們在函數傳參時的表現有差異：值類型傳遞時是拷貝復制，而指針類型實際存儲的是所指向變量的地址，經過拷貝復制后，在函數內部對所指變量的任何修改都能生效，外部變量會實際改變。至于引用類型，它并非是Go中的原生概念，而是一個語法糖，實際在內部封裝了一個指針，例如map類型本質上就是 *hmap；這樣做的好處是無需再顯式使用指針，使用更方便。

4. Constants

下面的例子演示了用const關鍵字定義的常量。

package main

import (
    "fmt"
    "math"
)

// 定義常量時用const代替var
const s string = "constant"

func main() {fmt.Println(s)
	// 定義常量時也可不指定類型，此時無類型
    const n = 500000000

	// numeric常量支持任意精度的運算
    const d = 3e20 / n
    fmt.Println(d)
    
	// 可以通過強制轉型賦予常量類型
    fmt.Println(int64(d))

	// 通過傳參也可以為常量指定類型，如Sin函數指定float64
    fmt.Println(math.Sin(n))

	// 不能將非const變量的運算結果賦值給const變量，否則會編譯報錯！
	// i := 100
	// const j = 100
	// const k = i + j

}

$ go run constant.go 
constant
6e+11
600000000000
-0.28470407323754404

5. For

下面例子展示了用for關鍵字實現的循環。Go中沒有其他語言通常使用的while關鍵字，所有循環都通過for來實現。

package main

import "fmt"

func main() {i := 1
    
 	// 類似于其他語言中的while
    for i<= 3 {fmt.Println(i)
        i = i + 1
    }

	// 常規for循環
    for j := 7; j<= 9; j++ {fmt.Println(j)
    }

	// 類似于其他語言中的while(true)
    for {fmt.Println("loop")
        break
    }

    for n := 0; n<= 5; n++ {if n%2 == 0 {continue
        }
        fmt.Println(n)
    }
}

$ go run for.go
1
2
3
7
8
9
loop
1
3
5

6. If/Else

下面例子展示了用if/else關鍵字實現的條件判斷。

package main

import "fmt"

func main() {// if條件句無需加括號
    if 7%2 == 0 {fmt.Println("7 is even")
    // 注意}和else必須在同一行，否則會編譯報錯
    } else {fmt.Println("7 is odd")
    }

    if 8%4 == 0 {fmt.Println("8 is divisible by 4")
    }

	// if可支持多條語句，用分號分隔
    if num := 9; num< 0 {fmt.Println(num, "is negative")
    } else if num< 10 {fmt.Println(num, "has 1 digit")
    } else {fmt.Println(num, "has multiple digits")
    }
}

$ go run if-else.go 
7 is odd
8 is divisible by 4
9 has 1 digit

7. Switch

下面例子展示了switch關鍵字實現的分支條件判斷。

package main

import (
    "fmt"
    "time"
)

func main() {i := 2
    fmt.Print("Write ", i, " as ")
    switch i {case 1:
        fmt.Println("one")
    // 注意這里無需加break，一個條件命中后自動退出，否則繼續遍歷其他條件
    case 2:
        fmt.Println("two")
    case 3:
        fmt.Println("three")
    }

    switch time.Now().Weekday() {case time.Saturday, time.Sunday:
        fmt.Println("It's the weekend")
    default:
        fmt.Println("It's a weekday")
    }

    t := time.Now()
    switch {case t.Hour()< 12:
        fmt.Println("It's before noon")
    default:
        fmt.Println("It's after noon")
    }

	// 可以用于類型判斷
    whatAmI := func(i interface{}) {switch t := i.(type) {case bool:
            fmt.Println("I'm a bool")
        case int:
            fmt.Println("I'm an int")
        default:
            fmt.Printf("Don't know type %T\n", t)
        }
    }
    whatAmI(true)
    whatAmI(1)
    whatAmI("hey")
}

$ go run switch.go 
Write 2 as two
It's a weekday
It's after noon
I'm a bool
I'm an int
Don't know type string

8. Arrays

下面例子展示了Go中數組的用法。數組用于存儲有序、固定數量的元素。

package main

import "fmt"

func main() {// 定義數組變量，需要指明元素類型
   var a [5]int
   // 數組類型作為參數，可以直接打印出所有元素變量
   fmt.Println("emp:", a)

   a[4] = 100
   fmt.Println("set:", a)
   fmt.Println("get:", a[4])

   // 用len方法獲取數組長度
   fmt.Println("len:", len(a))

   // 也可以在定義時直接初始化
   b := [5]int{1, 2, 3, 4, 5}
   fmt.Println("dcl:", b)

   // 二維數組的定義方法
   var twoD [2][3]int
   for i := 0; i< 2; i++ {   for j := 0; j< 3; j++ {   twoD[i][j] = i + j
       }
   }
   fmt.Println("2d: ", twoD)
}

$ go run arrays.go
emp: [0 0 0 0 0]
set: [0 0 0 0 100]
get: 100
len: 5
dcl: [1 2 3 4 5]
2d:  [[0 1 2] [1 2 3]]

9. Slices

下面例子介紹了切片的用法。切片是有序、不定長的數據結構，它的用法和數組非常類似，區別在于前者是不定長，后者是定長的。另一個區別是，前者是引用類型，后者是值類型，在函數傳參時需要注意區分。

package main

import "fmt"

func main() {// slice需要用make初始化，否則會賦成零值nil
   s := make([]string, 3)
   fmt.Println("emp:", s)

   s[0] = "a"
   s[1] = "b"
   s[2] = "c"
   fmt.Println("set:", s)
   fmt.Println("get:", s[2])

   fmt.Println("len:", len(s))
   
   // 可以動態往尾部添加元素
   s = append(s, "d")
   s = append(s, "e", "f")
   fmt.Println("apd:", s)

   c := make([]string, len(s))
   // copy可用于拷貝slice
   copy(c, s)
   fmt.Println("cpy:", c)

   // 可以靈活按下標生成新slice
   l := s[2:5]
   fmt.Println("sl1:", l)

   l = s[:5]
   fmt.Println("sl2:", l)

   l = s[2:]
   fmt.Println("sl3:", l)

   // slice可以和array一樣在定義時初始化
   t := []string{"g", "h", "i"}
   fmt.Println("dcl:", t)

   twoD := make([][]int, 3)
   for i := 0; i< 3; i++ {   innerLen := i + 1
       twoD[i] = make([]int, innerLen)
       for j := 0; j< innerLen; j++ {   twoD[i][j] = i + j
       }
   }
   fmt.Println("2d: ", twoD)
}

$ go run slices.go
emp: [  ]
set: [a b c]
get: c
len: 3
apd: [a b c d e f]
cpy: [a b c d e f]
sl1: [c d e]
sl2: [a b c d e]
sl3: [c d e f]
dcl: [g h i]
2d:  [[0] [1 2] [2 3 4]]

10. Maps

下面例子展示了map的用法。map用于key-value二元關系數據的存儲。

package main

import "fmt"

func main() {// map是引用類型，也需要用make初始化
    m := make(map[string]int)

    m["k1"] = 7
    m["k2"] = 13

    fmt.Println("map:", m)

    v1 := m["k1"]
    fmt.Println("v1: ", v1)

    fmt.Println("len:", len(m))

    delete(m, "k2")
    fmt.Println("map:", m)
	
	// 可以通過返回的第二個參數判斷key是否存在于map中
    _, prs := m["k2"]
    fmt.Println("prs:", prs)

	// 可以在定義時直接初始化
    n := map[string]int{"foo": 1, "bar": 2}
    fmt.Println("map:", n)
}

$ go run maps.go 
map: map[k1:7 k2:13]
v1:  7
len: 2
map: map[k1:7]
prs: false
map: map[bar:2 foo:1]

11. Range

下面例子展示了range關鍵字在遍歷slice、map和string時的用法。

package main

import "fmt"

func main() {nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {sum += num
    }
    fmt.Println("sum:", sum)

	// 遍歷slice返回的變量，第一個是下標，第二個是對應下標的元素
    for i, num := range nums {if num == 3 {fmt.Println("index:", i)
        }
    }

	// 遍歷map返回的變量，第一個是key，第二個是value
    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {fmt.Printf("%s ->%s\n", k, v)
    }

    for k := range kvs {fmt.Println("key:", k)
    }

	// 遍歷string返回的變量，第一個是對應rune的byte的起始下標，第二個是對應的rune
    for i, c := range "go" {fmt.Println(i, c)
    }
    for i, c := range "我們" {fmt.Println(i, c)
    }
}

$ go run range.go
sum: 9
index: 1
a ->apple
b ->banana
key: a
key: b
0 103
1 111
0 25105
3 20204

12. Functions

下面例子展示了func關鍵字定義的函數。

package main

import "fmt"

// 定義函數，順序：func、函數名、參數列表、返回值類型
func plus(a int, b int) int {return a + b
}

func plusPlus(a, b, c int) int {return a + b + c
}

func main() {res := plus(1, 2)
    fmt.Println("1+2 =", res)

    res = plusPlus(1, 2, 3)
    fmt.Println("1+2+3 =", res)
}

$ go run functions.go 
1+2 = 3
1+2+3 = 6

13. Multiple Return Values

下面例子展示了擁有多個返回值的函數。

package main

import "fmt"

func vals() (int, int) {return 3, 7
}

func main() {a, b := vals()
    fmt.Println(a)
    fmt.Println(b)

	// 可以用_占位，表示這個變量不實際使用
    _, c := vals()
    fmt.Println(c)
}

$ go run multiple-return-values.go
3
7
7

14. Variadic Functions

下面例子展示了變長參數函數的用法。變長參數提供了傳參的靈活性，可以是多個不定數量的參數，也可以是slice。

package main

import "fmt"

// 用...表示變長參數
func sum(nums ...int) {fmt.Print(nums, " ")
    total := 0

    for _, num := range nums {total += num
    }
    fmt.Println(total)
}

func main() {// 可用于多個參數
    sum(1, 2)
    sum(1, 2, 3)
    
	// 也可用于slice，注意要加...
    nums := []int{1, 2, 3, 4}
    sum(nums...)
}

$ go run variadic-functions.go 
[1 2] 3
[1 2 3] 6
[1 2 3 4] 10

15. Closures

下面的例子展示了閉包的概念。閉包一般與匿名函數相關，匿名函數可以引用外部函數中定義的變量，對其形成閉包。該變量可作為“半全局變量”，生命周期存在于多次匿名函數調用中，任何對它的修改都可在匿名函數中可見。

package main

import "fmt"

func intSeq() func() int {i := 0
    // 匿名函數對外部定義的i形成閉包
    return func() int {i++
        return i
    }
}

func main() {nextInt := intSeq()
    
	// 每次調用匿名函數都會將i加1
    fmt.Println(nextInt())
    fmt.Println(nextInt())
    fmt.Println(nextInt())

    newInts := intSeq()
    fmt.Println(newInts())
}

$ go run closures.go
1
2
3
1

16. Recursion

下面例子展示了函數遞歸的用法。

package main

import "fmt"

func fact(n int) int {if n == 0 {return 1
    }
    return n * fact(n-1)
}

func main() {fmt.Println(fact(7))

    var fib func(n int) int

    fib = func(n int) int {if n< 2 {return n
        }

        return fib(n-1) + fib(n-2)
    }

    fmt.Println(fib(7))
}

$ go run recursion.go 
5040
13

17. Pointers

下面例子展示了指針的用法。對于值類型的變量，如果傳參給函數后需要在內部做修改，那么需要使用指針傳遞。

package main

import "fmt"

// 通過值傳遞，僅拷貝變量，不會修改實際值
func zeroval(ival int) {ival = 0
}

// 通過指針傳遞，可以修改實際值
func zeroptr(iptr *int) {*iptr = 0
}

func main() {i := 1
    fmt.Println("initial:", i)

    zeroval(i)
    fmt.Println("zeroval:", i)

	// 用&獲取指針，即變量i的地址
    zeroptr(&i)
    fmt.Println("zeroptr:", i)

    fmt.Println("pointer:", &i)
}

$ go run pointers.go
initial: 1
zeroval: 1
zeroptr: 0
pointer: 0x42131100

18. Strings and Runes

下面例子展示了string與rune的關系。string可以看做是由byte元素組成的slice，默認采用UTF-8編碼。rune類似于其他語言中的character，它是code point，即該字符在字符表中的唯一序號。注意它與encoding概念不同，encoding代表不同編碼方式，如UTF-8、UTF-16，對同一個字符可以使用不同長度的編碼來表示。

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {const s = "??????"

	// len獲取底層byte slice的長度
    fmt.Println("Len:", len(s))
    
	// 打印底層的每個byte
    for i := 0; i< len(s); i++ {fmt.Printf("%x ", s[i])
    }
    fmt.Println()

    fmt.Println("Rune count:", utf8.RuneCountInString(s))
	
	// 用range遍歷，獲取的是每個rune及對應的byte起始下標。使用UTF-8編碼，每個rune占用3個字節
    for idx, runeValue := range s {fmt.Printf("%#U starts at %d\n", runeValue, idx)
    }

    fmt.Println("\nUsing DecodeRuneInString")
    for i, w := 0, 0; i< len(s); i += w {	// 使用DecodeRuneInString也能達到同樣的遍歷效果
        runeValue, width := utf8.DecodeRuneInString(s[i:])
        fmt.Printf("%#U starts at %d\n", runeValue, i)
        w = width

        examineRune(runeValue)
    }
}

func examineRune(r rune) {if r == 't' {fmt.Println("found tee")
    } else if r == '?' {fmt.Println("found so sua")
    }
}

$ go run strings-and-runes.go
Len: 18
e0 b8 aa e0 b8 a7 e0 b8 b1 e0 b8 aa e0 b8 94 e0 b8 b5 
Rune count: 6
U+0E2A '?' starts at 0
U+0E27 '?' starts at 3
U+0E31 '?' starts at 6
U+0E2A '?' starts at 9
U+0E14 '?' starts at 12
U+0E35 '?' starts at 15

	

Using DecodeRuneInString
U+0E2A '?' starts at 0
found so sua
U+0E27 '?' starts at 3
U+0E31 '?' starts at 6
U+0E2A '?' starts at 9
found so sua
U+0E14 '?' starts at 12
U+0E35 '?' starts at 15

19. Structs

下面例子展示了用struct關鍵字實現結構體。結構體是一種自定義類型，屬于值變量類型，它可以用于多個變量的封裝。

package main

import "fmt"

// 定義新struct類型，順序：type、struct名、struct
type person struct {name string
    age  int
}

func newPerson(name string) *person {// 定義struct變量
    p := person{name: name}
    p.age = 42
    return &p
}

func main() {fmt.Println(person{"Bob", 20})

    fmt.Println(person{name: "Alice", age: 30})

    fmt.Println(person{name: "Fred"})

    fmt.Println(&person{name: "Ann", age: 40})

    fmt.Println(newPerson("Jon"))

    s := person{name: "Sean", age: 50}
    fmt.Println(s.name)

    sp := &s
    fmt.Println(sp.age)

    sp.age = 51
    fmt.Println(sp.age)
}

$ go run structs.go
{Bob 20}
{Alice 30}
{Fred 0}
&{Ann 40}
&{Jon 42}
Sean
50
51

20. Methods

下面例子展示了方法的使用。Go非傳統面向對象語言，沒有其他語言中的class關鍵字。但可以使用結構體和方法達到類似的效果。與一般的函數不同，方法需要指定struct類型的值或者指針作為接收者，接收者的角色類似于其他語言中的對象。

package main

import "fmt"

type rect struct {width, height int
}

// 方法定義，順序：func、接收者、方法名、返回值類型
// 接收者可以是struct類型的指針
func (r *rect) area() int {return r.width * r.height
}

// 接受者也可以是struct類型的值
func (r rect) perim() int {return 2*r.width + 2*r.height
}

func main() {r := rect{width: 10, height: 5}
    
	// go可以自動做struct值類型和指針類型的轉換，使得與方法定義適配
    fmt.Println("area: ", r.area())
    fmt.Println("perim:", r.perim())

    rp := &r
    fmt.Println("area: ", rp.area())
    fmt.Println("perim:", rp.perim())
}

$ go run methods.go 
area:  50
perim: 30
area:  50
perim: 30

你是否還在尋找穩定的海外服務器提供商？創新互聯www.cdcxhl.cn海外機房具備T級流量清洗系統配攻擊溯源，準確流量調度確保服務器高可用性，企業級服務器適合批量采購，新人活動首月15元起，快前往官網查看詳情吧

網頁名稱：跟著實例學Go語言（一）-創新互聯
網頁地址：http://www.yijiale78.com/article42/ceipec.html

成都網站建設公司_創新互聯，為您提供面包屑導航、品牌網站建設、企業網站制作、做網站、定制網站、建站公司

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯