go基本支持要略

1,select类似于switch

2,无限循环
    for true{
        ...
    }
3,循环嵌套
    for i=2; i < 100; i++ {
      for j=2; j <= (i/j); j++ {
         if(i%j==0) {
            break; // 如果发现因子，则不是素数
         }
      }
      if(j > (i/j)) {
         fmt.Printf("%d  是素数\n", i);
      }
   }  
   
   
 3，函数定义
    func function_name([parameter list]) [return_types]{
        ...
    }
4,数组：
    var variable_name[size] variable_type
        var balance[10] float32
    初始化：var balance =[5]float{1.0,3.2,3.0,43.2,4.3}
    
    初始化数组中 {} 中的元素个数不能大于 [] 中的数字
    根据元素个数设置数组大小
     var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
    
     多维数组：var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type
     a = [3][4]int{  
         {0, 1, 2, 3} ,   /*  第一行索引为 0 */
         {4, 5, 6, 7} ,   /*  第二行索引为 1 */
         {8, 9, 10, 11},   /* 第三行索引为 2 */
        }
        
5，Go 空指针

    当一个指针被定义后没有分配到任何变量时，它的值为 nil。
    
6，指针数组：是一个数组，每一个元素是一个指针
var ptr [MAX]*int;

7，结构体

    type struct_variable_type struct {
       member definition;
       member definition;
       ...
       member definition;
    }
    
    实例：
        package main

        import "fmt"

        type Books struct {
           title string
           author string
           subject string
           book_id int
        }

        func main() {

            // 创建一个新的结构体
            fmt.Println(Books{"Go 语言", "www.runoob.com", "Go 语言教程", 6495407})

            // 也可以使用 key => value 格式
            fmt.Println(Books{title: "Go 语言", author: "www.runoob.com", subject: "Go 语言教程", book_id: 6495407})

            // 忽略的字段为 0 或 空
           fmt.Println(Books{title: "Go 语言", author: "www.runoob.com"})
        }
        
8，切片，切片是对数组的抽象。Go 数组的长度不可改变

    定义切片：
        声明一个未指定大小的数组来定义切片：
            var identifier []type
                切片不需要说明长度。

                或使用make()函数来创建切片:
                    var slice1 []type = make([]type, len)

                    也可以简写为

                    slice1 := make([]type, len)
                    也可以指定容量，其中capacity为可选参数。

                    make([]T, length, capacity)
9，map:
    var map_variable map[key_data_type]value_data_type
    或者
    map_variable := make(map[key_data_type]value_data_type)
    
    
10，接口
    Go 语言提供了另外一种数据类型即接口，它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些
        方法就是实现了这个接口。
        /* 定义接口 */
        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] {
           /* 方法实现*/
        }
        
11，错误处理
    error类型是一个接口类型，这是它的定义：

        type error interface {
            Error() string
        }
        我们可以在编码中通过实现 error 接口类型来生成错误信息。

        函数通常在最后的返回值中返回错误信息。使用errors.New 可返回一个错误信息：

        func Sqrt(f float64) (float64, error) {
            if f < 0 {
                return 0, errors.New("math: square root of negative number")
            }
            // 实现
        }
12：并发
    goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。

        goroutine 语法格式：

        go 函数名( 参数列表 )
     同一个程序中的所有 goroutine 共享同一个地址空间。
    
13:通道（channel）
    声明一个通道很简单，我们使用chan关键字即可，通道在使用前必须先创建：

    ch := make(chan int)
    
    ch <- v    // 把 v 发送到通道 ch
    v := <-ch  // 从 ch 接收数据
           // 并把值赋给 v
    注意：默认情况下，通道是不带缓冲区的。发送端发送数据，同时必须又接收端相应的接收数据。
    
通道缓冲区

    通道可以设置缓冲区，通过 make 的第二个参数指定缓冲区大小：
 
    ch := make(chan int, 100)

    带缓冲区的通道允许发送端的数据发送和接收端的数据获取处于异步状态，就是说发送端发送的数据可以放在缓冲区里面，可以等待接收端去获取数据，而不是立刻需要接收端去获取数据。

    不过由于缓冲区的大小是有限的，所以还是必须有接收端来接收数据的，否则缓冲区一满，数据发送端就无法再发送数据了。

    注意：如果通道不带缓冲，发送方会阻塞直到接收方从通道中接收了值。如果通道带缓冲，发送方则会阻塞直到发送的值被拷贝到缓冲区内；如果缓冲区已满，则意味着需要等待直到某个接收方获取到一个值。接收方
    在有值可以接收之前会一直阻塞。
Go 遍历通道与关闭通道

Go 通过 range 关键字来实现遍历读取道的数据，类似于与数组或切片。格式如下：

v, ok := <-ch

如果通道接收不到数据后 ok 就为 false，这时通道就可以使用 close() 函数来关闭。
    如果通道接收不到数据后 ok 就为 false，这时通道就可以使用 close() 函数来关闭。
    
    
defer执行顺序为先进后出

Go中如果函数名的首字母大写，表示该函数是公有的，可以被其他程序调用，如果首字母小写，该函数就是是私有的

WaitGroup
WaitGroup 用于等待一组 goroutine 结束，用法比较简单。它有三个方法：
func (wg *WaitGroup) Add(delta int)
func (wg *WaitGroup) Done()
func (wg *WaitGroup) Wait()

Add 用来添加 goroutine 的个数。Done 执行一次数量减 1。Wait 用来等待结束：
注意，wg.Add() 方法一定要在 goroutine 开始前执行。

空接口

具有0个方法的接口称为空接口。它表示为interface {}。由于空接口有0个方法，所有类型都实现了空接口。

    type name string

    name类型与string等价