首页手记 go语言学习笔记（九）

go语言学习笔记（九）

标签：

Go 区块链源码

1.go语言——defer语句
defer语句仅能被放置在函数或方法中。它由关键字defer和一个调用表达式组成。注意，这里的调用表达式所表示的既不能是对Go语言内建函数的调用也不能是对Go语言标准库代码包unsafe中的那些函数的调用。实际上，满足上述条件的调用表达式被称为表达式语句。
请看下面的示例：

func readFile(path string) ([]byte, error) {
    file, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer file.Close()
    return ioutil.ReadAll(file)
}

函数readFile的功能是读出指定文件或目录（以下统称为文件）本身的内容并将其返回，同时当有错误发生时立即向调用方报告。其中，os和ioutil（导入路径是io/ioutil）代表的都是Go语言标准库中的代码包。请注意这个函数中的倒数第二条语句。我们在打开指定文件且未发现有错误发生之后，紧跟了一条defer语句。其中携带的表达式语句表示的是对被打开文件的关闭操作。

注意，当这条defer语句被执行的时候，其中的这条表达式语句并不会被立即执行。它的确切的执行时机是在其所属的函数（这里是readFile）的执行即将结束的那个时刻。也就是说，在readFile函数真正结束执行的前一刻file.Close()才会被执行。这也是defer语句被如此命名的原因。

我们在结合上下文之后就可以看出，语句defer file.Close()的含义是在打开文件并读取其内容后及时地关闭它。该语句可以保证在readFile函数将结果返回给调用方之前，那个文件或目录一定会被关闭。这实际上是一种非常便捷和有效的保险措施。

更为关键的是，无论readFile函数正常地返回了结果还是由于在其执行期间有运行时恐慌发生而被剥夺了流程控制权，其中的file.Close()都会在该函数即将退出那一刻被执行。这就更进一步地保证了资源的及时释放。

注意，当一个函数中存在多个defer语句时，它们携带的表达式语句的执行顺序一定是它们的出现顺序的倒序。

下面的示例可以很好的证明这一点：

func deferIt() {
    defer func() {
        fmt.Print(1)
    }()
    defer func() {
        fmt.Print(2)
    }()
    defer func() {
        fmt.Print(3)
    }()
    fmt.Print(4)
}

deferIt函数的执行会使标准输出上打印出4321。

func deferIt2() {
    for i := 1; i < 5; i++ {
        defer fmt.Print(i)
    }
}

deferIt2函数的执行会使标准输出上打印出4321。

defer携带的表达式语句代表的是对某个函数或方法的调用。这个调用可能会有参数传入，比如：fmt.Print(i + 1)。如果代表传入参数的是一个表达式，那么在defer语句被执行的时候该表达式就会被求值了。注意，这与被携带的表达式语句的执行时机是不同的。
请揣测下面这段代码的执行：

func deferIt3() {
    f := func(i int) int {
        fmt.Printf("%d ",i)
        return i * 10
    }
    for i := 1; i < 5; i++ {
        defer fmt.Printf("%d ", f(i))
    }
}

它在被执行之后，标准输出上打印出1 2 3 4 40 30 20 10 。

如果defer携带的表达式语句代表的是对匿名函数的调用，那么我们就一定要非常警惕。
请看下面的示例：

func deferIt4() {
    for i := 1; i < 5; i++ {
        defer func() {
            fmt.Print(i)
        }()
    }
}

deferIt4函数在被执行之后输出5555，而不是4321。原因是defer语句携带的表达式语句中的那个匿名函数包含了对外部（确切地说，是该defer语句之外）的变量的使用。注意，等到这个匿名函数要被执行（且会被执行4次）的时候，包含该defer语句的那条for语句已经执行完毕了。此时的变量i的值已经变为了5。因此该匿名函数中的打印函数只会打印出5。正确的用法是：把要使用的外部变量作为参数传入到匿名函数中。修正后的deferIt4函数如下：

func deferIt4() {
    for i := 1; i < 5; i++ {
        defer func(n int) {
            fmt.Print(n)
        }(i)
    }
}

实例代码1：

package main

import "fmt"

func deferIt() {
	defer func() {
		fmt.Print(1)
	}()
	defer func() {
		fmt.Print(2)
	}()
	defer func() {
		fmt.Print(3)
	}()
	fmt.Print(4)
}

func deferIt2() {
	for i := 1; i < 5; i++ {
		defer fmt.Print(i)
	}
}

