Go大道至简之基础教程

素颜马尾好姑娘i 2022-12-02 13:56 138阅读 0赞

### 目录大纲 ###

*  基础语法
 *   *  变量声明
     *   *  var
     *  常量和枚举
     *   *  常量
         *  预定义常量
         *  枚举
         *  常量的作用域
     *  数据类型
     *   *  布尔类型
         *  整型
         *  浮点类型
         *  复数类型
         *  字符串
         *  字符类型
     *  复合类型
     *   *  指针（pointer）
         *  数组（array）
         *  切片（slice）
         *  字典（map）
         *  通道（chan）
         *  结构体（struct）
         *  接口（interface）
     *  流程控制
     *   *  条件语句
         *  分支语句
         *  循环语句
         *  跳转语句
     *  函数
     *   *  普通函数
         *  匿名函数（闭包）
         *  类方法
     *  面向对象
     *   *  类属性和初始化和可见性
         *  类方法
         *  类的继承和重写
         *  接口定义和实现
         *  接口赋值实现类的映射
         *  接口类型查询和转化
         *  接口组合实现接口继承
         *  空接口
     *  错误和异常处理
     *   *  Error
         *  Defer
         *  Panic和Recover
     *  并发编程
     *   *  协程
         *  管道
         *  互斥锁
         *  原子锁
     *  上下文 context
     *  并行计算
     *  网络编程
     *   *  Socket
         *  HTTP
         *  RPC
         *  JSON

# 基础语法 #

## 变量声明 ##

### var ###

> Go 语言引入了关键字 var，并且将类型信息放在变量名之后，此外，变量声明语句不需要使用分号作为结束符

//单定义
    var varib int
    //多变量定义
    var (
    	varib1 int
    	varib2 string 
    )
    //省略写法
    varib3 := 14
    //变量数据类型
    var v1 int            // 整型
    var v2 string         // 字符串
    var v3 bool           // 布尔型
    var v4 [10]int        // 数组，数组元素类型为整型
    var v5 struct {        // 结构体，成员变量 f 的类型为64位浮点型
        f float64
    } 
    var v6 *int           // 指针，指向整型
    var v7 map[string]int   // map（字典），key为字符串类型，value为整型
    var v8 func(a int) int  // 函数，参数类型为整型，返回值类型为整型

## 常量和枚举 ##

### 常量 ###

> 通过 const 关键字定义常量时，可以指定常量类型，也可以省略（底层会自动推导）

//定义常量数据类型
    const Pi float64 = 3.1415926
    //省略常量类型
    const Pi1 = 3.1415926
    //通过一个 const 关键字定义多个常量，和 var 类似
    const(
    	Pi3 int
    	Pi4 = 3
    )
    // u = 0.0, v = 3.0，常量的多重赋值 
    const u, v float32 = 0, 3  
    // a = 3, b = 4, c = "foo", 无类型整型和字符串常量
    const a, b, c = 3, 4, "foo"

### 预定义常量 ###

> Go 语言预定义了这些常量：true、false 和 iota，iota 比较特殊，可以被认为是一个可被编译器修改的常量，在每一个 const 关键字出现时被重置为 0，然后在下一个 const 出现之前，每出现一次 iota，其所代表的数字会自动增 1。

const (    // iota 被重置为 0
    	c0 = iota   // c0 = 0
    	c1 = iota   // c1 = 1
    	c2 = iota   // c2 = 2
    )
    const (
        u = iota * 2;  // u = 0
        v = iota * 2;  // v = 2
        w = iota * 2;  // w = 4
    )
    const x = iota;  // x = 0
    const y = iota;  // y = 0

> 两个 const 的赋值语句的表达式是一样的，那么还可以省略后一个赋值表达式

const ( 
        c0 = iota 
        c1 
        c2 
    )
    const ( 
        u = iota * 2 
        v 
        w 
    )

### 枚举 ###

> Go 语言并不支持其他语言用于表示枚举的 enum 关键字，而是通过在 const 后跟一对圆括号定义一组常量的方式来实现枚举。

