命令记不住

Go语言关键字

1 Go语言25个关键字

2 关键字使用方式

• var
  定义变量

package main

import "fmt"

func main() {
	//用于声明变量，声明方式包括以下几种
	var name2 = 15 //int类型
	//在func内可以使用简写等价，但是简写不可以用于声明全局变量，既不能用于func外
	var name1 int64
	name3 := 15
	name4, name5, name6 := "a", "b", "c"

	fmt.Println(name1, name2, name3, name4, name5, name6)
}

• const
  定义常量或常量集

//用于声明常量，可以不用声明类型，对于int类型的常量可以用于int，int64等计算
package main

import "fmt"

const a = 14

func main() {
	var b = 16        //int
	var c = int64(20) //int64

	d := a + b
	e := a + c

	fmt.Printf("d = %d  %T\n",d,d)
	fmt.Printf("e = %d  %T\n",e,e)

}

d = 30  int
e = 34  int64

• package
  用于包声明，在Go中包的概念一般指同一文件夹下的的文件，与其它部分语言每个文件可以自己就是一个包不同。
  包名可以与文件夹名称不同，但是一般建议相同（如果文件夹带有版本号情况可以忽略版本号部分）
  需要写在程序的可执行文件的第一行。
• import
  用于包的引用，引用路径为工作区下的相对路径
  如果程序内引用了两个不同路径下相同的包名，可以通过设定别名的方式进行区分
  如果程序内需要用到引用包的初始化或者接口实现，但是没有显示调用，则需要使用“_”来进行区分

package main

import (
	"context"
	echoContex "echo/context"
	_ "notuse/context"
)

func main() {
	context.Background()
	echoContex.text()
}

• func /return
  定义函数接收返回值

func 函数方法体声明
返回参数如果为一个且不带参数名，可以不用写括号
返回参数超过一个或者带参数名则需要用括号扩起

return 函数方法体返回
如果函数返回参数带有参数名称则返回时不需要将每个参数显示返回，否则需要显示返回

package main

// 无入参，无出参
func main() {
	demo1("hello")
	demo2("hello", 1, 2, 3)
	intArr := []int64{1, 2, 3}
	demo2("hello", intArr...)
	demo3()
	demo4()
	demo5()
	demo6()
}

// 有固定入参，无出参数
func demo1(name string) {
	return
}

// 无固定入参，无出参数
func demo2(name string, params ...int64) {
	return
}

// 无入参，单参数无名称
func demo3() int64 {
	return 0
}

//无入参，单参数有名称

func demo4() (age int64) {
	return
}

// 无入参，多参数无名称
func demo5() (int64, string) {
	return 0, ""
}

// 无入参，多参数有名称
func demo6() (age int64, name string) {
	return
}

• type
  结构体或者接口的声明
• interface
  接口，可以存放任意格式数据，也可以定义接口方法
• struct
  结构体

package main

import "fmt"

type demoI interface {
	funDemo1(string)int
	funDemo2(int64)string
}
//定义结构体实现的方法
type demoS1 struct {

}

func (d * demoS1) funDemo1(string)int{
	return 0
}
func (d *demoS1) funDemo2(int64)string{
	return ""
}

//接受参数为接口类型
func demo3(d demoI){
	v,t :=d.(*demoS1)
	fmt.Println(v)
	fmt.Println(t)
}

func main(){
	s := &demoS1{}
	demo3(s)
}


&{}
true

一个 interface 被多种类型实现时，需要区分 interface 的变量究竟存储哪种类型的值。

go 可以使用 comma, ok 的形式做区分 value, ok := em.(T)：em 是 interface 类型的变量。
T代表要断言的类型，value 是 interface 变量存储的值，ok 是 bool 类型表示是否为该断言的类型 T。
如果是按 pointer 调用，go 会自动进行转换，因为有了指针总是能得到指针指向的值。
如果是 value 调用，go 将无从得知 value 的原始值是什么，因为 value 是份拷贝。go 会把指针进行隐式转换得到 value，但反过来则不行 。

• map
  map 是 Go 内置关联数据类型（在一些其他的语言中称为"哈希"或者"字典"）

package main

func main() {
	//仅仅进行了类型声明，并没有分配内存空间，直接调用会报错
	var m0 map[string]int
	//声明的同时进行了内存空间的申请
	m1 := make(map[string]int)

	//读取数据参数，返回参数可选，一个参数时为返回值，两个参数时第二个参数表示是否存在
	//如果数据不存在则会返回数据类型的默认数据，但数据为指针类型时则返回nil，不做判断直接使用的话会panic
	value, h := m1["key"]
	m0 = make(map[string]int, 100) //对变量进行初始化，并且预先分配存储空间大小

	_, _, _ = m0, value, h
}

• range
  与for配合，用于遍历，可遍历数组，map，string（string底层存储为byte数组）
• go
  goroutine异步携程,但是不建议携程处理大文件 , 可以携程来写日志和处理高IO操作，如果
  是cup密集型运算，则不建议使用
• select

Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操
作，要么是发送要么是接收。
如果有同时多个case去处理,比如同时有多个channel可以接收数据，那么Go会伪随机
的选择一个case处理(pseudo-random)。如果没有case需要处理，则会选择default去
处理，如果default case存在的情况下。如果没有default case，则select语句会阻塞，
直到某个case需要处理。

• chan

package main

var aChan chan int64              // nil chan
var bChan = make(chan int64)      //无缓冲
var cChan = make(chan int64, 100) //带缓冲区

• if / else / switch / case / default / fallthrough
  流程控制语句
• for / break / continue
  循环控制语句
• goto
  goto语句可以无条件地转移到过程中指定的行。
  通常与条件语句配合使用。可用来实现条件转移， 构成循环，跳出循环体等功能。
  在结构化程序设计中一般不主张使用goto语句， 以免造成程序流程的混乱 goto 对应(标签)
  既可以定义在for循环前面，也可以定义在for循环后面，当跳转到标签地方时，继续执行标签下面的代码。

Loop:
// 代码块
goto Loop

• defer

defer后面必须是函数调用语句，不能是其他语句，否则编译器会出错。
defer后面的函数在defer语句所在的函数执行结束的时候会被调用

package main
import "fmt"
func main() {
	defer fmt.Println("假装第一行")
	defer fmt.Println("假装第二行")
	defer fmt.Println("假装第三行")
	defer fmt.Println("假装第四行")
}

C:\Users\vSphere\go\src\day00>go run 08.go
假装第四行
假装第三行
假装第二行
假装第一行