从例子中学习 go 语言 —— 基本语法

陆仁贾 · · 4597 次点击 · · 开始浏览

这是一个创建于的文章，其中的信息可能已经有所发展或是发生改变。

go 语言或是 golang 官网上有个 tour。从例子中学习一门语言虽然具有片面性，但是往往是一个入门的好方法；如果一开始就去是看手册的话，有些凌乱，摸不着头脑，有点看字典的味道。所以，先从例子中学习，然后再系统的学习，应该是个不错的方法。

本篇文章基本按照 tour 的步骤，跑跑例子，从例子中去猜测/分析 go 的语法以及结构等，一定程度上可以锻炼一下，观察和分析能力。

hello,world：
1. package main
3. import "fmt"
5. func main() {
6. fmt.Println("hello,world") // 输出 hello,world
7. }
1). package 将程序打包； 2). import 导入其他包，包名用双引号引住；fmt 包 —— 应该是 format 格式化输入/输出的包； 3). func 声明函数，main 函数，不带参数，不返回值，函数体用 { } 括号括住；左大括号 { 与声明在同一行（必须！）； 4). fmt.Println 向控制台输出，包名小写，函数名首字母大写； 5). 语句不带分号； // 试验发现，分号可有可无；实际上 go 是自动插入分号； 6). package 必须写在前面；必须先 import 包，然后才能使用包中的东西； 7). // 行注释，/* */ 块注释，都是常用的方法；
导入多个包：
1. package main
3. import (
4. "fmt"
5. "math"
6. )
8. func main() {
9. fmt.Println("Happy", math.Pi, "Day")
10. }
1). import 导入多个包的简单写法；小括号括住，包名换行写；或是用分号将它们隔开； 2). 新的包 math，应该是数学包； 3). math.Pi 圆周率；// 小数点后有十五位 math.Pi == 3.141592653589793；math.E == 2.718281828459045； 4). fmt.Println 多个参数多个输出，从左到有一一输出； 5). 程序从 main 包的 main 函数开始执行；
格式化输出：
1. package main
3. import (
4. "fmt"
5. "math"
6. )
8. func main() {
9. fmt.Printf("Now you have %g problems.",
10. math.Nextafter(2, 3))
11. }
1). 一条语句可以换行写，不过是在逗号处隔开； 2). fmt.Printf 格式化输出函数，类似于 c 语言的 printf ，第一参数是格式化字符串；函数输出不自动换行； 3). fmt.Printf 名字类似于 fmt.Println；包的名字一般小写；包中的函数 Printf/Println 和值 Pi/E 首字母看来是大写； 4). math.Nextafter 方法，暂时不纠结到底什么意思；// Nextafter(2,2) == 2；Nextafter(2,3) == 2.0000000000000004；Nextafter(2,1) == 1.9999999999999998
函数定义和使用：
1. package main
3. import "fmt"
5. func add(x int, y int) int {
6. return x + y
7. }
9. func main() {
10. fmt.Println(add(42, 13))
11. }
1). func 进行函数声明，func 函数名(参数列表) 返回值类型；参数以及返回值的类型向后写，而不是像 c、c++ 和 Java 等写在前面； 2). 函数调用都一样，函数名后面跟上参数，参数之间逗号隔开，小括号括住； 3). int 是整数类型，两个 int 相加，结果是 int；貌似是废话；
函数声明时类型省略：
1. package main
3. import "fmt"
5. func add(x, y int, z int) int {
6. return x + y + z
7. }
9. func main() {
10. fmt.Println(add(42, 13, 12))
11. }
1). 这里 x 类型么有指定，认为和后面的 y 的类型一致；因为 x、y、z 都是 int 型，所以实际上可以只留 z 的 int 就可以，y 的也可以省略； 2). 省略了认为是和后面的重复，也就是只有类型重复的时候，偶们才可以省略；
函数多返回值的用法：
1. package main
3. import "fmt"
5. func swap(x, y string) (string, string) {
6. return y, x
7. }
9. func main() {
10. a, b := swap("hello", "world")
11. // var a, b := swap("hello", "world")
12. fmt.Println(a, b) // world hello
13. }
1). c 类的语言(c/c++/java等) 一般函数只有一个返回值，如果想返回多个，一般都要进行封装称结构体或是类，F# 引入元组类型，就是简单的用小括号一括，就可以把若干个值放在一块；这里的用法是类似的，函数返回值用括号一括就表明一下子返回多个值，简单易用； 2). 至此，貌似都嚒见过怎么声明变量，只是用了函数中的变量以及将函数返回值简单返回；这个例子中有两种声明方法，一种不需要借助 var关键字进行隐式声明，一种需要算式显式声明——明白滴告诉你这就是个变量 variable，至于类型，看后面； 3). 如此交换两个变量甚好，以前见过的交换，一般都需要借助于辅助变量或是其他运算；
声明函数的返回值，不仅仅是类型：
1. package main
3. import "fmt"
5. func split(sum int) (x, y int) {
6. x = sum * 4/9
7. y = sum - x
8. return
9. }
11. func main() {
12. fmt.Println(split(36))
13. // fmt.Println(split(17))
14. }
1). 看函数声明，直接把返回值 x、y声明出来了，函数内部可以直接使用参数和返回值变量，而且 return 不需要显式地返回 x、y； 2). 声明的返回值变量，不赋值就用的话，默认值是 0 或是 false 等； 3). 可能你奇怪，如果 return x+2,y+2 会怎么样，实际上是将 x、y 各加 2 的结果返回，不报警告也不报错；也就是所如果有 return 值那就是返回值，没有的话，才将声明的返回值返回； 4). int * int 结果是 int ； int / int 结果也是 int，不是浮点数 —— 这也是 c 语言的一贯传统；
变量声明：
1. package main
3. import "fmt"
5. var x, y, z int
6. var c, python, java bool
8. func main() {
9. fmt.Println(x, y, z, c, python, java)
10. }
1). 用 var 进行变量声明，和函数声明时参数的声明一样，类型向后写，也就是先写变量名，再写类型； 2). 多个变量类型一样的话，可以合在一起写；int 和 bool 是目前见过的整数和布尔类型； 3). 声明变量如果么有显式的初始化，都有默认值，int 为 0，bool 为 false ； 4). 没有初始化的变量声明，类型不同不能连在一起写；
变量声明和类型推断：
1. package main
3. import "fmt"
5. var x, y, z int = 1, 2, 3
6. var c, python, java = true, false, "no!"
8. func main() {
9. fmt.Println(x, y, z, c, python, java)
10. }
1). 变量声明的同时可以初始化； 2). 如果有初始化的话，变量类型可以不写，类型靠推断而得； 3). 变量声明可以连着写； 4). "hello"、"yes" 这是 string —— 字符串类型；
两种变量声明方法：
1. package main
3. import "fmt"
5. func main() {
6. var x, y, z int = 1, 2, 3
7. c, python, java := true, false, "no!"
9. fmt.Println(x, y, z, c, python, java)
10. }
1). 隐式变量声明和显式变量声明，也就是不使用和使用 var 关键字，同时两种运算符也不相同； 2). 函数外不能使用隐式变量声明，也就是 a : = 3 这种；
常量声明：
1. package main
3. import "fmt"
5. const Pi = 3.14
7. func main() {
8. const World = "世界"
9. fmt.Println("Hello", World)
10. fmt.Println("Happy", Pi, "Day")
12. const Truth = true
13. fmt.Println("Go rules?", Truth)
14. }
1). const 用来声明常量，const 浮点数、const 整数、const 字符串、const 布尔值；
接触浮点数 / 实数：
1. package main
3. import "fmt"
5. func add(x int, y float64) int {
6. return x + int(y)
7. }
9. func main() {
10. fmt.Println(add(42, 13))
11. }
1). float64 是 64 位的浮点数，还有 float32；总之现在简单滴看，就是 —— 实数或是小数； 2). int + float64 不合法，也就是 int 不能直接和 float64 相加； 3). int(y) 将 y 转化为 int 值； 4). 函数传参数的时候，可以将 int 传给 float64；
大整数常量以及浮点数：
1. package main
3. import "fmt"
5. const (
6. Big = 1<<100
7. Small = Big>>99 // 2
8. )
10. func needInt(x int) int { return x*10 + 1 }
11. func needFloat(x float64) float64 {
12. return x*0.1
13. }
15. func main() {
16. // fmt.Println(Big) // overflow int
17. fmt.Println(float64(Big))
18. fmt.Println(Small) // 2
19. fmt.Println(needInt(Small)) // 21
20. fmt.Println(needFloat(Small)) // 0.2
21. fmt.Println(needFloat(Big))
22. }
1). 声明多个 const 可以简写；小括号括起来，然后换行写，和 import 包类似； 2). 参数传递，可以将 int 传给 float64； 3). int 有表示范围一说，数值太大，会溢出；
for 循环结构：
1. package main
3. import "fmt"
5. func main() {
6. sum := 0
7. for i := 0; i < 10; i++ {
8. sum += i
9. }
10. fmt.Println(sum)
11. }
1). 相对于 c 的 for 循环结构来说，去掉了两侧的小括号；
for 循环结构简化版：
1. package main
3. import "fmt"
5. func main() {
6. sum := 1
7. for ; sum < 1000; {
8. sum += sum
9. }
10. fmt.Println(sum)
11. }
1). for 去掉了前置和后置语句，但是分号还在；
for 循环结构再次简化：
1. package main
3. import "fmt"
5. func main() {
6. sum := 1
7. //for ; sum < 1000; {
8. for sum < 1000 {
9. sum += sum
10. }
11. fmt.Println(sum)
12. }
1). for 去掉了前置和后置语句，但是分号还在； 2). for 去掉了前置和后置语句，分号也可以去掉，这样就相当于 c 的while 结构；
死循环结构：
1. package main
3. func main() {
4. for ; ; {
5. //for {
6. }
7. }
1). for 没有判断条件，默认为 true，也就是死循环； 2). for 没有判断条件，也没有前置和后置语句，去掉所有的分号，就有了 for 的最简化形式；
if 选择结构：
1. package main
3. import (
4. "fmt"
5. "math"
6. )
8. func sqrt(x float64) string {
9. if x < 0 {
10. return sqrt(-x) + "i"
11. }
12. return fmt.Sprint(math.Sqrt(x))
13. }
15. func main() {
16. fmt.Println(sqrt(2), sqrt(-4))
17. }
1). if 选择结构，相对于 c 来说，去掉了两边的小括号； 2). math.Sqrt 求实数的平方根； 3). 递归调用啊，有木有！ sqrt 函数！ 3). 将 float64 值字符串化的方法 fmt.Sprint；Sprint 名字类似于 Print/Println/Printf/Fprintf ，可以略猜出来，S 应该是 string 的意思；
if 选择结构加强版：
1. package main
3. import (
4. "fmt"
5. "math"
6. )
8. func pow(x, n, lim float64) float64 {
9. if v := math.Pow(x, n); v < lim {
10. return v
11. }
12. return lim
13. }
15. func main() {
16. fmt.Println(
17. pow(3, 2, 10),
18. pow(3, 3, 20),
19. )
20. }
1). if 选择结构可以加前置语句，类似于 for ；如果嚒有前置语句为空，可以留下分号，也可以去掉分号； 2). 前置语句引入的变量的作用域仅限于 if 结构； 3). math.Pow 求幂指数；
if - else 选择结构
1. package main
3. import (
4. "fmt"
5. "math"
6. )
8. func pow(x, n, lim float64) float64 {
9. if v := math.Pow(x, n); v < lim {
10. return v
11. } else {
12. fmt.Printf("%g >= %g\n", v, lim)
14. }
15. // can't use v here, though
16. return lim
17. }
19. func main() {
20. fmt.Println(
21. pow(3, 2, 10),
22. pow(3, 3, 20),
23. )
24. }
1). if - else 结构 2). if 前置语句引入的变量作用域也可以用于 else ； 3). 这个运行结果有些比较奇怪！
复数运算：
1. package main
3. import (
4. "math/cmplx"
5. "fmt"
6. )
8. var (
9. ToBe bool = false
10. MaxInt uint64 = 1<<64 - 1
11. z complex128 = cmplx.Sqrt(-5+12i)
12. )
14. func main() {
15. const f = "%T(%v)\n"
16. fmt.Printf(f, ToBe, ToBe)
17. fmt.Printf(f, MaxInt, MaxInt)
18. fmt.Printf(f, z, z)
19. }
1). go 内置复数运算，使用 math/cmplx 包； 2). const 常量字符串可以用于 fmt.Printf 的第一个参数，见过的格式化有 %T %v %g 几种； 3). 换行符，都熟悉的； 4). math/cmplex 复数包；cmplx.Sqrt 复数开根号 5). go 的基本类型：
```
bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // uint8
rune // int32
float32 float64
complex64 complex128
```

