Go备注

环境变量：

• $GOROOT:
  表示Go的安装目录。也就是上面我们解压出来的文件夹里面的go文件夹。

• $GOPATH:
  表示我们的工作空间。用来存放我们的工程目录的地方。

---

GOPATH目录：

一般来说GOPATH下面会有三个文件夹：bin、pkg、src，没有的话自己创建。每个文件夹都有它的作用。

• bin：编译后可的执行文件的存放路径
• pkg：编译包时，生成的.a文件的存放路径
• src：源码路径，一般我们的工程就创建在src下面。

注意：
如果要用Go Mod(Go1.11及以上支持)进行包管理，则需要在 GOPATH 以外的目录创建工程。

---

Go程序主要组成：

• 包声明
• 导入包
• 函数
• 变量
• 语句和表达式
• 注释

package main // 包声明

import "fmt" // 导入包

func main() {
   /* This is my first sample program. */
   fmt.Println("Hello, World!")
}

让我们来看看上面的程序的各个部分：

1. 程序包体的第一行定义了这个程序包的名称。这是一个必须声明为Go程序运行在什么包。main包是起始点来运行程序。每个包都有一个与之关联的路径和名称。

2. 下一行import "fmt" 是告诉编译器去包含文件在包fmt的预处理命令。

3. 下一行 func main()主要功能是为程序执行的开始。

4. 下一行/*...*/会被编译器被忽略，它已被加入到程序添加注释。因此，这样的行称为程序中的注释。注释也使用//类似于Java或C++注释。

5. 下一行fmt.Println（...）是提供另一种功能，使消息“Hello, World!”要显示在屏幕上。这里fmt包已导出，println方法用来在屏幕上显示消息。

6. 注意println方法。在Go语言中，一个名字如果它用大写字母开头为导出。导出是指一个函数或变量/常访问到相应的包导入。

---

fmt 打印

    fmt.Println("helloworld")
    fmt.Println("a=", a)
    var x float32
    fmt.Println(x)
    fmt.Printf("x is of type %T\n", x) // x is of type float32

---

结构体

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

结构体定义

type struct_variable_type struct {
   member definition
   member definition
   ...
   member definition
}

一旦定义了结构体类型，它就能用于变量的声明，语法格式如下：

variable_name := structure_variable_type {value1, value2...valuen}
或
variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}

例子：

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}

func main() {
    // 创建一个新的结构体
    fmt.Println(Books{"Go 语言", "张一", "Go 语言教程", 6495407})
    // 也可以使用 key => value 格式
    fmt.Println(Books{title: "Go 语言", author: "张二", subject: "Go 语言教程", book_id: 6495407})
    // 忽略的字段为 0 或 空
   fmt.Println(Books{title: "Go 语言", author: "张三"})
}

访问结构体成员

如果要访问结构体成员，需要使用点号 . 操作符，格式为：

结构体.成员名"

结构体指针

你可以定义指向结构体的指针类似于其他指针变量，格式如下：

var struct_pointer *Books

以上定义的指针变量可以存储结构体变量的地址。查看结构体变量地址，可以将 & 符号放置于结构体变量前：

struct_pointer = &Book1

使用结构体指针访问结构体成员，使用 . 操作符：

struct_pointer.title

---

外接方法

语法

func (variable_name variable_data_type) function_name() [return_type]{
   /* function body*/
}

package main

import (
   "fmt"
   "math"
)

/* define a circle */
type Circle strut {
   x,y,radius float64
}

/* define a method for circle */
func(circle Circle) area() float64 {
   return math.Pi * circle.radius * circle.radius
}

func main(){
   circle := Circle(x:0, y:0, radius:5)
   fmt.Printf("Circle area: %f", circle.area())
}

---

切片

子切片

    numbers = []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    // 子切片
    subSlice1 := numbers[1:4]
    fmt.Println("subSlice1 = ", subSlice1) // subSlice1 =  [1 2 3]
    subSlice2 := numbers[:4]
    fmt.Println("subSlice2 = ", subSlice2) // subSlice2 =  [0 1 2 3]
    subSlice3 := numbers[4:]
    fmt.Println("subSlice3 = ", subSlice3) // subSlice3 =  [4 5 6 7 8 9]

append() 和 copy() 函数

    // append()  copy() 函数
    var appends_array []int
    appends_array = append(appends_array, 0)
    printSlice(appends_array)
    appends_array = append(appends_array, 1, 2, 3)
    printSlice(appends_array)

    appends_copy := make([]int, len(appends_array), cap(appends_array))
    copy(appends_copy, appends_array)
    printSlice(appends_copy)

range

    //  range
    range_array := []int{0, 1, 2, 3, 4, 5, 6, 7}
    for i := range range_array {
        fmt.Println("range item:", i)
    }
// --- console
range item: 0
range item: 1
range item: 2
range item: 3
range item: 4
range item: 5
range item: 6
range item: 7

---

map 字典

    // map 映射  就是字典
    var coutryMap map[string]string     // 声明一个key是string，值是string的map
    coutryMap = make(map[string]string) // 创建一个map
    coutryMap["France"] = "Paris"
    coutryMap["China"] = "Beijing"
    for i := range coutryMap {
        fmt.Printf("coutry %s capital is %s \n", i, coutryMap[i])
    }

    captial, ok := coutryMap["Janpan"]
    if ok {
        fmt.Println("capital of Janpan is ", captial)
    } else {
        fmt.Println("capital of Janpan is not present")
    }

--- console
coutry France capital is Paris
coutry China capital is Beijing
capital of Janpan is not present

delete() 函数

delete()函数是用于从映射中删除一个项目。映射和相应的键将被删除。下面是一个例子：

   delete(countryMap,"France");

---

类型转换

类型转换是一种可变从一种数据类型转换成另一种数据类型。例如，如果要存储一个long值转成一个简单的整数，那么可以强制类型转换 long为int。可以从一种类型使用转换运算符将原类型值转换为另一种类型值，如下：
type_name(expression)

package main

import "fmt"

func main() {
   var sum int = 17
   var count int = 5
   var mean float32
   
   maen = float32(sum)/float32(count)
   fmt.Printf("Value of mean : %f\n",mean)
}

--- console
Value of mean : 3.400000

---

错误处理

Go编程提供了一个非常简单的错误处理框架，下面的声明中内置错误接口类型：

type error interface {
   Error() string
}

例子

// 错误处理
func sqrt(value float64) (float64, error) {
    if value < 0 {
        return 0, errors.New("Math: negative number passed to Sqrt")
    }
    return math.Sqrt(value), nil
}
---
    // 错误处理
    result, error := sqrt(-1)
    if error == nil {
        fmt.Println("sqrt: ", result)
    } else {
        fmt.Println("sqrt: ", error)
    }
---console
sqrt:  Math: negative number passed to Sqrt