const (
        Sunday = iota 
        Monday 
        Tuesday 
        Wednesday 
        Thursday 
        Friday 
        Saturday 
        numberOfDays
    )

### 常量的作用域 ###

1.  和函数体外声明的变量一样，以大写字母开头的常量在包外可见，类似于 public 修饰的类属性。
2.  以小写字母开头的常量只能在包内访问，类似于通过 protected 修饰的类属性。
3.  函数体内声明的常量只能在函数体内生效。

## 数据类型 ##

### 布尔类型 ###

> 关键字为 bool，可赋值且只可以赋值为预定义常量 true 和 false

//定义
    var v1 bool 
    v1 = true 
    // v2 也会被推导为 bool 类型
    v2 := (1 == 2)
    // 打印结果为Result: true
    fmt.Println("Result:", v2) 
    //第二种写法 推导
    var b bool 
    // 编译正确 
    b = (1!=0)
    // 打印结果为Result: true
    fmt.Println("Result:", b)

### 整型 ###

> 整型是所有编程语言里最基础的数据类型，Go 语言默认支持如下这些整型类型

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>长度</th> 
   <th>说明</th> 
   <th>值范围</th> 
   <th>默认</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>int8</td> 
   <td>1</td> 
   <td>带符号8位整型</td> 
   <td>-128~127</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>uint8</td> 
   <td>1</td> 
   <td>无符号8位整型，与 byte 类型等价</td> 
   <td>0~255</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>int16</td> 
   <td>2</td> 
   <td>带符号16位整型</td> 
   <td>-32768~32767</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>uint16</td> 
   <td>2</td> 
   <td>无符号16位整型</td> 
   <td>0~65535</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>int32</td> 
   <td>4</td> 
   <td>带符号32位整型，与 rune 类型等价</td> 
   <td>-2147483648~2147483647</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>uint32</td> 
   <td>4</td> 
   <td>无符号32位整型</td> 
   <td>0~4294967295</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>int64</td> 
   <td>8</td> 
   <td>带符号64位整型</td> 
   <td>-9223372036854775808~9223372036854775807</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>uint64</td> 
   <td>8</td> 
   <td>无符号64位整型</td> 
   <td>0~18446744073709551615</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>32位或64位</td> 
   <td>与具体平台相关</td> 
   <td>与具体平台相关</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>uint</td> 
   <td>32位或64位</td> 
   <td>与具体平台相关</td> 
   <td>与具体平台相关</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>uintptr</td> 
   <td>与对应指针相同</td> 
   <td>无符号整型，足以存储指针值的未解释位</td> 
   <td>32位平台下为4字节，64位平台下为8字节</td> 
   <td>0</td> 
  </tr> 
 </tbody> 
</table>

//定义
    var i1 int32 = -45
    var (
    	i2 uint32 = 666
    	i3 int64 = 888 
    )
    //多赋值
    var i4，i5,i6 int64 = 123,456,789

### 浮点类型 ###

> Go 语言中的浮点数采用IEEE-754 标准的表达方式，定义了两个类型：float32 和 float64

*  Float32，可以精确到小数点后 7 位。
 *  Float64，可以精确到小数点后 15 位。

//定义
    var fat float32
    //赋值
    fat = 14
    //省略写法，如果不加小数点，会被推导为整型而不是浮点型。
    fat2 := 3.1415926 //其类型将被自动设置为 float64
    //下面的赋值将导致编译错误,float64不能赋值float32。
    fat = fat2 
    //强制类型转换才可以
    fat = float32(fat2)

### 复数类型 ###

> 复数是实数的延伸，可以通过两个实数（在计算机中用浮点数表示）构成，一个表示实部（real），一个表示虚部（imag）

*  complex64（32位实部和虚部）
 *  complex128（64位实部和虚部）

//定义
    var comp1 complex64
    comp1 = 1.10 + 10i // 由两个 float32 实数构成的复数类型
    comp2 := 1.10 + 10i //和浮点型一样，默认自动推导的实数类型是 float64，所以 comp2 是 complex128 
    //读取实数
     real(comp1) //获得该复数的实部
    //读取虚数
    imag(comp2)