func deferIt3() {
	f := func(i int) int {
		fmt.Printf("%d ",i)
		return i * 10
	}
	for i := 1; i < 5; i++ {
		defer fmt.Printf("%d ", f(i))
	}
}

func deferIt4() {
	for i := 1; i < 5; i++ {
		defer func() {
			fmt.Print(i)
		}()
	}
}

func deferIt41() {
	for i := 1; i < 5; i++ {
		defer func(n int) {
			fmt.Print(n)
		}(i)
	}
}

func main(){
	//deferIt()
	deferIt2()
	//deferIt3()
	//deferIt4()
	deferIt41()
}

defer语言常用于关闭文件，关闭SQL语句等，释放资源。

2.go语言异常处理——error
Go语言的函数可以一次返回多个结果。

func readFile(path string) ([]byte, error) {
    file, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer file.Close()
    return ioutil.ReadAll(file)
}

函数readFile有两个结果声明。第二个结果声明的类型是error。
error是Go语言内置的一个接口类型。它的声明是这样的：
type error interface {
Error() string
}
只要一个类型的方法集合包含了名为Error、无参数声明且仅声明了一个string类型的结果的方法，就相当于实现了error接口。
os.Open函数的第二个结果值的类型就是这样的。我们把它赋给了变量err。也许你已经意识到，在Go语言中，函数与其调用方之间温和地传递错误的方法即是如此。
在调用了os.Open函数并取得其结果之后，我们判断err是否为nil。如果答案是肯定的，那么就直接把该错误（这里由err代表）返回给调用方。这条if语句实际上是一条卫述语句。这样的语句会检查流程中的某个步骤是否存在异常，并在必要时中止流程并报告给上层的程序（这里是调用方）。在Go语言的标准库以及很多第三方库中，我们经常可以看到这样的代码。我们也建议大家在自己的程序中善用这样的卫述语句。

现在我们把目光聚焦到readFile函数中的最后一条语句上。这是一条return语句。它把对ioutil.ReadAll函数的调用的结果直接作为readFile函数的结果返回了。实际上，ioutil.ReadAll函数的结果声明列表与readFile的结果声明列表是一致的。也就是说，它们声明的结果的数量、类型和顺序都是相同的。因此，我们才能够做这种返回结果上的“嫁接”。这又是一个Go语言编码中的惯用法。

在很多时候，我们需要创造出错误（即error类型的值）并把它传递给上层程序。这很简单。只需调用标准库代码包errors的New函数即可。
例如，我们只要在readFile函数的开始处加入下面这段代码就可以更快的在参数值无效时告知调用方：

if path == "" {
    return nil, errors.New("The parameter is invalid!")
}

errors.New是一个很常用的函数。在Go语言标准库的代码包中有很多由此函数创建出来的错误值，比如os.ErrPermission、io.EOF等变量的值。我们可以很方便地用操作符==来判断一个error类型的值与这些变量的值是否相等，从而来确定错误的具体类别。就拿io.EOF来说，它代表了一个信号。该信号用于通知数据读取方已无更多数据可读。我们在得到这样一个错误的时候不应该把它看成一个真正的错误，而应该只去结束相应的读取操作。
请看下面的示例：

br := bufio.NewReader(file)
var buf bytes.Buffer
for {
    ba, isPrefix, err := br.ReadLine()
    if err != nil {
        if err == io.EOF {
            break
        }
        fmt.Printf("Error: %s\n", err)
        break
    }
    buf.Write(ba)
    if !isPrefix {
        buf.WriteByte('\n')
    }
}

可以看到，这段代码使用到了前面示例中的变量file。它的功能是把file代表的文件中的所有内容都读取到一个缓冲器（由变量buf代表）中。请注意，该示例中的第6~8行代码。如果判定err代表的错误值等于io.EOF的值（即它们是同一个值），那么我们只需退出当前的循环以使读取操作结束即可。

总之，只要能够善用error接口、errors.New函数和比较操作符==，我们就可以玩儿转Go语言中的一般错误处理。
实例代码1：

package main

import (
	"errors"
	"math"
	"fmt"
)

/*
Go编程提供了一个非常简单的错误处理框架，以及内置的错误接口类型，如下声明：

type error interface {
   Error() string
}
Go
函数通常返回错误作为最后一个返回值。 可使用errors.New来构造一个基本的错误消息
*/


func Sqrt(value float64) (float64, error){
	if value < 0 {
		return 0, errors.New("错误的参数")
	}
	return math.Sqrt(value), nil
}

