Rewrited the last segment in 2.3; modified some sentence.

2012-09-26 18:09:42 +08:00
parent c2a1c55de4
commit 2dde07d0aa
4 changed files with 53 additions and 56 deletions
--- a/1.4.md
+++ b/1.4.md
@@ -10,8 +10,8 @@

  LiteIDE配置需要按照前面几个小节配置了相应的go和`$GOPATH`（LiteIDE中也可以图形化配置LiteIDE专用的GOPATH）。LiteIDE当前的编译环境可以通过编译工具栏上的环境配置来切换，如切换32位和64位，针对自己的系统，可能需要修改相应的LiteEnv环境变量，如64位版本，LiteIDE => 查看 => 选项 => LiteEnv => Win64.env => GOROOT=c:\go-w64 为你的`$GOROOT`，不然会无法使用`build`命令。

-  配置好LiteIDE后，可以打开或拖动任何目录到LiteIDE中作为项目，LiteIDE的编译是针对当前编辑文档所属目录来执行相应的go命令，所以编译时要先打开相应的GO文件。LiteIDE仿IDEA界面，支持项目浏览、文件系统，Package浏览、Golang文档检索、类视图、大纲显示等多个工具窗口的切换。
-  
+  配置好LiteIDE后，可以打开或拖动任何目录到LiteIDE中作为项目，LiteIDE的编译是针对当前编辑文档所属目录来执行相应的go命令，所以编译时要先打开相应的Go文件。LiteIDE仿IDEA界面，支持项目浏览、文件系统，Package浏览、Golang文档检索、类视图、大纲显示等多个工具窗口的切换。
+
  代码补全需要安装gocode，目前LiteIDE的自动化提示只支持本文件中函数的提示，还没有做到整个项目中函数的提示。


--- a/2.3.md
+++ b/2.3.md
@@ -384,11 +384,8 @@ Go里面有一个不错的设计，就是回调函数，有点类似面向对象
 		return false
 	}

-<<<<<<< HEAD
 	// 声明的函数类型在这个地方当做了一个参数
