根据大牛陈皓的GO语言简介（上）目录，基本上完成了目录中如下部分的学习：

Hello World

运行

自己的package

fmt输出格式

变量和常量

数组

数组的切片操作

分支循环语句

关于分号

map

指针

内存分配

函数

现在互联网的资源很多，所以对比学习很有必要，可以参考不同的教材Step by Step的学习，每天都有一点收获，而后才能真正的学有所用。

我参考李文周的Go语言教程多些！

变量、常量、指针

声明变量的一般形式是使用 var 关键字：

var name type

其中，var 是声明变量的关键字，name 是变量名，type 是变量的类型。

需要注意的是，Go语言和许多编程语言不同，它在声明变量时将变量的类型放在变量的名称之后。这样做的好处就是可以避免像C语言中那样含糊不清的声明形式，例如：int* a, b;  。其中只有 a 是指针而 b 不是。如果你想要这两个变量都是指针，则需要将它们分开书写。而在 Go 中，则可以和轻松地将它们都声明为指针类型：

var a, b *int

Go语言的基本类型有：

• bool
• string
• int、int8、int16、int32、int64
• uint、uint8、uint16、uint32、uint64、uintptr
• byte // uint8 的别名
• rune // int32 的别名 代表一个 Unicode 码
• float32、float64
• complex64、complex128

当一个变量被声明之后，系统自动赋予它该类型的零值：int 为 0，float 为 0.0，bool 为 false，string 为空字符串，指针为 nil 等。所有的内存在 Go 中都是经过初始化的。

变量的命名规则遵循骆驼命名法，即首个单词小写，每个新单词的首字母大写，例如：numShips 和 startDate 。

什么是指针

指针的值是一个变量的地址. 一个指针指向的值所保存的位置.  

不是所有的值都有地址, 但是所有的变量都有.

使用指针, 可以在无须知道变量名字的情况下, 间接读取或者更改变量值.

指针的限制

1. 不同类型的指针不能互相转化, 例如*int, int32, 以及int64

2. 任何普通指针类型*T和uintptr之间不能互相转化

3. 指针变量不能进行运算, 比如C/C++里面的++, --运算

// 指针声明
// var name   * type
// var 变量名 * 类型

var p * int // *int=nil>
    


var i = 1
var p * int // 声明指针p
p = &
    i // 指针指向变量地址(即在指针中存放变量地址): *int=0xc042054080
*p = 10 // 间接变量,设置指针指向变量的值：
fmt.Printf("p=%v, *p=%v, i=%v", p, *p, i) // p=0xc042054080, *p=10, i=10


// 指针判断
var p * int // p=nil>

if (p == nil) {
     // 是空指针
    fmt.Printf("p=%v", p) // p=nil>

}
    
i := 10
p = &
i
if (p != nil) {
 // 不是空指针
    fmt.Printf("p=%v", p) // p=0xc0420100d0
}

test1/main.go的代码：

package main

import (
"calc" //自定义的模块
"container/list"
"fmt"
"runtime"
"time"
)

//声明全局变量，必须使用var，不能使用 := 类型推导
var globalValue int = 9
var globalArray2 [10]int
var globalArray [3]int = [3]int{
1, 2, 3}


//类型推导
var name = "Q1mi"
var age = 18

func threadTest(name string) {

    t0 := time.Now()
    fmt.Println(name, " thread start at ", t0)
}


func timeDemo() {

    //短变量声明
    i := 0
    now := time.Now() //获取当前时间
    fmt.Printf("current time:%v, i:%d\n", now, i)
    
    //枚举数组成员
    for i, v := range globalArray {

        fmt.Printf("%d:%d\n", i, v)
    }

    
    for _, v := range globalArray {

        fmt.Printf("value:%d\n", v)
    }

    
    globalArray2 = [10]int{
1, 2, 3}

    for _, v := range globalArray {

        fmt.Printf("globalArray2 value:%d\n", v)
    }

    
    testslice := globalArray2[:5]
    fmt.Printf("testslice len:")
    fmt.Println(len(testslice))
    for index, value := range testslice {

        fmt.Println(index, value)
    }

    
    year := now.Year()     //年
    month := now.Month()   //月
    day := now.Day()       //日
    hour := now.Hour()     //小时
    minute := now.Minute() //分钟
    second := now.Second() //秒
    fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}


func testTypeAlias() {

    type Gender int8
    
    const (
        MALE   Gender = 1
        FEMALE Gender = 2
    )
    gender := FEMALE
    switch gender {

        case FEMALE:
        fmt.Println("famale")
        fallthrough
        case MALE:
        fmt.Println("male")
        default:
        fmt.Println("unknown")
    
    }

}