func main(){
	result, err := Sqrt(-1)
	if err != nil {
		fmt.Println("发生错误1")
	}else{
		fmt.Println(result)
	}

	result, err = Sqrt(9)

	if err != nil {
		fmt.Println("发生错误2")
	}else{
		fmt.Println(result)
	}
}

实例代码2：

package main

import (
	"io"
	"bufio"
	"bytes"
	"os"
	"path/filepath"
	"fmt"
)

func read(file io.Reader) ([]byte, error) {
	br := bufio.NewReader(file)
	var buf bytes.Buffer
	for {
		ba, isPrefix, err := br.ReadLine()
		if err != nil {
			if err == io.EOF {
				break
			}
			return nil, err
		}
		buf.Write(ba)
		if !isPrefix {
			buf.WriteByte('\n')
		}
	}
	return buf.Bytes(), nil
}

func readFile(path string) ([]byte, error) {
	parentPath, err := os.Getwd()
	if err != nil {
		return nil, err
	}
	fullPath := filepath.Join(parentPath, path)
	file, err := os.Open(fullPath)
	if err != nil {
		return nil, err
	}
	defer file.Close()
	return read(file)
}

func main() {
	path := "D:\\go\\go\\GO_WorkSpace\\src\\go_test\\go_test.go"
	ba, err := readFile(path)
	if err != nil {
		fmt.Printf("Error: %s\n", err)
	}
	fmt.Printf("The content of '%s':\n%s\n", path, ba)
}

3.go语言异常处理——panic和recover
panic可被意译为运行时恐慌。因为它只有在程序运行的时候才会被“抛出来”。并且，恐慌是会被扩散的。当有运行时恐慌发生时，它会被迅速地向调用栈的上层传递。如果我们不显式地处理它的话，程序的运行瞬间就会被终止。这里有一个专有名词——程序崩溃。内建函数panic可以让我们人为地产生一个运行时恐慌。不过，这种致命错误是可以被恢复的。在Go语言中，内建函数recover就可以做到这一点。

实际上，内建函数panic和recover是天生的一对。前者用于产生运行时恐慌，而后者用于“恢复”它。不过要注意，recover函数必须要在defer语句中调用才有效。因为一旦有运行时恐慌发生，当前函数以及在调用栈上的所有代码都是失去对流程的控制权。只有defer语句携带的函数中的代码才可能在运行时恐慌迅速向调用栈上层蔓延时“拦截到”它。
这里有一个可以起到此作用的defer语句的示例：

defer func() {
    if p := recover(); p != nil {
        fmt.Printf("Fatal error: %s\n", p)
    }
}()

在这条defer语句中，我们调用了recover函数。该函数会返回一个interface{}类型的值。还记得吗？
interface{}代表空接口。Go语言中的任何类型都是它的实现类型。

我们把这个值赋给了变量p。如果p不为nil，那么就说明当前确有运行时恐慌发生。这时我们需根据情况做相应处理。
注意，一旦defer语句中的recover函数调用被执行了，运行时恐慌就会被恢复，不论我们是否进行了后续处理。所以，我们一定不要只“拦截”不处理。

panic函数可接受一个interface{}类型的值作为其参数。也就是说，我们可以在调用panic函数的时候可以传入任何类型的值。不过，建议大家在这里只传入error类型的值。这样它表达的语义才是精确的。更重要的是，当我们调用recover函数来“恢复”由于调用panic函数而引发的运行时恐慌的时候，得到的值正是调用后者时传给它的那个参数。

总之，运行时恐慌代表程序运行过程中的致命错误。我们只应该在必要的时候引发它。人为引发运行时恐慌的方式是调用panic函数。recover函数是我们常会用到的。
因为在通常情况下，我们肯定不想因为运行时恐慌的意外发生而使程序崩溃。最后，在“恢复”运行时恐慌的时候，大家一定要注意处理措施的得当。
实例：

package main

import "fmt"
import "errors"

func innerFunc() {
	fmt.Println("Enter innerFunc")
	panic(errors.New("Occur a panic!")) //引发运行时恐慌
	fmt.Println("Quit innerFunc")
}

func outerFunc() {
	fmt.Println("Enter outerFunc")
	innerFunc()
	fmt.Println("Quit outerFunc")
}

func main() {
	defer func() {
		if p := recover(); p != nil {
			fmt.Printf("Fatal error: %s\n", p)
		}
	}()
	fmt.Println("Enter main")
	outerFunc()
	fmt.Println("Quit main")
}

