go基础知识-关键字

go基础知识点整理:关键字

---

Go 内置关键字 (25个 按字母顺序)

break
case chan const continue
default defer
else
fallthrough for func
go goto
if import interface
map
package
range return
select struct switch
type
var

关键词说明:

break:

// break 作用于跳出循环 
func main() {
    // 1.break跳出for循环
    for i := 0; i < 10; i++ {
        fmt.Println(i)
        if i == 5 {
            fmt.Println("退出循环")
            break
        }
    }
    // 2.break跳出select、switch
    select {
    default:
        fmt.Println("进入default选择")
        break
        fmt.Println("因为跳出无法输出")
    }
    // 3.break跳出嵌套循环时只能跳出当前层次,如果想要跳出外层，需要指定标签
loop:
    for i := 0; i < 10; i++ {
        switch i {
        case 5:
            fmt.Println("i=5跳出整个循环")
            break loop
        default:
            fmt.Println(i)
        }
    }
}

case:

// case作用于选择结构中
func main() {
    // case只作用于switch或者select中作选择分支
    var i = 3
    switch i {
    case 1,2:
        fmt.Println("i=1或者2")
    case 3:
        fmt.Println("i=3")
    }
}

chan:

// chan作用于定义通道(channel)类型(目的为goroutine间通信)
func main() {
    // ch1无缓冲
    var ch1 = make(chan int)
    // ch2有1缓冲数
    var ch2 = make(chan int, 1)
    go func() {
        // 无缓冲 所以会阻塞
        ch1 <- 0
        fmt.Println("发送数据到ch1")
    }()
    go func() {
        // 有缓冲 会直接发送
        ch2 <- 0
        fmt.Println("发送数据到ch2")
    }()
    // 保证通道有数据
    time.Sleep(2 * time.Second)
    <- ch1
    <- ch2
    time.Sleep(1 * time.Second)
}

const:

// const作用于定义常量
const G = "全局常量"
const g = "包内常量"
const (
    c1 = iota + 1
    c2 = 111
    c3 = iota
    c4
)
func main() {
    fmt.Println(G)  // 全局常量
    fmt.Println(g)  // 包内常量
    fmt.Println(c1) // 1
    fmt.Println(c2) // 111
    fmt.Println(c3) // 2
    fmt.Println(c4) // 3
}

continue:

与break用法一致，跳过当前循环，执行下一次循环

default:

与case用法一致，作用于分支结构，用作默认分支

defer:

//作用于注册延迟调用，这些调用会知道return前才会被执行，按先进后出的顺序执行
type Person struct {
    name string
}
//需要注意defer时函数的参数是否为引用
func main() {
    var p = &Person{name: "xiaoming"}
    defer fmt.Println("1:" + p.name)
    defer func() {
        fmt.Println("2:" + p.name)
    }()
    defer func(pe *Person) {
        fmt.Println("3:" + pe.name)
    }(p)
    p.name = "xiaohong"

    var name = "xiaoming"
    defer fmt.Println("4:" + name)
    defer func() {
        fmt.Println("5:" + name)
    }()
    defer func(na string) {
        fmt.Println("6:" + na)
    }(name)
    name = "xiaohong"
}
/**
输出如下:
6:xiaoming
5:xiaohong
4:xiaoming
3:xiaohong
2:xiaohong
1:xiaoming
*/

else:

与if成对出现，作选择分支

fallthrough:

// fallthrough作用于case选择中，程序会执行下一个case事件
func main() {
    var i = 1
    switch i {
    case 1:
        fmt.Println("进入选择1")
        fallthrough
    case 2:
        fmt.Println("进入选择2")
        fallthrough
    default:
        fmt.Println("进入default选择")
    }
}
/**
输出如下:
进入选择1
进入选择2
进入default选择
*/

for:

作用于循环

func:

定义函数

go:

并发执行

goto:

跳转语句

if:

条件选择

import:

导入包

interface:

// 定义接口
type Animal interface {
    Speak() string
}

map:

定义map类型

package:

定义包名

range:

// 循环从slice、map等结构中提取数据
func main() {
    var m = map[string]interface{}{
        "name": "xiaoming",
        "age": 18,
    }
    for k, v := range m {
        fmt.Println(k,v)
    }
}
/**
输出:
name xiaoming
age 18
*/

return:

返回

select:

用法类似switch，select下的case必须是一个通信

struct:

定义结构体

switch:

选择结构

type:

定义类型

var:

定义变量