func main() {

    runtime.GOMAXPROCS(4)
    
    timeDemo()
    
    //go goroutine
    go threadTest("goroutine test1 ")
    threadTest("test2")
    
    fmt.Println("helloWorld")
    
    var mapAssigned map[string]int = make(map[string]int, 1)
    // mapAssigned = map[string]int{
"one": 1, "two": 2}
    
    mapAssigned["one"] = 3
    mapAssigned["test"] = 34
    
    fmt.Printf("Map literal at \"one\" is: %d, test:%d\n", mapAssigned["one"], mapAssigned["test"])
    
    var listTemp list.List
    listTemp.PushBack("abc")
    listTemp.PushBack("efg")
    for i := listTemp.Front();
     i != nil;
 i = i.Next() {

        fmt.Println(i.Value)
    }

    
    //常量声明
    const pi = 3.1415
    const e = 2.7182
    
    //iota是go语言的常量计数器，只能在常量的表达式中使用
    // const (
    //  a = iota
    //  b
    //  c
    // )
    const (
    a, b = iota + 1, iota + 2 //1,2
    c, d                      //2,3
    )
    fmt.Printf("a:%d, b:%d, c:%d\n", a, b, c)
    
    //指针
    testa := new(int)
    fmt.Printf("testa:%T\n", testa)
    
    fmt.Println(testa)
    
    var testpoint *int = new(int)
    *testpoint = 10
    fmt.Println(*testpoint)
    
    //指针数组
    var testpointerArr [3]*int
    var temp1 []int = make([]int, 10)
    fmt.Printf("v:%p, 1:%d", temp1, temp1[0])
    for _, v := range temp1 {

        fmt.Println(v)
    }
    
    
    for i := 0;
     i  3;
 i++ {
    
        testpointerArr[i] = &
temp1[i]
    }

    // fmt.Printf("testpointerArr:%p, 0:%d", testpointerArr, *testpointerArr[0])
    
    //测试switch和自定义类型
    testTypeAlias()
    
    //测试模块
    fmt.Printf("Calc.Add:%d", calc.Add(1, 2))
}

函数的特点类似JavaScript的解释型语言多些，可以返回多个值，支持闭包、匿名函数、函数延迟执行等特性：

package main
import "fmt"
func main(){
    
    v, e := multi_ret("one")
    fmt.Println(v,e) //输出 1 true
    v, e = multi_ret("four")
    fmt.Println(v,e) //输出 0 false
    //通常的用法(注意分号后有e)
    if v, e = multi_ret("four");
 e {

        // 正常返回
    }
else{

        // 出错返回
    }

    
    sum(1, 2)
    sum(1, 2, 3)

    //传数组
    nums := []int{
1, 2, 3, 4}

    sum(nums...)
}


func multi_ret(key string) (int, bool){

    m := map[string]int{
"one": 1, "two": 2, "three": 3}

    var err bool
    var val int
    val, err = m[key]
    return val, err
}


func sum(nums ...int) {

    fmt.Print(nums, " ")  //输出如 [1, 2, 3] 之类的数组
    total := 0
    for _, num := range nums {
 //要的是值而不是下标
        total += num
    }

    fmt.Println(total)
}
    

包、模块和引用

这块可能稍微有点复杂，类似与其他语言中引用自定义模块的头文件，相对来说java文件的包管理会简单些，像Object-C或者C/C++语言可能就复杂一点，不过都只需要指定好搜索路径，#include一个头文件那都是没有问题的；

Go由于有模块的概念，模块的搜索路径都指向了GOPATH的路径下，包括安装三方的模块，也是安装到了GOPATH路径下，所以模块的默认搜索路径也就是GOPATH所在的路径，如果是自定义的模块，则稍显复杂，路径和文件中的代码如下，看看也就懂了；

以test1的包路径为例说明：

└─ test1

├── calc

 │   ├── go.mod

 │   └── main.go

    ├── go.mod

    └── main.go

如下路径下的 go.mod 可以拷贝一个或者使用go mod init命令生成：

liyizhang@bogon test3 % go mod init test3/m

ll@bogon test1 % ls -l

total 16

drwxr-xr-x  4 ll  staff   128 12 17 11:15 calc

-rw-r--r--  1 ll  staff    95 12 17 11:09 go.mod

-rw-r--r--  1 ll  staff  2899 12 17 14:22 main.go

