Go语言基础

男娘i 2024-03-23 12:36 61阅读 0赞

**目录**

Go语言特性

第一个Go程序

Go语言基础

常量

变量

数据类型

整型

浮点型

字符串

格式化字符串

字符类型

切片

包

总结

--------------------

### Go语言特性 ###

**并发编程**

Go 语言引入了 **`goroutine`**，它是 Go 实现快速高效的并发编程的关键。

**错误处理**

Go 语言中的错误处理的哲学和 C 语言一样，函数通过返回错误类型 (`error`) 或者 `bool` 类型（不需要区分多种错误状态时）表明函数的执行结果，调用检查返回的错误类型值是否是 `nil` 来判断调用结果。并引入了 defer 关键字用于标准的错误处理流程，并提供了内置函数 `panic`、`recover` 完成异常的抛出与捕捉。

**垃圾回收**

Go 语言自带垃圾自动回收的功能，让 Go 语言不需要 `delete` 关键字，也不需要 `free()` 来释放内存。因此开发者无需考虑何时需要释放之前分配的内存的问题，系统会自动帮我们判断，并在适当的时候进行垃圾处理。垃圾自动回收是 Go 语言的一个特点，也是一大亮点。

**多返回值**

Go 语言和 Python 一样也支持函数的多返回值功能，这个特性让开发者可以从原来用各种比较别扭的方式返回多个值得痛苦中解脱出来，不需要为了一次返回多个值而专门定义一个结构体。并且每个返回值都有自己的名字，开发者还可以选择具体需要返回的值，只需要使用下划线作为占位符来丢掉不要的返回值即可。

**匿名函数**

Go 语言支持常规的匿名函数和闭包，开发者可以随意对匿名函数变量进行传递和调用，下面就是一个匿名函数样例：

f := func(x,y int) int {
        return x+y
    }

#### 第一个Go程序 ####

第一个例子当然是 `HelloWorld` 了，让我们通过一个 Go 语言版本的 HelloWorld 来认识这门新语言的模样。

新建 `hello.go` 文件，输入以下代码保存：

package main
    
    import (
        "fmt" //导入fmt包，调用其中的Println()函数
    )
    
    func main() {
        fmt.Println("Hello，world！")
    }

### Go语言基础 ###

#### **常量** ####

const limit = 512
    const top uint16 = 1421
    const Pi float64 = 3.1415926
    const x,y int = 1,3 //多重赋值

当需要设置多个常量的时候，不必重复使用 `const` 关键字，可以使用以下语法：

const (
        Cyan = 0
        Black = 1
        White = 2
    )

Go 语言还预定义了这些常量：**`true`、`false`、`iota`**。

每出现一次iota，代表数字自动加 1。下面通过一个例子讲解 `iota` 的用法：

const (
        a = iota  //a == 0
        b = iota  //b ==1
        c = iota  //c == 2
    )
    
    const d = iota //d==0,因为const的出现，iota被重置为0

#### **变量** ####

Go 语言引入了关键字 `var` 对变量进行声明，也可以使用 `:=` 来对变量直接进行初始化，Go 编译器会自动推导出该变量的类型，这大大的方便了开发者的工作。但是需要注意的是 `:=` 左侧的变量不能是已经被声明过的，否则会导致编译器错误。

以下是 Go 声明和初始化变量的各种方法：

var a int
    var b string
    var c float64
    var d [5] int  //数组
    var e [] int   //数组切片
    var f * int    //正确
    var v1 int = 5 //正确
    var v2 = 5     //正确，编译器自动推导出V2类型
    v3 := 5        //正确，编译器自动推导出V3的类型

**多重赋值**

Go 语言提供了大多数语言不支持的多重赋值，这使得变量的交换变得十分简单。下面通过一个例子来了解 Go 语言的多重赋值：

i := 2
    j := 3
    i, j = j, i  //交换i和j的值，此时i == 3，j == 2

