乐趣区

关于golang:GO基础知识分享2

jiezi

[TOC]

兵长：胖 sir，咋还在看基础知识嘞？你以前可不是这样的哦

胖 sir：切，我明天看的和之前的可不一样

兵长：有啥不一样的，你能给我说出花来嘛

胖 sir：小样，你本人好好看看

兵长：看看就看看

GO 基础知识分享 2

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、字符串解决波及的函数

http://www.zzvips.com/article…

16、值类型的变量，存在栈中，援用类型的变量，存在堆中

  • 值类型：根本数据类型 int、float、bool、string 以及数组和 struct
  • 援用类型： 指针、slice、map、chan 等都是援用类型

以上为本期全部内容，如有疑难能够在评论区或后盾提出你的疑难，咱们一起交换，一起成长。

好家伙要是文章对你还有点作用的话，请帮忙点个关注，分享到你的朋友圈，分享技术，分享高兴

技术是凋谢的，咱们的心态，更应是凋谢的。拥抱变动，背阴而生，致力向前行。

作者：小魔童哪吒

退出移动版