前言
上一篇入门篇算是初识庐山真面目，我们知道了一个go程序的构成，在这里总结一下。
//包名
package
//导入包
import "fmt"
//main方法，程序入口
func main() {
//程序主体
fmt.Println("Hello World!")
}
那么，作为一个经验丰富的程序员，接下来很自然地就是看看它的语法是怎么样的，怎么声明变量、常量，有哪些数据类型，有哪些运算符，有哪些控制语句，有哪些数据结构，怎么使用函数，还有注释、转义等等。
当然，作为OO，还会涉及如何定义接口、类，如何创建对象。但下面的内容只会对go语法作一个全览，不作深入探究。更多的细节或者我觉得比较有趣的内容留待后面的文章中探讨。比如go的变量声明为什么设计成名字在前类型在后，为什么go没有三元操作符等等。
行分隔
一行代表一个语句结束，不需要使用分号结尾。
同时go源码格式是语言规范的一部分，并提供了 gofmt工具格式化代码，因此团队协作时，不需要担心格式式模板的问题。
注释
//单行注释
/*
* 块注释
*/
转义
go语言的转义符是，其他没有什么特别的。
变量&常量
//声明整型变量a
var a int
//声明整型变量a，并赋初值1
var a = 1
//声明整型变量a，并赋初值1
a := 1
//多变量声明
var a, b int
var a, b = 123, 456 //同类型
c, d := 111, "abc" //不同类型
var (
a int
b string
)
//声明常量
const a int = 1
const b = 1
const (
c string = "abc"
d := 1
)
const (
x = iota //0
y //1, 自动加1
z //2, 自动加1
)
可以看出，变量的声明名称在前，类型在后。而对于不同的数据类型或结构，初值及初始化语法有所差别。此差别会在下文中可以看到。
数据类型
| 名称 | 说明 |
|---|---|
| 布尔类型 | bool，值true or false |
| 数字类型 | 包括整型(int,uint,uintptr,byte,rune,uint8,uint16,uint32,uint64,int8,int16,int32,int64)、浮点型(float32,float64,complex64,complex128) |
| 字符类型 | 即字符串类型，采用UTF-8编码 |
| 派生类型 | 包括指针,数组,切片,map,结构,通道,函数,接口 |
其中数字类型区分了有符号类型、无符号类型，同时还细分了位数。go号称性能高，如果没有这些细分的数据类型，恐怕就不好吹牛B了。
运算符
| 名称 | 说明 |
|---|---|
| 算术运算符 | +, -, *, /, %, ++, -- |
| 关系运算符 | ==, !=, >, <, >=, <= |
| 逻辑运算符 | &&, ||, ! |
| 位运算符 | &, |, ^(异或), >>, << |
| 赋值运算符 | =, +=, -=, *=, /=, %=, <<=, >>=, &=, |
| 其他运算符 | &(取地址), *(指针) |
运算符倒没什么特别的，该有的都有，除了三元操作符
控制语句
//if语句
a := 1
if a == 1 {//if条件是不带括号的，除了复合条件
fmt.Println("a==1")
} else if a < 1 {
fmt.Println("a<1")
} else {
fmt.Println("a>1")
}
//switch语句
b := "abc"
switch b {
case "abc":
fmt.Println("abc")
case "xyz":
fmt.Println("xyz")
case "hello", "world":
fmt.Println("Hello World")
default:
fmt.Println("unknown")
}
//type-switch，用于类型判断
swithc b.(type) {
case int:
fmt.Println("int")
case string:
fmt.Println("string")
default:
fmt.Println("unknown")
}
//select语句，常用于channel通信
var c1, c2 chan int
select {
case <- c1:
fmt.Println("c1")
case <- c2:
fmt.Println("c2")
default
fmt.Println("none")
}
//如果没有 default，select语句会从可用的case中公平随机地选择一个，否则阻塞直至某个 case可用
//case都不可用且有default时，选择default分支
//for循环
for i := 1; i < 10; i++ {
fmt.Println(i)
}
i := 1
for {
if i >= 10 {
break
}
fmt.Println(i)
i++
}
array := [2]int{1,2}
for index, value := range array {
fmt.Printf("index: %d, value: %d", index, value)
}
看起来多了select语句，但少了while语句。但其for语句的可用性显著地高于其他语言。
数据结构
//声明指针
var a *int
//声明int数组
var array [2]int
array[0] = 1
var array2 = [3]int{1,2,3}
var array3 = [...]int{1,2}
//数组访问
b := array2[0] //第1个元素
c := array2[1:2] //c = [2]int{2,3}
d := array2[1:] //d = [2]int{2,3}
e := array2[:2] //e = [2]int{1,2}
//数组遍历
for index, value := range array2 {
}
//_表示忽略返回值
for _, value := range array2 {
}
//声明切片(相当于Java的List)
var slice []int //相当于List<Integer>
slice = make([]int, 2) //相当于new ArrayList<Integer>(2)
var slice2 []int = make([]int, 2)
slice3 := make([]int, 2)
//切片的访问与数组一样
//声明map
var map1 map[string]string
map1 = make(map[string]string, 2) //相当于new HashMap<String, String>(2)
var map2 map[string]string = make(map[string]string, 2)
map3 := make(map[string]string, 2)
//map 赋值
map3["a"] = "a"
map3["b"] = "b"
//map 访问
ma := map3["a"] //ma = a
//map 遍历
for key, value := range map3 {
}
//判断元素是否存在
if exists, value := map3["a"]; exists {
}
//声明 struct，可认为是go语言的类定义
type House struct {
Area float32
Price int64
}
//struct 构建
h := House{}
h.Area = 120.0
h.Price = 30000
h1 := House{Area: 120.0, Price: 30000}
函数
package main
import "fmt"
//函数声明
func foo() string {
return "bar"
}
//函数声明2
func foo2(value string) (string, error) {
return bar + value, nil
}
//函数调用
func main() {
fmt.Println(foo())
if r, err := foo2("xyz"); err != nil {
fmt.Println(r)
}
}
到此为止，go的基础语法已经罗列完毕。这些都是绝大多数语言的共性，除了表达方式上有所不同之外，所有的这些元素都是一门编程语言不可或缺的。总的来说，名字在前，类型在后，语句无分号，判断无括号，其他无两样。
如果说go有什么不一样的话，那确实有许多不一样之处，留待下回细说。
请关注公众号
