学go之路（二）基本类型及变量、常量

1.go help命令及解释

go env用于打印Go语言的环境信息。

go run命令可以编译并运行命令源码文件。

go get可以根据要求和实际情况从互联网上下载或更新指定的代码包及其依赖包，并对它们进行编译和安装。

go build命令用于编译我们指定的源码文件或代码包以及它们的依赖包。

go install用于编译并安装指定的代码包及它们的依赖包。

go clean命令会删除掉执行其它命令时产生的一些文件和目录。

go doc命令可以打印附于Go语言程序实体上的文档。我们可以通过把程序实体的标识符作为该命令的参数来达到查看其文档的目的。

go test命令用于对Go语言编写的程序进行测试。

go list命令的作用是列出指定的代码包的信息。

go fix会把指定代码包的所有Go语言源码文件中的旧版本代码修正为新版本的代码。

go vet是一个用于检查Go语言源码中静态错误的简单工具。

go tool pprof命令来交互式的访问概要文件的内容。

2.go的内置类型
（1）值类型

bool
int(32 or 64), int8, int16, int32, int64
uint(32 or 64), uint8(byte), uint16, uint32, uint64
float32, float64
string
complex64, complex128
array – 固定长度的数组

（2）引用类型（指针）：

slice – 序列数组(最常用)
map – 映射
chan – 管道

（3）函数类型

append – 用来追加元素到数组、slice中,返回修改后的数组、slice
close – 主要用来关闭channel
delete – 从map中删除key对应的value
panic – 停止常规的goroutine （panic和recover：用来做错误处理）
recover – 允许程序定义goroutine的panic动作
real – 返回complex的实部 （complex、real imag：用于创建和操作复数）
imag – 返回complex的虚部
make – 用来分配内存，返回Type本身(只能应用于slice, map, channel)
new – 用来分配内存，主要用来分配值类型，比如int、struct。返回指向Type的指针
cap – capacity是容量的意思，用于返回某个类型的最大容量（只能用于切片和 map）
copy – 用于复制和连接slice，返回复制的数目
len – 来求长度，比如string、array、slice、map、channel ，返回长度
print、println – 底层打印函数，在部署环境中建议使用 fmt 包

（4）接口error

type error interface {
     //只要实现了Error()函数，返回值为String的都实现了err接口

            Error()    String

    }

3.init（）与main（）

相同点：
两个函数在定义时不能有任何的参数和返回值，且Go程序自动调用
不同点：
init可以应用于任意包中，且可以重复定义多个
main函数只能用于main包中，且只能定义一个
两个函数的执行顺序：

对同一个go文件的init()调用顺序是从上到下的。

对同一个package中不同文件是按文件名字符串比较“从小到大”顺序调用各文件中的init()函数。

对于不同的package，如果不相互依赖的话，按照main包中”先import的后调用”的顺序调用其包中的init()，如果package存在依赖，则先调用最早被依赖的package中的init()，最后调用main函数。

如果init函数中使用了println()或者print()你会发现在执行过程中这两个不会按照你想象中的顺序执行。这两个函数官方只推荐在测试环境中使用，对于正式环境不要使用。

4.运算符

= 简单的赋值运算符，将一个表达式的值赋给一个左值
+= 相加后再赋值
-= 相减后再赋值
*= 相乘后再赋值
/= 相除后再赋值
%= 求余后再赋值
<<= 左移后赋值
<<= 右移后赋值
&= 按位与后赋值
l= 按位或后赋值
^= 按位异或后赋值
&& 逻辑 AND 运算符。 如果两边的操作数都是 True，则为 True，否则为 False。
ll 逻辑 OR 运算符。 如果两边的操作数有一个 True，则为 True，否则为 False。
! 逻辑 NOT 运算符。 如果条件为 True，则为 False，否则为 True。
== 检查两个值是否相等，如果相等返回 True 否则返回 False。
!= 检查两个值是否不相等，如果不相等返回 True 否则返回 False。
检查左边值是否大于右边值，如果是返回 True 否则返回 False。
= 检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
< 检查左边值是否小于右边值，如果是返回 True 否则返回 False。
<= 检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。
+相加
-相减
*相乘
/相除
%求余

5.变量与常量

（1）变量申明、批量变量申明、变量的初始化

var name string 
var age int
var isOk boo

var (
    a string
    b int
    c bool
    d float32
)

var name string = "pprof.cn"
var sex int = 1

#编译器也会根据类型自动推导变量类型
var name, sex = "pprof.cn", 1

（2）短变量申明

package main

import (
    "fmt"
)
// 全局变量m
var m = 100

func main() {
    
    n := 10
    m := 200 // 此处声明局部变量m
    fmt.Println(m, n)
}

（3）匿名变量

