2. 顺序编程

1. 变量

1.1 变量声明

var v1 int

var v2 string

var v3 [10] int  //数组

var v4 [] int   //数组切片

var v5 struct{

<span style="white-space:pre">	</span>f int

}

var v6 *int //指针

var v7 map[string] int //map,key 为string类型，value为int类型

var v8 func（a int） int

</pre><pre name="code" class="plain">var(

<span style="white-space:pre">	</span>v1 int

<span style="white-space:pre">	</span>v2 string

}

</pre><h2>1.2 变量初始化</h2><div><pre name="code" class="plain">var v1 int =10
var v2=10
v3:=10

1.3 变量赋值

var v10 int
v10=123

</pre><pre name="code" class="plain">i,j=j,i

2 常量

2.1 字面常量

-12
3.141592653589<span style="white-space:pre">		</span>//浮点类型的常量
3.2+12i<span style="white-space:pre">			</span>//复数类型的常量
true<span style="white-space:pre">			</span>//布尔类型的常量
“foo”<span style="white-space:pre">			</span>//字符串常量

2.2 常量定义

</pre><pre name="code" class="plain">const Pi float64=3.141592653589
const zero=0.0
const(
<span style="white-space:pre">	</span>size int64=1024

<span style="white-space:pre">	</span>eof=-1
)

const a,b,c=3,4,"foo"

2.3 预定义常量

true、false 和 iota

const(
<span style="white-space:pre">	</span>c0=iota<span style="white-space:pre">		</span>//c0==0

<span style="white-space:pre">	</span>c1=iota<span style="white-space:pre">		</span>//c1==1

<span style="white-space:pre">	</span>c2=iota<span style="white-space:pre">		</span>//c2==2
)

也可以简写为

const（

<span style="white-space:pre">	</span>c0=iota

<span style="white-space:pre">	</span>c1

<span style="white-space:pre">	</span>c2

）

2.4 枚举

const (
Sunday = iota
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
numberOfDays // 这个常量没有导出
)

3 类型

内置的基础类型：

布尔类型：bool

整形：int8、byte、int16、int、uint、uintptr 等

浮点类型：float32、float64

复数类型：complex64、complex128

字符串：string

字符类型：rune

错误类型：error

复合类型

指针：（pointer）

数组：（array）

切片：（slice）

字典：（map）

通道：(chan)

结构体：(struct)

接口：(interface)

比较运算时：注意应该同类型。各种类型的整形变量都可以直接与字面常量进行比较

位运算： ^x(取反)

fvalue:=12.0       (float64)

str := "Hello,世界"
n := len(str)
for i := 0; i < n; i++ {
ch := str[i] // 依据下标取字符串中的字符，类型为<span style="background-color: rgb(255, 0, 0);">byte</span>
fmt.Println(i, ch)
}

str := "Hello,世界"
for i, ch := range str {
fmt.Println(i, ch)//ch的类型为<span style="background-color: rgb(255, 0, 0);">rune</span>
}

数组是值类型

数组切片 更像指针

[:]

make()

mySlice2 := []int{8, 9, 10}
// 给mySlice后面添加另一个数组切片
mySlice = append(mySlice, mySlice2 ...)

基于切片创建切片时，范围为原切片的 容量

4. 流程控制

条件语句：if、else和else if

选择语句：switch、case、select

循环语句：for、range

跳转语句：goto

break、continue、fallthrough

4.1 条件语句

关于条件语句，需要注意以下几点：
 条件语句不需要使用括号将条件包含起来()；
 无论语句体内有几条语句，花括号{}都是必须存在的；
 左花括号{必须与if或者else处于同一行；
 在if之后，条件语句之前，可以添加变量初始化语句，使用;间隔；
 在有返回值的函数中，不允许将“最终的”return语句包含在if...else...结构中，否则会编译失败：

4.2 选择语句

switch {
case 0 <= Num && Num <= 3:
fmt.Printf("0-3")
case 4 <= Num && Num <= 6:
fmt.Printf("4-6")
case 7 <= Num && Num <= 9:
fmt.Printf("7-9")
}

注意以下几点：
 左花括号{必须与switch处于同一行；
 条件表达式不限制为常量或者整数；
 单个case中，可以出现多个结果选项；
 与C语言等规则相反，Go语言不需要用break来明确退出一个case；
 只有在case中明确添加fallthrough关键字，才会继续执行紧跟的下一个case；
 可以不设定switch之后的条件表达式，在此种情况下，整个switch结构与多个
if...else...的逻辑作用等同。

4.3 循环语句

sum := 0
for i := 0; i < 10; i++ {
sum += i
}

注意的有以下几点。
 左花括号{必须与for处于同一行。
 Go语言中的for循环与C语言一样，都允许在循环条件中定义和初始化变量，唯一的区别
是，Go语言不支持以逗号为间隔的多个赋值语句，必须使用平行赋值的方式来初始化多
个变量。
 Go语言的for循环同样支持continue和break来控制循环，但是它提供了一个更高级的
break，可以选择中断哪一个循环，

5. 函数

func Printf(format string, args ...interface{}) {
// ...
}

func(ch chan int) {
ch <- ACK
} (reply_chan) // 花括号后直接跟参数列表表示函数调用

func()(func()) {
var i int = 10
return func() {
fmt.Printf("i, j: %d, %d\n", i, j)
}
}()()  // 此处第一个括号代表什么意思？

6. 错误处理

6.1 error接口

type error interface {
Error() string
}

type PathError struct {
Op string

Path string
Err error
}

func (e *PathError) Error() string {
return e.Op + " " + e.Path + ": " + e.Err.Error()
}

6.2 defer

defer 语句的调用遵照先进后出的原则。

6.3 panic()和recover()

func panic(interface{})
func recover() interface{}

recover()函数用于终止错误处理流程。一般情况下，recover()应该在一个使用defer关键字的函数中执行以有效截取错误处理流程