[Golang自学] 简单的语法汇总2

一、整型

1.整型

在Golang中包含有符号和无符号两种整形，按可保存值的范围大小可分为以下：

有符号整型：
int8 (-128~127)
int16 (-32768~32767)
int32 (-2147483648~2147483647)
int64 (-9223372036854775808~9223372036854775807)
int
    在32位操作系统上使用默认为int32
    在64位操作系统上使用默认为int64

无符号整型：
uint8 (0~255)
uint16 (0~65535)
uint32 (0~4294967295)
uint64 (0~18446744073709551615)
int
    在32位操作系统上使用默认为uint32
    在64位操作系统上使用默认为uint64

如果要使用比int64范围还大的整数类型，则需要使用Golang提供的big.Int包提供的类型。

2.整型之间的转换

var num1 int8 = 18
var num2 int16 = 20
num3 := int16(num1) + num2  // 不能将int8和int16类型相加，需要转换为相同类型
fmt.Println(num3)

基本和C/C++的类型强制转换一样。

3.整型和字符串之间的转换

整型转换为字符串：

v1 := 19
result := strconv.Itoa(v1)  // v1为int类型，可以直接转换为string
fmt.Println(result, reflect.TypeOf(result)) // 打印result类型，输出string
var v2 int8 = 19
data := strconv.Itoa(int(v2)) // 这里需要将int8转换为int,因为Itoa只接受int类型参数
fmt.Println(data)

字符串转换为整型：

str1 := "666"
res, err := strconv.Atoi(str1)
if err == nil {  // "666"可以被转换为整型，所以err为空
    fmt.Println(res) // 输出666
}
str2 := "SB"
res, err = strconv.Atoi(str2)
fmt.Println(res, err) // "SB"不能转换为整型，所以res输出0，err输出：strconv.Atoi: parsing "SB": invalid syntax,

4.进制转换

十进制转二进制、八进制、十六进制：

vv := 99
// 将十进制转换为二进制
rr1 := strconv.FormatInt(int64(vv), 2) // 第一个参数必须为int64类型，第二个参数代表要转换为的进制
fmt.Println(rr1, reflect.TypeOf(rr1))  // 输出1100011 string

vv := 99
// 将十进制转换为八进制
rr1 := strconv.FormatInt(int64(vv), 8)
fmt.Println(rr1, reflect.TypeOf(rr1))  // 输出143 string

vv := 99
// 将十进制转换为十六进制
rr1 := strconv.FormatInt(int64(vv), 16)
fmt.Println(rr1, reflect.TypeOf(rr1))  // 输出63 string

二进制、八进制、十六进制转十进制整型：

data := "1001000110"
// result为转换后的十进制（永远是int64类型），err为错误信息
// 第一个参数为需要转换的二进制字符串，第二个参数指定转换前的进制，
// 第三个参数用于约束转换的范围，例如16代表int16，如果待转换的二进制值大于int16的范围，则err会报错。0代表int
result, err := strconv.ParseInt(data, 2, 16)
if err == nil {
    fmt.Println(result,reflect.TypeOf(result)) // 打印 582 int64
}

特别注意第三个参数，只用作约束范围，不代表返回值result的类型。

进制间转换关系图：

二、常见数学运算

package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Println(math.Abs(-19)) // 取绝对值
    fmt.Println(math.Floor(3.14)) // 向下取整
    fmt.Println(math.Ceil(3.14)) // 向上取整
    fmt.Println(math.Round(3.3478)) // 四舍五入
    fmt.Println(math.Round(3.3478*100) / 100) // 保留两位小数
    fmt.Println(math.Mod(11, 3)) // 同11%3，取余
    fmt.Println(math.Pow(2, 5)) // 计算次方，2的5次方
    fmt.Println(math.Pow10(2)) // 计算10次方，2的10次方
    fmt.Println(math.Max(1,2)) // 取较大值（只能输入两个值）
    fmt.Println(math.Min(1,2)) // 取较小值（只能输入两个值）
}

三、指针、声明变量、new

1.声明变量

var v1 int  // 在内存中开辟一块内存用于存放int类型的值，默认为0
v2 := 999 // 在内存中开辟一块内存用于存放int类型的值，赋值为999

2.指针

与C语言几样，只是声明和定义形式不同：

var ptr1 *int  // 声明一个int类型的指针变量，该指针指向的是nil，也就是空指针

3.new关键字

ptr2 := new(int) // 开辟一个用于存放int的内存块A，存放的默认值为0，另外再创建一个用于存放int指针的内存块，存放A的地址。
*ptr2 = 999 // 给ptr2指向的内存块赋值为999

