1、go的每个程序都是由包(就是说hello.go是一个包)构成的。go的入口包是main。go的包名是目录最后一层目录的名字。譬如：hello.go在路径 /user/src/test 路径下，那么hello.go里面的包名就是“package test”
2、导入了一个包之后，可以用其导出的名称来调用它。go中，首字母大写的名称是被导出的。譬如fmt包中，导出Printf。 fmt.Printf（）
3、语法 x int，y int .可以写为 x，y int
4、函数可以返回任意数量的返回值
5、go的返回值可以被命名，并且像变量那样应用。
6、var语句定义了变量列表，var语句可以定义在包级别和函数级别
var x int,y string
7、变量定义可以包含初始值，每个变量对应一个。
如果初始化是使用表达式，则可以省略类型，类型从赋值的值中取得。变量从初始值中获得类型。
var i,j int = 1,2
var o , r,t = "hello",2,"world"
8、“:=”简洁赋值语句，可以不用var。但是在函数外的每个语句都必须用关键字开头(var func )，“:=”不能用在函数之外。
var i,j,k = 1,2,3
x := 5
9、变量在定义的时候如果没有被赋值，就会被赋值为零值。
零值：数值型“0” ，布尔型“false” ，字符串为“”（空字符串）
10、与c不同，go不同类型之间的转换需要显示转换。go的类型如下所示：
Go 的基本类型有Basic types
bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // uint8 的别名
rune // int32 的别名
// 代表一个Unicode码
float32 float64
complex64 complex12811、定义一个变量但是不指定他的类型时，（譬如var 或者:= 定义一个变量），那么他的类型由右值来决定。
var x int
y :=x //y的类型是int
当右值是未指明类型的数字常量时，类型有可能是int float64 或者uint，取决于数字常量的类型。
i :=42
j :=2.33
k :=3.9999999
12、常量的定义和变量的定义类似，必须用const关键字。而且不能用:=语法定义。常量类型可以是数值、字符串、布尔、字符
var Pi = 3.14
一个未指定类型的常量，由上下文决定其类型。
const (
Big = 1 << 100
Small = Big >> 99
)
13、go中只有一种循环结构for循环。且必须不能用()，必须用{}
sum :=0
for i:=0; i<10; i++{
sum +=i
}
14、if条件语句也是，必须不能用（），必须使用{}
if sum>10{
fmt.Printf("---mym---%v---sum--
",sum)
}
15、结构体（struct）就是字段的集合。
16、switch 分为有条件和无条件的语句。
switch i{
case i>1:
fmt.Printf("mym")
case i>13:
fmt.Printf("mym")
}
switch {
case i>1:
fmt.Printf("mym")
case i>13:
fmt.Printf("mym")
}
17、defer函数会延迟函数的执行，直到上层函数返回。延迟调用的参数会立刻生成，但是上层函数不返回，就一直不会被调用。
defer fmt.Println("---end---bye---")
延迟的函数调用会被压入一个栈中，函数返回的时候，会按照后进先出的顺序调用被延迟的函数调用。
for i:=0 ; i<10 ; i++ {
defer fmt.Println(i)
}
输出顺序：9，8，7，6，5，4，3，2，1，0
18、Go指针 *T 表示指向类型T的类型的指针，其零值是nil。（这就注定go里面一旦使用指针，如果不判断空，而直接引用就会发生panic错误）
var p *int
i :=42
p = &i //&符号会生成一个指向其作用对象的指针
fmt.Println(*p) //* 符号表示指针指向底层的值，该句表示通过指针p读取i
*p =21 //该句表示，通过指针p设置i。 这就是常说的“间接引用”或“非直接引用”。
//与c不同，GO没有指针运算。
19、struct（结构体）就是字段的集合，结构体字段用点符号来引用。
type Vertex struct{
X int
Y int
}
v :=Vertex{1,2}
c := &v
fmt.Println(c.X)
c.X=1e9
fmt.Println(v)
fmt.Println(c.X)
20、结构体文法表示：使用结构体字段的值来新分配一个结构体。使用Name： 可以仅列出部分字段（字段名的顺序无关）。特殊的&返回一个指向结构体的指针。
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
)
21、数组[n]T是具有n个类型为T的数组。数组的长度是其类型的一部分，因此数组长度不能改变。
var a [2]string
a[0] = "Hello"
a[1] = "World"
fmt.Println(a[0],a[1])
fmt.Println(a)
22、slice : []T 是一个元素类型为T的slice
p := []int{2,3,4,5,6,7,8}
fmt.Println("p ==",p)
23、slice可以重新切片。slice[lo:lo]是空的，slice[lo,lo+1]有一个元素。slice[lo,lh]表示lo到lh-1的元素
p := []int{2,3,4,5,6,7,8}
fmt.Println("p ==",p)
fmt.Println("p[1:4] == ",p[1:4])
24、slice由make创建，会分配一个零长度的数组，并返回一个slice指向该数组。
a := make([]int,5) //len(a)=5
fmt.Println("a",a)
b := make([]int,0,5) //len(b)=0,cap(b)=5
fmt.Println("b",b)
c := b[:2]
fmt.Println("c",c)
d :=c[2:5]
fmt.Println("d",d)
b = b[:cap(b)] // len(b)=5, cap(b)=5
25、slice的零值是nil。一个零值的slice的长度和容量都是0
var q []int
fmt.Println(q,len(q),cap(q))
if q==nil{
fmt.Println("nil!")
}
26、使用go的内建函数“append”向slice添加数值。
func append(s []T,vs ...T)[]T //append的第一个参数s是一个类型为T的数组，其余类型为T的值将会添加到slice
//append的结果是一个包含原slice所有元素添加上新添加的元素的slice
27、for循环的range格式可以对slice和map迭代循环
var pow = []int{1,2,3,4,5,6,67,7,7}
func main(){
for i,v = range pow{
fmt.Printf("--%d----%d--
",i,v)
}
}
可以使用_去掉索引编号
var pow = []int{1,2,3,4,5,6,67,7,7}
func main(){
for _,v = range pow{
fmt.Printf("--%d----%d--
",v)
}
}
28、