go doc

.go源文件

// main.go
// 1. .go文件
// 2. utf8编码

package main //包名

import "fmt"   //导入扩展包

func main() {
    fmt.Println("hello 毛台")
}

$go run main.go
  
hello 毛台

变量

func main() {
	var x int
	var s = "hello" //函数内可省略var关键字
	fmt.Println(x, s)
}
//0 hello

//函数内可省略var关键字
func main() {
	x := 100
	fmt.Println(x)
}
//100

表达式

go有3种流程控制语句

• if

func main() {
	x := -1
	if x > 0 {
		fmt.Println("x")
	} else if x < 0 {
		fmt.Println("-x")
	} else {
		fmt.Println("0")
	}
}

//-x

• switch

func main() {
	x := 0
	switch {
	case x > 0:
		fmt.Println("x")
	case x < 0:
		fmt.Println("-x")
	default:
		fmt.Println(0)
	}
}

//0

func main() {
	for i := 0; i < 5; i++ {
		switch i {
		case 0, 2: //任意命中1个即可
			fmt.Println("even")
			//命中这个分支后， 不需要写break，会被自动break
		case 1, 3:
			fmt.Println("odd")
		default:
			fmt.Println("it is not 0-3")
		}
	}
}

//even
//odd
//even
//odd
//it is not 0-3

• for

//正常的for循环
func main() {
	for i:=0;i<5 ;i++  {
		fmt.Println(i)
	}
}
//0
//1
//2
//3
//4

//相当于while
func main() {
	i := 0
	for i < 5 {
		fmt.Println(i)
		i++
	}
}

//0
//1
//2
//3
//4

//死循环
for{
	
}

// for range遍历返回索引
func main(){
	arr:=[]int{1,2,3}
	for k,v := range arr {
		fmt.Println(k,v)
	}
}

函数

//函数可返回多个值
func div(a int, b int) (int, error) {
	if b == 0 {
		return 0, errors.New("b is 0")
	}
	return a / b, nil
}

func main() {
	res,err:=div(10,0)
	fmt.Println(res,err)
}

//函数是第一类型, 可作为参数或返回值(也可以赋值)
func test(x int) func() {
	return func() {
		println(x)
	}
}

//defer定义延迟调用, 无论函数是否panic,结束时都被执行
func div(x, y int) {
	defer println("div end...")
	fmt.Println(x / y)
}

func main() {
	div(10, 0)
}

//div end...
//panic: runtime error: integer divide by zero

数据

//切片 - 类似动态数组
func main() {
	arr := make([]int, 0, 2)
	for i := 0; i < 5; i++ {
		arr = append(arr, i) //当容量不够时自动重新分配空间扩容
	}
	fmt.Println(arr)
}

//map
func main() {
	m := make(map[string]int)
	m["a"] = 1         //增加/更新元素
	ok, v := m["a"]    //判断是否存在
	fmt.Println(ok, v) //判断存在:1 true
	delete(m, "a")     //删除元素
}

方法

type user struct {
	name string
	age  int
}

type manager struct {
	user
	title string
}

func main() {
	var m manager
	m.name = "mm"
	m.age = 22
	m.title = "CTO"
	fmt.Println(m)
}

//{{mm 22} CTO}

//可以调用父类方法, 实现类似继承的功能
type user struct {
	name string
	age  int
}

func (u *user) toString() string {
	return fmt.Sprintf("%v", u)
}

type manager struct {
	user
	title string
}

func main() {
	var m manager
	m.name = "mm"
	m.age = 22
	m.title = "CTO"
	fmt.Println(m.toString())
}

//&{mm 22}

//可以为任意类型绑定方法

type X int

func (x *X) incr() {
	*x++
}
func main() {
	var x X
	x = 1
	x.incr()
	x.incr()
	fmt.Println(x)
}

//3

接口

type user struct {
	name string
	age  int
}

func (u user) Say() {
	fmt.Printf("%v", u)
}

type people interface {
	Say()
}

func main() {
	var u user
	u.name = "mm"
	u.age = 22

	var p people
	p = u
	p.Say()
}

//空接口可以接受任意类型的值

func test(x interface{}){
	fmt.Println(x)
}

func main() {
	test(10)
	test("mm")
}

并发

整个runtime并发设计, 几乎所有的进程都是以goroutine方式运行
channel与goroutine搭配, 实现通信,替代传统的通过共享内存通信的csp(Communicating Sequential Processes)模型,

// 消费者 
func consumer(data chan int, done chan bool) {
	for x := range data { // 接收数据，直到通道被关闭 
		println("recv:", x)
	}

	done <- true // 通知main，消费结束 
}

// 生产者 
func producer(data chan int) {
	for i := 0; i < 4; i++ {
		data <- i // 发送数据 
	}

	close(data) // 生产结束，关闭通道 
}

func main() {
	done := make(chan bool) // 用于接收消费结束信号 
	data := make(chan int)  // 数据管道 

	go consumer(data, done) // 启动消费者 
	go producer(data)       // 启动生产者 

	<-done // 阻塞，直到消费者发回结束信号 
}

main函数

• 每个程序只能又一个main函数,程序入口
• main函数不支持return, 使用os.Exit返回状态

//main不支持参数，传参使用os.Args
func main() {
	fmt.Println(os.Args)
}

//$: go run main.go 1 2 3
//[/var/folders/4g/nfky9hks3j39qhvz741tmcn40000gn/T/go-build150967295/b001/exe/main 1 2 3]

//main函数不支持返回值

func main() int{
	return 10
}
//$: go run main.go
//# command-line-arguments
//./main.go:3:6: func main must have no arguments and no return values

//main函数返回状态值的方法: os.Exit
func main() {
	fmt.Println("hello")
	os.Exit(-1)
}
//$: go run main.go
//hello
//exit status 255