GO速成（二）

Range

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

**package** main
**import** "fmt"
func main() {
  *//这是我们使用range去求一个slice的和。使用数组跟这个很类似*
  nums := []int{2, 3, 4}
  sum := 0
  **for** _, num := **range** nums {
    sum += num
  }
  fmt.Println("sum:", sum)
  *//在数组上使用range将传入index和值两个变量。上面那个例子我们不需要使用该元素的序号，所以我们使用空白符"_"省略了。有时侯我们确实需要知道它的索引。*
  **for** i, num := **range** nums {
    **if** num == 3 {
      fmt.Println("index:", i)
    }
  }
  *//range也可以用在map的键值对上。*
  kvs := map[string]string{"a": "apple", "b": "banana"}
  **for** k, v := **range** kvs {
    fmt.Printf("%s -> %s**\n**", k, v)
  }
  *//range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。*
  **for** i, c := **range** "go" {
    fmt.Println(i, c)
  }
}

以上实例运行输出结果为：

sum: 9
index: 1
a -> apple
b -> banana
0 103
1 111

Map(集合)

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。

/* 声明变量，默认 map 是 nil */
var map_variable map[key_data_type]value_data_type

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

如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对

基于 go 实现简单 HashMap https://www.runoob.com/go/go-map.html

**package** main

**import** "fmt"

func main() {
  **var** countryCapitalMap map[string]string */\*创建集合 \*/*
  countryCapitalMap = make(map[string]string)

  */\* map插入key - value对,各个国家对应的首都 \*/*
  countryCapitalMap [ "France" ] = "巴黎"
  countryCapitalMap [ "Italy" ] = "罗马"
  countryCapitalMap [ "Japan" ] = "东京"
  countryCapitalMap [ "India " ] = "新德里"

  */\*使用键输出地图值 \*/*
  **for** country := **range** countryCapitalMap {
    fmt.Println(country, "首都是", countryCapitalMap [country])
  }

  */\*查看元素在集合中是否存在 \*/*
  capital, ok := countryCapitalMap [ "American" ] */\*如果确定是真实的,则存在,否则不存在 \*/*
  */\*fmt.Println(capital) \*/*
  */\*fmt.Println(ok) \*/*
  **if** (ok) {
    fmt.Println("American 的首都是", capital)
  } **else** {
    fmt.Println("American 的首都不存在")
  }
}

以上实例运行结果为：

France 首都是 巴黎
Italy 首都是 罗马
Japan 首都是 东京
India  首都是 新德里
American 的首都不存在

Go 语言类型转换

类型转换基本格式如下：

type_name(expression)

type_name 为类型，expression 为表达式。

go 不支持隐式转换类型，比如 :

package main
import "fmt"

func main() {  
    var a int64 = 3
    var b int32
    b = a
    fmt.Printf("b 为 : %d", b)
}

接口

接口把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口。

/* 定义接口 */
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] {
   /* 方法实现*/
}

**package** main

**import** (
  "fmt"
)

**type** Phone interface {
  call()
}

**type** NokiaPhone struct {
}

func (nokiaPhone NokiaPhone) call() {
  fmt.Println("I am Nokia, I can call you!")
}

**type** IPhone struct {
}

func (iPhone IPhone) call() {
  fmt.Println("I am iPhone, I can call you!")
}

func main() {
  **var** phone Phone

  phone = new(NokiaPhone)
  phone.call()

  phone = new(IPhone)
  phone.call()

}

在上面的例子中，我们定义了一个接口Phone，接口里面有一个方法call()。然后我们在main函数里面定义了一个Phone类型变量，并分别为之赋值为NokiaPhone和IPhone。然后调用call()方法，输出结果如下：

I am Nokia, I can call you!
I am iPhone, I can call you!

Go 错误处理 !

通过实现 error 接口类型来生成错误信息。

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

func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, errors.New("math: square root of negative number")
    }
    // 实现
}

Go 并发

通过 go 关键字来开启 goroutine , goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。

Go 允许使用 go 语句开启一个新的运行期线程， 即 goroutine，以一个不同的、新创建的 goroutine 来执行一个函数。 同一个程序中的所有 goroutine 共享同一个地址空间。

**package** main

**import** (
    "fmt"
    "time"
)

func say(s string) {
    **for** i := 0; i < 5; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    **go** say("world")
    say("hello")
}

执行以上代码，你会看到输出的 hello 和 world 是没有固定先后顺序。因为它们是两个 goroutine 在执行：

world
hello
hello
world
world
hello
hello
world
world
hello

通道（channel）是用来传递数据的一个数据结构。

通道可用于两个 goroutine 之间通过传递一个指定类型的值来同步运行和通讯。操作符 <- 用于指定通道的方向，发送或接收。如果未指定方向，则为双向通道。

ch <- v    // 把 v 发送到通道 ch
v := <-ch  // 从 ch 接收数据
           // 并把值赋给 v

声明一个通道很简单，我们使用chan关键字即可，通道在使用前必须先创建：

ch := make(chan int)

通道可以设置缓冲区，通过 make 的第二个参数指定缓冲区大小：

ch := make(chan int, 100)

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

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

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

v, ok := <-ch

如果通道接收不到数据后 ok 就为 false，这时通道就可以使用 close() 函数来关闭。