30分钟上手GO语言--基础语法

iori84888340 · · 7396 次点击 · 开始浏览    置顶
这是一个创建于 的主题,其中的信息可能已经有所发展或是发生改变。
本章主要分成三个部分:第一部分包括基本语法和数据结构;第二部分讨论方法和接口;第三部分介绍并发机制。 包、变量和函数 先看一个例子Packages.go: ```golang package main import ( "fmt" "math/rand" ) func add(x int, y int) int { return x + y } func main() { fmt.Println("My favorite number is", rand.Intn(10)) fmt.Println(add(42, 13)) } ``` 包:每个 Go 程序都是由包(package)组成的,程序运行的入口是包 `main`。 导入:这个代码用圆括号组合了导入,这是“打包”导入语句。同样可以编写多个导入语句,例如: import "fmt" import "math" 这个程序使用并导入了包 "fmt" 和 `"math/rand"`。包名与导入路径的最后一个目录一致。例如,如果你导入了`"math/rand"`,那么你就可以在程序里面直接写rand.Intn(10),但如果你导入的是`"math"`,那么你就得写math.rand.Intn(10)。 函数:函数可以没有参数或接受多个参数。在这个例子中,`add` 接受两个 int 类型的参数,注意类型在变量名之后。有没有觉得很奇怪呢,下面就详细解释一下go这样做的原因。 看一个c的例子: int (*fp)(int (*ff)(int x, int y), int b) 我相信学过c的同学为了看懂这个都下了不少功夫吧,有没有感觉到痛苦或者说痛苦之后的那一点点优越感。 什么?你还能看懂?那么再来一个: int (*(*fp)(int (*)(int, int), int))(int, int);// 10s内看懂的同学给我回复下这个定义是啥,我请你吃饭。 用go语言的话这两个例子的定义如下: f func(func(int,int) int, int) int f func(func(int,int) int, int) func(int, int) int 是不是清晰多了,原来f返回的是一个函数啊。。。 函数参数: 当两个或多个连续的函数命名参数是同一类型,则除了最后一个类型之外,其他都可以省略,比如func add(x int, y int) int可以写为func add(x, y int) int 函数返回值: 函数可以返回任意数量的返回值,比如func swap(x, y string) (string, string)。 并且,函数的返回值还可以被命名,并且像变量那样使用,比如 ```golang func split(sum int) (x, y int) { x = sum * 4 / 9 y = sum - x return } ``` 没有参数的 return 语句返回结果的当前值。 变量: var 语句定义了一个变量的列表;跟函数的参数列表一样,类型在后面,可以定义在包或函数级别。比如: ```golang package main import "fmt" var c, python, java bool func main() { var i int fmt.Println(i, c, python, java) } ``` 变量的初始化: 变量定义可以包含初始值,每个变量对应一个。如果初始化是使用表达式,则可以省略类型;变量从初始值中获得类型。比如:var i, j int = 1, 2或者var c, python, java = true, false, "no!" 短声明变量:在函数中,`:=` 简洁赋值语句在明确类型的地方,可以用于替代 var 定义。 函数外的每个语句都必须以关键字开始(`var`、`func`、等等),`:=` 结构不能使用在函数外。比如: ```golang package main import "fmt" func main() { var i, j int = 1, 2 k := 3 c, python, java := true, false, "no!" fmt.Println(i, j, k, c, python, java) } ``` Go的基本类型:这里先简单列一下,后面再具体讲 bool string int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr byte // uint8 的别名 rune // int32 的别名// 代表一个Unicode码 float32 float64 complex64 complex128 零值:变量在定义时没有明确的初始化时会赋值为零值。数值类型为 `0`,布尔类型为 `false`,字符串为 `""`。 类型转换:Go 的在不同类型之间的项目赋值时需要显式转换。表达式 T(v) 将值 v 转换为类型 `T`。比如: var i int = 42 var f float64 = float64(i) var u uint = uint(f) 或者,更加简单的形式: i := 42 f := float64(i) u := uint(f) 类型推导:在定义一个变量但不指定其类型时(使用没有类型的 var 或 := 语句), 变量的类型由右值推导得出。 var i int j := i // j 也是一个 int 但是当右边包含了未指名类型的数字常量时,新的变量就可能是 int 、 float64 或 `complex128`。 这取决于常量的精度: i := 42 // int f := 3.142 // float64 g := 0.867 + 0.5i // complex128 常量:常量的定义与变量类似,只不过使用 const 关键字,常量可以是字符、字符串、布尔或数字类型的值,常量不能使用 := 语法定义。 流程控制语句 for循环:Go 只有一种循环结构for循环。基本的 for 循环除了没有了 `( )` 之外(,看起来跟 C 或者 Java 中做的一样,而 `{ }` 是必须的。比如: ```golang package main import "fmt" func main() { sum := 0 for i := 0; i < 10; i++ { sum += i } fmt.Println(sum) } ``` 死循环:如果省略了循环条件,循环就不会结束,因此可以用更简洁地形式表达死循环。 ```golang package main func main() { for { } } ``` If语句:if 语句除了没有了 `( )` 之外,看起来跟 C 或者 Java 中的一样,而 `{ }` 是必须的。 ```golang func sqrt(x float64) string { if x < 0 { return sqrt(-x) + "i" } return fmt.Sprint(math.Sqrt(x)) } ``` 可以在if条件之前执行一个简单的语句,由这个语句定义的变量的作用域仅在 if 范围之内,比如: ```golang func pow(x, n, lim float64) float64 { if v := math.Pow(x, n); v < lim { return v } return lim } ``` 在 if 的便捷语句定义的变量同样可以在任何对应的 else 块中使用,比如: ```golang func pow(x, n, lim float64) float64 { if v := math.Pow(x, n); v < lim { return v } else { fmt.Printf("%g >= %g\n", v, lim) } // 这里开始就不能使用 v 了 return lim } ``` Switch语句:switch 的条件从上到下的执行,当匹配成功的时候停止,除非以 fallthrough 语句结束,否则分支会自动终止。比如: switch i { case 0: case f(): } 当 i==0 时不会调用 `f`。没有条件的 switch 同 `switch true` 一样,这一构造使得可以用更清晰的形式来编写长的 if-then-else 链。 ```golang func main() { t := time.Now() switch { case t.Hour() < 12: fmt.Println("Good morning!") case t.Hour() < 17: fmt.Println("Good afternoon.") default: fmt.Println("Good evening.") } } ``` Defer语句:defer 语句会延迟函数的执行直到上层函数返回,延迟调用的参数会立刻生成,但是在上层函数返回前函数都不会被调用。比如打印hello world: ```golang func main() { defer fmt.Println("world") fmt.Println("hello") } ``` 延迟的函数调用被压入一个栈中。当函数返回时, 会按照后进先出的顺序调用被延迟的函数调用。 ```golang func main() { fmt.Println("counting") for i := 0; i < 10; i++ { defer fmt.Println(i) } fmt.Println("done") } ``` 输出 counting done 9 8 7 6 5 4 3 2 1 0 这个功能用来做清理工作非常清晰且强大,可以用结构化编程的思路处理面向对象编程中类似析构函数的功能。举一个实际点的例子: ```golang func CopyFile(dstName, srcName string) (written int64, err error) { src, err := os.Open(srcName) if err != nil { return } defer src.Close() dst, err := os.Create(dstName) if err != nil { return } defer dst.Close() return io.Copy(dst, src) } ``` 复杂类型 指针:Go 具有指针。 指针保存了变量的内存地址,类型 *T 是指向类型 T 的值的指针。其零值是 `nil`,& 符号会生成一个指向其作用对象的指针,* 符号表示指针指向的底层的值。 var p *int i := 42 p = &i fmt.Println(*p) // 通过指针 p 读取 i *p = 21 // 通过指针 p 设置 i 与 C 不同,Go 没有指针运算。 结构体:一个结构体(`struct`)就是一个字段的集合,跟C类似,结构体字段使用点号来访问,结构体字段可以通过结构体指针来访问。 ```golang type Vertex struct { X int Y int } func main() { fmt.Println(Vertex{1, 2}) v.X = 4 fmt.Println(v.X) p := &v p.X = 1e9 } ``` 结构体文法:结构体文法表示通过结构体字段的值作为列表来新分配一个结构体。使用 Name: 语法可以仅列出部分字段。(字段名的顺序无关。)特殊的前缀 & 返回一个指向结构体的指针。 ```golang 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 ) ``` 数组:类型 [n]T 是一个有 n 个类型为 T 的值的数组,数组的长度是其类型的一部分,因此数组不能改变大小。 Slice:一个 slice 会指向一个序列的值,并且包含了长度信息,[]T 是一个元素类型为 T 的 slice。slice 可以重新切片,创建一个新的 slice 值指向相同的数组。s[lo:hi] 表示从 lo 到 hi-1 的 slice 元素,含两端,因此s[lo:lo] 是空的。下标从0开始。 ```golang package main import "fmt" func main() { p := []int{2, 3, 5, 7, 11, 13} fmt.Println("p ==", p) fmt.Println("p[1:4] ==", p[1:4]) // 省略下标代表从 0 开始 fmt.Println("p[:3] ==", p[:3]) // 省略上标代表到 len(s) 结束 fmt.Println("p[4:] ==", p[4:]) } ``` 构造slice:slice 由函数 make 创建。这会分配一个零长度的数组并且返回一个 slice 指向这个数组,比如: a := make([]int, 5) // len(a)=5 为了指定容量,可传递第三个参数到 `make`: b := make([]int, 0, 5) // len(b)=0, cap(b)=5 b = b[:cap(b)] // len(b)=5, cap(b)=5 b = b[1:] // len(b)=4, cap(b)=4 slice 的零值是 `nil`,一个 nil 的 slice 的长度和容量是 0。 向slice添加元素: func append(s []T, vs ...T) []T append 的第一个参数 s 是一个类型为 T 的数组,append 的结果是一个包含原 slice 所有元素加上新添加的元素的 slice,如果 s 的底层数组太小,而不能容纳所有值时,会分配一个更大的数组,返回的 slice 会指向这个新分配的数组。 range: for 循环的 range 格式可以对 slice 或者 map 进行迭代循环。 ```golang package main import "fmt" var pow = []int{1, 2, 4, 8, 16, 32, 64, 128} func main() { for i, v := range pow { fmt.Printf("2**%d = %d\n", i, v) } } ``` 可以通过赋值给 _ 来忽略序号和值,如果只需要索引值,去掉“, value”的部分即可。 ```golang func main() { pow := make([]int, 10) for i := range pow { pow[i] = 1 << uint(i) } for _, value := range pow { fmt.Printf("%d\n", value) } } ``` map:map 在使用之前必须用 make 而不是 new 来创建;值为 nil 的 map 是空的,并且不能赋值。 ```golang type Vertex struct { Lat, Long float64 } var m map[string]Vertex func main() { m = make(map[string]Vertex) m["Bell Labs"] = Vertex{ 40.68433, -74.39967, } fmt.Println(m["Bell Labs"]) } ``` map 的文法跟结构体文法相似,不过必须有键名。 ```golang var m = map[string]Vertex{ "Bell Labs": Vertex{ 40.68433, -74.39967, }, "Google": Vertex{ 37.42202, -122.08408, }, } ``` 如果顶级的类型只有类型名的话,可以在文法的元素中省略键名。 var m = map[string]Vertex{ "Bell Labs": {40.68433, -74.39967}, "Google": {37.42202, -122.08408}, } 修改 map: 在 map m 中插入或修改一个元素:m[key] = elem 获得元素:elem = m[key] 删除元素:delete(m, key) 通过双赋值检测某个键存在:elem, ok = m[key] 如果 key 在 m 中,`ok` 为 true 。否则, ok 为 `false`,并且 elem 是 map 的元素类型的零值,同样的,当从 map 中读取某个不存在的键时,结果是 map 的元素类型的零值。 函数值:函数也是值。 ```golang package main import ( "fmt" "math" ) func main() { hypot := func(x, y float64) float64 { return math.Sqrt(x*x + y*y) } fmt.Println(hypot(3, 4)) } ``` 函数的闭包:这个意思简单点就是以函数作为返回值。 Go 函数可以是闭包的。闭包是一个函数值,它来自函数体的外部的变量引用。 函数可以对这个引用值进行访问和赋值;换句话说这个函数被“绑定”在这个变量上。 ```golang package main import "fmt" func adder() func(int) int { sum := 0 return func(x int) int { sum += x return sum } } func main() { pos, neg := adder(), adder() for i := 0; i < 10; i++ { fmt.Println( pos(i), neg(-2*i), ) } } ```
7396 次点击  ∙  1 赞  
加入收藏 微博
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传