go语言中关键字有多少个

import _ "package path"
import . "package path"
import alias "package path"

import (
	_ "package path"
	. "package path"
	alias "package path"
)

导入声明						Sin的本地名
import   "lib/math"         math.Sin
import m "lib/math"         m.Sin
import . "lib/math"         Sin

package <packagename>

chan T      	// 可以被用来发送和接收类型T的值
chan<- T  		// 只能被用来发送浮点数
<-chan T      	// 只能被用来接收整数

ci := make(chan int)            // 整数类型的无缓冲信道
cj := make(chan int, 0)         // 整数类型的无缓冲信道
cp := make(chan *os.File, 100)  // 指向文件指针的带缓冲信道

const name = value
const name T = value
const (
	name = value
	name T = value
)

func test(const name *string)
func test(name *string) const *string

func funcName(){}							//无参无返回值
func funcName(t T) T {}						//有参有返回值
func funcName(t T, list ...T) (T1,T1) {}	//有变参有多个返回值

//空接口
interface{}

//一个简单的File接口
type File interface {
	Read(b Buffer) bool
	Write(b Buffer) bool
	Close()
}

//创建0容量的map
var myMap = make(map[T1] T2) 

//创建指定容量的map
var myMap = make(map[T]T2, cap) 

//创建并初始化map
var myMap = map[string]int { 
	"dable" : 27,
	"cat" : 28,
}

package main

import "fmt"

func main() {
        nameAge := make(map[string]int)
        nameAge["bob"] = 18                     //增
        nameAge["tom"] = 16                     //增
        delete(nameAge, "bob")                  //删
        nameAge["tom"] = 19                     //改
        v := nameAge["tom"]                     //查
        fmt.Println("v=",v)
        v, ok := nameAge["tom"]                 //查，推荐用法
        if ok { 
            fmt.Println("v=",v,"ok=",ok)
        }   
        for k, v :=range nameAge {      		//遍历
                fmt.Println(k, v)
        }   
}

v= 19
v= 19 ok= true
tom 19

package main

import "fmt"

type Vertex struct {
	X, Y int
}

var (
	v1 = Vertex{1, 2}  // 类型为 Vertex
	v2 = Vertex{X: 1}  // Y:0 被省略
	v3 = Vertex{}      // X:0 和 Y:0
	p  = &Vertex{1, 2} // 类型为 *Vertex
)

func main() {
	fmt.Printf("%#v %#v %#v %#v\n", v1, v2, v3, p)
}

main.Vertex{X:1, Y:2} main.Vertex{X:1, Y:0} main.Vertex{X:0, Y:0} &main.Vertex{X:1, Y:2}

//定义struct
type Person struct { name string }

//定义接口
type Person interface {
	speak(Word string)
}

//定义等价类型，rune等价于int32
type rune int32

var name T			//name默认为类型T的零值
var name = value	//根据值value推断变量name的类型
var name T = value	//赋初始值时指明类型
var name1, name2 T	//同时定义多个同类型变量

//同时定义多个不同类型的变量
var (
	name string ="dable"
	age int = 18
)

//单条件
i := 1
for i <= 3 {
	fmt.Println(i)
	i = i + 1
}

//初始化/条件/后续形式
//注意Go中没有前置自增与自减运算符，即++i是非法的
for i:=0; i < 3; i++ {
	fmt.Println(i)
}

//for range形式遍历数组
array :=[...]int{0,1,2,3,4,5}
for i, v :=range array{
	fmt.Println(i,v)
}

//终止for
L:
	for i < n {
		switch i {
		case 5:
			break L
		}
	}

//提前进入下一轮循环
for i:=0; i < 3; i++ { 
	if i == 1 {
		continue
	}
	fmt.Println(i)
}
//输出结果
0
2

//提前进入标签处for的下一轮循环
L:
for i:=0; i < 2; i++ { 
	for j:=0; j < 3; j++{
		if j == 1 {
			continue L
		}
		fmt.Println(i, j)
	}
}
//输出结果
0 0
1 0

//终止for
L:
	for i < n {
		switch i {
		case 5:
			goto L
		}
	}

	goto L  //编译报错
	v := 3
L:
	fmt.Println(v)

if n%2 == 1 {
	goto L1
}
for n > 0 {
	f()
	n--
L1:
	f()
	n--
}

//表达式选择

switch tag {
default: s3()			//default子句可以出现在switch语句中的任意位置，不一定是最后一个
case 0, 1, 2, 3: s1()	//case表达式可以提供多个待匹配的值，使用逗号分隔
case 4, 5, 6, 7: s2()
}

switch x := f(); {		
case x < 0: return -x	//case表达式无需为常量
default: return x
}

switch {				//缺失的switch表达式意为"true"
case x < y: f1()
fallthrough				//强制执行下一个case子句
case x < z: f2()
//此处没有fallthrough，switch执行流在此终止	
case x == 4: f3()
}

//类型选择
switch i := x.(type) {
case int:
	printInt(i)                            // i 的类型为 int
case float64:
	printFloat64(i)                        // i 的类型为 float64
case func(int) float64:
	printFunction(i)                       // i 的类型为 func(int) float64
case bool, string:
	printString("type is bool or string")  // i 的类型为 bool or string
default:
	printString("don't know the type")     // i 的类型未知
}

if err := file.Chmod(0664); err != nil {
	log.Print(err)
	return err
}

//无返回值
func noResult() {
	return
}

//单返回值
func simpleF() int {
	return 2
}

//多返回值
func complexF2() (float64, float64) {
	re = 7.0
	im = 4.0
	return re, im
}

//返回值已具名
unc complexF3() (re float64, im float64) {
	re = 7.0
	im = 4.0
	return
}

//将文件的内容作为字符串返回。
func Contents(filename string) (string, error) {
	f, err := os.Open(filename)
	if err != nil {
		return "", err
	}
	defer f.Close()  // f.Close 会在函数结束后运行

	var result []byte
	buf := make([]byte, 100)
	for {
		n, err := f.Read(buf[0:])
		result = append(result, buf[0:n]...)
		if err != nil {
			if err == io.EOF {
				break
			}
			return "", err  // 我们在这里返回后，f 就会被关闭
		}
	}
	return string(result), nil // 我们在这里返回后，f 就会被关闭
}

for i := 0; i < 5; i++ {
	defer fmt.Printf("%d ", i)
}

package main

import (
        "fmt"   
        "time"  
)

func main() {
        go func(){ 
            fmt.Println("in first goroutine")
        }()     
        go func(){ 
            fmt.Println("in second goroutine")
        }()     

        fmt.Println("main thread start sleep, and other goroutine start execute")
        time.Sleep(10*time.Second)
}

main thread start sleep, and other goroutine start execute
in second goroutine
in first goroutine

package main

import "fmt"

func main(){
    ch1 := make(chan int, 1)
    ch2 := make(chan int, 1)

    ch1 <- 3
    ch2 <- 5

    select {
    case <- ch1:
        fmt.Println("ch1 selected.")
    case <- ch2:
        fmt.Println("ch2 selected.")
	default:
		//如果ch1与ch2没有数据到来，则进入default处理流程。如果没有default子句，则select一直阻塞等待ch1与ch2的数据到来
		fmt.Println("default")
	}
}

ch1 selected.

//或者
ch2 selected.