### 字符串 ###

> 在 Go 语言中，字符串是一种基本类型，默认是通过 UTF-8 编码的字符序列，当字符为 ASCII 码时则占用 1 个字节，其它字符根据需要占用 2-4 个字节，比如中文编码通常需要 3 个字节。

//声明和初始化
    var str1 string
    // 变量初始化
    str1 = "Hello Golang" 
    //省略写法 
    str2 := "你好，明哥哥" 
    //截取字符串
    str[开始|结束]
    ch1 := str1[0]  // 取字符串的第一个字符
    ch2 := str1[:5] //获取索引5之前的字符串
    ch3 := str1[5:] //获取索引5之后的字符串
    ch4 := str1[3:6] //获取3-6之间的字符串
    //字符串长度len
    ch5 := len(str2)
    //字符串连接
    str1 = str1 + "emmmm"
    str1 += "，2333333" //简写为这样，效果完全一样
    //字符串遍历
    n := len(str1) 
    for i := 0; i < n; i++ { 
        ch := str1[i]    // 依据下标取字符串中的字符，类型为byte
        fmt.Println(i, ch) 
    }

### 字符类型 ###

*  byte（实际上是 uint8 的别名），代表 UTF-8 字符串的单个字节的值。
 *  rune，代表单个 Unicode 字符

> rune 相关的操作，可查阅 Go 标准库的 unicode 包。 另外 unicode/utf8 包也提供了 UTF-8 和 Unicode 之间的转换。

## 复合类型 ##

### 指针（pointer） ###

> 变量的本质对一块内存空间的命名，可以通过引用变量名来使用这块内存空间存储的值，而指针的含义则指向存储这些变量值的内存地址。

a := 100
    var ptr *int
    ptr = &a
    fmt.Println(ptr)
    fmt.Println(*ptr)
    //如上，ptr 就是一个指针类型，表示指向存储 int 类型值的指针。我们可以通过 *ptr 获取指针指向内存地址存储的变量值（我们通常将这种引用称作「间接引用」），ptr 本身是一个内存地址值（通过 &a 可以获取变量 a 所在的内存地址），
    //所以上述代码打印结果是：
    0xc0000a2000
    100

*  通过指针传值

> 通过指针传值就类似于 PHP 中通过引用传值，这样做的好处是节省内存空间，此外还可以在调用函数中实现对变量值的修改，因为直接修改的是指针指向内存地址上存储的变量值，而不是值拷贝。

func swap(a, b *int)  { 
        *a, *b = *b, *a
        fmt.Println(*a, *b)
    }
    func main() { 
        a := 1
        b := 2
        swap(&a, &b)
        fmt.Println(a, b)
    }
    //上述代码的打印结果是:
    // 2 1
    // 2 1

### 数组（array） ###

> Go 语言中，数组是固定长度的、同一类型的数据集合。数组中包含的每个数据项被称为数组元素，一个数组包含的元素个数被称为数组的长度。

*  常见的数组声明方法

var a [8]byte // 长度为8的数组，每个元素为一个字节
    var b [3][3]int // 二维数组（9宫格）
    var c [3][3][3]float64 // 三维数组（立体的9宫格）
    var d = [3]int{ 1, 2, 3}  // 声明时初始化
    var e = new([3]string)   // 通过 new 初始化
    //:= 对数组进行声明和初始化：
    f := [5]int{ 1,2,3,4,5}
    //语法糖省略数组长度的声明：
    g := [...]int{ 1, 2, 3} //Go 会在编译期自动计算出数组长度

*  访问数组元素

> 可以使用数组下标来访问 Go 语言数组中的元素，数组下标默认从 0 开始，len(arr)-1 表示最后一个元素的下标。

arr := [5]int{ 1,2,3,4,5}
    a1, a2 := arr[0], arr[len(arr) - 1]
    //a1 的值是 1，a2 的值是 5。

*  遍历数组

