(walk through) overview of go
.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