Go语言探险思考笔记（1）

时间 2019-11-12

原文原文链接

最近接触对象存储，国际上鼎鼎有名的Amazon S3还有Google Cloud Service在国内因为防火墙还有机房过远的问题，并不能投入生产使用。国内有名的对象存储，你们众所周知的七牛云，后台就是Go语言实现的。对于第一个敢吃螃蟹的人，我一直很佩服。因而抱着憧憬的心态走进Go语言的大门。
首先，接触一门语言，就从最啰嗦可是最不能缺乏的基础语法和顺序变成开始。对于接触这些，我通常是从搭建好本身的编译构建环境开始，首先下载Go语言SDK，国内下载地址：http://golangtc.com/download
我这里用的是最新的1.7.2，若是你要用IDEA 的go plugin进行编程，则须要用1.4.2，不能用高版本的。以后，下载LiteIDE，进行编码：http://www.golangtc.com/download/liteide
咱们打开LiteIDE，新建一个非GOPATH目录下的示例项目（咱们这里吐槽下LiteIDE，他并非一个很严谨，很好用，很完整的IDE，对于习惯了IDEA的懒人程序员，可能不太习惯。可是，回归原始也是颇有好处的），命名为Gotest。
项目会自动生成目录和代码。咱们只保留main.go就能够。Go语言有他智能的一面，首先摆上两个原则：git

对于每一个项目，都须要配置GOPATH。为了能构建这个项目，须要把项目根目录加入到GOPATH，不然找不到这个项目内部的package。
Go根据项目目录结构自动构建，这里基本原则就是：须要一个main入口，本身新建应用或者一个代码包都是在src目录下新建一个文件夹，文件夹名称通常是代码包名称，固然也容许多级目录，例如在src下面新建了目录$GOPATH/src/github.com/hashZhang/test那么这个包路径就是“github.com/hashZhang/test”，包名称是最后一个目录test

变量定义

Go语言兼顾了自由性和严谨性：首先，对于变量的定义，咱们有三种方式，很自由。接着，没用的元素在编译时就不会经过。例如：没用的包引入，没用的变量定义，这些在编译时就会报错。
下面咱们写一个小程序：
咱们在项目根目录新建pkg和src两个文件夹，src目录存放咱们的源代码，pkg是给go编译器用的，会生成编译好的文件，其实就是编译好的库文件。根目录保留main.go
在src目录下新建fundamental文件夹，在fundamental文件夹新建variables.go。
编写源码（这里先提出一点Go语言不用分号分割，回车就能够）：程序员

package fundamental

import "fmt" //包若是没用，则会在编译时报错，这里用了标准输出函数

func Initialization() { //go，模块中要导出的函数，必须首字母大写。
    var var1 int //变量若是没有用过，也会在编译时报错，初始化为默认值0
    fmt.Println("var1:", var1)
    var var2 string //注意小写s，初始化为默认值""
    fmt.Println("var2:", var2)
    var var3 [10]int //数组，初始化为默认值[0 0 0 0 0 0 0 0 0 0]
    fmt.Println("var3:", var3)
    var var4 []int //动态数组，数组切片，初始化为默认值[]
    fmt.Println("var4:", var4)
    var var5 struct { //至关于C语言中的结构体，，初始化为默认值{0 ""}
        f int
        j string
    }
    fmt.Println("var5:", var5)
    var var6 *int //指针，初始化为默认值<nil>
    fmt.Println("var6:", var6)
    var var7 map[string]int //Key为string，value为int，初始化为默认值map[]
    fmt.Println("var7:", var7)
    var var8 func(a int) int //定义为一个function，规定输入输出，初始化为默认值<nil>
    fmt.Println("var8:", var8)
    var var9 = 10 //根据初始值自动判断类型
    fmt.Println("var9:", var9)
    var10 := 11 //第三种初始化
    fmt.Println("var10:", var10)
}

func SwapDisplay1() { //常规思路的交换，利用a+b-a和a+b-b来达到交换的目的
    var (
        a = 19
        b = -7
    )
    fmt.Println("Before swap:\n", "a:", a, ",b:", b)
    a = a + b
    b = a - b
    a = a - b
    fmt.Println("After swap:\n", "a:", a, ",b:", b)
}