4.go语句
go语句和通道类型是Go语言的并发编程理念的最终体现。相比之下，go语句在用法上要比通道简单很多。与defer语句相同，go语句也可以携带一条表达式语句。注意，go语句的执行会很快结束，并不会对当前流程的进行造成阻塞或明显的延迟。
一个简单的示例如下：
go fmt.Println(“Go!”)

可以看到，go语句仅由一个关键字go和一条表达式语句构成。同样的，go语句的执行与其携带的表达式语句的执行在时间上没有必然联系。这里能够确定的仅仅是后者会在前者完成之后发生。在go语句被执行时，其携带的函数（也被称为go函数）以及要传给它的若干参数（如果有的话）会被封装成一个实体（即Goroutine），并被放入到相应的待运行队列中。Go语言的运行时系统会适时的从队列中取出待运行的Goroutine并执行相应的函数调用操作。注意，对传递给这里的函数的那些参数的求值会在go语句被执行时进行。这一点也是与defer语句类似的。

正是由于go函数的执行时间的不确定性，所以Go语言提供了很多方法来帮助我们协调它们的执行。其中最简单粗暴的方法就是调用time.Sleep函数。
请看下面的示例：
package main
import (
“fmt”
)
func main() {
go fmt.Println(“Go!”)
}
这样一个命令源码文件被运行时，标准输出上不会有任何内容出现。因为还没等Go语言运行时系统调度那个go函数执行，主函数main就已经执行完毕了。函数main的执行完毕意味着整个程序的执行的结束。因此，这个go函数根本就没有执行的机会。

但是，当我们在上述go语句的后面添加一条对time.Sleep函数的调用语句之后情况就会不同了：

package main
import (
    "fmt"
    "time"
)
func main() {
    go fmt.Println("Go!")
    time.Sleep(100 * time.Millisecond)
}

语句time.Sleep(100 * time.Millisecond)会把main函数的执行结束时间向后延迟100毫秒。100毫秒虽短暂，但足够go函数被调度执行的了。上述命令源码文件在被运行时会如我们所愿地在标准输出上打印出Go!。
另一个比较绅士的做法是：在main函数的最后调用runtime.Gosched函数。相应的程序版本如下：

package main
import (
    "fmt"
    "runtime"
)
func main() {
    go fmt.Println("Go!")
    runtime.Gosched()
}

runtime.Gosched函数的作用是让当前正在运行的Goroutine（这里是运行main函数的那个Goroutine）暂时“休息”一下，而让Go运行时系统转去运行其它的Goroutine（这里是与go fmt.Println(“Go!”)对应并会封装fmt.Println(“Go!”)的那个Goroutine）。如此一来，我们就更加精细地控制了对几个Goroutine的运行的调度。

当然，我们还有其它方法可以满足上述需求。并且，如果我们需要去左右更多的Goroutine的运行时机的话，下面这种方法也许更合适一些。请看代码：

package main
import (
    "fmt"
    "sync"
)
func main() {
    var wg sync.WaitGroup
    wg.Add(3)
    go func() {
        fmt.Println("Go!")
        wg.Done()
    }()
    go func() {
        fmt.Println("Go!")
        wg.Done()
    }()
    go func() {
        fmt.Println("Go!")
        wg.Done()
    }()
    wg.Wait()
}

sync.WaitGroup类型有三个方法可用——Add、Done和Wait。Add会使其所属值的一个内置整数得到相应增加，Done会使那个整数减1，而Wait方法会使当前Goroutine（这里是运行main函数的那个Goroutine）阻塞直到那个整数为0。
这下你应该明白上面这个示例所采用的方法了。我们在main函数中启用了三个Goroutine来封装三个go函数。每个匿名函数的最后都调用了wg.Done方法，并以此表达当前的go函数会立即执行结束的情况。当这三个go函数都调用过wg.Done函数之后，处于main函数最后的那条wg.Wait()语句的阻塞作用将会消失，main函数的执行将立即结束。

package main

import "fmt"

func main() {
	//创建三个通道
	ch1 := make(chan int, 1)
	ch2 := make(chan int, 1)
	ch3 := make(chan int, 1)
	go func() {
		fmt.Println("1")
		ch1 <- 1
	}()
	go func() {
		<-ch1
		fmt.Println("2")
		ch2 <- 2
	}()
	go func() {
		<-ch2
		fmt.Println("3")
		ch3 <- 3
	}()
	<-ch3
}

代码：https://github.com/JavaCodeMood/go_test
代码：https://github.com/JavaCodeMood/go_test1

到此，关于go语言的基础语法，就说完了。
感谢诸君的支持！

点击查看更多内容