基础

语言象限图

基础 - 图1

go 环境配置

变量 值 说明
GOPATH 定义go的项目目录，可以定义多个
GOROOT /usr/local/go go的安装路径

Go项目目录结构

重点关注src目录下的目录结构，因为目录下为我们编写项目的项目源码目录

开源项目 使用gin快速搭建WEB站点以及提供RestFull接口的目录结构如下

  1. src/github.com/ffhelicopter/tmm  
  2.                                /api  
  3.                                /handler
  4.                                /model
  5.                                /task
  6.                                /website
  7.                                main.go    // 文件中定义了 package main

当我们运行go install main.go会在GOPATH/bin目录中生成可执行文件。

常用命令

  • go get 动态获取远程代码包（内部实际上分成了两步操作）
    • 从远程下载需要用到的包
    • 执行 go install
  • go install 内部实际上分成了两步操作
    • 生成可执行文件或者.a的包
    • 把编译好的结果移动到 bin/pkg 目录下
  • go build
    • 如果是普通包，不会产生任何文件
    • 如果需要在pkg下生成相应文件，就得执行 go install
    • 如果某个项目目录下有多个文件，你只想编译某个文件，使用 go build filename.go
    • 也可以指定编译输出的文件名 go build -o astaxie.exe
    • 会忽略目录下以 _/.开头的go文件
    • 如果源码针对不同的操作系统需要不同的处理，你可以根据不同的操作后缀来命名文件。
      • array_linux.go
      • array_windows.go
      • array_freebsd.go
  • go clean 用来移除当前源码包和关联源码包里编译生成的文件
  • go fmt 格式化代码文件
  • go test 自动读取源码目录下命名为 *_test.go的文件，生成并运行测试用的可执行文件。
  • go tool
    • go tool fix 用来修复以前老版本的代码到新版本
    • go tool vet directory | fiels 用来分析当前目录的代码是否都是正确的代码。
  • go generate 用于在编译前自动化生成某类代码
  • go doc
  • go version 查看go当前的版本
  • go env 查看当前go的环境变量
  • go list 列出当前全部安装的 package
  • go run 编译并运行 go 程序

开发工具

  • gocode
  • gopkgs
  • go-outline
  • go-symbols
  • guru
  • gorename
  • dlv
  • godef
  • goreturns
  • golin
  1. 有且仅有一个入口main
  2. 左大括号{必须与函数名同行
  3. Println()会自动换行
  4. 调用函数大部分都需要 import 包
  5. golang以包package为管理单位
  6. 每个文件必须先声明包
  7. 程序必须有一个main包
  8. 导入包必须使用
  9. 变量声明后，必须使用
  1. // demo01
  2. package main
  4. import (
  5.     "fmt"
  6. )
  8. func main() {
  9.     fmt.Println("Hello go!")
  10. }

注释

Go也支持单行注释和块注释

  1. // Cap returns the capacity of the buffer's underlying byte slice,
  2. // that is, the total space allocated for the buffer's date
  4. /*
  5.     Cap returns the capacity of the buffer's underlying byte slice,
  6.     that is, the total space allocated for the buffer's date
  7. */
  9. // 函数之前的注释称为文档注释，应该以函数名同名开头
  10. // enterOrbit causes Superman to fly into low Earth orbit, a position
  11. // that presents several possibilitles for planet salvation.
  12. func enterOrbit() error {
  13.     // do something
  14. }

map类型

  1. package main
  3. // 声明与初始化
  4. func main() {
  5.     var m map[string]int     //map声明后，需要使用make分配内存空间
  6.     //m = make(map[string]int)
  7.     m["a"] = 1
  9.     //if v := m["b"]; v != nil { //b  map取值时，返回v的默认零值
  10.     if v, ok := m["b"]; ok {
  11.         println(v)
  12.     }
  13. }
  16. // map 循环赋值
  17. const N = 3
  19. func main() {
  20.     m := make(map[int]*int)
  22.     for i := 0; i < N; i++ {
  23.         j := int(i)
  24.         m[i] = &j
  25.     }
  27.     for _, v := range m {
  28.         print(*v)
  29.     }
  30. }

指针

  1. package main
  3. type S struct {
  4.     m string
  5. }
  7. // 修改 A和B的行，确保输出 foo
  8. func f() *S {
  9.     return __ //A
  10. }
  12. func main() {
  13.     p := __    //B
  14.     print(p.m) //print "foo"
  15. }
  18. // 修改后
  19. type S struct {
  20.     m string
  21. }
  23. func f() *S {
  24.     return new(S)//A
  25. }
  27. func main() {
  28.     p := S{"foo"}    //B
  29.     print(p.m) //print "foo"
  30. }

接收输入

  1. func main() {
  2.     var a int
  3.     fmt.Printf("请输入变量a：")
  5.     // 接收单个输入
  6.     // fmt.Scanf("%d", &a)
  7.     fmt.Scan(&a)
  9.     fmt.Println("a =", a)
  12.     var aa int
  13.     var bb float64
  14.     var cc string
  15.     // 接收多个输入，按指定格式读取输入
  16.     fmt.Println("please enter s string: ")
  17.     fmt.Scanf("%d, %f, %s", &aa, &bb, &cc)
  18.     fmt.Println("output", aa, bb, cc)
  19.     /*
  20.     please enter s string:
  21.     3333, 3.1111,            hhhhhhhhhhhhhhhhh
  22.     output 3333 3.1111 hhhhhhhhhhhhhhhhh
  23.     */
  25.     // 接收多个输入， 按空格分割读取输入
  26.     fmt.Scanln(&aa, &bb, &cc)
  27.     fmt.Println("output", aa, bb, cc)
  28.     /*
  29.     please enter s string:
  30.     300 3.4 haha
  31.     output 300 3.4 haha
  33.     please enter s string:
  34.     300, 3.4 , haha
  35.     output 300 
  36.     */
  40.     reader := bufio.NewReader(os.Stdin)
  42.     data, _, _ := reader.ReadLine()        // 返回字节切片
  43.     fmt.Println(data)
  45.     dataStr, _ := reader.ReadString('\n')    // 指定结束字节符，接收输入；返回值为 string
  46.     fmt.Println(dataStr)
  47. }

作用域

什么是作用域

声明语句的作用域是指源代码中可以有效使用这个名字的范围。

一个声明语句将程序的实体和一个名字关联：var name int =10，函数func Add(a, b int) int

不要将作用域与生命周期混为一谈。

1557452735661.png

类型判断

作用：类型断言表达式断言类型的变量X.(T)

  1. value, ok := variable.(type)    
  2. // variable 必须是接口类型
  3. // type 是想要判断的类型

例如

  1. package main
  3. import "fmt"
  5. var container = []string("zero", "one", "two")
  7. func main() {
  8.     value, ok := interface{}(container).([]string)
  9.     fmt.Println(value, ok)
  10. }

deffer

类似于 pyton中的 try...exception的final

  1. func Clear() {
  2.     fmt.Println("Clear resource.") 
  3. }
  6. func TestDefer(t *testing.T) {
  7.     defer Clear()
  8.     fmt.Println("Start")
  9. }
  10. // output:
  11. // Start
  12. // Clear resource.
  14. func TestDefer(t *testing.T) {
  15.     defer Clear()
  16.     fmt.Println("Start")
  17.     panic("err")
  18. }
  19. // output:
  20. // Start
  21. // Clear resource.
  22. // FAIL: 
  23. // panicf: err [recovered]
  24. //         panic: err