-=======
-	//声明的函数类型在这个地方当做了一个参数
->>>>>>> 707af97968bca65f2f1ba6a95132911b25585603
+
 	func filter(slice []int, f testInt) []int {
 		var result []int
 		for _, value := range slice {
@@ -412,7 +409,7 @@ Go里面有一个不错的设计，就是回调函数，有点类似面向对象

 ###Panic和Recover

-Go没有像Java那样的异常机制：不能抛出一个异常。作为代替，它使用了`panic`和`recover`机制。一定要记得，这应当作为最后的手段被使用，你的代码中应当没有，或者很少的令人恐慌的东西。这是个强大的工具，请明智地使用它。那么，应该如何使用它？
+Go没有像Java那样的异常机制，它不能抛出异常，而是使用了`panic`和`recover`机制。一定要记住，你应当把它作为最后的手段来使用，也就是说，你的代码中应当没有，或者很少有`panic`的东西。这是个强大的工具，请明智地使用它。那么，我们应该如何使用它呢？

 Panic
 >是一个内建函数，可以中断原有的控制流程，进入一个令人恐慌的流程中。当函数`F`调用`panic`，函数F的执行被中断，但是`F`中的延迟函数会正常执行，然后F返回到调用它的地方。在调用的地方，`F`的行为就像调用了`panic`。这一过程继续向上，直到发生`panic`的`goroutine`中所有调用的函数返回，此时程序退出。恐慌可以直接调用`panic`产生。也可以由运行时错误产生，例如访问越界的数组。
@@ -444,11 +441,11 @@ Recover

 ###`main`函数和`init`函数

-Go里面有两个保留的函数：`init`函数(能够应用于所有的`package`)和`main`函数(只能应用于`package main`)。这两个函数定义的时候必须都是没有任何参数，也没有任何返回值的。虽然一个`package`里面可以随便写多个`init`函数，但是对于易读性还是以后的维护性来说，我们还是强烈建议用户一个`package`只写一个`init`函数。
+Go里面有两个保留的函数：`init`函数（能够应用于所有的`package`）和`main`函数（只能应用于`package main`）。这两个函数在定义时不能有任何的参数和返回值。虽然一个`package`里面可以写任意多个`init`函数，但这无论是对于可读性还是以后的可维护性来说，我们都强烈建议用户在一个`package`中只写一个`init`函数。

-Go程序里面会自动调用`init()`和`main()`，所以你不需要在任何地方调用这两个函数。`init`函数每个`package`里面是可选的，但是对于`package main`就必须包含一个`main`函数。
+Go程序会自动调用`init()`和`main()`，所以你不需要在任何地方调用这两个函数。每个`package`中的`init`函数都是可选的，但`package main`就必须包含一个`main`函数。

-初始化和执行程序都是开始于`main`包，如果有`import`其它包，那么依次`import`进来。虽然有很多个包里面`import`了同一个包，但是这个包只会`import`一次（例如`fmt`包，可能很多`package`里面都会用到，但是只`import`了一次，因为没有必要包含多次）。当一个`package`被`import`进来的时候，如果它本身还`import`了其它包，那么先执行`import`其它包，然后执行这个包里面的包级别的常量和变量，然后执行`init`函数（如果包里面有的话）。最后所有的被`main`包`import`的包都加载完毕了，然后开始执行`main`包里面的常量和变量的初始化，然后执行`main`包里面的`init`函数（如果存在的话），最后执行到了`main`函数。下图详细的解释了整个的执行过程。
+程序的初始化和执行都起始于`main`包。如果`main`包还导入了其它的包，那么就会在编译时将它们依次导入。有时一个包会被多个包同时导入，那么它只会被导入一次（例如很多包可能都会用到`fmt`包，但它只会被导入一次，因为没有必要导入多次）。当一个包被导入时，如果该包还导入了其它的包，那么会先将其它包导入进来，然后再对这些包中的包级常量和变量进行初始化，接着执行`init`函数（如果有的话），依次类推。等所有被导入的包都加载完毕了，就会开始对`main`包中的包级常量和变量进行初始化，然后执行`main`包中的`init`函数（如果存在的话），最后执行`main`函数。下图详细地解释了整个执行过程：

 ![](images/2.3.init.png?raw=true)

--- a/2.7.md
+++ b/2.7.md
@@ -9,7 +9,7 @@ Goroutines是Go并行设计的核心。Goroutines说到底其实就是线程，
 Goroutines是通过Go的runtime管理的一个线程管理器。Goroutines通过`go`关键字实现了，其实就是一个普通的函数。

 	go hello(a, b, c)
-	
+
 通过关键字go就启动了一个Goroutines。我们来看一个例子

 	package main
@@ -29,8 +29,8 @@ Goroutines是通过Go的runtime管理的一个线程管理器。Goroutines通过
 	func main() {
 		go say("world") //开一个新的Goroutines执行
 		say("hello") //当前Goroutines执行
-	}	
-	
+	}
+
 	输出：
 	hello
 	world
@@ -41,7 +41,7 @@ Goroutines是通过Go的runtime管理的一个线程管理器。Goroutines通过
 	hello
 	world
 	hello
-	
+
 我们可以看到go关键字很方便的就实现了并发编程。
 ##channels
 Goroutines运行在相同的地址空间，因此访问共享内存必须做好同步。那么Goroutines之间如何进行数据的通信呢，Go提供了一个很好的通信机制channel。channel可以与Unix shell 中的双向管道做类比：可以通过它发送或者接收值。这些值只能是特定的类型：channel类型。定义一个channel 时，也需要定义发送到channel 的值的类型。注意，必须使用make 创建channel：
@@ -68,15 +68,15 @@ channel通过操作符`<-`来接收和发送数据
 		}
 		c <- sum  // send sum to c
 	}
-	
+
 	func main() {
 		a := []int{7, 2, 8, -9, 4, 0}
-	
-	    c := make(chan int)
+
+		c := make(chan int)
 		go sum(a[:len(a)/2], c)
 		go sum(a[len(a)/2:], c)
-	    x, y := <-c, <-c  // receive from c
-	
+		x, y := <-c, <-c  // receive from c
+
 		fmt.Println(x, y, x + y)
 	}

@@ -86,9 +86,9 @@ channel通过操作符`<-`来接收和发送数据
 上面我们介绍了默认的非缓存类型的channel，不过Go也允许指定channel的缓冲大小，很简单，就是channel可以存储多少元素。ch:= make(chan bool, 4)，创建了可以存储4个元素的bool 型channel。在这个channel 中，前4个元素可以无阻塞的写入。当写入第5个元素时，代码将会阻塞，直到其他goroutine从channel 中读取一些元素，腾出空间。

 	ch := make(chan type, value)
-	
+
 	value == 0 ! 无缓冲（阻塞）