1. for 循环遍历所有数组元素：
    for i := 0; i < len(arr); i++ { 
        fmt.Println("Element", i, "of arr is", arr[i])
    }
    2. range，用于快速遍历数组中的元素：
    for i, v := range arr {  
        fmt.Println("Element", i, "of arr is", v) 
    }

*  多维数组

> 多维数组的操作与一维数组一样，只不过每个元素可能是个数组，在进行循环遍历的时候需要多层嵌套循环

// 通过二维数组生成九九乘法表
    var multi [9][9]string
    for j := 0; j < 9; j++ { 
        for i := 0; i < 9; i++ { 
                n1 := i + 1
                n2 := j + 1
                if n1 < n2 {   // 摒除重复的记录
                    continue
                }
                multi[i][j] = fmt.Sprintf("%dx%d=%d", n2, n1, n1 * n2)
            }
      }
    // 打印九九乘法表
    for _, v1 := range multi { 
        for _, v2 := range v1 { 
            fmt.Printf("%-8s", v2)  // 位宽为8，左对齐
        }
        fmt.Println()
    }

### 切片（slice） ###

> 数组切片是一个新的数据类型，与数组最大的不同在于，切片的类型字面量中只有元素的类型，没有长度

//定义
    var slice []string = []string{ "a", "b", "c"}

*  基于数组

> 数组切片可以基于一个已存在的数组创建

// 先定义一个数组
    months := [...]string{ 
    	"January", "February", "March", "April", "May", "June",
        "July", "August", "September", "October", "November", "December"
    }
    // 基于数组创建数组切片
    q2 := months[3:6]    // 第二季度
    summer := months[5:8]  // 夏季
    //打印
    fmt.Println(q2)
    fmt.Println(summer)
    /** 结果： [April May June] [June July August] */

*  基于数组切片

> 类似于数组切片可以基于一个数组创建，数组切片也可以基于另一个数组切片创建

firsthalf := months[:6]
    q1 := firsthalf[:3] // 基于firsthalf的前3个元素构建新数组切片

*  直接创建

> Go 语言提供的内置函数 make() 可以用于灵活地创建数组切片。

// 创建一个初始元素个数为 5 的数组切片，元素类型为整型，初始值为 0，容量为 5
    mySlice1 := make([]int, 5)
    //创建一个初始元素个数为 5 的整型数组切片，初始值为 [0 0 0 0 0]，并预留 10 个元素的存储空间（容量为10）
    mySlice2 := make([]int, 5, 10)
    //直接创建并初始化包含 5 个元素的数组切片
    mySlice3 := []int{ 1, 2, 3, 4, 5}

*  **遍历数组切片**

//range 关键字可以让遍历代码显得更简洁，range 表达式有两个返回值，第一个是索引，第二个是元素的值
    for i, v := range summer {  
        fmt.Println("summer[", i, "] =", v) 
    }
    //for 传统的元素遍历方法
    for i := 0; i < len(summer); i++ { 
        fmt.Println("summer[", i, "] =", summer[i]) 
    }

*  **动态增加元素**

> 切片比数组更强大之处在于支持动态增加元素，甚至可以在容量不足的情况下自动扩容。在切片类型中，元素个数和实际可分配的存储空间是两个不同的值，元素的个数即切片的实际长度，而可分配的存储空间就是切片的容量。

*Go 语言内置的 cap() 函数和 len() 函数来获取某个切片的容量和实际长度*

//定义
    var oldSlice = make([]int, 5, 10)
    //打印
    fmt.Println("len(oldSlice):", len(oldSlice))
    fmt.Println("cap(oldSlice):", cap(oldSlice))

*通过 append() 函数向切片追加新元素*

//新切片赋值给 newSlice，此时 newSlice 的长度是 8，容量是 10
    newSlice := append(oldSlice, 1, 2, 3)
    //值
    [0 0 0 0 0 1 2 3]

*  **内容复制**

> Go 语言的另一个内置函数 copy()，用于将元素从一个数组切片复制到另一个数组切片。如果加入的两个数组切片不一样大，就会按其中较小的那个数组切片的元素个数进行复制