由于篇幅所限，也为了看着方便，后面的例子见下一篇文章。

有疑问加站长微信联系（非本文作者）

本文来自：陆仁贾个人站点

感谢作者：陆仁贾

查看原文：从例子中学习 go 语言 —— 基本语法

入群交流（和以上内容无关）：加入Go大咖交流群，或添加微信：liuxiaoyan-s 备注：入群；或加QQ群：692541889

4597 次点击

加入收藏微博

收入我的专栏

上一篇：go 语言学习

下一篇：从例子中学习 go 语言 —— 数据结构、指针

函数

变量

返回值

小括号

0 回复

添加一条新回复（您需要登录后才能回复没有账号？）

请尽量让自己的回复能够对别人有帮助
支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
支持 @ 本站用户；支持表情（输入 : 提示），见 Emoji cheat sheet
图片支持拖拽、截图粘贴等方式上传

关注我

扫码关注领全套学习资料
加入 QQ 群：
- 192706294（已满）
- 731990104（已满）
- 798786647（已满）
- 729884609（已满）
- 977810755（已满）
- 815126783（已满）
- 812540095（已满）
- 1006366459（已满）
- 692541889
加入微信群：liuxiaoyan-s，备注入群
也欢迎加入知识星球 Go粉丝们（免费）

从例子中学习 go 语言 —— 基本语法

用户登录

今日阅读排行

一周阅读排行

关注我

从例子中学习 go 语言 —— 基本语法

用户登录

今日阅读排行

一周阅读排行

关注我

给该专栏投稿 写篇新文章

收入到我管理的专栏 新建专栏

给该专栏投稿写篇新文章

收入到我管理的专栏新建专栏