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,可以通过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)

ScanfScan类似,只是可以自己定义输入格式。

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)

ScanlnScan几乎一样,只不过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)
}