slice1 := []int{ 1, 2, 3, 4, 5} 
    slice2 := []int{ 5, 4, 3}
    // 复制 slice1 到 slice 2
    copy(slice2, slice1) // 只会复制 slice1 的前3个元素到 slice2 中
    // 复制 slice2 到 slice 1
    copy(slice1, slice2) // 只会复制 slice2 的 3 个元素到 slice1 的前 3 个位置

*  **动态删除元素**

> 切片除了支持动态增加元素之外，还可以动态删除元素，在切片中动态删除元素可以通过多种方式实现（其实是通过切片实现的「伪删除」）

slice3 := []int{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
     // 删除 slice3 尾部5个元素
    slice3 = slice3[:len(slice3) - 5] 
    // 删除 slice3 头部 5 个元素
    slice3 = slice3[5:]

*通过上述介绍的 append 函数和 copy 函数实现切片元素的「删除」*

slice3 := []int{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    //
    slice4 := append(slice3[:0], slice3[3:]...)  // 删除开头三个元素
    slice5 := append(slice3[:1], slice3[4:]...)  // 删除中间三个元素
    slice6 := append(slice3[:0], slice3[:7]...)  // 删除最后三个元素
    slice7 := slice3[:copy(slice3, slice3[3:])]  // 删除开头前三个元素

### 字典（map） ###

> 字典，其实就是存储键值对映射关系的集合，只不过对于强类型的 Go 语言来说，与 PHP 关联数组的不同之处在于需要在声明时指定键和值的类型，此外 Go 字典是个无序集合，底层不会像 PHP 那样按照元素添加顺序维护元素的存储顺序。

*  **字典声明**

//定义
    var maps map[int]string
    //初始化
    maps = map[int]string{ 
    	0:"a",
    	1:"b",
    	2:"c",
    }
    //读取map
    v,ok:=maps[2]
    if ok { 
    	fmt.println(v)
    }else{ 
    	fmt.println("Not found!")
    }
    //省略写法
    mapss := map[int]string{ 
    	1:"Hi",
    	2:"How",
    	3:"Are",
    	4:"You",
    }
    //make创建字典
    var mapsss = make(map[string]int)
    //元素赋值
    mapsss["a"]=0	//类似于PHP的关联数组
    mapsss["b"]=1
    //也可以选择是否在创建时指定该字典的初始存储能力（超出会自动扩容）
    testMap = make(map[string]int, 100)

*  **字典初始化**

> 可以通过先声明再初始化的方式进行初始化，就像上面示例代码做的那样，也可以通过 := 将声明和初始化合并为一条语句

//第一种
    var maps map[int]string
    maps = map[int]string{ 
    	0:"a",
    	1:"b",
    	2:"c",
    }
    //第二种
    mapss := map[int]string{ 
    	1:"Hi",
    	2:"How",
    	3:"Are",
    	4:"You",
    }
    //第三种
    var mapsss = make(map[string]int)
    mapsss["a"]=0
    mapsss["b"]=1

*  **元素赋值**

> 和 PHP 关联数组的赋值操作一致

mapsss["b"] = 4

*  **查找元素**

> Go 语言中，字典的查找功能设计得比较精巧，要从字典中查找一个特定的键对应的值

v,ok := mapsss["c"]
    if ok != true{ 
    	fmt.println("Not Found!")
    }

*  **删除元素**

> Go 语言提供了一个内置函数 delete()，用于删除容器内的元素，我们可以通过这个函数来实现字典元素的删除

delete(mapsss,"c")
    //上面的代码将会从 mapsss中删除键为「c」的键值对。如果「c」这个键不存在或者字典尚未初始化，这个调用也不会有什么副作用

*php也有类似的语句 unset()*

unset($arr[3]);

*  **字典遍历**

> 可以像遍历数据那样对字段类型数据进行遍历

// range
    for v,k := range mapss{ 
    	fmt.println(k,v)
    }

*php也有类似的语句 foreach*

foreach(mapss as $key=>$value){ 
    	echo $key.'='.$value;
    }

*  **字典排序**

> Go 语言的字典不同于 PHP 的关联数组，是一个无序集合，如果你想要对字典进行排序，可以通过分别为字典的键和值创建切片，然后通过对切片进行排序来实现

keys := make([]string, 0)
    for k, _ := range mpass{ 
        keys = append(keys, k)
    }
    sort.Strings(keys)  // 对键进行排序
    fmt.Println("Sorted map by key:")
    for _, k := range keys { 
        fmt.Println(k, mpass[k])
    }

### 通道（chan） ###

*  **通道声明和初始化**

> 可以通过 chan 类型关键字来声明通道类型变量

var ch chan int

### 结构体（struct） ###

### 接口（interface） ###

## 流程控制 ##

### 条件语句 ###

> 对应的关键字有 if、else 和 else if

//if
    if condition { 
    }
    //if else
    if condition { 
    }else{ 
    }
    //if else if
    if condition { 
    }else if condition { 
    }else { 
    }
    //在 if 之后，条件语句之前，可以添加变量初始化语句，使用 ; 间隔。如下：
    if score := 100; score > 90 { 
    }

### 分支语句 ###

> 对应的关键字有 switch、case 和 select

*  **switch**

//go语言中，没有break跳出
    switch condition { 
    	case condition1:
    		...
    	case condition2:
    		...
    	default:
    		...
    }
    //分数评级案例
    score := 100
    switch { 
    case score >= 90:
        fmt.Println("Grade: A")
    case score >= 80 && score < 90:
        fmt.Println("Grade: B")
    case score >= 70 && score < 80:
        fmt.Println("Grade: C")
    case score >= 60 && score < 70:
        fmt.Println("Grade: D")
    default:
        fmt.Println("Grade: F")
    }

**需要注意以下几点：**

1.  和条件语句一样，左花括号 \{ 必须与 switch 处于同一行；
2.  单个 case 中，可以出现多个结果选项（通过逗号分隔）；
3.  与其它语言不同，Go 语言不需要用 break 来明确退出一个 case；
4.  只有在 case 中明确添加 fallthrough 关键字，才会继续执行紧跟的下一个 case；
5.  可以不设定 switch 之后的条件表达式，在这种情况下，整个 switch 结构与多个 if…else… 的逻辑作用等同。

*  **select**

> Go 语言还支持通过 select 分支语句选择指定分支代码执行，select 语句和之前介绍的 switch 语句语法结构类似，不同之处在于 select 的每个 case 语句必须是一个通道操作，要么是发送数据到通道，要么是从通道接收数据，此外 select 语句也支持 default 分支

select {  
        case <-chan1:
            // 如果从 chan1 通道成功接收数据，则执行该分支代码
        case chan2 <- 1:
            // 如果成功向 chan2 通道成功发送数据，则执行该分支代码 
        default:
            // 如果上面都没有成功，则进入 default 分支处理流程 
    }

> **注：Go 语言的 select 语句借鉴自 Unix 的 select() 函数，在 Unix 中，可以通过调用 select() 函数来监控一系列的文件句柄，一旦其中一个文件句柄发生了 IO 动作，该 select() 调用就会被返回（C 语言中就是这么做的），后来该机制也被用于实现高并发的 Socket 服务器程序。Go 语言直接在语言级别支持 select 关键字，用于处理并发编程中通道之间异步 IO 通信问题。**

### 循环语句 ###

> 对应的关键字有 for 和 range

*  **for**

> Go 语言中的循环语句只支持 for 关键字，而不支持 while 和 do-while 结构

sum := 0 
    for i := 1; i <= 100; i++ {  
        sum += i 
    }
    fmt.Println(sum)

*  **无限循环**

> 通过不带循环条件的 for 语句实现

sum := 0
    for { 
    	sum ++
    	if sum > 100 { 
    		break
    	}
    }

*  **多重赋值**

> for 循环条件表达式中也支持多重赋值

a := []int{ 1, 2, 3, 4, 5, 6} 
    for i, j := 0, len(a) – 1; i < j; i, j = i + 1, j – 1 {  
        a[i], a[j] = a[j], a[i] 
    }
    fmt.Println(a)
    //上述代码的打印结果是 [6 5 4 3 2 1]

*  **嵌套循环**

> 通过嵌套循环对多维数组进行遍历
> 
> > **参考九九乘法表**

*  **for-range**

> Go 语言还支持通过 for-range 结构对其进行循环遍历

for k, v := range a { 
        fmt.Println(k, v)
    }

*  **基于条件判断进行循环**

sum := 0
    i := 0
    for i < 100 { 
        i++
        sum += i
    }
    fmt.Println(sum)

**注意以下几点**

1.  和条件语句、分支语句一样，左花括号 \{ 必须与 for 处于同一行；
2.  不支持 whie 和 do-while 结构的循环语句；
3.  可以通过 for-range 结构对可迭代集合进行遍历；
4.  支持基于条件判断进行循环迭代；
5.  与 PHP 一样，都允许在循环条件中定义和初始化变量，且支持多重赋值；
6.  Go 语言的 for 循环同样支持 continue 和 break 来控制循环，但是它提供了一个更高级的 break，可以选择中断哪一个循环。如下：

for j := 0; j < 5; j++ {  
        for i := 0; i < 10; i++ {  
            if i > 5 {  
                break JLoop
            }
            fmt.Println(i)
        } 
    } 
    JLoop: 
    // ...

### 跳转语句 ###

> 对应的关键字有 goto、continue、break、标签

*  **break**

> break 的默认作用范围是该语句所在的最内部的循环体

arr := [][]int{ { 1,2,3},{ 4,5,6},{ 7,8,9}}
    for i := 0; i < 3; i++ { 
        for j := 0; j < 3; j++ { 
            num := arr[i][j]
            if j > 1 { 
                break
            }
            fmt.Println(num)
        }
    }

*  **continue**

> continue 则用于忽略剩余的循环体而直接进入下一次循环的过程

arr := [][]int{ { 1,2,3},{ 4,5,6},{ 7,8,9}}
    for i := 0; i < 3; i++ { 
        for j := 0; j < 3; j++ { 
            num := arr[i][j]
            if j > 2 { 
                continue
            }
            fmt.Println(num)
        }
    }

*  **标签**

> Go 语言的 break 和 contine 与 PHP 的不同之处在于支持与标签结合跳转到指定的标签语句，从而改变这两个语句的默认跳转逻辑，标签语句通过标签+「:」进行声明

arr := [][]int{ { 1,2,3},{ 4,5,6},{ 7,8,9}}
    //标签 ITERATOR1
    ITERATOR1:
    for i := 0; i < 3; i++ { 
        for j := 0; j < 3; j++ { 
            num := arr[i][j]
            if j > 1 { 
                break ITERATOR1 //条件满足 则跳转到 标签 ITERATOR1位置
            }
            fmt.Println(num)
        }
    }

*  **goto**

> goto 语句被多数语言学者所反对，告诫大家不要使用，因为很容易造成代码逻辑混乱，容易导致不易发现的 bug。但 Go 语言仍然支持 goto 关键字，goto 语句的语义非常简单，就是跳转到本函数内的某个标签

arr := [][]int{ { 1,2,3},{ 4,5,6},{ 7,8,9}}
    for i := 0; i < 3; i++ { 
        for j := 0; j < 3; j++ { 
            num := arr[i][j]
            if j > 1 { 
                goto EXIT //跳出循环，到标签位置 EXIT
            }
            fmt.Println(num)
        }
    }   
    //标签
    EXIT:	
    fmt.Println("Exit.")
    //所以上述代码的输出是：1，2，Exit.

## 函数 ##

### 普通函数 ###

### 匿名函数（闭包） ###

### 类方法 ###

## 面向对象 ##

### 类属性和初始化和可见性 ###

### 类方法 ###

### 类的继承和重写 ###

### 接口定义和实现 ###

### 接口赋值实现类的映射 ###

### 接口类型查询和转化 ###

### 接口组合实现接口继承 ###