func foo() (int, string) {
    
    return 10, "Q1mi"
}
func main() {
    
    x, _ := foo()
    _, y := foo()
    fmt.Println("x=", x)
    fmt.Println("y=", y)
}

匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。

（4）常量

const pi = 3.1415
const e = 2.7182

const同时声明多个常量时，如果省略了值则表示和上面一行的值相同。 例如：

const (
    n1 = 100
    n2
    n3
)

上面示例中，常量n1、n2、n3的值都是100。

（5）iota
iota是go语言的常量计数器，只能在常量的表达式中使用。
iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。 使用iota能简化定义，在定义枚举时很有用。

举个例子：

const (
        n1 = iota //0
        n2        //1
        n3        //2
        n4        //3
    )

几个常见的iota示例:
使用_跳过某些值

const (
        n1 = iota //0
        n2        //1
        _
        n4        //3
    )

iota声明中间插队

const (
        n1 = iota //0
        n2 = 100  //100
        n3 = iota //2
        n4        //3
    )
const n5 = iota //0

定义数量级 （这里的<<表示左移操作，1<<10表示将1的二进制表示向左移10位，也就是由1变成了10000000000，也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位，也就是由10变成了1000，也就是十进制的8。）

const (
        _  = iota
        KB = 1 << (10 * iota)
        MB = 1 << (10 * iota)
        GB = 1 << (10 * iota)
        TB = 1 << (10 * iota)
        PB = 1 << (10 * iota)
    )

多个iota定义在一行

const (
        a, b = iota + 1, iota + 2 //1,2
        c, d                      //2,3
        e, f                      //3,4
    )

6.基本类型
（1）整型

整型分为以下两个大类：
按长度分为：int8、int16、int32、int64对应的无符号整型：uint8、uint16、uint32、uint64

（2）浮点型

Go语言支持两种浮点型数：float32和float64。这两种浮点型数据格式遵循IEEE 754标准： float32
的浮点数的最大范围约为3.4e38，可以使用常量定义：math.MaxFloat32。 float64 的浮点数的最大范围约为
1.8e308，可以使用一个常量定义：math.MaxFloat64。

（3）复数

complex64和complex128

复数有实部和虚部，complex64的实部和虚部为32位，complex128的实部和虚部为64位。

（4）布尔值

Go语言中以bool类型进行声明布尔型数据，布尔型数据只有true（真）和false（假）两个值。
注意：
布尔类型变量的默认值为false。
Go 语言中不允许将整型强制转换为布尔型.
布尔型无法参与数值运算，也无法与其他类型进行转换。

（5）字符串

Go语言中的字符串以原生数据类型出现，使用字符串就像使用其他原生数据类型（int、bool、float32、float64 等）一样。 Go
语言里的字符串的内部实现使用UTF-8编码。 字符串的值为双引号(“)中的内容，可以在Go语言的源码中直接添加非ASCII码字符，例如：

s1 := "hello"
s2 := "你好"

（6）字符串转义符

转义 含义
\r 回车符（返回行首）
\n 换行符（直接跳到下一行的同列位置）
\t 制表符
’ 单引号
" 双引号
\ 反斜杠

（7）多行字符串

Go语言中要定义一个多行字符串时，就必须使用反引号字符：

s1 := `第一行 第二行 第三行 `
fmt.Println(s1)

反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。

（8）字符串常用操作方法介绍

len(str) 求长度
+或fmt.Sprintf 拼接字符串
strings.Split 分割
strings.Contains 判断是否包含 strings.HasPrefix,strings.HasSuffix 前缀/后缀判断
strings.Index(),strings.LastIndex() 子串出现的位置
strings.Join(a[]string,sep string) join操作

（9）byte和rune类型

组成每个字符串的元素叫做“字符”，可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号（’）包裹起来，如：

var a := ‘中’

var b := ‘x’

Go 语言的字符有以下两种：

uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。

rune类型，代表一个 UTF-8字符。

当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。
Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode的文本处理更为方便，也可以使用 byte 型进行默认字符串处理，性能和扩展性都有照顾

// 遍历字符串
func traversalString() {
    
    s := "pprof.cn博客"
    for i := 0; i < len(s); i++ {
     //byte
        fmt.Printf("%v(%c) ", s[i], s[i])
    }
    fmt.Println()
    for _, r := range s {
     //rune
        fmt.Printf("%v(%c) ", r, r)
    }
    fmt.Println()
}

输出：

   112(p) 112(p) 114(r) 111(o) 102(f) 46(.) 99(c) 110(n) 229(å) 141() 154() 229(å) 174() 162(¢)
   112(p) 112(p) 114(r) 111(o) 102(f) 46(.) 99(c) 110(n) 21338(博) 23458(客)