GO基礎知識分享2

小魔童哪吒發表於2021-03-31
Go
[TOC]

兵長：胖sir，咋還在看基礎知識嘞？你以前可不是這樣的哦

胖sir：切，我今天看的和之前的可不一樣

兵長：有啥不一樣的，你能給我說出花來嘛

胖sir：小樣，你自己好好看看

兵長：看看就看看

1、 多重賦值

交換2個數字的值

i := 10
j := 20
i , j = j, i

2、複數

t := 3 + 5i
fmt.Println(t) //(3+5i)
fmt.Printf("type == %T", t)//type == complex128

3、輸入

    var tmp int
    fmt.Scanf("%d", &tmp)
    fmt.Println("tmp == ", tmp)  //tmp ==  1

    var tmp2 int
    fmt.Scan(&tmp2)
    fmt.Printf("type == %T", tmp2)//type == int

4、型別轉換

bool型別不能與int型別互相轉化

5、type 自定義型別

    type long int64

    var a long
    a = 2

    fmt.Printf("type == %T", a)  //type == main.long

6、switch

case後面不需要寫break; 預設就有該功能

     num := 2
    switch num {
    case 1:
        fmt.Println("111")
    case 2:
        fmt.Println("222") //222
    case 3:
        fmt.Println("333")
    case 4:
        fmt.Println("4444")
    }

fallthrough – 不跳出switch語句，後面無條件執行

    num := 2
    switch num {
    case 1:
        fmt.Println("111")
    case 2:
        fmt.Println("222") //222
        fallthrough
    case 3:
        fmt.Println("333") // 333
    case 4:
        fmt.Println("4444")
    }

switch 後面可以不用寫 條件，case 後面可以寫條件

    score := 90
    switch {  //這裡可以不用寫 條件
    case score > 90:  //case 後面可以寫條件
        fmt.Println("extent")
    case score > 80:
        fmt.Println("good")
    case score > 70:
        fmt.Println("not bad")
    }

7、goto 的寫法和功能與C語言保持一致

8、golang函式名字首字母小寫，為私有，大寫為公有

9、不定引數型別和傳遞

func getname(args ...string) {
    length := len(args)
    if length > 0 {
        for i, data := range args {
            fmt.Printf("%d -- %s\n", i, data)
        }
    }
}

func test(args ...string) {
    getname(args[1:]...)  //只傳遞不定引數中的其中幾個
}

func main() {
    test("qqq", "yyy", "bbb")
    //0 -- yyy
    //1 -- bbb
}

10、函式型別

可以設定函式型別

func Add(a, b int) int {
    return a + b
}

type Universal func(int, int) int

func main() {
    var uni Universal
    uni = Add
    res := uni(1, 2)
    fmt.Println(res)
}

11 、回撥函式

通過回撥函式實現多型

func Add(a, b int) int {
    return a + b
}

type Universal func(int, int) int

func cal(uni Universal, a int, b int) int {
    return uni(a, b)
}
func main() {
    uni := Add
    res := cal(uni, 1, 2)
    fmt.Println(res)
}

12、匿名函式和閉包

golang中，所有的匿名函式都是閉包

1、匿名函式

2、定義匿名函式的時候直接呼叫

3、定義匿名函式有引數有返回值


    name := "qqq"
    age := 24
    //1、匿名函式
    f1 := func() {
        fmt.Printf("name == %s\n", name)
        fmt.Printf("age == %d\n", age)
    }

    f1()

    //2、定義匿名函式的時候直接呼叫
    func(hobby string) {
        fmt.Println(name)
        fmt.Println(hobby)
    }("basketball")

    //3、定義匿名函式有引數有返回值
    f3 := func(a, b int) int {
        return a + b
    }

    fmt.Println(f3(1, 3))

    res := func(a, b int) int {
        return a + b
    }(3, 8)
    fmt.Println(res)

閉包的特點

1、閉包的特點1，可以捕獲變數，且是以引用的方式捕獲的

2、必要的特點2 ，閉包裡面使用的變數，只要閉包還在使用，則一直有效，哪怕超出該變數的作用域

func cal() func() int {
    var x int
    return func() int {
        x++
        return x * x
    }
}

func main() {

    //1、閉包的特點1，可以捕獲變數，且是以引用的方式捕獲的
    a := 1
    name := "go"
    func() {
        a = 2
        name = "hello wrold"
        fmt.Printf("內部  ： a == %d, name == %s\n", a, name)
    }()
    fmt.Printf("外部  ： a == %d, name == %s\n", a, name)

    //2、必要的特點2 ，閉包裡面使用的變數，只要閉包還在使用，則一直有效，哪怕超出該變數的作用域
    f := cal()
    fmt.Println(f())
    fmt.Println(f())
    fmt.Println(f())
    fmt.Println(f())
}

13、defer

defer的使用

使用方式類似於棧，先進後出

//延遲呼叫，main函式結束前進行呼叫
    fmt.Println("hello")

    defer fmt.Println("over!!")

    fmt.Println("world")
    //hello
    //world 
    //over!!


    //多個defer的執行順序，類似於棧的方式，先進後出，哪怕中間出現程式錯誤，defer修飾的語句仍然會執行
    for i := 0; i < 10; i++ {
        defer fmt.Println(i)
    }

    --------------------------------------------
    defer fmt.Println("aaaa")
    defer fmt.Println("bbb")
    defer fmt.Println("ccc")
// ccc
// bbb
// aaaa

defer 和匿名函式的使用

// a := 10
    // b := 20

    // defer func() {
    //  fmt.Printf("inner  a == %d, b == %d\n", a, b)
    // }()

    // a = 1
    // b = 2
    // fmt.Printf("externer  a == %d, b == %d\n", a, b)

// externer  a == 1, b == 2
// inner  a == 1, b == 2

    a := 10
    b := 20

    defer func(a, b int) {
        fmt.Printf("inner  a == %d, b == %d\n", a, b)
    }(a, b) //此處引數 a=10 b=20的參與已經傳入到函式中了，只是匿名函式最後執行而已

    a = 1
    b = 2
    fmt.Printf("externer  a == %d, b == %d\n", a, b)

// externer  a == 1, b == 2
// inner  a == 10, b == 20

14、init函式

每一個包 預設都會有一個init函式，也可以自己寫一個init函式

每呼叫一個包，程式會先執行這個包的init函式

main.go

package main

import (
    "fmt"
    "hhh/test"
)

var a int = 10

func init() {
    fmt.Println("this is main init")
}

func main() {

    a := "xiaozhu"
    fmt.Println(a)
    {
        a := 1.4
        fmt.Println(a)
    }
    test.Pr()
}

test.go

package test

import "fmt"

func init() {
    fmt.Println("test init")
}
func Pr() {
    fmt.Println("hello wrold")
}

15、字串處理涉及的函式

www.zzvips.com/article/61040.html

16、值型別的變數，存在棧中，引用型別的變數，存在堆中

  • 值型別：基本資料型別int、float、bool、string以及陣列和struct
  • 引用型別：指標、slice、map、chan等都是引用型別

以上為本期全部內容，如有疑問可以在評論區或後臺提出你的疑問，我們一起交流，一起成長。

好傢伙要是文章對你還有點作用的話，請幫忙點個關注，分享到你的朋友圈，分享技術，分享快樂

技術是開放的，我們的心態，更應是開放的。擁抱變化，向陽而生，努力向前行。

作者：小魔童哪吒

本作品採用《CC 協議》，轉載必須註明作者和本文連結

相關文章