Go语言观感

简洁的语法

虽然看了很多批判go语法的文章，但是，我个人还是很喜欢go的风格的，产品的功能应该做到少即使多，就像乔布斯把手机上的按键缩减到一个

下面就简单介绍几个我比较喜欢的点

多返回值与返回值命名

• 错误处理

//传统的异常处理
try{
  var data = fs.readFile();
}catch(e){
  print("文件读取错误")
}

//利用多返回值
data,err := fs.readFile()
if(err){
  print("文件读取错误")
}

• 命名返回值

func readFull(r io.Reader, buf []byte) (int, error) {
    var n int
    var err error
    for len(buf) > 0 {
        var nr int
        nr, err = r.Read(buf)
        n += nr
        if err != nil {
            return n, err
        }
        buf = buf[nr:]
    }
    return n, err
}

func readFullV2(r io.Reader, buf []byte) (n int, err error) {
    for len(buf) > 0 && err == nil {
        var nr int
        nr, err = r.Read(buf)
        n += nr
        buf = buf[nr:]
    }
    return  // 在返回值列表中对变量声明，则可以不必再return语句中写死
}

break到你想要的地方

TARGET:
    for j := 0; j < 5; j++ {
        for i := 0; i < 10; i++ {
            if i > 5 {
                break TARGET
            }
            fmt.Println(i)
        }
    }
输出结果：
0
1
2
3
4
5

平行赋值

• for循环的时候使用

//平行赋值版本，go认为平行赋值比较简洁，所以在for的时候强制使用这种方式
for i, j := 1, 2; i < 10; i, j = i+1, j+1 {
        fmt.Println(i, j)
}

//非平行赋值版本
for(i =0,j=1;i<10;i=i+1,j=j+1){
    console.log(i,j)
}

• if 的时候使用

//从map中获取key对应的value
myMap := make(map[string]string)
if value, ok := myMap["aaa"]; ok {
    fmt.Println(value)
} else {
    fmt.Println("not find")
}

• 交换两个变量的值

i,j = j,i

数组的值传递

记得面试的时候经常有人会问，某某语言是引用传递还是值传递。这个时候，你就要具体问题决堤分析，告诉他xx类型是引用的，xx类型是值传递
而在Go中，没有具体问题具体分析这么一说，全都是值传递，为了充分体现这一惊人，我们以数组为例子

func demoArray(eles [5]int) {
    eles[0] = -1
}

func main() {
    data := [5]int{1, 2, 3, 4, 5}
    demoArray(data)
    fmt.Println(data)//demoArray中的修改对data并不起作用
}
//输出
[1 2 3 4 5]

defer关键字

package main

import (
    "fmt"
    "os"
)

func main() {
    f := createFile("/tmp/defer.txt")
    defer closeFile(f)
    writeFile(f)
}
func createFile(p string) *os.File {
    fmt.Println("creating")
    f, err := os.Create(p)
    if err != nil {
        panic(err)
    }
    return f
}
func writeFile(f *os.File) {
    fmt.Println("writing")
    fmt.Fprintln(f, "data")
}
func closeFile(f *os.File) {
    fmt.Println("closing")
    f.Close()
}
//输出
creating
writing
closing

• defer关键字，主要作用是清理资源，替代了原先的try...catch...finally
• defer 关键字后面的表达式，会在函数return之后执行
• 一个函数中可以有多个defer关键字，按照先进后出的顺序执行

func a() {
    i := 0
    defer fmt.Println(i)
    i++
    return
}

• defer 表达式的变量在定义的时候就已经确定了，所以上面的输出为0

func c() (i int) {
    defer func() { i++ }()
    return 1
}

• defer表达式中可以修改函数中的命名返回值，虽然return的时候为1，但是调用方获得的结果为2

友好的大兵团作战工具

godoc

godoc可以将你本地的go package展示出来，如下所示：

//Package docDemo is a package using demonstrate godoc tool
package docDemo

import "io"

// ReadFullV2 is a demo of name return value
func ReadFullV2(r io.Reader, buf []byte) (n int, err error) {
    for len(buf) > 0 && err == nil {
        var nr int
        nr, err = r.Read(buf)
        n += nr
        buf = buf[nr:]
    }
    return
}

demo1.png

cgo

package main

/*
#include <stdio.h>
void hello(){
    printf("Hello,Cgo\n");
}
*/
import "C"

func main() {
    C.hello()
}

上面的小demo展示了，使用C语言打印一个hello

• 在go文件中import "C"表示这是一个带有Cgo代码的Go文件
• import前的注释可以写你想嵌入的c代码
• go安装的时候，会自带一个cgo命令行工具，他用来处理所有带Cgo代码的Go文件
• 而go 语言的编辑器对于cgo进行了集成，因此，直接使用go build就可以完成便利
• 这里只是一个简单的小例子，后面还会在这个话题上深入讨论