ll@bogon calc %cat go.mod 

module test1

go 1.15

replace calc => ./calc

require calc v0.0.0-00010101000000-000000000000 

ll@bogon test1 % cd calc

ll@bogon calc % ls -l

total 16

-rw-r--r--  1 ll  staff   23 12 17 11:09 go.mod

-rw-r--r--  1 ll  staff  841 12 17 11:17 main.go 

ll@bogon calc %% cat go.mod

module calc

go 1.15

main.go的代码：

package calc

import "fmt"

type person struct {
 // 首字母小写，外部包不可见，只能在当前包内使用
    name string
}


//Student 首字母大写外部包可见，可在其他包中使用
type Student struct {

    Name  string //可在包外访问的方法
    class string //仅限包内访问的字段
}


//Payer 首字母大写外部包可见，可在其他包中使用
type Payer interface {

init() //仅限包内访问的方法
Pay()  //可在包外访问的方法
}


//Mode 首字母大写外部包可见，可在其他包中使用
const Mode = 1

func init() {

    fmt.Printf("calc module init\n")
}


//Add 首字母大写，外部包可见，可在其他包中使用
func Add(a int, b int) int {

    return a + b
}


//Mul 首字母大写，外部包可见，可在其他包中使用
func Mul(a int, b int) int {

    return a * b
}

陈皓的文章提到：你可以使用GOPATH环境变量，或是使用相对路径来import你自己的package。

Go的规约是这样的：

1）在import中，你可以使用相对路径，如 ./或 ../ 来引用你的package

//使用相对路径 import "./haoel"  //import当前目录里haoel子目录里的所有的go文件

2）如果没有使用相对路径，那么，go会去找$GOPATH/src/目录。

运行

如果使用Visual Studio的IDE，则可能忽略了下面的步骤，不过敲敲命令也能知道IDE点Run的时候到底做了些撒。

#解释执行（实际是编译成a.out再执行）

$go run hello.go

hello world

#编译执行

$go build hello.go

$ls

hello hello.go

$./hello

hello world

并发编程

看似简单，第一次这个例子也没跑成功，原因是我将 go func(10)放到了函数最后了，整个程序还没来得及运行go里面的goroutine，程序就结束了，所以通常需要在main方法的结尾之前进行一个等待或者延时处理；

其他

参考其他模块的时候，可能需要安装github的三方模块，比方安装gin，需要设置GOProxy才能正常安装：

安装gin

GO111MODULE=on GOPROXY=https://goproxy.cn/,direct go get -u github.com/gin-gonic/gin

安装govendor

GO111MODULE=on GOPROXY=https://goproxy.cn/,direct go get -u  github.com/kardianos/govendor

注意：无论任何时候，你都不应该将一个控制结构（(if、for、switch或select）的左大括号放在下一行。如果这样做，将会在大括号的前方插入一个分号，这可能导致出现不想要的结果。

常见的错误与陷阱

来源：https://github.com/qq1060656096/go-tutorials/blob/master/basic/12/README.md

1. 误用短声明导致变量被覆盖

// go run examples/demo1/short_var.go
// if中语句中声明的name,age覆盖了if外声明的name,age变量
package main
import "fmt"
func main()  {
    
	var name , age = "张三", 18
	if name, age := "李四", 10;
     age >
 10 {

		fmt.Println("if name=%s, age=%d", name, age)
	}
 else {

		fmt.Println("else name=%s, age=%d", name, age)// else name=%s, age=%d 李四 10
	}

	fmt.Println("name=%s, age=%d", name, age)// name=%s, age=%d 张三 18
}

2. 误用字符串

当对一个字符串进行频繁的操作时，请记住在go语言中字符串是不可变得。 使用+拼接字符串会导致拼接后的新字符串和之前字符串不同，导致需要分配新的存储空间存放新字符串 从而导致大量的内存分配和拷贝。频繁操作字符串建议用bytes.Buffer

// go run examples/demo2/string.go
package main
import (
	"fmt"
)
func main()  {
    
	var s = "test"
	for i := 0;
     i  10;
 i++{

		// 字符串不可变，由于s字符串和si字符串拼接后字符串不在相同，
		// 导致需要分配新的存储空间存放新字符串，从而导致大量的内存分配和拷贝。
		si := fmt.Sprintf(" %d", i)
		s = s + si
	}

	fmt.Println(s)
}
    

3. 误用defer

4. 误用map

5. 何时使用new()和make()函数

6. 误用new()函数

7. 误用指针

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！