Go小tips

1、不用以‘；’结尾。但若是多条语句写在同一行，还是需要‘；’
   函数用func而不是常规的function
   if、for、switch等语句的条件也没有‘（）’啦

2、变量声明
  （1）var 变量名 变量类型 = 值 
       var a int = 10 (可以事后赋值)
  （2）var 变量名 = 值
       var a = 10
  （3）变量名 ：= 值
       a := 10  （若之前a已经声明过，会编译错误。只能在函数内出现）
   多变量声明
  （1）var vname1, vname2, vname3 type
       vname1, vname2, vname3 = v1, v2, v3
  （2）var vname1, vname2, vname3 = v1, v2, v3 //和python很像,不需要显示声明类型，自动推断
  （3）vname1, vname2, vname3 := v1, v2, v3 
  （4）var (
               vname1 v_type1
               vname2 v_type2
           )
           这种方式多用于全局变量声明，注意这里没有用逗号隔开
   注意：如果你声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误。但是全局变量是允许声明但不使用。

3、iota特殊常量  
     在每一个const关键字出现时，被重置为0，然后再下一个const出现之前，每出现一次iota，其所代表的数字会自动增加1。
     eg:
         const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
        )
        a-i依次为：0 1 2 ha ha 100 100 7 8
    eg2:
            const (
               i=1<<iota
               j=3<<iota
               k
               l
            )
        i-l依次为：1 6 12 24

4、switch
switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型。
switch x.(type){
    case type:
       statement(s);      
    case type:
       statement(s); 
    /* 你可以定义任意个数的case */
    default: /* 可选 */
       statement(s);
}
eg:
   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、select条件语句
select是Go中的一个控制结构，类似于用于通信的switch语句。每个case必须是一个通信操作，要么是发送要么是接收。
select随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。一个默认的子句应该总是可运行的。
（不太懂）？

6、for循环
for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：
for key, value := range oldMap {
    newMap[key] = value
}

eg:
   numbers := [6]int{1, 2, 3, 5} 

   for i,x:= range numbers {
      fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
   }   
   输出：
第 0 位 x 的值 = 1
第 1 位 x 的值 = 2
第 2 位 x 的值 = 3
第 3 位 x 的值 = 5
第 4 位 x 的值 = 0
第 5 位 x 的值 = 0

7、函数
func function_name( [parameter list] ) [return_types] {
   函数体
}
注意返回类型所在位置。跟PHP和JAVA都不一样。可返回多个值。
默认情况参数传递的是值而不是引用。
eg:
func swap(x, y string) (string, string) {
   return y, x
}

它也支持闭包！！！可以用来做计数器。详见demo
go的方法没太理解：http://www.runoob.com/go/go-method.html

8、数组
声明：var variable_name [SIZE] variable_type
多维声明 var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type
size要在type前面，这个跟其他语言有点差异。

可以声明时赋值，如下：
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}。其中size可以为“...”或空，系统会根据{}大小自动设置，如：
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
var balance = []float32{1000.0, 2.0, 3.4, 7.0, 50.0}

var balances = [3][4]int{
  {0,1,2,3},
  {4,5,6,7},
  {8,9,10,11}
}

9、指针
var var_name *var_type
var var_name [SIZE] *var_type

空指针的值为nil，输出却是0
eg:
   var  ptr *int
   fmt.Printf("ptr 的值为 : %x\n", ptr  )      /* 输出0 */
   if(ptr != nil)     /* ptr 不是空指针 */
   if(ptr == nil)    /* ptr 是空指针 */ 

指针的指针：
var var_name **var_type

10、结构体
结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体有中一个或多个成员。type 语句设定了结构体的名称。

type struct_variable_type struct {
   member definition;
   member definition;
   ...
   member definition;
}

一旦定义了结构体类型，它就能用于变量的声明，语法格式如下：
variable_name := structure_variable_type {value1, value2...valuen}

11、切片
数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

可以用未指定大小的数组来定义切片，或者用make()函数来定义
var name []type
var name []type = make([]type,len)   或者  name := make([]type,len,[capacity])  capacity为可选参数

初始化：
slice := [] int {1,2,3}
slice := arr[startIndex:endIndext]  //初始化用数组arr的引用，里面值可以省略

切片是可索引的，并且可以由 len() 方法获取长度。 len(slice)
切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。

一个切片在未初始化之前默认为 nil，长度为 0

截取切片直接用 slice[startIndex:endIndext]

增加切片的容量，用append()和copy()
append(slice,data) ———— 往slice追加data
copy(target,source) ———— 把source复制到target

12、RANGE
range关键字用于for循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引值，在集合中返回 key-value 对的 key 值。
???????????????????????????


13、Map
/* 声明变量，默认 map 是 nil */
var map_name map[key_data_type]value_data_type

/* 使用 make 函数 */
map_name := make(map[key_data_type]value_data_type)


14、接口
/* 定义接口 */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

/* 定义结构体 */
type struct_name struct {
   /* variables */
}

/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* 方法实现 */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /* 方法实现*/
}

？？？？？问号脸  http://www.runoob.com/go/go-interfaces.html