1.go 变量声明

1.变量的声明
	1.第一种，指定变量类型，声明后若不赋值，使用默认值。
	var 变量名 类型
	var a int
	a = 10

	2.第二种，根据值自行判定变量类型。
	var 变量名 [类型] = 值

	3.第三种，省略var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误。
	变量名 := 值


2.多变量声明
	1.声明，没有立即初始化
	var 变量1， 变量2， 变量3 类型
	var a,b,c int
	a,b,c = 1,2,3

	2.立即初始化
	var 变量1，变量2，变量3 = 值1，值2，值3
	var a,b,c = 1,2,3

	变量1，变量2，变量3 := 值1，值2，值3
	a,b,c := 1,2,3

	3.因式分解写法
	var (
		a int
		b int
	)


 并行或同时赋值:
 	a, b, c := 5, 7, "abc"
	
如果你想要交换两个变量的值，则可以简单地使用 a, b = b, a，两个变量的类型必须是相同。 

空白标识符 _ 也被用于抛弃值，如值 5 在：_, b = 5, 7 中被抛弃。

_ 实际上是一个只写变量，你不能得到它的值。这样做是因为 Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值


3.常量的定义
	const 标识符 [类型] = 值
	const LENGTH int = 10
	const a,b,c = 1,false,"str"

	//枚举作用
	const (
    	Unknown = 0
    	Female = 1
    	Male = 2
	)

http://www.runoob.com/go/go-variables.html

http://www.runoob.com/go/go-constants.html

 

4.数组
	1.声明
	var 数组名 [size] 类型

	2.初始化
	var 数组名 = [5] 类型 {1,2,3,4,5}
	var 数组名 = [...] 类型 {1,2,3,4,5} //如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：

5.指针
	1.声明
	var 名字 *类型
	var ip *int

	2.指针数组
	var 名字[] *类型
	var ptr[] *类型

	3.指向指针的指针
	var ptr **int 


6.结构体
	type 结构体名字 struct {
		成员1 类型1
		成员2 类型2
		...
	}

	结构体指针：
	var 结构体名字 *结构体类型 

7.切片
	1.定义
	var 名字 []类型 // 未定义大小的数组
	slice1 := make([]type, len)
	slice2 := make([]type, len, capacity)

	2.初始化
	slice := []int {1,2,3}
	s := arr[:]
	s := arr[startIndex:endIndex] 
	s := arr[startIndex:] 
	s := arr[:endIndex] 

	len();
	cap();
	append();
	copy();

8. map 类型
	1.定义
	var 名字 map[键类型]值类型
	名字 = make(map[键类型]值类型)

	2.初始化
	countryCapitalMap := map[string]string{"France": "Paris", "Italy": "Rome", "Japan": "Tokyo", "India": "New delhi"}


	delete();

9.强制类型转换
	类型(表达式)
	float32(表达式)


10.接口类型
	1.定义
	type 接口名 interface {
		方法1()
		方法2()
		。。。

	}
http://www.runoob.com/go/go-interfaces.html

go switch 用法:

用法1 :

package main

import "fmt"

func main() {
	var a int = 10

	switch a {
	case 10:
		fmt.Println("10")
	case 20:
		fmt.Println("20")
	}
}


用法2 : 

package main

import "fmt"

func main() {
	var a int = 20
	var b int = 20

	switch  {
	case b == 10:
		fmt.Println("10")
	case a == 20:
		fmt.Println("20")
	}
}


用法3 : 可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3

package main

import "fmt"

func main() {
	var a int = 10

	switch a {
	case 1,5,10 :
		fmt.Println("11111")
	case 2,6,11 :
		fmt.Println("22222")
	}
}


用法4 : Type Switch

package main

import "fmt"

func main() {
   var x interface{}
     
   switch i := x.(type) {
      case nil:  
         fmt.Printf(" x 的类型 :%T",i)                
      case int:  
         fmt.Printf("x 是 int 型")                      
      case float64:
         fmt.Printf("x 是 float64 型")          
      case func(int) float64:
         fmt.Printf("x 是 func(int) 型")                      
      case bool, string:
         fmt.Printf("x 是 bool 或 string 型" )      
      default:
         fmt.Printf("未知型")    
   }  
}


用法5 : fallthrough, 使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。

package main

import "fmt"

func main() {
	switch {
	case false:
		fmt.Println("1、case 条件语句为 false")
		fallthrough
	case true:
		fmt.Println("2、case 条件语句为 true")
		fallthrough
	case false:
		fmt.Println("3、case 条件语句为 false")
		fallthrough
	case true:
		fmt.Println("4、case 条件语句为 true")
	case false:
		fmt.Println("5、case 条件语句为 false")
		fallthrough
	default:
		fmt.Println("6、默认 case")
	}
}

//从以上代码输出的结果可以看出：switch 从第一个判断表达式为 true 的 case 开始执行，如果 case 带有 fallthrough，程序会继续执行下一条 case，且它不会去判断下一个 case 的表达式是否为 true。