-	value > 0 ! 缓冲（非阻塞，直到value 个元素）	
+	value > 0 ! 缓冲（非阻塞，直到value 个元素）

 我们看一下下面这个例子，你可以在自己本机测试一下，修改相应的value值

@@ -103,32 +103,32 @@ channel通过操作符`<-`来接收和发送数据
 		c <- 2
 		fmt.Println(<-c)
 		fmt.Println(<-c)
-	}	
+	}

 ##Range和Close
 上面这个例子中，我们需要读取两次c，这样不是很方便，Go考虑到了这一点，所以也可以通过range，像操作slice或者map一样操作缓存类型的channel，请看下面的例子

 	package main
-	
+
 	import (
 		"fmt"
 	)
-	
+
 	func fibonacci(n int, c chan int) {
-	        x, y := 1, 1
-	        for i := 0; i < n; i++ {
-	                c <- x
-	                x, y = y, x + y
-	        }
-	        close(c)
+			x, y := 1, 1
+			for i := 0; i < n; i++ {
+					c <- x
+					x, y = y, x + y
+			}
+			close(c)
 	}
-	
+
 	func main() {
-	    c := make(chan int, 10)
+		c := make(chan int, 10)
 		go fibonacci(cap(c), c)
-	    for i := range c {
-	         fmt.Println(i)
-	    }
+		for i := range c {
+			 fmt.Println(i)
+		}
 	}

 `for i := range c`能够不断的读取channel里面的数据，直到该channel被显示的关闭。上面代码我们看到可以显示的关闭channel，生产者通过关键字`close`函数关闭channel。关闭channel之后就无法再发送任何数据了，在消费方可以通过语法`v, ok := <-ch`测试channel是否被关闭。如果ok返回false，那么说明channel已经没有任何数据并且已经被关闭。
@@ -143,24 +143,24 @@ channel通过操作符`<-`来接收和发送数据
 `select`默认是阻塞的，只有当监听的channel中有发送或接收可以进行时才会运行，当多个channel都准备好的时候，select是随机的选择一个执行的。

 	package main
-	
+
 	import "fmt"
-	
+
 	func fibonacci(c, quit chan int) {
-        x, y := 1, 1
-        for {
-                select {
-                case c <- x:
-                          x, y = y, x + y
-                case <-quit:
+		x, y := 1, 1
+		for {
+				select {
+				case c <- x:
+						  x, y = y, x + y
+				case <-quit:
 			fmt.Println("quit")
-                        return
-                }
-        }
+						return
+				}
+		}
 	}
-	
+
 	func main() {
-    	c := make(chan int)
+		c := make(chan int)
 		quit := make(chan int)
 		go func() {
 			for i := 0; i < 10; i++ {
@@ -188,5 +188,5 @@ channel通过操作符`<-`来接收和发送数据
   * 上一章: [interface](<2.6.md>)
   * 下一节: [总结](<2.8.md>)

-## LastModified 
+## LastModified
   * $Id$
--- a/2.8.md
+++ b/2.8.md
@@ -1,7 +1,7 @@
 #2.8总结

 这一章我们主要介绍了Go语言的一些语法，通过语法我们可以发现Go是多么的简单，只有二十五个关键字。让我们再来回顾一下这些关键字都是用来干什么的。
-	
+
 	break    default      func    interface    select
 	case     defer        go      map          struct
 	chan     else         goto    package      switch
@@ -12,15 +12,15 @@
 - package和import已经有过短暂的接触
 - func 用于定义函数和方法
 - return 用于从函数返回
- defer用于类似析构函数
+- defer 用于类似析构函数
 - go 用于并行
 - select 用于选择不同类型的通讯
- interface用于定义接口，参考2.6小节
+- interface 用于定义接口，参考2.6小节
 - struct 用于定义抽象数据类型，参考2.5小节
 - break、case、continue、for、fallthrough、else、if、switch、goto、default这些参考2.3流程介绍里面
 - chan用于channel通讯
- type用于什么自定义类似
- map用于什么map类型数据
+- type用于声明自定义类型
+- map用于声明map类型数据
 - range用于读取slice、map、channel数据

 上面这二十五个关键字记住了，那么Go你也已经差不多学会了。
@@ -30,5 +30,5 @@
   * 上一节: [并发](<2.7.md>)
   * 下一章: [Web基础](<3.md>)

-## LastModified 
-   * $Id$
+## LastModified
+   * $Id$