new关键字，用于创建一块内存块，并帮我们初始化，并返回一个指向其空间的指针。

四、超大整型

超出int64的时候，就需要使用超大整型，big.Int类型。

1.定义超大整型

var v1 big.Int
var v2 *big.Int
v3 := new(big.Int)

2.写入数据

package main

import (
    "fmt"
    "math/big"
)

func main() {

    var v1 big.Int
    v1.SetInt64(10) // 将1990写入v1
    fmt.Println(v1) // 输出{false [9182637123817232]}

    v2:=new(big.Int)
    v2.SetString("9182637123817232",10) // 将其以10进制写进v1，2进制8进制一样
    fmt.Println(*v2)

    // 做加法
    res := new(big.Int)
    res.Add(&v1,v2) // Add方法要穿指针
    fmt.Println(res)
}

五、浮点型

1.浮点型变量

float32和float64，分别用32bit和64bit来存储浮点数。

var f1 float32  // 声明f1为float32类型
f1 = 3.14
f2 := 9.99  // 默认为float64
f3 := float64(f1)+f2  // f1和f2不能直接相加
fmt.Println(f3)

注意，不指定类型的情况下，默认使用float64类型，在做运算时要注意类型一致。

2.使用decimal精准浮点

1）在goland IDE中使用命令行安装第三方包decimal

先在项目的Setting页面设置GOPATH：

在goland的terminal中使用命令：

D:\golang_workspace\src\day1>go env -w GOPROXY=https://goproxy.cn

D:\golang_workspace\src\day1>go get github.com/shopspring/decimal

在执行go get后，可以在%GOPATH%/src目录下看到decimal源码：

 

在%GOPATH%/pkg目录下可以看到编译好的静态库：

2）使用decimal

package main

import (
    "fmt"
    "github.com/shopspring/decimal"
)

func main() {

    var v1 = decimal.NewFromFloat(0.0000000000019)
    var v2 = decimal.NewFromFloat(0.29)

    var v3 = v1.Add(v2)         // 加法
    var v4 = v1.Sub(v2)         // 减法
    var v5 = v1.Mul(v2)         // 乘法
    var v6 = v1.Div(v2)         // 除法
    fmt.Println(v3, v4, v5, v6) // 0.2900000000019 -0.2899999999981 0.000000000000551 0.0000000000065517

    var price = decimal.NewFromFloat(3.4675)
    var d1 = price.Round(2)    // 四舍五入保留两位小数
    var d2 = price.Truncate(2) // 截取保留两位小数
    fmt.Println(d1, d2)        // 打印3.47和3.46
}

六、字符串

1.golang中字符串的本质

golang中字符串的本质是UTF-8编码的序列

var name string = "中国"
fmt.Println(name[0],strconv.FormatInt(int64(name[0]),2)) // 打印"中国"字符串的第一个字节  打印228 11100100
fmt.Println(name[1],strconv.FormatInt(int64(name[1]),2)) // 打印"中国"字符串的第二个字节  打印184 10111000
fmt.Println(name[2],strconv.FormatInt(int64(name[2]),2)) // 打印"中国"字符串的第三个字节  打印173 10101101
fmt.Println(name[3],strconv.FormatInt(int64(name[3]),2)) // 打印"中国"字符串的第四个字节  打印229 11100101
fmt.Println(name[4],strconv.FormatInt(int64(name[4]),2)) // 打印"中国"字符串的第五个字节  打印155 10011011
fmt.Println(name[5],strconv.FormatInt(int64(name[5]),2)) // 打印"中国"字符串的第六个字节  打印189 10111101
fmt.Println(len(name)) // 获取name中字符串的字节长度 打印6

2.字节集合与字符串

将字符串转换为一个字节的"集合"：

// 将字符串转换为字节"集合"
byteSet := []byte(name)
fmt.Println(byteSet)  // 打印[228 184 173 229 155 189]，其中包含6个字节的十进制表示

将字节"集合"转换为字符串：

// 将字节集合转换为string
byteList := []byte{228,184,173,229,155,189}
fmt.Println(string(byteList)) // 打印"中国"

3.rune类型

rune类型一般用于代表一个unicode码点，例如一个汉字：

runeSet:= []rune(name) // 将"中国"转换为rune"集合"
fmt.Println(runeSet) // 打印 [20013 22269]
fmt.Println(runeSet[0]) // 拿到第一个rune，打印 20013。这个rune代表的就是"中"字，三个字节的十进制表示
fmt.Println(strconv.FormatInt(int64(runeSet[0]),16)) // 转换为16进制为4e2d

在Unicode码表中，4e2d的16进制数就表示"中"字。

获取字符串中中文的长度：

