From 462ff085f791518fcd73366dd0f88e39c9e0797c Mon Sep 17 00:00:00 2001 From: chidouhu Date: Tue, 19 Nov 2013 17:47:39 +0800 Subject: [PATCH 1/6] add 7.0.md and 7.1.md --- eBook/07.0.md | 9 +++ eBook/07.1.md | 92 +++++++++++++++++++++++++ eBook/examples/chapter_7/for_arrays.go | 14 ++++ eBook/images/7.1_fig7.1.png | Bin 0 -> 13204 bytes 4 files changed, 115 insertions(+) create mode 100644 eBook/07.0.md create mode 100644 eBook/07.1.md create mode 100644 eBook/examples/chapter_7/for_arrays.go create mode 100644 eBook/images/7.1_fig7.1.png diff --git a/eBook/07.0.md b/eBook/07.0.md new file mode 100644 index 0000000..08b4e3b --- /dev/null +++ b/eBook/07.0.md @@ -0,0 +1,9 @@ +#7.0 数组与分片 +本章我们从包含大量项的检测数据结构开始（例如数组和map），我们称之为容器。在这里很明显Go受到了python的影响。 + +以[ ]符号标识的数组类型几乎在所有的编程语言中都是一个基本主力。Go语言中的数组也是类似的，只是有一些特点。Go没有C那么灵活，但是拥有分片（slice）类型。这是一种建立在Go语言数组类型智商的抽象，要想理解slice我们必须先理解数组。数组有特定的用处，但是却有一些呆板，所以在Go语言的代码里并不是特别常见。相对的，slice确实随处可见的。它们构建在数组之上并且提供更强大的能力和便捷。 + +##链接 +- [目录](directory.md) +- 上一节：[]() +- 下一节：[声明和初始化](07.1.md) \ No newline at end of file diff --git a/eBook/07.1.md b/eBook/07.1.md new file mode 100644 index 0000000..0ba8d7d --- /dev/null +++ b/eBook/07.1.md @@ -0,0 +1,92 @@ +#6.1 函数介绍 +每一个程序都包含很多的函数：函数是基本的代码块。 + +Go是编译型语言，所以函数编写的顺序是无关紧要的；鉴于可读性的需求，最好把 main() 函数写在文件的前面，其他函数按照一定逻辑顺序进行编写（例如函数被调用的顺序）。 + +编写多个函数的主要目的是将一个需要很多行代码的复杂问题分解为一系列简单的任务（那就是函数）来解决。而且，同一个任务（函数）可以被调用多次，有助于代码重用。 + +（事实上，好的程序是非常注意DRY原则的，即不要重复你自己（Don't Repeat Yourself），意思是执行特定任务的代码只能在程序里面出现一次。） + +当函数执行到代码块最后一行（`}`之前）或者`return`语句的时候会退出，其中`return`语句可以带有零个或多个参数；这些参数将作为返回值（参考[6.2节](06.2.md)）供调用者使用。简单的`return`语句也可以用来结束for死循环，或者结束一个协程（goroutine）。 + +Go里面拥三种类型的函数： + +- 普通的带有名字的函数 +- 匿名函数或者lambda函数（参考[6.8节](06.8.md)） +- 方法（Methods，参考[10.6节](10.6.md)） + +所有类型的函数都可以有参数与返回值。函数参数、返回值以及它们的类型被统称为函数签名。 + +作为提醒，提前介绍一个语法： + +这样是不正确的Go代码： + + func g() + { + } + +它必须是这样的： + + func g() { + } + +函数被调用的基本格式如下： + + pack1.Function(arg1, arg2, …, argn) + +Function是pack1包里面的一个函数，括号里的是被调用函数的*实参*（argument）：这些值被传递给被调用函数的*形参*（parameter，参考[6.2节](06.2.md)）。函数被调用的时候，这些实参将被复制（简单而言）然后传递给被调用函数。函数一般是在其他函数里面被调用的，这个其他函数被称为调用函数（calling function）。函数能多次调用其他函数，这些被调用函数按顺序（简单而言）执行，理论上，函数调用其他函数的次数是无穷的（直到函数调用栈被耗尽）。 + +一个简单的函数调用其他函数的例子： + +示例 6.1 [greeting.go](examples/chapter_6/greeting.go) + + package main + + func main() { + println("In main before calling greeting") + greeting() + println("In main after calling greeting") + } + + func greeting() { + println("In greeting: Hi!!!!!") + } + +代码输出： + + In main before calling greeting + In greeting: Hi!!!!! + In main after calling greeting + +函数可以将其他函数调用作为它的参数，只要这个被调用函数的返回值个数、返回值类型和返回值的顺序与调用函数所需求的实参是一致的，例如： + +假设 f1 需要3个参数 `f1(a, b, c int)`，同时 f2 返回3个参数 `f2(a, b int) (int, int, int)`，就可以这样调用 f1：`f1(f2(a, b))` + +函数重载（function overloading）指的是可以编写多个同名函数，只要它们拥有不同的形参与/或者不同的返回值，在Go里面函数重载是不被允许的。这将导致一个编译错误： + + funcName redeclared in this book, previous declaration at lineno + +Go语言不支持这项特性的主要原因是函数重载需要进行多余的类型匹配影响性能；没有重载意味着只是一个简单的函数调度。所以你需要给不同的函数使用不同的名字，我们通常会根据函数的特征对函数进行命名（参考[11.12.5节](11.12.md)）。 + +如果需要申明一个在外部定义的函数，你只需要给出函数名与函数签名，不需要给出函数体： + + func flushICache(begin, end uintptr) // implemented externally + +**函数也可以以申明的方式被使用，作为一个函数类型**，就像： + + type binOp func(int, int) int + +在这里，不需要函数体`{}`。 + +函数是一等值（first-class value）：它们可以赋值给变量，就像`add := binOp`一样。 + +这个变量知道自己指向的函数的签名，所以给它赋一个具有不同签名的函数值是不可能的。 + +函数值（functions value）之间可以相互比较：如果它们引用的是相同的函数或者都是nil的话，则认为它们是相同的函数。函数不能在其它函数里面声明（不能嵌套），不过我们可以通过使用匿名函数（参考[6.8节](06.8.md)）来破除这个限制。 + +目前Go没有泛型（generic）的概念，也就是说它不支持那种支持多种类型的函数。不过在大部分情况下可以通过接口（interface），特别是空接口与类型选择（type switch，参考[11.12节](11.12.md)）与/或者通过使用反射（reflection，参考[6.8节](06.8.md)）来实现相似的功能。使用这些技术将导致代码更为复杂、性能更为地下，所以在非常注意性能的的场合，最好是为每一个类型单独创建一个函数，而且代码可读性更强。 + +##链接 +- [目录](directory.md) +- 上一节：[函数](06.0.md) +- 下一节：[函数参数与返回值](06.2.md) \ No newline at end of file diff --git a/eBook/examples/chapter_7/for_arrays.go b/eBook/examples/chapter_7/for_arrays.go new file mode 100644 index 0000000..f5a6239 --- /dev/null +++ b/eBook/examples/chapter_7/for_arrays.go @@ -0,0 +1,14 @@ +package main +import "fmt" + +func main() { + var arr1 [5]int + + for i:=0; i < len(arr1); i++ { + arr1[i] = i * 2 + } + + for i:=0; i < len(arr1); i++ { + fmt.Printf("Array at index %d is %d\n", i, arr1[i]) + } +} diff --git a/eBook/images/7.1_fig7.1.png b/eBook/images/7.1_fig7.1.png new file mode 100644 index 0000000000000000000000000000000000000000..f34140e73acee2f54d0c992db1d52879af65003c GIT binary patch literal 13204 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 F{{U|PWa9t; literal 0 HcmV?d00001 From 1465cada1f2fbd2dc8fff876bbf4e0b9f18df850 Mon Sep 17 00:00:00 2001 From: chidouhu Date: Tue, 19 Nov 2013 17:52:57 +0800 Subject: [PATCH 2/6] Delete 07.1.md wrong file --- eBook/07.1.md | 92 --------------------------------------------------- 1 file changed, 92 deletions(-) delete mode 100644 eBook/07.1.md diff --git a/eBook/07.1.md b/eBook/07.1.md deleted file mode 100644 index 0ba8d7d..0000000 --- a/eBook/07.1.md +++ /dev/null @@ -1,92 +0,0 @@ -#6.1 函数介绍 -每一个程序都包含很多的函数：函数是基本的代码块。 - -Go是编译型语言，所以函数编写的顺序是无关紧要的；鉴于可读性的需求，最好把 main() 函数写在文件的前面，其他函数按照一定逻辑顺序进行编写（例如函数被调用的顺序）。 - -编写多个函数的主要目的是将一个需要很多行代码的复杂问题分解为一系列简单的任务（那就是函数）来解决。而且，同一个任务（函数）可以被调用多次，有助于代码重用。 - -（事实上，好的程序是非常注意DRY原则的，即不要重复你自己（Don't Repeat Yourself），意思是执行特定任务的代码只能在程序里面出现一次。） - -当函数执行到代码块最后一行（`}`之前）或者`return`语句的时候会退出，其中`return`语句可以带有零个或多个参数；这些参数将作为返回值（参考[6.2节](06.2.md)）供调用者使用。简单的`return`语句也可以用来结束for死循环，或者结束一个协程（goroutine）。 - -Go里面拥三种类型的函数： - -- 普通的带有名字的函数 -- 匿名函数或者lambda函数（参考[6.8节](06.8.md)） -- 方法（Methods，参考[10.6节](10.6.md)） - -所有类型的函数都可以有参数与返回值。函数参数、返回值以及它们的类型被统称为函数签名。 - -作为提醒，提前介绍一个语法： - -这样是不正确的Go代码： - - func g() - { - } - -它必须是这样的： - - func g() { - } - -函数被调用的基本格式如下： - - pack1.Function(arg1, arg2, …, argn) - -Function是pack1包里面的一个函数，括号里的是被调用函数的*实参*（argument）：这些值被传递给被调用函数的*形参*（parameter，参考[6.2节](06.2.md)）。函数被调用的时候，这些实参将被复制（简单而言）然后传递给被调用函数。函数一般是在其他函数里面被调用的，这个其他函数被称为调用函数（calling function）。函数能多次调用其他函数，这些被调用函数按顺序（简单而言）执行，理论上，函数调用其他函数的次数是无穷的（直到函数调用栈被耗尽）。 - -一个简单的函数调用其他函数的例子： - -示例 6.1 [greeting.go](examples/chapter_6/greeting.go) - - package main - - func main() { - println("In main before calling greeting") - greeting() - println("In main after calling greeting") - } - - func greeting() { - println("In greeting: Hi!!!!!") - } - -代码输出： - - In main before calling greeting - In greeting: Hi!!!!! - In main after calling greeting - -函数可以将其他函数调用作为它的参数，只要这个被调用函数的返回值个数、返回值类型和返回值的顺序与调用函数所需求的实参是一致的，例如： - -假设 f1 需要3个参数 `f1(a, b, c int)`，同时 f2 返回3个参数 `f2(a, b int) (int, int, int)`，就可以这样调用 f1：`f1(f2(a, b))` - -函数重载（function overloading）指的是可以编写多个同名函数，只要它们拥有不同的形参与/或者不同的返回值，在Go里面函数重载是不被允许的。这将导致一个编译错误： - - funcName redeclared in this book, previous declaration at lineno - -Go语言不支持这项特性的主要原因是函数重载需要进行多余的类型匹配影响性能；没有重载意味着只是一个简单的函数调度。所以你需要给不同的函数使用不同的名字，我们通常会根据函数的特征对函数进行命名（参考[11.12.5节](11.12.md)）。 - -如果需要申明一个在外部定义的函数，你只需要给出函数名与函数签名，不需要给出函数体： - - func flushICache(begin, end uintptr) // implemented externally - -**函数也可以以申明的方式被使用，作为一个函数类型**，就像： - - type binOp func(int, int) int - -在这里，不需要函数体`{}`。 - -函数是一等值（first-class value）：它们可以赋值给变量，就像`add := binOp`一样。 - -这个变量知道自己指向的函数的签名，所以给它赋一个具有不同签名的函数值是不可能的。 - -函数值（functions value）之间可以相互比较：如果它们引用的是相同的函数或者都是nil的话，则认为它们是相同的函数。函数不能在其它函数里面声明（不能嵌套），不过我们可以通过使用匿名函数（参考[6.8节](06.8.md)）来破除这个限制。 - -目前Go没有泛型（generic）的概念，也就是说它不支持那种支持多种类型的函数。不过在大部分情况下可以通过接口（interface），特别是空接口与类型选择（type switch，参考[11.12节](11.12.md)）与/或者通过使用反射（reflection，参考[6.8节](06.8.md)）来实现相似的功能。使用这些技术将导致代码更为复杂、性能更为地下，所以在非常注意性能的的场合，最好是为每一个类型单独创建一个函数，而且代码可读性更强。 - -##链接 -- [目录](directory.md) -- 上一节：[函数](06.0.md) -- 下一节：[函数参数与返回值](06.2.md) \ No newline at end of file From 492fc77196627ba800e5eaba8d5a0f8a058d1264 Mon Sep 17 00:00:00 2001 From: chidouhu Date: Tue, 19 Nov 2013 17:56:29 +0800 Subject: [PATCH 3/6] add 7.1.md --- eBook/07.1.md | 87 +-------------------------------------------------- 1 file changed, 1 insertion(+), 86 deletions(-) diff --git a/eBook/07.1.md b/eBook/07.1.md index 0ba8d7d..40ae176 100644 --- a/eBook/07.1.md +++ b/eBook/07.1.md @@ -1,90 +1,5 @@ -#6.1 函数介绍 -每一个程序都包含很多的函数：函数是基本的代码块。 +#7.1 函数介绍 -Go是编译型语言，所以函数编写的顺序是无关紧要的；鉴于可读性的需求，最好把 main() 函数写在文件的前面，其他函数按照一定逻辑顺序进行编写（例如函数被调用的顺序）。 - -编写多个函数的主要目的是将一个需要很多行代码的复杂问题分解为一系列简单的任务（那就是函数）来解决。而且，同一个任务（函数）可以被调用多次，有助于代码重用。 - -（事实上，好的程序是非常注意DRY原则的，即不要重复你自己（Don't Repeat Yourself），意思是执行特定任务的代码只能在程序里面出现一次。） - -当函数执行到代码块最后一行（`}`之前）或者`return`语句的时候会退出，其中`return`语句可以带有零个或多个参数；这些参数将作为返回值（参考[6.2节](06.2.md)）供调用者使用。简单的`return`语句也可以用来结束for死循环，或者结束一个协程（goroutine）。 - -Go里面拥三种类型的函数： - -- 普通的带有名字的函数 -- 匿名函数或者lambda函数（参考[6.8节](06.8.md)） -- 方法（Methods，参考[10.6节](10.6.md)） - -所有类型的函数都可以有参数与返回值。函数参数、返回值以及它们的类型被统称为函数签名。 - -作为提醒，提前介绍一个语法： - -这样是不正确的Go代码： - - func g() - { - } - -它必须是这样的： - - func g() { - } - -函数被调用的基本格式如下： - - pack1.Function(arg1, arg2, …, argn) - -Function是pack1包里面的一个函数，括号里的是被调用函数的*实参*（argument）：这些值被传递给被调用函数的*形参*（parameter，参考[6.2节](06.2.md)）。函数被调用的时候，这些实参将被复制（简单而言）然后传递给被调用函数。函数一般是在其他函数里面被调用的，这个其他函数被称为调用函数（calling function）。函数能多次调用其他函数，这些被调用函数按顺序（简单而言）执行，理论上，函数调用其他函数的次数是无穷的（直到函数调用栈被耗尽）。 - -一个简单的函数调用其他函数的例子： - -示例 6.1 [greeting.go](examples/chapter_6/greeting.go) - - package main - - func main() { - println("In main before calling greeting") - greeting() - println("In main after calling greeting") - } - - func greeting() { - println("In greeting: Hi!!!!!") - } - -代码输出： - - In main before calling greeting - In greeting: Hi!!!!! - In main after calling greeting - -函数可以将其他函数调用作为它的参数，只要这个被调用函数的返回值个数、返回值类型和返回值的顺序与调用函数所需求的实参是一致的，例如： - -假设 f1 需要3个参数 `f1(a, b, c int)`，同时 f2 返回3个参数 `f2(a, b int) (int, int, int)`，就可以这样调用 f1：`f1(f2(a, b))` - -函数重载（function overloading）指的是可以编写多个同名函数，只要它们拥有不同的形参与/或者不同的返回值，在Go里面函数重载是不被允许的。这将导致一个编译错误： - - funcName redeclared in this book, previous declaration at lineno - -Go语言不支持这项特性的主要原因是函数重载需要进行多余的类型匹配影响性能；没有重载意味着只是一个简单的函数调度。所以你需要给不同的函数使用不同的名字，我们通常会根据函数的特征对函数进行命名（参考[11.12.5节](11.12.md)）。 - -如果需要申明一个在外部定义的函数，你只需要给出函数名与函数签名，不需要给出函数体： - - func flushICache(begin, end uintptr) // implemented externally - -**函数也可以以申明的方式被使用，作为一个函数类型**，就像： - - type binOp func(int, int) int - -在这里，不需要函数体`{}`。 - -函数是一等值（first-class value）：它们可以赋值给变量，就像`add := binOp`一样。 - -这个变量知道自己指向的函数的签名，所以给它赋一个具有不同签名的函数值是不可能的。 - -函数值（functions value）之间可以相互比较：如果它们引用的是相同的函数或者都是nil的话，则认为它们是相同的函数。函数不能在其它函数里面声明（不能嵌套），不过我们可以通过使用匿名函数（参考[6.8节](06.8.md)）来破除这个限制。 - -目前Go没有泛型（generic）的概念，也就是说它不支持那种支持多种类型的函数。不过在大部分情况下可以通过接口（interface），特别是空接口与类型选择（type switch，参考[11.12节](11.12.md)）与/或者通过使用反射（reflection，参考[6.8节](06.8.md)）来实现相似的功能。使用这些技术将导致代码更为复杂、性能更为地下，所以在非常注意性能的的场合，最好是为每一个类型单独创建一个函数，而且代码可读性更强。 ##链接 - [目录](directory.md) From 9dbd1c5d2a876355f554eff61bda304990ab68a0 Mon Sep 17 00:00:00 2001 From: chidouhu Date: Wed, 20 Nov 2013 14:50:00 +0800 Subject: [PATCH 4/6] modify 07.1.md --- eBook/examples/chapter_7/array_literals.go | 14 ++++++++ eBook/examples/chapter_7/array_slices.go | 32 +++++++++++++++++++ eBook/examples/chapter_7/array_sum.go | 16 ++++++++++ eBook/examples/chapter_7/copy_append_slice.go | 15 +++++++++ eBook/examples/chapter_7/make_slice.go | 17 ++++++++++ eBook/examples/chapter_7/multidim_array.go | 16 ++++++++++ eBook/examples/chapter_7/pointer_array.go | 10 ++++++ eBook/examples/chapter_7/pointer_array2.go | 10 ++++++ eBook/examples/chapter_7/reslicing.go | 17 ++++++++++ eBook/examples/chapter_7/slices_forrange.go | 15 +++++++++ 10 files changed, 162 insertions(+) create mode 100644 eBook/examples/chapter_7/array_literals.go create mode 100644 eBook/examples/chapter_7/array_slices.go create mode 100644 eBook/examples/chapter_7/array_sum.go create mode 100644 eBook/examples/chapter_7/copy_append_slice.go create mode 100644 eBook/examples/chapter_7/make_slice.go create mode 100644 eBook/examples/chapter_7/multidim_array.go create mode 100644 eBook/examples/chapter_7/pointer_array.go create mode 100644 eBook/examples/chapter_7/pointer_array2.go create mode 100644 eBook/examples/chapter_7/reslicing.go create mode 100644 eBook/examples/chapter_7/slices_forrange.go diff --git a/eBook/examples/chapter_7/array_literals.go b/eBook/examples/chapter_7/array_literals.go new file mode 100644 index 0000000..5b9ad34 --- /dev/null +++ b/eBook/examples/chapter_7/array_literals.go @@ -0,0 +1,14 @@ +package main +import "fmt" + +func main() { + // var arrAge = [5]int{18, 20, 15, 22, 16} + // var arrLazy = [...]int{5, 6, 7, 8, 22} + // var arrLazy = []int{5, 6, 7, 8, 22} + var arrKeyValue = [5]string{3: "Chris", 4: "Ron"} + // var arrKeyValue = []string{3: "Chris", 4: "Ron"} + + for i:=0; i < len(arrKeyValue); i++ { + fmt.Printf("Person at %d is %s\n", i, arrKeyValue[i]) + } +} diff --git a/eBook/examples/chapter_7/array_slices.go b/eBook/examples/chapter_7/array_slices.go new file mode 100644 index 0000000..de3ffdc --- /dev/null +++ b/eBook/examples/chapter_7/array_slices.go @@ -0,0 +1,32 @@ +package main +import "fmt" + +func main() { + var arr1 [6]int + var slice1 []int = arr1[2:5] // item at index 5 not included! + + // load the array with integers: 0,1,2,3,4,5 + for i := 0; i < len(arr1); i++ { + arr1[i] = i + } + + // print the slice + for i := 0; i < len(slice1); i++ { + fmt.Printf("Slice at %d is %d\n", i, slice1[i]) + } + + fmt.Printf("The length of arr1 is %d\n", len(arr1)) + fmt.Printf("The length of slice1 is %d\n", len(slice1)) + fmt.Printf("The capacity of slice1 is %d\n", cap(slice1)) + +// grow the slice + slice1 = slice1[0:4] + for i := 0; i < len(slice1); i++ { + fmt.Printf("Slice at %d is %d\n", i, slice1[i]) + } + fmt.Printf("The length of slice1 is %d\n", len(slice1)) + fmt.Printf("The capacity of slice1 is %d\n", cap(slice1)) + +// grow the slice beyond capacity + //slice1 = slice1[0:7 ] // panic: runtime error: slice bound out of range +} diff --git a/eBook/examples/chapter_7/array_sum.go b/eBook/examples/chapter_7/array_sum.go new file mode 100644 index 0000000..a1a3a7f --- /dev/null +++ b/eBook/examples/chapter_7/array_sum.go @@ -0,0 +1,16 @@ +package main +import "fmt" + +func main() { + array := [3]float64{7.0, 8.5, 9.1} + x := Sum(&array) // Note the explicit address-of operator + // to pass a pointer to the array + fmt.Printf("The sum of the array is: %f", x) +} + +func Sum(a *[3]float64) (sum float64) { + for _, v := range a { // derefencing *a to get back to the array is not necessary! + sum += v + } + return +} diff --git a/eBook/examples/chapter_7/copy_append_slice.go b/eBook/examples/chapter_7/copy_append_slice.go new file mode 100644 index 0000000..a20a291 --- /dev/null +++ b/eBook/examples/chapter_7/copy_append_slice.go @@ -0,0 +1,15 @@ +package main +import "fmt" + +func main() { + sl_from := []int{1, 2, 3} + sl_to := make([]int, 10) + + n := copy(sl_to, sl_from) + fmt.Println(sl_to) + fmt.Printf("Copied %d elements\n", n) // n == 3 + + sl3 := []int{1, 2, 3} + sl3 = append(sl3, 4, 5, 6) + fmt.Println(sl3) +} diff --git a/eBook/examples/chapter_7/make_slice.go b/eBook/examples/chapter_7/make_slice.go new file mode 100644 index 0000000..f7d9bf4 --- /dev/null +++ b/eBook/examples/chapter_7/make_slice.go @@ -0,0 +1,17 @@ +package main +import "fmt" + +func main() { + var slice1 []int = make([]int, 10) + // load the array/slice: + for i := 0; i < len(slice1); i++ { + slice1[i] = 5 * i + } + + // print the slice: + for i := 0; i < len(slice1); i++ { + fmt.Printf("Slice at %d is %d\n", i, slice1[i]) + } + fmt.Printf("\nThe length of slice1 is %d\n", len(slice1)) + fmt.Printf("The capacity of slice1 is %d\n", cap(slice1)) +} diff --git a/eBook/examples/chapter_7/multidim_array.go b/eBook/examples/chapter_7/multidim_array.go new file mode 100644 index 0000000..c787ec2 --- /dev/null +++ b/eBook/examples/chapter_7/multidim_array.go @@ -0,0 +1,16 @@ +package main +const ( + WIDTH = 1920 + HEIGHT = 1080 +) + +type pixel int +var screen [WIDTH][HEIGHT]pixel + +func main() { + for y := 0; y < HEIGHT; y++ { + for x := 0; x < WIDTH; x++ { + screen[x][y] = 0 + } + } +} diff --git a/eBook/examples/chapter_7/pointer_array.go b/eBook/examples/chapter_7/pointer_array.go new file mode 100644 index 0000000..6f5e9a4 --- /dev/null +++ b/eBook/examples/chapter_7/pointer_array.go @@ -0,0 +1,10 @@ +package main +import "fmt" +func f(a [3]int) { fmt.Println(a) } +func fp(a *[3]int) { fmt.Println(a) } + +func main() { + var ar [3]int + f(ar) // passes a copy of ar + fp(&ar) // passes a pointer to ar +} diff --git a/eBook/examples/chapter_7/pointer_array2.go b/eBook/examples/chapter_7/pointer_array2.go new file mode 100644 index 0000000..0096720 --- /dev/null +++ b/eBook/examples/chapter_7/pointer_array2.go @@ -0,0 +1,10 @@ +package main +import "fmt" + +func fp(a *[3]int) { fmt.Println(a) } + +func main() { + for i := 0; i < 3; i++ { + fp(&[3]int{i, i * i, i * i * i}) + } +} diff --git a/eBook/examples/chapter_7/reslicing.go b/eBook/examples/chapter_7/reslicing.go new file mode 100644 index 0000000..87fe45d --- /dev/null +++ b/eBook/examples/chapter_7/reslicing.go @@ -0,0 +1,17 @@ +package main +import "fmt" + +func main() { + slice1 := make([]int, 0, 10) + // load the slice, cap(slice1) is 10: + for i := 0; i < cap(slice1); i++ { + slice1 = slice1[0:i+1] + slice1[i] = i + fmt.Printf("The length of slice is %d\n", len(slice1)) + } + + // print the slice: + for i := 0; i < len(slice1); i++ { + fmt.Printf("Slice at %d is %d\n", i, slice1[i]) + } +} diff --git a/eBook/examples/chapter_7/slices_forrange.go b/eBook/examples/chapter_7/slices_forrange.go new file mode 100644 index 0000000..772a663 --- /dev/null +++ b/eBook/examples/chapter_7/slices_forrange.go @@ -0,0 +1,15 @@ +package main +import "fmt" + +func main() { + slice1 := make([]int, 4) + + slice1[0] = 1 + slice1[0] = 2 + slice1[0] = 3 + slice1[0] = 4 + + for ix, value := range slice1 { + fmt.Printf("Slice at %d is: %d\n", ix, value) + } +} From 9fa4f0072531513117e14293d794b8cf25a13ae3 Mon Sep 17 00:00:00 2001 From: chidouhu Date: Wed, 20 Nov 2013 15:30:06 +0800 Subject: [PATCH 5/6] 07.1.md --- eBook/07.1.md | 250 +++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 247 insertions(+), 3 deletions(-) diff --git a/eBook/07.1.md b/eBook/07.1.md index 40ae176..3d2d202 100644 --- a/eBook/07.1.md +++ b/eBook/07.1.md @@ -1,7 +1,251 @@ -#7.1 函数介绍 +#7.1 声明和初始化 +##7.1.1 概念 +数组是具有相同`唯一类型`的一组已编号且长度固定的数据项序列（这是一种同构的数据结构）；这种类型可以是任意的原始类型例如整形、字符串或者自定义类型。数组长度必须是一个常量表达式，并且必须是一个非负整数。数组长度也是数组类型的一部分，所以[5]int和[10]int是属于不同类型的。数组的编译时值初始化是按照数组顺序完成的（如下）。 + +**注意事项** +如果我们想让数组元素类型为任意类型的话可以使用空接口作为类型（参考[第11章](11.9.md)。当使用值时我们必须先做一个类型判断（参考[第11章](11.3.md)。 + +数组元素可以通过`索引`（位置）来读取（或者修改），索引从0开始，第一个元素索引为0，第二个索引为1，以此类推。（数组以0开始在所有类C语言中是相似的）。元素的数目，也称为`length`或者数组大小必须是固定的并且在声明该数组时就给出（编译时需要知道数组长度以便分配内存）；数组长度最大为2Gb。 + +声明的格式是： var identifier [len]type + +例如： var arr1 [5]int + +在内存中的结构是：![](images/7.1_fig7.1.png?raw=true) + +每个元素是一个整形值，当声明数组时所有的元素都会被自动初始化为默认值0. + +arr1的长度是5，索引范围从0到len(arr1)-1 + +第一个元素是arr1[0]，第3个元素是arr1[2]；总体来说索引i代表的元素是arr1[i]，最后一个元素是arr1[len(arr1)-1]。 + +对索引项为i的数组元素赋值可以这么操作：arr[i] = value，所以数组是`可变的`。 + +只有有效的索引可以被使用，当使用等于或者大于len(arr1)的索引时：如果编译器可以检测到，会给出索引超限的提示信息；如果检测不到的话编译会通过而运行时会panic:（参考[第13章](13.0.md) + +runtime error: index out of range + +由于索引的存在，遍历数组的方法自然就是使用for-construct: + +- 通过for初始化数组项 +- 通过for打印数组元素 +- 通过for依次处理元素 + +示例 7.1 [for_arrays.go](exmaples/chapter_7/for_arrays.go) + + package main + import "fmt" + + func main() { + var arr1 [5]int + + for i:=0; i < len(arr1); i++ { + arr1[i] = i * 2 + } + + for i:=0; i < len(arr1); i++ { + fmt.Printf("Array at index %d is %d\n", i, arr1[i]) + } + } + +输出结果： + + Array at index 0 is 0 + Array at index 1 is 2 + Array at index 2 is 4 + Array at index 3 is 6 + Array at index 4 is 8 + +for-loop中的条件非常重要：i < len(arr1)，如果写成i <= len(arr1)的话会产生越界错误。 + +IDIOM: + + for i:=0; i < len(arr1); i++｛ + arr1[i] = ... + } + +也可以使用for-range的生成方式： + +IDIOM: + + for i:= range arr1 { + ... + } + +在这里i也是数组的索引。当然这两种for-construct方式对于分片(slices)（参考[第7章](07.2.md)来说也同样适用。 + +**问题 7.1** 下面代码段的输出是什么？ + + a := [...]string{"a", "b", "c", "d"} + for i := range a { + fmt.Println("Array item", i, "is", a[i]) + } + +Go语言中的数组是一种`值类型`（不像C/C++中是指向首元素的指针），所以可以通过`new()`来创建： var arr1 = new([5]int) + +那么这种方式和var arr2 [5]int的区别是什么呢？arr1的类型是*[5]int，而arr2的类型是[5]int。 + +这样的结果就是当把一个数组赋值给另一个时，需要在做一次数组内存的拷贝操作。例如： + + arr := arr1 + arr2[2] = 100 + +这样两个数组就有了不同的值，在赋值后修改arr2不会对arr1生效。 + +所以在函数中数组作为参数传入时，如func1(arr1)，会产生一次数组拷贝，func1方法不会修改原始的数组arr1。 + +如果你想修改原数组，那么arr1必须通过&操作符以引用方式传过来，例如func1(&arr1），下面是一个例子 + +Example 7.2 [pointer_array.go](examples/chapter_7/pointer_array.go): + package main + import "fmt" + func f(a [3]int) { fmt.Println(a) } + func fp(a *[3]int) { fmt.Println(a) } + + func main() { + var ar [3]int + f(ar) // passes a copy of ar + fp(&ar) // passes a pointer to ar + } + +输出结果： + + [0 0 0] + &[0 0 0] + +另一种方法就是生成数组分片slice并将其传递给函数（参见传递数组参数给函数7.1.4节） + +**练习** + +练习7.1：array_value.go: 证明当数组赋值时，发生了数组内存拷贝。 +练习7.2：for_array.go: 写一个循环并用下标给数组赋值（从0到15）并且将数组打印在屏幕上。 +练习7.3：fibonacci_array.go: 在6.6节我们看到了一个递归计算Fibonacci数值的方法。但是通过数组我们可以更快的计算出Fibonacci数。完成该方法并打印出前50个Fibonacci数字。 + +##7.1.2 数组常量 +如果数组值已经提前知道了，那么可以通过`数组常量`的方法来初始化数组，而不用依次使用[]=方法。（所有的组成元素都有相同的常量语法） + +Example 7.3 [array_literals.go][examples/chapter_7/array_literals.go] + + package main + import "fmt" + + func main() { + // var arrAge = [5]int{18, 20, 15, 22, 16} + // var arrLazy = [...]int{5, 6, 7, 8, 22} + // var arrLazy = []int{5, 6, 7, 8, 22} + var arrKeyValue = [5]string{3: "Chris", 4: "Ron"} + // var arrKeyValue = []string{3: "Chris", 4: "Ron"} + + for i:=0; i < len(arrKeyValue); i++ { + fmt.Printf("Person at %d is %s\n", i, arrKeyValue[i]) + } + } + +第一种变化： var arrAge = [5]int{18, 20, 15, 22, 16} + +注意[5]int可以从左边起开始忽略：[10]int {1, 2, 3} :这是一个有10个元素的数组，除了前三个元素外其他元素都为0。 + +第二种变化： var arrLazy = [...]int{5, 6, 7, 8, 22} + +`...`可同样可以忽略，从技术上说它们其实变化成了slice。 + +第三种变化：key: value syntax + + var arrKeyValue = [5]string{3: "Chris", 4:＂Ron"} + +只有索引3和4被赋予实际的值，其他元素都被设置为空的字符串，所以输出结果为： + + Person at 0 is + Person at 1 is + Person at 2 is + Person at 3 is Chris + Person at 4 is Ron + +在这里数组长度同样可以写成`...`或者直接忽略。 + +你可以取任意数组常量的地址来作为指向新实例的指针。 + +Example 7.3 [pointer_array2.go][examples/chapter_7/pointer_array2.go] + + package main + import "fmt" + + func fp(a *[3]int) { fmt.Println(a) } + + func main() { + for i := 0; i < 3; i++ { + fp(&[3]int{i, i * i, i * i * i}) + } + } + +输出结果： + + &[0 0 0] + &[1 1 1] + &[2 4 8] + +几何点（或者数学向量）是一个使用数组的经典例子。为了简化代码通常使用一个别名： + + type Vector3D [3]float32 + var vec Vector3D + +## 7.1.3 多维数组 +数组通常是1维的，但是可以用来组装成多维数组，例如：[3][5]int，[2][2][2]float64 + +内部数组总是长度相同的。Go语言的多维数组是矩形式的（唯一的例外是分片slice的数组，参见7.2.5） + +Example 7.5 [multidim_array.go][examples/chapter_7/multidim_array.go] + + package main + const ( + WIDTH = 1920 + HEIGHT = 1080 + ) + + type pixel int + var screen [WIDTH][HEIGHT]pixel + + func main() { + for y := 0; y < HEIGHT; y++ { + for x := 0; x < WIDTH; x++ { + screen[x][y] = 0 + } + } + } + +## 7.1.4 将数组传递给函数 +把第一个大数组传递给函数会消耗很多内存。有两种方法可以避免这种现象： +- 传递数组的指针 +- 使用数组的分片slice + +接下来的例子阐明了第一种方法： + +Example 7.6 [array_sum.go][examples/chapter_7/array_sum.go] + + package main + import "fmt" + + func main() { + array := [3]float64{7.0, 8.5, 9.1} + x := Sum(&array) // Note the explicit address-of operator + // to pass a pointer to the array + fmt.Printf("The sum of the array is: %f", x) + } + + func Sum(a *[3]float64) (sum float64) { + for _, v := range a { // derefencing *a to get back to the array is not necessary! + sum += v + } + return + } + +输出结果： + The sum of the array is: 24.600000 + +但这在Go中并不常用，通常使用分片slice。（参考[第7章](07.2.md) ##链接 - [目录](directory.md) -- 上一节：[函数](06.0.md) -- 下一节：[函数参数与返回值](06.2.md) \ No newline at end of file +- 上一节：[数组与分片](07.0.md) +- 下一节：[分片slices](07.2.md) \ No newline at end of file From b8d6e4d46919b512b421c1a464e89f88ff815c1e Mon Sep 17 00:00:00 2001 From: chidouhu Date: Wed, 20 Nov 2013 15:59:00 +0800 Subject: [PATCH 6/6] modify embrace --- eBook/07.1.md | 23 +++++++++++++---------- eBook/images/7.1_fig7.1.png | Bin 13204 -> 14819 bytes 2 files changed, 13 insertions(+), 10 deletions(-) diff --git a/eBook/07.1.md b/eBook/07.1.md index 3d2d202..440ac33 100644 --- a/eBook/07.1.md +++ b/eBook/07.1.md @@ -4,7 +4,7 @@ 数组是具有相同`唯一类型`的一组已编号且长度固定的数据项序列（这是一种同构的数据结构）；这种类型可以是任意的原始类型例如整形、字符串或者自定义类型。数组长度必须是一个常量表达式，并且必须是一个非负整数。数组长度也是数组类型的一部分，所以[5]int和[10]int是属于不同类型的。数组的编译时值初始化是按照数组顺序完成的（如下）。 **注意事项** -如果我们想让数组元素类型为任意类型的话可以使用空接口作为类型（参考[第11章](11.9.md)。当使用值时我们必须先做一个类型判断（参考[第11章](11.3.md)。 +如果我们想让数组元素类型为任意类型的话可以使用空接口作为类型（参考[第11章](11.9.md)）。当使用值时我们必须先做一个类型判断（参考[第11章](11.3.md)）。 数组元素可以通过`索引`（位置）来读取（或者修改），索引从0开始，第一个元素索引为0，第二个索引为1，以此类推。（数组以0开始在所有类C语言中是相似的）。元素的数目，也称为`length`或者数组大小必须是固定的并且在声明该数组时就给出（编译时需要知道数组长度以便分配内存）；数组长度最大为2Gb。 @@ -22,9 +22,9 @@ arr1的长度是5，索引范围从0到len(arr1)-1 对索引项为i的数组元素赋值可以这么操作：arr[i] = value，所以数组是`可变的`。 -只有有效的索引可以被使用，当使用等于或者大于len(arr1)的索引时：如果编译器可以检测到，会给出索引超限的提示信息；如果检测不到的话编译会通过而运行时会panic:（参考[第13章](13.0.md) +只有有效的索引可以被使用，当使用等于或者大于len(arr1)的索引时：如果编译器可以检测到，会给出索引超限的提示信息；如果检测不到的话编译会通过而运行时会panic:（参考[第13章](13.0.md)） -runtime error: index out of range + runtime error: index out of range 由于索引的存在，遍历数组的方法自然就是使用for-construct: @@ -73,7 +73,7 @@ IDIOM: ... } -在这里i也是数组的索引。当然这两种for-construct方式对于分片(slices)（参考[第7章](07.2.md)来说也同样适用。 +在这里i也是数组的索引。当然这两种for-construct方式对于分片(slices)（参考[第7章](07.2.md)）来说也同样适用。 **问题 7.1** 下面代码段的输出是什么？ @@ -98,6 +98,7 @@ Go语言中的数组是一种`值类型`（不像C/C++中是指向首元素的 如果你想修改原数组，那么arr1必须通过&操作符以引用方式传过来，例如func1(&arr1），下面是一个例子 Example 7.2 [pointer_array.go](examples/chapter_7/pointer_array.go): + package main import "fmt" func f(a [3]int) { fmt.Println(a) } @@ -108,7 +109,7 @@ Example 7.2 [pointer_array.go](examples/chapter_7/pointer_array.go): f(ar) // passes a copy of ar fp(&ar) // passes a pointer to ar } - + 输出结果： [0 0 0] @@ -119,13 +120,15 @@ Example 7.2 [pointer_array.go](examples/chapter_7/pointer_array.go): **练习** 练习7.1：array_value.go: 证明当数组赋值时，发生了数组内存拷贝。 + 练习7.2：for_array.go: 写一个循环并用下标给数组赋值（从0到15）并且将数组打印在屏幕上。 + 练习7.3：fibonacci_array.go: 在6.6节我们看到了一个递归计算Fibonacci数值的方法。但是通过数组我们可以更快的计算出Fibonacci数。完成该方法并打印出前50个Fibonacci数字。 ##7.1.2 数组常量 如果数组值已经提前知道了，那么可以通过`数组常量`的方法来初始化数组，而不用依次使用[]=方法。（所有的组成元素都有相同的常量语法） -Example 7.3 [array_literals.go][examples/chapter_7/array_literals.go] +Example 7.3 [array_literals.go](examples/chapter_7/array_literals.go) package main import "fmt" @@ -166,7 +169,7 @@ Example 7.3 [array_literals.go][examples/chapter_7/array_literals.go] 你可以取任意数组常量的地址来作为指向新实例的指针。 -Example 7.3 [pointer_array2.go][examples/chapter_7/pointer_array2.go] +Example 7.4 [pointer_array2.go](examples/chapter_7/pointer_array2.go) package main import "fmt" @@ -195,7 +198,7 @@ Example 7.3 [pointer_array2.go][examples/chapter_7/pointer_array2.go] 内部数组总是长度相同的。Go语言的多维数组是矩形式的（唯一的例外是分片slice的数组，参见7.2.5） -Example 7.5 [multidim_array.go][examples/chapter_7/multidim_array.go] +Example 7.5 [multidim_array.go](examples/chapter_7/multidim_array.go) package main const ( @@ -221,7 +224,7 @@ Example 7.5 [multidim_array.go][examples/chapter_7/multidim_array.go] 接下来的例子阐明了第一种方法： -Example 7.6 [array_sum.go][examples/chapter_7/array_sum.go] +Example 7.6 [array_sum.go](examples/chapter_7/array_sum.go) package main import "fmt" @@ -243,7 +246,7 @@ Example 7.6 [array_sum.go][examples/chapter_7/array_sum.go] 输出结果： The sum of the array is: 24.600000 -但这在Go中并不常用，通常使用分片slice。（参考[第7章](07.2.md) +但这在Go中并不常用，通常使用分片slice。（参考[第7章](07.2.md)） ##链接 - [目录](directory.md) diff --git a/eBook/images/7.1_fig7.1.png b/eBook/images/7.1_fig7.1.png index f34140e73acee2f54d0c992db1d52879af65003c..292bd47f16e360463589ac92fa2fde196f204771 100644 GIT binary patch literal 14819 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 I#3<;00VuD4FaQ7m literal 13204 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 F{{U|PWa9t;