func SwapDisplay2() { //Go语言交换，由于函数能够返回多个值，并且支持相似于a,b=b,a的多重赋值语法
    var (
        a = 19
        b = -7
    )
    fmt.Println("Before swap:\n", "a:", a, ",b:", b)
    a, b = swap(a, b)
    fmt.Println("After swap:\n", "a:", a, ",b:", b)
}

func swap(a int, b int) (int, int) { //go，对于模块中不须要导出的函数，首字母不要大写。
    return b, a
}

咱们总结下：github

1 变量有3种定义或初始化方式：golang

var var1 int
    var var9 = 10 
    var10 := 11

2.变量类型很是自由，有C语言的结构体，也有像Javascript那样的函数类型变量。
3.变量赋值很自由，对于其余语言，变量交换有两种方式：一种是中间变量，另外一种是利用a+b-a和a+b-b来达到交换的目的。Go语言支持多重赋值，i,j=j,i编程

func SwapDisplay1() { //常规思路的交换，利用a+b-a和a+b-b来达到交换的目的
    var (
        a = 19
        b = -7
    )
    fmt.Println("Before swap:\n", "a:", a, ",b:", b)
    a = a + b
    b = a - b
    a = a - b
    fmt.Println("After swap:\n", "a:", a, ",b:", b)
}

func SwapDisplay2() { //Go语言交换，由于函数能够返回多个值，并且支持相似于a,b=b,a的多重赋值语法
    var (
        a = 19
        b = -7
    )
    fmt.Println("Before swap:\n", "a:", a, ",b:", b)
    a, b = swap(a, b)
    fmt.Println("After swap:\n", "a:", a, ",b:", b)
}

4.以上的多重赋值，也来源于Go语言的函数能够返回多个值。小程序

func swap(a int, b int) (int, int) { //go，对于模块中不须要导出的函数，首字母不要大写。
    return b, a
}

5.Go语言的var关键字和import关键字都支持括号内多个定义，例如：数组

var(
        v1 int
        v2 string
    )

6.对于包外部可见的function，function名称开头必须大写（就是说，利用开头字母大写的方法定义包外部可见能够调用的function）
这里咱们能够调用的是Initialization()，SwapDisplay1()，SwapDisplay2()方法，而swap方法不能够。
在main.go中编写：markdown

// Gotest project main.go
package main

import (
    "fmt"
    "fundamental"
)

func main() {
    fundamental.Initialization() //go，模块中要导出的函数，必须首字母大写。
    fmt.Println("Hello World!")
    fundamental.SwapDisplay1() //go，模块中要导出的函数，必须首字母大写
    fundamental.SwapDisplay2() //go，模块中要导出的函数，必须首字母大写
}

编译运行：ide

var1: 0
var2: 
var3: [0 0 0 0 0 0 0 0 0 0]
var4: []
var5: {0 }
var6: <nil>
var7: map[]
var8: <nil>
var9: 10
var10: 11
Hello World!
Before swap:
 a: 19 ,b: -7
After swap:
 a: -7 ,b: 19
Before swap:
 a: 19 ,b: -7
After swap:
 a: -7 ,b: 19

生成的文件：

如咱们以前所说，在pkg目录下自动生成了.a库文件。在根目录下还生成了和项目名称同样的exe可执行文件。函数

常量定义

Go语言的字面量是无类型的
在fundamental文件夹下新建constants.go：

package fundamental

import "fmt" //包若是没用，则会在编译时报错，这里用了标准输出函数

func ConstDefinition() {
    const PI_f32 float32 = 3.141592654 //不用像其余语言那样指定是float仍是double，末尾加上f，字面量常量都是无类型的，这里其实是3.1415927
    const PI_f64 float64 = 3.141592654 //不用像其余语言那样指定是float仍是double，末尾加上f，字面量常量都是无类型的，这里其实是3.141592654
    fmt.Println("PI_f32:", PI_f32)
    fmt.Println("PI_f64:", PI_f64)
    const PI = 3.141592654 //不指定类型也能够,会自动匹配成能容纳这个变量的浮点类型常量
    fmt.Println("PI:", PI)
    const (
        a, b, c = "a", 1, 3.0
        d       = "asd"
    )
    fmt.Println("a:", a, ",b:", b, ",c:", c, ",d:", d)

    const ( //三种预约义常量，iota会在下一个const以前递增，可是，必须在不一样赋值语句才能递增。
        e1, e2 = true, false
        e3     = iota //0
        e4     = iota //1
    )
    fmt.Println("e1:", e1, ",e2:", e2, ",e3:", e3, ",e4:", e4)

    const ( //iota必须在不一样赋值语句才能递增。
        f1, f2 = iota, iota //0,0
        f3, f4 = iota, iota //1,1
    )
    fmt.Println("f1:", f1, ",f2:", f2, ",f3:", f3, ",f4:", f4)
}