runeLength := utf8.RuneCountInString(name)
fmt.Println(runeLength) // 打印2，表示有2个汉字

4.字符串常见操作

1）字符串长度

len(name) // 获取字符串的字节长度
utf8.RuneCountInString(name) // 获取字符长度（字符个数）

2）是否以XX开头或结尾

strings.HasPrefix(name,"中") // 是否以"中"字开头
strings.HasSuffix(name,"国") // 是否以"国"字结尾

3）大小写转换

strings.ToUpper(name) // 转换为大写
strings.ToLower(name) // 转换为小写

4）去除两边的指定字符

strings.TrimRight(name,"w") // 去除最右边的'w'
strings.TrimLeft(name,"w") // 去除最左边的'w'
strings.Trim(name,"w") // 去除左右两边的'w'

5）替换字符

strings.Replace(name,"w","m",1) // 在name中从左到右找到第一个w，替换为m
strings.Replace(name,"w","m",2) // 从左到右找到第二个w替换为m
strings.Replace(name,"w","m",-1) // 找到所有w替换为m

6）分割

str1 := "192.168.1.9"
result := strings.Split(str1,".") // 将str1字符串按"."分割
fmt.Println(result,reflect.TypeOf(result)) // 打印[192 168 1 9] []string

7）拼接

不建议使用"字符串"+"字符串"的形式。

dataList := []string{"我爱", "中国"}
res := strings.Join(dataList, "-")
fmt.Println(res) // 打印"我爱-中国"

// 建议：效率更高一点（go 1.10之前）
var buffer bytes.Buffer
buffer.WriteString("我想") // 加入到buffer中
buffer.WriteString("您")
buffer.WriteString("喜欢中国")
data:= buffer.String() // 将buffer转换为string
fmt.Println(data)

// 建议：效果更更更高一点（go 1.10之后）
var builder strings.Builder
builder.WriteString("我想") // 加入到string builder中
builder.WriteString("我也")
builder.WriteString("喜欢中国")
value:= builder.String() // 将builder转换为string
fmt.Println(value)

8）字符与编码转换

// 编码转字符
v1 := string(65)
fmt.Println(v1) // 打印"A"
v2 := string(27494)
fmt.Println(v2) // 打印"武"
// 字符串转成编码
v3,size := utf8.DecodeRuneInString("中") // 将字符"中"转换为编码，以及字节长度
fmt.Println(v3,size) // 打印20013 3

9）切片和循环

mystr := "我爱北京天安门"
fmt.Println(mystr[0:3]) // 取前三个字节，也就是中文"我"

// 循环获取所有字节
for i:=0;i<len(mystr);i++ {
    fmt.Println(i,mystr[i]) // 打印每个index上的字节，7个中文，一共21个字节
}

// 使用for range遍历
for idx,item := range mystr {
    fmt.Println(idx,item)
}

// 转换为rune获取遍历中文
runeList := []rune(mystr)
for idx,item := range runeList {
    fmt.Println(idx,string(item))
}

七、数组

1.数组声明

四种方式：

var numbers [3]int
numbers[0] = 99
numbers[1] = 100
numbers[2] = 5

var names = [3]string{"Leo","John","Lee"}

var ages = [3]int{0:21, 2:47} // 将第一个数初始化为21，第3个数初始化为47

// 当声明时赋值的话，可以省略个数
var names = [...]string{"Leo","John","Lee"}
var ages = [...]int{0:21,2:47}

2.数组指针

var p_num *[3]int // 申明一个指向[3]int类型数组的指针
p_num = &[3]int{1,2,3} // 定义一个[3]int数组，将地址复制给p_num
fmt.Println(*p_num) // 打印p_num指针指向的值，[1 2 3]


numbers := new([3]int)
numbers[0] = 99
numbers[1] = 1
numbers[2] = 2
fmt.Println(*numbers)

3.数组内存管理

类似于C/C++：

 

 4.数组常用功能

1）数组长度

nums := [3]int{1,2,3}
fmt.Println(len(nums)) // 打印3

2）遍历

nums := [3]int{11,22,33}
for key,item := range nums {
    fmt.Println(key,item)
}

nums := [3]int{11,22,33}
for _,item := range nums {
    fmt.Println(item) // 不需要idx的时候，可以用"_"
}

3）数组的嵌套

var data [2][3]int  // 声明一个二维数组
data[0] = [3]int{1,2,3}
data[1] = [3]int{4,5,6}
fmt.Println(data)  // 打印[[1 2 3] [4 5 6]]

var data *[2][3]int
data = &[2][3]int{{1,2,3},{4,5,6}}
fmt.Println(data)