这样的方式可以一行代码实现变量的交换，明显的减少代码的行数，而不需要像 C/C++ 那样引入一个中间变量。

### 数据类型 ###

#### **整型** ####

Go 语言提供了 11 种整型，如下列表所示。

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>byte</code></td> 
   <td>等同于 uint8</td> 
  </tr> 
  <tr> 
   <td><code>int</code></td> 
   <td>依赖于不同平台下的实现，可以是 int32 或者 int64</td> 
  </tr> 
  <tr> 
   <td><code>int8</code></td> 
   <td>[-128, 127]</td> 
  </tr> 
  <tr> 
   <td><code>int16</code></td> 
   <td>[-32768, 32767]</td> 
  </tr> 
  <tr> 
   <td><code>int32</code></td> 
   <td>[-2147483648, 2147483647]</td> 
  </tr> 
  <tr> 
   <td><code>int64</code></td> 
   <td>[-9223372036854775808, 9223372036854775807]</td> 
  </tr> 
  <tr> 
   <td><code>rune</code></td> 
   <td>等同于 int32</td> 
  </tr> 
  <tr> 
   <td><code>uint</code></td> 
   <td>依赖于不同平台下的实现，可以是 uint32 或者 uint64</td> 
  </tr> 
  <tr> 
   <td><code>uint8</code></td> 
   <td>[0, 255]</td> 
  </tr> 
  <tr> 
   <td><code>uint16</code></td> 
   <td>[0, 65535]</td> 
  </tr> 
  <tr> 
   <td><code>uint32</code></td> 
   <td>[0, 4294967295]</td> 
  </tr> 
  <tr> 
   <td><code>uint64</code></td> 
   <td>[0, 18446744073709551615]</td> 
  </tr> 
  <tr> 
   <td><code>uintptr</code></td> 
   <td>一个可以恰好容纳指针值的无符号整型（对 32 位平台是 uint32, 对 64 位平台是 uint64）</td> 
  </tr> 
 </tbody> 
</table>

在 `C` 语言中我们可以通过 `sizeof` 操作符查看类型的字节长度，在 Go 语言中可以通过 `unsafe.Sizeof` 函数进行，创建源文件 `type_length.go`，输入以下代码：

package main
    
    import (
        "fmt"
        "unsafe"
    )
    
    func main() {
        a := 12
        fmt.Println("length of a: ", unsafe.Sizeof(a))
        var b int = 12
        fmt.Println("length of b(int): ", unsafe.Sizeof(b))
        var c int8 = 12
        fmt.Println("length of c(int8): ", unsafe.Sizeof(c))
        var d int16 = 12
        fmt.Println("length of d(int16): ", unsafe.Sizeof(d))
        var e int32 = 12
        fmt.Println("length of e(int32): ", unsafe.Sizeof(e))
        var f int64 = 12
        fmt.Println("length of f(int64): ", unsafe.Sizeof(f))
    }

> 以上代码中，首先声明了目前的源文件属于 `main` 包，然后导入了 `fmt` 和 `unsafe` 包，`fmt` 包用于格式化字符串，`unsafe` 包含了用于获取 Go 语言类型信息的方法。然后在 `main()` 函数中，我们分别声明了几种类型的整型变量，并通过 `unsafe.Sizeof` 方法获取该类型的字节长度。

输出：

$ go run type_length.go
    length of a:  8
    length of b(int):  8
    length of c(int8):  1
    length of d(int16):  2
    length of e(int32):  4
    length of f(int64):  8

#### 浮点型 ####

Go 语言提供了两种浮点类型和两种复数类型，具体如下：

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>float32</td> 
   <td>±3.402 823 466 385 288 598 117 041 834 845 169 254 40x1038 计算精度大概是小数点后 7 个十进制数</td> 
  </tr> 
  <tr> 
   <td>float64</td> 
   <td>±1.797 693 134 862 315 708 145 274 237 317 043 567 981x1038 计算精度大概是小数点后 15 个十进制数</td> 
  </tr> 
  <tr> 
   <td>complex32</td> 
   <td>复数，实部和虚部都是 float32</td> 
  </tr> 
  <tr> 
   <td>complex64</td> 
   <td>复数，实部和虚部都是 float64</td> 
  </tr> 
 </tbody> 
