Go内置关键字（25个均为小写）
break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var
Go注释方法
// ：单行注释
/* */：多行注释
Go程序的一般结构：见代码
Go程序是通过 package 来组织的（与python类似）
只有 package 名称为 main 的包可以包含 main 函数
一个可执行程序 有且仅有 一个 main 包
通过 import 关键字来导入其它非 main 包
通过 const 关键字来进行常量的定义
通过在函数体外部使用 var 关键字来进行全局变量的声明与赋值
通过 type 关键字来进行结构(struct)或接口(interface)的声明
通过 func 关键字来进行函数的声明
代码示例
//当前程序的包名
package main
//导入其它的包
import (
std "fmt"
)
//常量的定义
const (
PI = 3.14
)
//全局变量的声明和赋值
var (
name = "song"
)
//一般类型的声明
type newType int
//结构的声明
type song struct{}
//接口的声明
type steven interface{}
//由main 函数作为程序入口点启动
func main() {
std.Println("hello word")
}
Go基本类型
布尔型：bool
- 长度：1字节
- 取值范围：true, false
- 注意事项：不可以用数字代表true或false
整型：int/uint
- 根据运行平台可能为32或64位
8位整型：int8/uint8
- 长度：1字节
- 取值范围：-128~127/0~255
字节型：byte（uint8别名）
16位整型：int16/uint16
- 长度：2字节
- 取值范围：-32768~32767/0~65535
32位整型：int32（rune）/uint32
- 长度：4字节
- 取值范围：-2^32/2~2^32/2-1/0~2^32-1
64位整型：int64/uint64
- 长度：8字节
- 取值范围：-2^64/2~2^64/2-1/0~2^64-1
浮点型：float32/float64
- 长度：4/8字节
- 小数位：精确到7/15小数位
复数：complex64/complex128
- 长度：8/16字节
足够保存指针的 32 位或 64 位整数型：uintptr
其它值类型：
- array、struct、string
引用类型：
- slice、map、chan
接口类型：inteface
函数类型：func
类型零值
零值并不等于空值，而是当变量被声明为某种类型后的默认值，通常情况下值类型的默认值为0，bool为false，string为空字符串
单个变量的声明与赋值
:=是声明并赋值，并且系统自动推断类型，不需要var关键字
- 变量的声明格式：var <变量名称> <变量类型>
- 变量的赋值格式：<变量名称> = <表达式>
- 声明的同时赋值：var <变量名称> [变量类型] = <表达式>
多个变量的声明与赋值
- 全局变量的声明可使用 var() 的方式进行简写
- 全局变量的声明不可以省略 var，但可使用并行方式
- 所有变量都可以使用类型推断
- 局部变量不可以使用 var() 的方式简写，只能使用并行方式
变量的类型转换
Go中不存在隐式转换，所有类型转换必须显式声明
转换只能发生在两种相互兼容的类型之间
类型转换的格式：
<ValueA> [:]= <TypeOfValueA>(<ValueB>)
常量的初始化规则与枚举
-在定义常量组时，如果不提供初始值，则表示将使用上行的表达式
-使用相同的表达式不代表具有相同的值
-iota是常量的计数器，从0开始，组中每定义1个常量自动递增1
-通过初始化规则与iota可以达到枚举的效果
-每遇到一个const关键字，iota就会重置为0
运算符
Go中的运算符均是从左至右结合
优先级（从高到低）
^ （） ! （取反 ） （一元运算符）
* （乘） / （除） % （取余） <<（二进制左移） >> （二进制右移） & &^
+ - | ^ （二元运算符）
== != < <= >= >
<- （专门用于channel）
&&
||
示例
/*
6：0110
11：1011
----------
& 与 0010 (两个是1才是1，其它是0)
| 或 1111 （有一个是1就是1）
^ 1101 （两个当中只能有一个为1）
&^ 0100 （第二个运算值是1的话，第一个强制为0，结果为0）
*/
func main() {
fmt.Println(6 & 11)
fmt.Println(6 | 11)
fmt.Println(6 ^ 11)
fmt.Println(6 &^ 11)
}
计算机存储单位
package main
import (
"fmt"
)
const (
_ = iota
KB float64 = 1 << (iota * 10)
MB
GB
TB
PB
EB
ZB
YB
)
func main() {
fmt.Println(KB)
fmt.Println(MB)
fmt.Println(GB)
fmt.Println(TB)
fmt.Println(PB)
fmt.Println(EB)
fmt.Println(ZB)
fmt.Println(YB)
}
指针
Go虽然保留了指针，但与其它编程语言不同的是，在Go当中不支持指针运算以及”->”运算符，
而直接采用”.”选择符来操作指针目标对象的成员操作符”&”取变量地址，
使用”*”通过指针间接访问目标对象默认值为 nil 而非 NULL
package main
import (
"fmt"
)
func main() {
a := 1
var b *int = &a
fmt.Println(b)//指向b的内存地址
fmt.Println(*b)//最出b的值
}
递增递减语句
在Go当中，++ 与 -- 是作为语句而并不是作为表达式 如：a++ 不能放在 = 的右侧，只能单独用
判断语句if
条件表达式没有括号
支持一个初始化表达式（可以是并行方式）
左大括号必须和条件语句或else在同一行
支持单行模式
初始化语句中的变量为block级别，同时隐藏外部同名变量
1.0.3版本中的编译器BUG
package main
import (
"fmt"
)
func main() {
a := 10
if a, b := 1, 5; a > 0 {
fmt.Println(a)
fmt.Println(b)
}
fmt.Println(a)
}
循环语句for
Go只有for一个循环语句关键字，但支持3种形式
初始化和步进表达式可以是多个值
条件语句每次循环都会被重新检查，因此不建议在条件语句中
使用函数，尽量提前计算好条件并以变量或常量代替
左大括号必须和条件语句在同一行
选择语句switch
可以使用任何类型或表达式作为条件语句
不需要写break，一旦条件符合自动终止
如希望继续执行下一个case，需使用fallthrough语句
支持一个初始化表达式（可以是并行方式），右侧需跟分号
左大括号必须和条件语句在同一行
跳转语句goto, break, continue
三个语法都可以配合标签使用
标签名区分大小写，若不使用会造成编译错误
Break与continue配合标签可用于多层循环的跳出
Goto是调整执行位置，与其它2个语句配合标签的结果并不相同
数组Array
定义数组的格式：var <varName> [n]<type>，n>=0
数组长度也是类型的一部分，因此具有不同长度的数组为不同类型
注意区分指向数组的指针和指针数组
数组在Go中为值类型
数组之间可以使用==或!=进行比较，但不可以使用<或>
可以使用new来创建数组，此方法返回一个指向数组的指针
Go支持多维数组
Go语言版冒泡排序
定义数组的格式：var <varName> [n]<type>，n>=0
数组长度也是类型的一部分，因此具有不同长度的数组为不同类型
注意区分指向数组的指针和指针数组
数组在Go中为值类型
数组之间可以使用==或!=进行比较，但不可以使用<或>
可以使用new来创建数组，此方法返回一个指向数组的指针
Go支持多维数组
Go语言版冒泡排序
package main
import (
"fmt"
)
func main() {
a := [...]int{4, 2, 6, 8, 1, 9, 10}
num := len(a)
for i := 0; i < num; i++ {
for j := i + 1; j < num; j++ {
if a[i] < a[j] {
temp := a[i]
a[i] = a[j]
a[j] = temp
}
}
}
fmt.Println(a)
}
