2.4 Go与包

1.1Go与包

1.1.1.  Go与包

1）开发中，往往要在不同的文件中调用其他文件的函数

2）Go代码最小粒度单位是"包"

3）Go的每一个文件都属于一个包，通过package管理

4）Go以包的形式管理文件和项目目录结构

5）包的命名不要和保留名称重复

6）编译可执行文件，必须包含package main，入口函数为main()

1.1.2. Go包的作用

1）区分同名的函数、变量等标识符

2）管理项目程序文件

3）控制函数、变量访问作用域

4）Go包中的变量，以首字母大小写决定是否可以被导出(public)，如Foo可以被导出，foo则不行(internal)

5）因此，在导入一个外部包后，能够，且只能够访问该包中导出的对象。

假设在包 pack1 中我们有一个变量或函数叫做 Thing（以 T 开头，是大写开头的，所以它能够被导出）

那么在当前包中导入 pack1 包，Thing 就可以像面向对象语言那样使用点标记来调用：

pack1.Thing //（pack1 在这里是不可以省略的）

6）不得导入未使用的包，编译器不通过

1.1.3. Go包目录结构

gostudy
    |
    +--- bin                 // go install 安装目录。
    |    |
    |     +--- hello            //可执行命令hello
    |
    +--- pkg             // go build 生成静态库 (.a) 存放目录。
    |      |
    |       +--- darwin_amd64
    |                |
    |                 +--- lib.a
    |                |
    |                 +--- lib
    |                       |
    |                        +--- sublib.a
    |
    +--- src             // 项目源码目录。
    |      |
    |      +---golearn
    |
    +--- learn
    |       |
    |        +--- main.go
    |

可在 GOPATH 环境变量列表中添加多个工作空间，但不能和 GOROOT 相同。

通常 go get使用第一个工作空间保存下载的第三方库。

1.1.4. Go包的导入

导入包 ：使用包成员前，必须先用 import 关键字导入，但不能形成导入循环。

import "相对目录/包主文件名"

相对目录是指从<workspace>/pkg/<os_arch>开始的子目录，以标准库为例:

import "fmt"      ->  /usr/local/go/src/fmt

在导入时，可指定包成员访问方式。比如对包重命名，以避免同名冲突。

import用法

import "fmt"        最常用导入系统包
import "./test"        导入当前目录的包（相对路径）
import "gostudy/model     加载$gopath/src/gostudy/model模块（绝对路径）
import f "fmt"        导入fmt，且给与别名ｆ，可以通过f. 方式调用函数
import . "fmt"         将fmt启用别名"."，这样就可以直接使用其内容，而不用再添加fmt.Println()
import  _ "fmt"     表示不使用该包，而是只是使用该包的init函数，而不能够使用该包的其他函数。

1.1.5. Go包的语法使用

声明包
package 包名

引入包
import "包的路径"

1.2. Go格式化fmt包

golang 的fmt 包实现了格式化I/O函数，类似于C的 printf 和 scanf。

普通占位符

占位符     说明                           举例                   输出
%v      相应值的默认格式。            Printf("%v", people)   {zhangsan}，
%+v     打印结构体时，会添加字段名     Printf("%+v", people)  {Name:zhangsan}
%#v     相应值的Go语法表示            Printf("#v", people)   main.Human{Name:"zhangsan"}
%T      相应值的类型的Go语法表示       Printf("%T", people)   main.Human
%%      字面上的百分号，并非值的占位符  Printf("%%")

布尔占位符

占位符       说明                举例                     输出
%t          true 或 false。     Printf("%t", true)       true

整数占位符

占位符     说明                                  举例                       输出
%b      二进制表示                             Printf("%b", 5)             101
%c      相应Unicode码点所表示的字符              Printf("%c", 0x4E2D)        中
%d      十进制表示                             Printf("%d", 0x12)          18
%o      八进制表示                             Printf("%d", 10)            12
%q      单引号围绕的字符字面值，由Go语法安全地转义 Printf("%q", 0x4E2D)        '中'
%x      十六进制表示，字母形式为小写 a-f         Printf("%x", 13)             d
%X      十六进制表示，字母形式为大写 A-F         Printf("%x", 13)             D
%U      Unicode格式：U+1234，等同于 "U+%04X"   Printf("%U", 0x4E2D)         U+4E2D

浮点数和复数的组成部分（实部和虚部）

占位符     说明                              举例            输出
%b      无小数部分的，指数为二的幂的科学计数法，
        与 strconv.FormatFloat 的 'b' 转换格式一致。例如 -123456p-78
%e      科学计数法，例如 -1234.456e+78        Printf("%e", 10.2)     1.020000e+01
%E      科学计数法，例如 -1234.456E+78        Printf("%e", 10.2)     1.020000E+01
%f      有小数点而无指数，例如 123.456        Printf("%f", 10.2)     10.200000
%g      根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出 Printf("%g", 10.20)   10.2
%G      根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的0）输出 Printf("%G", 10.20+2i) (10.2+2i)

