From 1bb0deab32f9c3b3514d831ffe33115c8edef6c4 Mon Sep 17 00:00:00 2001 From: vCaesar Date: Sat, 10 Dec 2016 18:02:50 +0800 Subject: [PATCH] Add syntax highlighting --- zh/02.2.md | 24 ++++++++++++++ zh/02.3.md | 95 ++++++++++++++++++++++++++++++++++++------------------ 2 files changed, 88 insertions(+), 31 deletions(-) diff --git a/zh/02.2.md b/zh/02.2.md index 5adcbad1..b2657426 100644 --- a/zh/02.2.md +++ b/zh/02.2.md @@ -8,21 +8,25 @@ Go语言里面定义变量有多种方式。 使用`var`关键字是Go最基本的定义变量方式，与C语言不同的是Go把变量类型放在变量名后面： ```Go + //定义一个名称为“variableName”，类型为"type"的变量 var variableName type ``` 定义多个变量 ```Go + //定义三个类型都是“type”的变量 var vname1, vname2, vname3 type ``` 定义变量并初始化值 ```Go + //初始化“variableName”的变量为“value”值，类型是“type” var variableName type = value ``` 同时初始化多个变量 ```Go + /* 定义三个类型都是"type"的变量,并且分别初始化为相应的值 vname1为v1，vname2为v2，vname3为v3 @@ -31,6 +35,7 @@ Go语言里面定义变量有多种方式。 ``` 你是不是觉得上面这样的定义有点繁琐？没关系，因为Go语言的设计者也发现了，有一种写法可以让它变得简单一点。我们可以直接忽略类型声明，那么上面的代码变成这样了： ```Go + /* 定义三个变量，它们分别初始化为相应的值 vname1为v1，vname2为v2，vname3为v3 @@ -40,6 +45,7 @@ Go语言里面定义变量有多种方式。 ``` 你觉得上面的还是有些繁琐？好吧，我也觉得。让我们继续简化： ```Go + /* 定义三个变量，它们分别初始化为相应的值 vname1为v1，vname2为v2，vname3为v3 @@ -55,6 +61,7 @@ Go语言里面定义变量有多种方式。 Go对于已声明但未使用的变量会在编译阶段报错，比如下面的代码就会产生一个错误：声明了`i`但未使用。 ```Go + package main func main() { @@ -67,12 +74,14 @@ Go对于已声明但未使用的变量会在编译阶段报错，比如下面的 它的语法如下： ```Go + const constantName = value //如果需要，也可以明确指定常量的类型： const Pi float32 = 3.1415926 ``` 下面是一些常量声明的例子： ```Go + const Pi = 3.1415926 const i = 10000 const MaxThread = 10 @@ -87,6 +96,7 @@ Go 常量和一般程序语言不同的是，可以指定相当多的小数位 在Go中，布尔值的类型为`bool`，值是`true`或`false`，默认为`false`。 ```Go + //示例代码 var isActive bool // 全局变量声明 var enabled, disabled = true, false // 忽略类型的声明 @@ -117,6 +127,7 @@ Go 常量和一般程序语言不同的是，可以指定相当多的小数位 这就是全部吗？No！Go还支持复数。它的默认类型是`complex128`（64位实数+64位虚数）。如果需要小一些的，也有`complex64`(32位实数+32位虚数)。复数的形式为`RE + IMi`，其中`RE`是实数部分，`IM`是虚数部分，而最后的`i`是虚数单位。下面是一个使用复数的例子： ```Go + var c complex64 = 5+5i //output: (5+5i) fmt.Printf("Value is: %v", c) @@ -126,6 +137,7 @@ Go 常量和一般程序语言不同的是，可以指定相当多的小数位 我们在上一节中讲过，Go中的字符串都是采用`UTF-8`字符集编码。字符串是用一对双引号（`""`）或反引号（`` ` `` `` ` ``）括起来定义，它的类型是`string`。 ```Go + //示例代码 var frenchHello string // 声明变量为字符串的一般方法 var emptyString string = "" // 声明了一个字符串变量，初始化为空字符串 @@ -137,12 +149,14 @@ Go 常量和一般程序语言不同的是，可以指定相当多的小数位 ``` 在Go中字符串是不可变的，例如下面的代码编译时会报错：cannot assign to s[0] ```Go + var s string = "hello" s[0] = 'c' ``` 但如果真的想要修改怎么办呢？下面的代码可以实现： ```Go + s := "hello" c := []byte(s) // 将字符串 s 转换为 []byte 类型 c[0] = 'c' @@ -152,6 +166,7 @@ Go 常量和一般程序语言不同的是，可以指定相当多的小数位 Go中可以使用`+`操作符来连接两个字符串： ```Go + s := "hello," m := " world" a := s + m @@ -159,6 +174,7 @@ Go中可以使用`+`操作符来连接两个字符串： ``` 修改字符串也可写为： ```Go + s := "hello" s = "c" + s[1:] // 字符串虽不能更改，但可进行切片操作 fmt.Printf("%s\n", s) @@ -176,6 +192,7 @@ Go中可以使用`+`操作符来连接两个字符串： ### 错误类型 Go内置有一个`error`类型，专门用来处理错误信息，Go的`package`里面还专门有一个包`errors`来处理错误： ```Go + err := errors.New("emit macho dwarf: elf header corrupted") if err != nil { fmt.Print(err) @@ -197,6 +214,7 @@ Go内置有一个`error`类型，专门用来处理错误信息，Go的`package` 例如下面的代码： ```Go + import "fmt" import "os" @@ -210,6 +228,7 @@ Go内置有一个`error`类型，专门用来处理错误信息，Go的`package` ``` 可以分组写成如下形式： ```Go + import( "fmt" "os" @@ -265,10 +284,12 @@ Go之所以会那么简洁，是因为它有一些默认的行为： ### array `array`就是数组，它的定义方式如下： ```Go + var arr [n]type ``` 在`[n]type`中，`n`表示数组的长度，`type`表示存储元素的类型。对数组的操作和其它语言类似，都是通过`[]`来进行读取或赋值： ```Go + var arr [10]int // 声明了一个int类型的数组 arr[0] = 42 // 数组下标是从0开始的 arr[1] = 13 // 赋值操作 @@ -319,6 +340,7 @@ Go之所以会那么简洁，是因为它有一些默认的行为： ``` `slice`可以从一个数组或一个已经存在的`slice`中再次声明。`slice`通过`array[i:j]`来获取，其中`i`是数组的开始位置，`j`是结束位置，但不包含`array[j]`，它的长度是`j-i`。 ```Go + // 声明一个含有10个元素元素类型为byte的数组 var ar = [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'} @@ -425,6 +447,7 @@ slice有一些简便的操作 fmt.Println("第三个数字是: ", numbers["three"]) // 读取数据 // 打印出来如:第三个数字是: 3 +``` 这个`map`就像我们平常看到的表格一样，左边列是`key`，右边列是值 @@ -438,6 +461,7 @@ slice有一些简便的操作 `map`的初始化可以通过`key:val`的方式初始化值，同时`map`内置有判断是否存在`key`的方式 通过`delete`删除`map`的元素： + ```Go // 初始化一个字典 diff --git a/zh/02.3.md b/zh/02.3.md index 71189b59..a3348656 100644 --- a/zh/02.3.md +++ b/zh/02.3.md @@ -6,6 +6,7 @@ `if`也许是各种编程语言中最常见的了，它的语法概括起来就是：如果满足条件就做某事，否则做另一件事。 Go里面`if`条件判断语句中不需要括号，如下代码所示 +```Go if x > 10 { fmt.Println("x is greater than 10") @@ -14,6 +15,7 @@ Go里面`if`条件判断语句中不需要括号，如下代码所示 } Go的`if`还有一个强大的地方就是条件判断语句里面允许声明一个变量，这个变量的作用域只能在该条件逻辑块内，其他地方就不起作用了，如下所示 +```Go // 计算获取值x,然后根据x返回的大小，判断是否大于10。 if x := computedValue(); x > 10 { @@ -24,8 +26,9 @@ Go的`if`还有一个强大的地方就是条件判断语句里面允许声明 //这个地方如果这样调用就编译出错了，因为x是条件里面的变量 fmt.Println(x) - +``` 多个条件的时候如下所示： +```Go if integer == 3 { fmt.Println("The integer is equal to 3") @@ -34,10 +37,11 @@ Go的`if`还有一个强大的地方就是条件判断语句里面允许声明 } else { fmt.Println("The integer is greater than 3") } - +``` ### goto Go有`goto`语句——请明智地使用它。用`goto`跳转到必须在当前函数内定义的标签。例如假设这样一个循环： +```Go func myFunc() { i := 0 @@ -46,19 +50,21 @@ Go有`goto`语句——请明智地使用它。用`goto`跳转到必须在当前 i++ goto Here //跳转到Here去 } - +``` >标签名是大小写敏感的。 ### for Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读取数据，又可以当作`while`来控制逻辑，还能迭代操作。它的语法如下： +```Go for expression1; expression2; expression3 { //... } - +``` `expression1`、`expression2`和`expression3`都是表达式，其中`expression1`和`expression3`是变量声明或者函数调用返回值之类的，`expression2`是用来条件判断，`expression1`在循环开始之前调用，`expression3`在每轮循环结束之时调用。 一个例子比上面讲那么多更有用，那么我们看看下面的例子吧： +```Go package main import "fmt" @@ -71,25 +77,28 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读 fmt.Println("sum is equal to ", sum) } // 输出：sum is equal to 45 - +``` 有些时候需要进行多个赋值操作，由于Go里面没有`,`操作符，那么可以使用平行赋值`i, j = i+1, j-1` 有些时候如果我们忽略`expression1`和`expression3`： +```Go sum := 1 for ; sum < 1000; { sum += sum } - +``` 其中`;`也可以省略，那么就变成如下的代码了，是不是似曾相识？对，这就是`while`的功能。 +```Go sum := 1 for sum < 1000 { sum += sum } - +``` 在循环里面有两个关键操作`break`和`continue` ,`break`操作是跳出当前循环，`continue`是跳过本次循环。当嵌套过深的时候，`break`可以配合标签使用，即跳转至标签所指定的位置，详细参考如下例子： +```Go for index := 10; index>0; index-- { if index == 5{ @@ -99,26 +108,29 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读 } // break打印出来10、9、8、7、6 // continue打印出来10、9、8、7、6、4、3、2、1 - +``` `break`和`continue`还可以跟着标号，用来跳到多重循环中的外层循环 `for`配合`range`可以用于读取`slice`和`map`的数据： +```Go for k,v:=range map { fmt.Println("map's key:",k) fmt.Println("map's val:",v) } - +``` 由于 Go 支持 “多值返回”, 而对于“声明而未被调用”的变量, 编译器会报错, 在这种情况下, 可以使用`_`来丢弃不需要的返回值 例如 +```Go for _, v := range map{ fmt.Println("map's val:", v) } - +``` ### switch 有些时候你需要写很多的`if-else`来实现一些逻辑处理，这个时候代码看上去就很丑很冗长，而且也不易于以后的维护，这个时候`switch`就能很好的解决这个问题。它的语法如下 +```Go switch sExpr { case expr1: @@ -130,8 +142,9 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读 default: other code } - +``` `sExpr`和`expr1`、`expr2`、`expr3`的类型必须一致。Go的`switch`非常灵活，表达式不必是常量或整数，执行的过程从上至下，直到找到匹配项；而如果`switch`没有表达式，它会匹配`true`。 +```Go i := 10 switch i { @@ -144,8 +157,9 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读 default: fmt.Println("All I know is that i is an integer") } - +``` 在第5行中，我们把很多值聚合在了一个`case`里面，同时，Go里面`switch`默认相当于每个`case`最后带有`break`，匹配成功后不会自动向下执行其他case，而是跳出整个`switch`, 但是可以使用`fallthrough`强制执行后面的case代码。 +```Go integer := 6 switch integer { @@ -167,24 +181,26 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读 default: fmt.Println("default case") } - +``` 上面的程序将输出 +```Go The integer was <= 6 The integer was <= 7 The integer was <= 8 default case - +``` ## 函数 函数是Go里面的核心设计，它通过关键字`func`来声明，它的格式如下： +```Go func funcName(input1 type1, input2 type2) (output1 type1, output2 type2) { //这里是处理逻辑代码 //返回多个值 return value1, value2 } - +``` 上面的代码我们看出 - 关键字`func`用来声明一个函数`funcName` @@ -196,6 +212,7 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读 - 如果有返回值， 那么必须在函数的外层添加return语句 下面我们来看一个实际应用函数的例子（用来计算Max值） +```Go package main import "fmt" @@ -220,13 +237,14 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读 fmt.Printf("max(%d, %d) = %d\n", x, z, max_xz) fmt.Printf("max(%d, %d) = %d\n", y, z, max(y,z)) // 也可在这直接调用它 } - +``` 上面这个里面我们可以看到`max`函数有两个参数，它们的类型都是`int`，那么第一个变量的类型可以省略（即 a,b int,而非 a int, b int)，默认为离它最近的类型，同理多于2个同类型的变量或者返回值。同时我们注意到它的返回值就是一个类型，这个就是省略写法。 ### 多个返回值 Go语言比C更先进的特性，其中一点就是函数能够返回多个值。 我们直接上代码看例子 +```Go package main import "fmt" @@ -245,29 +263,34 @@ Go语言比C更先进的特性，其中一点就是函数能够返回多个值 fmt.Printf("%d + %d = %d\n", x, y, xPLUSy) fmt.Printf("%d * %d = %d\n", x, y, xTIMESy) } - +``` 上面的例子我们可以看到直接返回了两个参数，当然我们也可以命名返回参数的变量，这个例子里面只是用了两个类型，我们也可以改成如下这样的定义，然后返回的时候不用带上变量名，因为直接在函数里面初始化了。但如果你的函数是导出的(首字母大写)，官方建议：最好命名返回值，因为不命名返回值，虽然使得代码更加简洁了，但是会造成生成的文档可读性差。 +```Go func SumAndProduct(A, B int) (add int, Multiplied int) { add = A+B Multiplied = A*B return } - +``` ### 变参 Go函数支持变参。接受变参的函数是有着不定数量的参数的。为了做到这点，首先需要定义函数使其接受变参： +```Go func myfunc(arg ...int) {} +``` `arg ...int`告诉Go这个函数接受不定数量的参数。注意，这些参数的类型全部是`int`。在函数体中，变量`arg`是一个`int`的`slice`： +```Go for _, n := range arg { fmt.Printf("And the number is: %d\n", n) } - +``` ### 传值与传指针 当我们传一个参数值到被调用函数里面时，实际上是传了这个值的一份copy，当在被调用函数中修改参数值的时候，调用函数中相应实参不会发生任何变化，因为数值变化只作用在copy上。 为了验证我们上面的说法，我们来看一个例子 +```Go package main import "fmt" @@ -288,7 +311,7 @@ Go函数支持变参。接受变参的函数是有着不定数量的参数的。 fmt.Println("x+1 = ", x1) // 应该输出"x+1 = 4" fmt.Println("x = ", x) // 应该输出"x = 3" } - +``` 看到了吗？虽然我们调用了`add1`函数，并且在`add1`中执行`a = a+1`操作，但是上面例子中`x`变量的值没有发生变化 理由很简单：因为当我们调用`add1`的时候，`add1`接收的参数其实是`x`的copy，而不是`x`本身。 @@ -296,6 +319,7 @@ Go函数支持变参。接受变参的函数是有着不定数量的参数的。 那你也许会问了，如果真的需要传这个`x`本身,该怎么办呢？ 这就牵扯到了所谓的指针。我们知道，变量在内存中是存放于一定地址上的，修改变量实际是修改变量地址处的内存。只有`add1`函数知道`x`变量所在的地址，才能修改`x`变量的值。所以我们需要将`x`所在地址`&x`传入函数，并将函数的参数的类型由`int`改为`*int`，即改为指针类型，才能在函数中修改`x`变量的值。此时参数仍然是按copy传递的，只是copy的是一个指针。请看下面的例子 +```Go package main import "fmt" @@ -316,7 +340,7 @@ Go函数支持变参。接受变参的函数是有着不定数量的参数的。 fmt.Println("x+1 = ", x1) // 应该输出 "x+1 = 4" fmt.Println("x = ", x) // 应该输出 "x = 4" } - +``` 这样，我们就达到了修改`x`的目的。那么到底传指针有什么好处呢？ - 传指针使得多个函数能操作同一个对象。 @@ -325,6 +349,7 @@ Go函数支持变参。接受变参的函数是有着不定数量的参数的。 ### defer Go语言中有种不错的设计，即延迟（defer）语句，你可以在函数中添加多个defer语句。当函数执行到最后时，这些defer语句会按照逆序执行，最后该函数返回。特别是当你在进行一些打开资源的操作时，遇到错误需要提前返回，在返回前你需要关闭相应的资源，不然很容易造成资源泄露等问题。如下代码所示，我们一般写打开一个资源是这样操作的： +```Go func ReadWrite() bool { file.Open("file") @@ -342,8 +367,9 @@ Go语言中有种不错的设计，即延迟（defer）语句，你可以在函 file.Close() return true } - +``` 我们看到上面有很多重复的代码，Go的`defer`有效解决了这个问题。使用它后，不但代码量减少了很多，而且程序变得更优雅。在`defer`后指定的函数会在函数退出前调用。 +```Go func ReadWrite() bool { file.Open("file") @@ -356,13 +382,14 @@ Go语言中有种不错的设计，即延迟（defer）语句，你可以在函 } return true } - +``` 如果有很多调用`defer`，那么`defer`是采用后进先出模式，所以如下代码会输出`4 3 2 1 0` +```Go for i := 0; i < 5; i++ { defer fmt.Printf("%d ", i) } - +``` ### 函数作为值、类型 在Go中函数也是一种变量，我们可以通过`type`来定义它，它的类型就是所有拥有相同的参数，相同的返回值的一种类型 @@ -370,6 +397,7 @@ Go语言中有种不错的设计，即延迟（defer）语句，你可以在函 type typeName func(input1 inputType1 , input2 inputType2 [, ...]) (result1 resultType1 [, ...]) 函数作为类型到底有什么好处呢？那就是可以把这个类型的函数当做值来传递，请看下面的例子 +```Go package main import "fmt" @@ -410,7 +438,7 @@ Go语言中有种不错的设计，即延迟（defer）语句，你可以在函 even := filter(slice, isEven) // 函数当做值来传递了 fmt.Println("Even elements of slice are: ", even) } - +``` 函数当做值和类型在我们写一些通用接口的时候非常有用，通过上面例子我们看到`testInt`这个类型是一个函数类型，然后两个`filter`函数的参数和返回值与`testInt`类型是一样的，但是我们可以实现很多种的逻辑，这样使得我们的程序变得非常的灵活。 ### Panic和Recover @@ -424,6 +452,7 @@ Recover >是一个内建的函数，可以让进入令人恐慌的流程中的`goroutine`恢复过来。`recover`仅在延迟函数中有效。在正常的执行过程中，调用`recover`会返回`nil`，并且没有其它任何效果。如果当前的`goroutine`陷入恐慌，调用`recover`可以捕获到`panic`的输入值，并且恢复正常的执行。 下面这个函数演示了如何在过程中使用`panic` +```Go var user = os.Getenv("USER") @@ -432,8 +461,9 @@ Recover panic("no value for $USER") } } - +``` 下面这个函数检查作为其参数的函数在执行时是否会产生`panic`： +```Go func throwsPanic(f func()) (b bool) { defer func() { @@ -444,7 +474,7 @@ Recover f() //执行函数f，如果f中出现了panic，那么就可以恢复回来 return } - +``` ### `main`函数和`init`函数 Go里面有两个保留的函数：`init`函数（能够应用于所有的`package`）和`main`函数（只能应用于`package main`）。这两个函数在定义时不能有任何的参数和返回值。虽然一个`package`里面可以写任意多个`init`函数，但这无论是对于可读性还是以后的可维护性来说，我们都强烈建议用户在一个`package`中每个文件只写一个`init`函数。 @@ -459,15 +489,17 @@ Go程序会自动调用`init()`和`main()`，所以你不需要在任何地方 ### import 我们在写Go代码的时候经常用到import这个命令用来导入包文件，而我们经常看到的方式参考如下： +```Go import( "fmt" ) - +``` 然后我们代码里面可以通过如下的方式调用 +```Go fmt.Println("hello world") - +``` 上面这个fmt是Go语言的标准库，其实是去`GOROOT`环境变量指定目录下去加载该模块，当然Go的import还支持如下两种方式来加载自己写的模块： 1. 相对路径 @@ -505,12 +537,13 @@ Go程序会自动调用`init()`和`main()`，所以你不需要在任何地方 3. _操作 这个操作经常是让很多人费解的一个操作符，请看下面这个import - +```Go + import ( "database/sql" _ "github.com/ziutek/mymysql/godrv" ) - +``` _操作其实是引入该包，而不直接使用包里面的函数，而是调用了该包里面的init函数。