总结以下几点：
1.Go语言的字面量是无类型的，对于浮点型，不用像其余语言那样指定是float仍是double，末尾加上f，字面量常量都是无类型的

const PI_f32 float32 = 3.141592654 //不用像其余语言那样指定是float仍是double，末尾加上f，字面量常量都是无类型的，这里其实是3.1415927
const PI_f64 float64 = 3.141592654 //不用像其余语言那样指定是float仍是double，末尾加上f，字面量常量都是无类型的，这里其实是3.141592654

2.在定义常量时，不指定类型也能够,会自动匹配成能容纳这个变量的浮点类型常量
3.三种预约义常量（true,false,iota），iota会在下一个const以前递增，可是，必须在不一样赋值语句才能递增。

const ( //三种预约义常量，iota会在下一个const以前递增，可是，必须在不一样赋值语句才能递增。
        e1, e2 = true, false
        e3     = iota //0
        e4     = iota //1
    )
    const ( //iota必须在不一样赋值语句才能递增。
        f1, f2 = iota, iota //0,0
        f3, f4 = iota, iota //1,1
    )

类型

布尔类型

func TestBool() {
    var v1 bool //初始化为bool类型，默认为false
    fmt.Println("v1:", v1)
    v1 = true
    fmt.Println("v1:", v1)
    v2 := (1 >= 0 && 2 <= 3) //也能够表达式赋值，须要加上括号
    fmt.Println("v2:", v2)
}

总结：
1. 布尔类型初始化，默认为false
2. 布尔类型不支持其它赋值或者强制转换，例如赋值为1

整型

func TestInt() {
    var a int8
    a = 6 //int类型能够指定长度
    fmt.Println("a:", a)
    var b int32
    b = 7.0000   //这个原本小数点全为0的也能够赋值给int类型，可是7.0001就不行了
    b = int32(a) //同时，也不能将a赋值给b，由于不一样类型，同时也不能互相比较
    fmt.Println("b:", b)
    fmt.Println("b > 0.00:", b > 0.00) //不一样类型也不能互相比较
    fmt.Println("^b:", ^b)             //其余运算符都和其余语言同样，除了非运算，非运算符为^
}

总结：
1. 不一样类型的整型不能够互相赋值，或者互相比较
2. 字面量无类型，能够复制，能够比较，可是必须为整型

b = 7.0000 //这个原本小数点全为0的也能够赋值给int类型，可是7.0001就不行了

3. 其余运算符都和其余语言同样，除了非运算，非运算符为^
4. 通常都用int,uint来编程

浮点型

func TestFloat() {
    var f1 float32
    fmt.Println("f1:", f1)
    f2 := 12.0 //不能f2 = f1 ，f2为float64
    f3 := 11.9091
    fmt.Println("isEqual(f2, f3, 1)", isEqual(f2, f3, 1))
}
func isEqual(f1, f2, p float64) bool {//浮点数不能直接用==判断相等，只能用精度比较
    return math.Abs(f1-f2) < p
}

总结：
1.不一样类型的浮点型不能够互相赋值，或者互相比较
2.浮点数不能直接用==判断相等，只能用精度比较

字符串

func TestString() {
    str := "Hello World! by 张哈希"
    fmt.Println("str:", str)
    fmt.Println("len(str):", str)//利用内置函数len获取长度
    for i := 0; i < len(str); i++ {//遍历
        fmt.Println(i, str[i])
    }
    for i, ch := range str {//以Unicode方式遍历
        fmt.Println(i, ch)
    }
}

输出：

str: Hello World! by 张哈希
len(str): Hello World! by 张哈希
0 72
1 101
2 108
3 108
4 111
5 32
6 87
7 111
8 114
9 108
10 100
11 33
12 32
13 98
14 121
15 32
16 229
17 188
18 160
19 229
20 147
21 136
22 229
23 184
24 140

0 72
1 101
2 108
3 108
4 111
5 32
6 87
7 111
8 114
9 108
10 100
11 33
12 32
13 98
14 121
15 32
16 24352
19 21704
22 24076