字符串与字节切片

占位符     说明                              举例                           输出
%s      输出字符串表示（string类型或[]byte)   Printf("%s", []byte("Go语言"))  Go语言
%q      双引号围绕的字符串，由Go语法安全地转义  Printf("%q", "Go语言")         "Go语言"
%x      十六进制，小写字母，每字节两个字符      Printf("%x", "golang")         676f6c616e67
%X      十六进制，大写字母，每字节两个字符      Printf("%X", "golang")         676F6C616E67

指针

占位符         说明                      举例                             输出
%p      十六进制表示，前缀 0x          Printf("%p", &people)             0x4f57f0

其他标记

占位符      说明                             举例          输出
+      总打印数值的正负号；对于%q（%+q）保证只输出ASCII编码的字符。
                                           Printf("%+q", "中文")  "\u4e2d\u6587"
-      在右侧而非左侧填充空格（左对齐该区域）
#      备用格式：为八进制添加前导 0（%#o）      Printf("%#U", '中')      U+4E2D
       为十六进制添加前导 0x（%#x）或 0X（%#X），为 %p（%#p）去掉前导 0x；
       如果可能的话，%q（%#q）会打印原始 （即反引号围绕的）字符串；
       如果是可打印字符，%U（%#U）会写出该字符的
       Unicode 编码形式（如字符 x 会被打印成 U+0078 'x'）。
' '    (空格)为数值中省略的正负号留出空白（% d）；
       以十六进制（% x, % X）打印字符串或切片时，在字节之间用空格隔开
0      填充前导的0而非空格；对于数字，这会将填充移到正负号之后

1.3. 实例

package main

import "fmt"

var area float32

func main() {
    area = 12345.678
    fmt.Printf("王思聪家的厨房面积%f平米\n", area)
    fmt.Printf("王思聪家的厨房面积%0.3f平米\n", area)
}

1.3.1. fmt包的函数

package main

import "fmt"

func main() {
    fmt.Println("a","b","c")
    fmt.Printf("名字%s 年纪%d\n","孙悟空",999)

    //获取字符串，返回字符串
    str:=fmt.Sprint("hello world",100,200)
    fmt.Println(str)

    //获取格式化字符串
    str2:=fmt.Sprintf("年纪:%d,姓名：%s\n",22,"行者孙")
    fmt.Println(str2)
}

1.4. go与stdin，读取键盘输入

fmt包提供了输入函数

• Scan
• Scanf
• Scanln

1.4.1. Scan

func Scan(a ...interface{}) (n int, err error)

Scan从标准输入读取数据，以空格作为分隔（换行符也视作空格），依次将输入赋给参数。

他会返回读取参数的个数，和读取过程中遇到的错误。

package main

import "fmt"

func main() {
    var i int
    var num float32
    var s string
    //可以传入任意类型
    //scan以空格和换行分割
    res, err := fmt.Scan(&i, &num, &s)
    if err != nil {
        fmt.Println("err is :", err)
    }
    fmt.Println("参数个数", res)

    //用户输入会通过空格分割 保存在三个变量中
    fmt.Println(i, num, s)
}

// Code:
func main() {
  var s string
  fmt.Scan(&s)
}

// Input:
This is a string.

上述代码接受上述输入之后，s里面存储的是This，而is a string会继续保留在stdin中。

1.5. Scanf

func Scanf(format string, a ...interface{}) (n int, err error)

Scanf 和Scan类似，只是可以自己定义输入格式。

package main

import "fmt"

func main() {
    var i int
    var d float32
    var s string

    num, err := fmt.Scanf("%d %f %s", &i, &d, &s)
    if err != nil {
        fmt.Println("err is :", err)
    }

    fmt.Println("参数个数：", num)
    /*
        用户输入的i存储 数字
        d存储浮点数
        s存储字符串
    */
    fmt.Println("用户输入信息：", i, d, s)
}

1.5.1. Scanln

func Scanln(a ...interface{}) (n int, err error)

Scanln和Scan几乎一样，只不过Scanln将换行符作为一次输入的结束。

1.6. bufio包

使用bufio包可以更好的读取IO，以及文件读取

1.6.1. 随机数math/rand包

根据种子数，定义随机数

1.设置种子数

2.获取随机数

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    //随机数，根据底层算法公式，算出的结果，根据种子数seed计算
    //默认种子数是1
    //修改种子数，种子数固定，随机数也固定，因此可以根据纳秒时间戳来定义
    rand.Seed(time.Now().UnixNano()) //接收一个int64的数值，数值随意
    num1 := rand.Intn(10)            //获取[0,n) 的一个随机数
    fmt.Println(num1)
    num2 := rand.Intn(10) //获取[0,n) 的一个随机数
    fmt.Println(num2)
    num3 := rand.Intn(10) //获取[0,n) 的一个随机数
    fmt.Println(num3)
}