</table>

**布尔类型**

Go 语言提供了内置的布尔值 `true` 和`false`。Go 语言支持标准的逻辑和比较操作，这些操作的结果都是布尔值。值得注意的地方是可以通过 `!b` 的方式反转变量 `b` 的真假。需要注意的是布尔类型不能接受其他类型的赋值，不支持自动或强制的类型转换。实例代码如下：

var a bool
    a = true
    b := (2 == 3) //b也会被推导为bool类型
    
    //错误示范
    var b bool
    b = 1 //编译错误
    b = bool(1) //编译错误

#### 字符串 ####

Go 语言中的字符串是 [UTF-8][] 字符的一个序列（当字符为 ASCII 码时则占用 1 个字节，其它字符根据需要占用 2-4 个字节）。UTF-8 是被广泛使用的编码格式，是文本文件的标准编码，其它包括 XML 和 JSON 在内，也都使用该编码。由于该编码对占用字节长度的不定性，Go 中的字符串也可能根据需要占用 1 至 4 个字节，这与其它语言如 C++、Java 或者 Python 不同。Go 这样做的好处是不仅减少了内存和硬盘空间占用，同时也不用像其它语言那样需要对使用 UTF-8 字符集的文本进行编码和解码。

Go 语言中字符串的可以使用**双引号 (`"`)** 或者**反引号 (**``` ``) 来创建。双引号用来创建可解析的字符串字面量，所谓可解析的是指字符串中的一些符号可以被格式化为其他内容，如```\\n 在输出时候会被格式化成换行符，如果需要按照原始字符输出必须进行转义。而反引号创建的字符串原始是什么样，那输出还是什么，不需要进行任何转义。以下是几个例子：

t1 := "\"hello\""             //内容： "hello"
    t2 := `"hello"`               //内容：和t1一致
    t3 := "\u6B22\u8FCE"          //内容：欢迎

Go 语言中的部分转义字符如下表所示：

<table> 
 <thead> 
  <tr> 
   <th>转义字符</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>\\</code></td> 
   <td>表示反斜线</td> 
  </tr> 
  <tr> 
   <td><code>\'</code></td> 
   <td>单引号</td> 
  </tr> 
  <tr> 
   <td><code>\"</code></td> 
   <td>双引号</td> 
  </tr> 
  <tr> 
   <td><code>\n</code></td> 
   <td>换行符</td> 
  </tr> 
  <tr> 
   <td><code>\uhhhh</code></td> 
   <td>4 个 16 进制数字给定的 Unicode 字符</td> 
  </tr> 
 </tbody> 
</table>

在 Go 语言中单个字符可以使用单引号 (`'`) 来创建。之前的课程中，我们有学习过 `rune` 类型，它等同于 `int32`，在 Go 语言中，一个单一的字符可以用一个单一的 `rune` 来表示。这也是容易理解的，因为 Go 语言的字符串是 UTF-8 编码，其底层使用 4 个字节表示，也就是 32 bit。

在 Go 语言中，字符串支持切片操作，但是需要注意的是如果字符串都是由 ASCII 字符组成，那可以随便使用切片进行操作，但是如果字符串中包含其他非 ASCII 字符，直接使用切片获取想要的单个字符时需要十分小心，因为对字符串直接使用切片时是通过字节进行索引的，但是非 ASCII 字符在内存中可能不是由一个字节组成。如果想对字符串中字符依次访问，可以使用 `range` 操作符。另外获取字符串的长度可能有两种含义，一种是指获取字符串的字节长度，一种是指获取字符串的字符数量。字符串支持以下操作：

<table> 
 <thead> 
  <tr> 
   <th>语法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>s += t</code></td> 
   <td>将字符串 t 追加到 s 末尾</td> 
  </tr> 
  <tr> 
   <td><code>s + t</code></td> 
   <td>将字符串 s 和 t 级联</td> 
  </tr> 
  <tr> 
   <td><code>s[n]</code></td> 
   <td>从字符串 s 中索引位置为 n 处的原始字节</td> 
  </tr> 
  <tr> 
   <td><code>s[n:m]</code></td> 
   <td>从位置 n 到位置 <code>m-1</code> 处取得的字符（字节）串</td> 
  </tr> 
  <tr> 
   <td><code>s[n:]</code></td> 
   <td>从位置 n 到位置 <code>len(s)-1</code> 处取得的字符（字节）串</td> 
  </tr> 
  <tr> 
   <td><code>s[:m]</code></td> 
   <td>从位置 0 到位置 <code>m-1</code> 处取得的字符（字节）串</td> 
  </tr> 
  <tr> 
   <td><code>len(s)</code></td> 
   <td>字符串 s 中的字节数</td> 
  </tr> 
  <tr> 
   <td><code>len([]rune(s))</code></td> 
   <td>字符串 s 中字符的个数，可以使用更快的方法 <code>utf8.RuneCountInString()</code></td> 
  </tr> 
  <tr> 
   <td><code>[]rune(s)</code></td> 
   <td>将字符串 s 转换为一个 unicode 值组成的串</td> 
  </tr> 
  <tr> 
   <td><code>string(chars)</code></td> 
   <td>chars 类型是 <code>[]rune</code> 或者 <code>[]int32</code>, 将之转换为字符串</td> 
  </tr> 
  <tr> 
   <td><code>[]byte(s)</code></td> 
   <td>无副本的将字符串 s 转换为一个原始的字节的切片数组，不保证转换的字节是合法的 UTF-8 编码字节</td> 
  </tr> 
 </tbody> 
</table>

创建源文件 `string_t.go`，然后输入以下源代码：

package main
    
    import (
        "fmt"
    )
    
    func main() {
        t0 := "\u6B22\u8FCE\u6765\u5230" // t0内容：欢迎来到
        t1 := "\u5B9E\u9A8C\u697C"       // t1内容：实验楼
        t2 := t0 + t1
        for index, char := range t2 {
            fmt.Printf("%-2d    %U      '%c'    %X      %d\n",
                index, char, char, []byte(string(char)), len([]byte(string(char))))
        }
        fmt.Printf("length of t0: %d, t1: %d, t2: %d\n", len(t0), len(t1), len(t2))
        fmt.Printf("content of t2[0:2] is: %X\n", t2[0:2])
    }

然后通过以下方式运行，在这里一起显示了程序的输出：

$ go run string_t.go
    0     U+6B22      '欢'    E6ACA2      3
    3     U+8FCE      '迎'    E8BF8E      3
    6     U+6765      '来'    E69DA5      3
    9     U+5230      '到'    E588B0      3
    12    U+5B9E      '实'    E5AE9E      3
    15    U+9A8C      '验'    E9AA8C      3
    18    U+697C      '楼'    E6A5BC      3
    length of t0: 12, t1: 9, t2: 21
    content of t2[0:2] is: E6AC

说明：

> 通过前面的课程我们知道通过 `\uhhhh` 的方式我们可以通过创建 Unicode 字符。
> 
> 在以上程序中，首先通过 `:=` 符号创建了变量 `t0`，其值为 `\u6B22\u8FCE\u6765\u5230`，是 `欢迎来到` 中文字符的 unicode 编码，然后以同样的方式创建了变量 `t1`，其值为 `实验楼`，然后通过 `+` 操作符将 `t0` 和`t1` 拼接赋值给 `t2`。然后我们通过 `range` 操作符号对 unicode 字符串 `t2` 中的每一个 unicode 字符依次操作，我们这里只是简单的打印出每个字符在 `t2` 中的位置，每个字符的 unicode 码值，每个字符的字面量，每个字符的十六进制值，以及每个字符的字节长度。
> 
> 这里我们使用 `fmt` 包种支持的格式指令，如果读者学习过 C 语言的话就一目了然。接着，我们通过 `len` 操作符计算出了每个字符串的字节长度。最后，我们使用切片访问了字符串 `t2` 的第 0-1 个字节，也就是前两个字节，其内容为 `E6AC`。前面我们说到不能使用切片的方式访问非 ASCII 字符串中的字符，原因在这里一目了然。字符 `欢` 其底层使用了三个字节表示，内容是 `E6ACA2`，如果只是简单的使用切片（只取切片中的一项）访问的是不能访问到整个字符的，因为字符的切片是通过字节数来索引的。

#### 格式化字符串 ####

Go 语言标准库中的 `fmt` 包提供了打印函数将数据以字符串形式输出到控制台，文件，其他满足 `io.Writer` 接口的值以及其他字符串。目前为止我们使用了 `fmt.Printf` 和 `fmt.Println`，对于前者的使用，就像 C 语言中的 `printf` 函数一样，我们可以提供一些格式化指令，让 Go 语言对输出的字符串进行格式化。同样的我们可以使用一些格式化修饰符，改变格式化指令的输出结果， 如左对齐等。常用的格式化指令如下：

<table> 
 <thead> 
  <tr> 
   <th>格式化指令</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>%%</code></td> 
   <td>% 字面量</td> 
  </tr> 
  <tr> 
   <td><code>%b</code></td> 
   <td>一个二进制整数，将一个整数格式化为二进制的表达方式</td> 
  </tr> 
  <tr> 
   <td><code>%c</code></td> 
   <td>一个 Unicode 的字符</td> 
  </tr> 
  <tr> 
   <td><code>%d</code></td> 
   <td>十进制数值</td> 
  </tr> 
  <tr> 
   <td><code>%o</code></td> 
   <td>八进制数值</td> 
  </tr> 
  <tr> 
   <td><code>%x</code></td> 
   <td>小写的十六进制数值</td> 
  </tr> 
  <tr> 
   <td><code>%X</code></td> 
   <td>大写的十六进制数值</td> 
  </tr> 
  <tr> 
   <td><code>%U</code></td> 
   <td>一个 Unicode 表示法表示的整形码值，默认是 4 个数字字符</td> 
  </tr> 
  <tr> 
   <td><code>%s</code></td> 
   <td>输出以原生的 UTF-8 字节表示的字符，如果 console 不支持 UTF-8 编码，则会输出乱码</td> 
  </tr> 
  <tr> 
   <td><code>%t</code></td> 
   <td>以 true 或者 false 的方式输出布尔值</td> 
  </tr> 
  <tr> 
   <td><code>%v</code></td> 
   <td>使用默认格式输出值，或者使用类型的 String() 方法输出的自定义值，如果该方法存在的话</td> 
  </tr> 
  <tr> 
   <td>%T</td> 
   <td>输出值的类型</td> 
  </tr> 
 </tbody> 
</table>

常用的格式化指令修饰符如下：

*  **`空白`** 如果输出的数字为负，则在其前面加上一个减号 `-`。如果输出的是整数，则在前面加一个空格。使用 `%x` 或者 `%X` 格式化指令输出时，会在结果之间添加一个空格。例如 `fmt.Printf("% X", "实")` 输出 E5 AE 9E。
 *      #
    
     *  `%#o` 输出以 `0` 开始的八进制数据。
     *  `%#x` 输出以 `0x` 开始的十六进制数据。
 *  `+` 让格式化指令在数值前面输出 `+` 号或者 `-` 号，为字符串输出 ASCII 字符（非 ASCII 字符会被转义），为结构体输出其字段名。
 *  `-` 让格式化指令将值向左对齐（默认值为像右对齐）。
 *  `0` 让格式指令以数字 0 而非空白进行填充。

创建源文件 `fmt_t.go`，输入以下源码：

package main
    
    import (
        "fmt"
    )
    
    func main() {
        text := "\u5B9E\u9A8C\u697C"
        fmt.Printf("bool output:\n%t\n%t\n\n", true, false)
        fmt.Println("number output, origin value: 64")
        fmt.Printf("|%b|%8b|%-8b|%08b|% 8b|\n", 64, 64, 64, 64, 64)
        fmt.Printf("|%x|%8x|%-8x|%08X|% 8X|\n\n", 64, 64, 64, 64, 64)
        fmt.Println(`text output, origin value: \u5B9E\u9A8C\u697C`)
        fmt.Printf("content: %s\n", text)
        fmt.Printf("hex value: % X\nUnicode value: ", text)
        for _, char := range text {
            fmt.Printf("%U ", char)
        }
        fmt.Println()
        bytes := []byte(text)
        fmt.Printf("value of bytes: %s\n", bytes)
        fmt.Printf("hex value of bytes: % X\n", bytes)
        fmt.Printf("origin value of bytes: %v\n", bytes)
    
    }

运行代码，输出如下：

$ go run fmt_t.go
    bool output:
    true
    false
    
    number output, origin value: 64
    |1000000| 1000000|1000000 |01000000| 1000000|
    |40|      40|40      |00000040|      40|
    
    text output, origin value: \u5B9E\u9A8C\u697C
    content: 实验楼
    hex value: E5 AE 9E E9 AA 8C E6 A5 BC
    Unicode value: U+5B9E U+9A8C U+697C
    value of bytes: 实验楼
    hex value of bytes: E5 AE 9E E9 AA 8C E6 A5 BC
    origin value of bytes: [229 174 158 233 170 140 230 165 188]

#### 字符类型 ####

在 Go 语言中支持两个字符类型，一个是 `Byte`（实际上是 Unit8 的别名），代表 UTF-8 字符串的单个字节的值；另一个是 `rune`，代表单个 Unicode 字符。

处于简化语言的考虑，Go 语言的多数 API 都假设字符串为 UTF-8 编码。尽管 Unicode 字符在标准库中有支持，但实际很少使用。

数组

Go 语言的数组是一个定长的序列，其中的元素类型相同。多维数组可以简单地使用自身为数组的元素来创建。数组的元素使用操作符号 `[ ]` 来索引，索引从 `0` 开始，到 `len(array)-1` 结束。数组使用以下语法创建：

*  **`[length]Type`**
 *  **`[N]Type{value1, value2, ..., valueN}`**
 *  **`[...]Type{value1, value2, ..., valueN}`**

如果使用了 `...`（省略符）操作符，Go 语言会为我们自动计算数组的长度。在任何情况下，一个数组的长度都是固定的并且不可修改。数组的长度可以使用 `len()` 函数获得。由于数组的长度是固定的，因此数组的长度和容量都是一样的，因此对于数组而言 `cap()` 和 `len()` 函数返回值都是一样的。数组也可以使用和切片一样的语法进行切片，只是其结果为一个切片，而非数组。同样的，数组也可以使用 `range` 进行索引访问。

#### 切片 ####

一般而言，Go 语言的切片比数组更加灵活，强大而且方便。数组是按值传递的（即是传递的副本），而切片是引用类型，传递切片的成本非常小，而且是不定长的。而且数组是定长的，而切片可以调整长度。创建切片的语法如下：

*  **`make([ ]Type, length, capacity)`**
 *  **`make([ ]Type, length)`**
 *  **`[ ]Type{}`**
 *  **`[ ]Type{value1, value2, ..., valueN}`**

内置函数 `make()` 用于创建切片、映射和通道。当用于创建一个切片时，它会创建一个隐藏的初始化为零值的数组，然后返回一个引用该隐藏数组的切片。该隐藏的数组与 Go 语言中的所有数组一样，都是固定长度，如果使用第一种语法创建，那么其长度为切片的容量 `capacity`；如果是第二种语法，那么其长度记为切片的长度 `length`。一个切片的容量即为隐藏数组的长度，而其长度则为不超过该容量的任意值。另外可以通过内置的函数 `append()` 来增加切片的容量。切片可以支持以下操作：

创建源文件 `slice_array.go`，输入以下代码：

package main
    
    import (
        "fmt"
    )
    
    func main() {
        a := [...]int{1, 2, 3, 4, 5, 6, 7}
        fmt.Printf("len and cap of array %v is: %d and %d\n", a, len(a), cap(a))
        fmt.Printf("item in array: %v is:", a)
        for _, value := range a {
            fmt.Printf("% d", value)
        }
    
        fmt.Println()
    
        s1 := a[3:6]
        fmt.Printf("len and cap of slice: %v is: %d and %d\n", s1, len(s1), cap(s1))
        fmt.Printf("item in slice: %v is:", s1)
        for _, value := range s1 {
            fmt.Printf("%d", value)
        }
    
        fmt.Println()
    
        s1[0] = 456
        fmt.Printf("item in array changed after changing slice: %v is:", s1)
        for _, value := range a {
            fmt.Printf("%d", value)
        }
    
        fmt.Println()
    
        s2 := make([]int, 10, 20)
        s2[4] = 5
        fmt.Printf("len and cap of slice: %v is: %d and %d\n", s2, len(s2), cap(s2))
        fmt.Printf("item in slice %v is:", s2)
        for _, value := range s2 {
            fmt.Printf("%d", value)
        }
    
        fmt.Println()
    }

> 以上代码中，我们首先创建了一个数组，数组的长度是由 Go 语言自动计算出的（省略号语法），然后通过切片操作从数组 `a` 中创建了切片 `s1`，接着我们修改了该切片的第一个位置的数值，然后发现数组 `a` 中的值也发生了变化。最后我们通过 `make()` 函数创建了一个切片，该切片的长度和容量分别为 10 和 20，还可以发现 Go 语言将未初始化的项自动赋予零值。

运行代码输出如下：

$  go run slice_array.go
    len and cap of array [1 2 3 4 5 6 7] is: 7 and 7
    item in array: [1 2 3 4 5 6 7] is: 1 2 3 4 5 6 7
    len and cap of slice: [4 5 6] is: 3 and 4
    item in slice: [4 5 6] is: 4 5 6
    item in array changed after changing slice: [456 5 6] is: 1 2 3 456 5 6 7
    len and cap of slice: [0 0 0 0 5 0 0 0 0 0] is: 10 and 20
    item in slice [0 0 0 0 5 0 0 0 0 0] is: 0 0 0 0 5 0 0 0 0 0

### 包 ###

前面我们了解过 Go 语言组织代码的方式是包，包是各种类型和函数的集合。在包中，如果标示符（类型名称，函数名称，方法名称）的首字母是大写，那这些标示符是可以被导出的，也就是说可以在包以外直接使用。前面我们也提到了 `$GOPATH` 环境变量（指向一个或多个目录），以及其子目录 `src` 目录的，当我们使用 `import` 关键字导入包的时候，Go 语言会在 `$GOPATH` 和 `GOROOT` 目录中搜索包。

我们创建的自定义的包最好放在 `$GOPATH` 的 `src` 目录下，如果这个包只属于某个应用程序，可以直接放在应用程序源代码的子目录下，但如果我们希望这个包可以被其他的应用程序共享，那就应该放在 `$GOPATH` 的 `src` 目录下，每个包单独放在一个目录里，如果两个不同的包放在同一目录下，会出现名字冲突的编译错误。作为惯例，包的源代码应该放在一个同名的文件夹下面。同一个包可以有任意多的源文件，文件名的名字也没有任何规定。

### 总结 ###

回顾本节内容主要包含以下知识点：

*  常量
 *  变量
 *  数据类型
 *  数组和切片
 *  包

[UTF-8]: http://zh.wikipedia.org/wiki/UTF-8