GO的学习笔记4

2024/2/18 学习笔记 GO基础

GoLang的语言基础

1.整型

Go中的整型分为有符号和无符号两大类，有符号的包含负值，无符号不包含负值。

有符号整型：

int8（-128 -> 127）
int16（-32768 -> 32767）
int32（-2,147,483,648 -> 2,147,483,647）
int64（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807）
int
- 在 32 位操作系统上使用 32 位（-2,147,483,648 -> 2,147,483,647） 2**32
- 在 64 位操作系统上使用 64 位（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,80）2**64

无符号整数：

uint8（0 -> 255）
uint16（0 -> 65,535）
uint32（0 -> 4,294,967,295）
uint64（0 -> 18,446,744,073,709,551,615）
uint
- 在 32 位操作系统上使用32 位（0 -> 4,294,967,295） 2**32
- 64 位操作系统上使用 64 位（0 -> 18,446,744,073,709,551,615） 2**64

不同整型可表示的数据范围不同，我们需要根据自己的需求来选择适合的类型。

1.2 整型与字符串的转换

package main

import (
    "fmt"
    "strconv"
)

func main() {
    //整型转化为字符串类型
    //v1 := 19
    //result := strconv.Itoa(v1)
    //fmt.Println(result, reflect.TypeOf(result))
    //
    //var v2 int8 = 17
    //data := strconv.Itoa(int(v2))
    //fmt.Println(data, reflect.TypeOf(data))
    v1 := "666"
    result, err := strconv.Atoi(v1)
    if err == nil {
        fmt.Println("转化成功", result)
    } else {
        fmt.Println("转化失败")
    }
    //fmt.Println(result, err)

    v2 := "zlw"
    data, err := strconv.Atoi(v2)
    if err == nil {
        fmt.Println("转化成功", result)
    } else {
        fmt.Println("转化失败")
    }
    fmt.Println(data, err)
}

1.3 进制转换

Go代码中：
- 十进制，整型的方式存在。
- 其他进制，是以字符串的形式存在。
整形，10进制数。

十进制转换为其他进制：

package main

import (
    "fmt"
    "reflect"
    "strconv"
)

func main() {
    //转化2进制
    v1 := 10

    result := strconv.FormatInt(int64(v1), 2)

    fmt.Println(result, reflect.TypeOf(result))

}

其他进制转换为十进制：

package main

import (
    "fmt"
    "reflect"
    "strconv"
)

func main() {
    v2 := "10101011"

    result1, err := strconv.ParseInt(v2, 2, 0)
    fmt.Println(result1, err)
}

1.4 常见数学运算

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.5478*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))               // 两个值，取较小值
}

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.5478*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))               // 两个值，取较小值
}

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.5478*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))               // 两个值，取较小值
}

1.5 超大整型

第一步：创建对象

创建超大整型对象

package main

import (
    "fmt"
    "math/big"
)

func main() {
    // 第一步：创建一个超大整型的一个对象
    var v1 big.Int
    var v2 big.Int

    // 第二步：在超大整型对象中写入值
    v1.SetInt64(9223372036854775807)
    fmt.Println(v1)

    v2.SetString("92233720368547758089223372036854775808", 10)
    fmt.Println(v2)

    // 第一步：创建一个超大整型的一个对象
    v3 := new(big.Int)
    v4 := new(big.Int)

    // 第二步：在超大整型对象中写入值
    v3.SetInt64(9223372036854775807)
    fmt.Println(v3)

    v4.SetString("92233720368547758089223372036854775808", 10)
    fmt.Println(v4)
}

第二步：加减乘除

package main

import (
    "fmt"
    "math/big"
)

func main() {

    n1 := new(big.Int)
    n1.SetInt64(89)
    n2 := new(big.Int)
    n2.SetInt64(99)

    //加法
    result := new(big.Int)
    result.Add(n1, n2)
    fmt.Println(result)

    //减法
    result.Sub(n2, n1)
    fmt.Println(result)

    //乘法
    result.Mul(n1, n2)
    fmt.Println(result)

    // 除（地板除，只能得到商）
    result.Div(n1, n2)
    fmt.Println(result)

    // 除，得商和余数
    minder := new(big.Int)
    result.DivMod(n1, n2, minder)
    fmt.Println(result, minder)
}

最后建议

尽量new方式去初始化并返回一个指针类型的方式。
易错的点（int类型和*int类型）

2.浮点型

浮点数，计算机中小数的表示方式，如：3.14

Go语言中提供了两种浮点型：

float32，用32位（4个字节）来存储浮点型。
float64，用64位（8个字节）来存储浮点型。

2.1 非精确

float类型，计算机中小数的非精确的表示方式，如：3.14

package main

import (
    "fmt"
)

func main() {
    var v1 float32
    v1 = 3.14
    v2 := 99.9
    v3 := float64(v1) + v2
    fmt.Println(v1, v2, v3)

    v4 := 0.1
    v5 := 0.2
    result := v4 + v5
    fmt.Println(result)

}

2.2 decimal

Go语言内部没有decimal。

第三方包，需要在本地的Go环境中先安装再使用。第三方包源码地址：https://github.com/shopspring/decimal 。

第一步：安装第三发的包

go get github.com/shopspring/decimal

命令执行完成之后，在 $GOPATH/src的目录下就会出现 github/shopspring/decimal的目录，这就是第三方模块安排的位置。

第二步：使用decimal包

package main

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

func main() {
    var v1 float32
    v1 = 3.14
    v2 := 99.9
    v3 := float64(v1) + v2
    fmt.Println(v1, v2, v3)

    v4 := 0.1
    v5 := 0.2
    result := v4 + v5
    fmt.Println(result)

    v6 := 0.3
    v7 := 0.2
    data := v6 + v7
    fmt.Println(data)
    var price = decimal.NewFromFloat(3.4626)
    var data1 = price.Round(1)    // 保留小数点后1位（四舍五入）
    var data2 = price.Truncate(1) // 保留小数点后1位
    fmt.Println(data1, data2)     // 输出：3.5  3.4
}

3.布尔类型

表示真假，一般是和条件等配合使用，用于满足某个条件时，执行某个操作

package main

import (
    "fmt"
    "reflect"
    "strconv"
)

func main() {
    // 字符串 转换 布尔类型
    // true:"1", "t", "T", "true", "TRUE", "True"
    // false:"0", "f", "F", "false", "FALSE", "False"
    //false,err错误信息
    v1, err := strconv.ParseBool("t")
    fmt.Println(v1, err, reflect.TypeOf(v1))

    // 布尔类型 转换 字符串
    v2 := strconv.FormatBool(false)
    fmt.Println(v2, reflect.TypeOf(v2))
}

4.字符串

4.1 字符串的底层存储

计算机中所有的操作和数据最终都是二进制，即：1000100001011…

Go语言中的字符串是utf-8编码的序列。

package main

import (
    "fmt"
    "strconv"
    "unicode/utf8"
)

func main() {
    // unicode字符集：文字 -> 码点（ucs4, 4个字节表示）
    // utf-8编码，对unicode字符集的码点进行编码最终得到：1000100001
    //var name string = "zlw"
    //fmt.Printf(name)

    var name string = "周洛薇"

    // 周 => 11100101 10010001 10101000
    fmt.Println(name[0], strconv.FormatInt(int64(name[0]), 2))
    fmt.Println(name[1], strconv.FormatInt(int64(name[1]), 2))
    fmt.Println(name[2], strconv.FormatInt(int64(name[2]), 2))

    // 周 => 11100101 10010001 10101000
    fmt.Println(name[3], strconv.FormatInt(int64(name[3]), 2))
    fmt.Println(name[4], strconv.FormatInt(int64(name[4]), 2))
    fmt.Println(name[5], strconv.FormatInt(int64(name[5]), 2))

    // 周 => 11100101 10010001 10101000
    fmt.Println(name[6], strconv.FormatInt(int64(name[6]), 2))
    fmt.Println(name[7], strconv.FormatInt(int64(name[7]), 2))
    fmt.Println(name[8], strconv.FormatInt(int64(name[8]), 2))

    // 2. 获取字符串的长度：9（字节长度）
    fmt.Println(len(name))

    // 3. 字符串转换为一个"字节集合"
    byteSet := []byte(name)
    fmt.Println(byteSet) // [229 145 168 230 180 155 232 150 135]
    // 4. 字节的集合转换为字符串
    byteList := []byte{229, 145, 168, 230, 180, 155, 232, 150, 135}
    targetString := string(byteList)
    fmt.Println(targetString)

    // 5. 将字符串转换为 unicode字符集码点的集合
    tempSet := []rune(name)
    fmt.Println(tempSet) //[21608 27931 34183]
    fmt.Println(tempSet[0], strconv.FormatInt(int64(tempSet[0]), 16))
    fmt.Println(tempSet[1], strconv.FormatInt(int64(tempSet[1]), 16))
    fmt.Println(tempSet[2], strconv.FormatInt(int64(tempSet[2]), 16))

    // 6. "rune集合" 转换 为字符串
    runeList := []rune{21608, 27931, 34183}
    targetName := string(runeList)
    fmt.Println(targetName)

    // 7. 长度的处理（获取字符长度）
    runeLength := utf8.RuneCountInString(name)
    fmt.Println(runeLength)

    result, err := strconv.ParseInt("123435", 10, 0)
    fmt.Println(result, err)
}

4.2 字符串常见功能

package main

import (
    "fmt"
    "strings"
    "unicode/utf8"
)

func main() {
    //获取长度
    var name string = "周洛薇"
    fmt.Println(len(name))                    // 获取 字节 长度，输出：9
    fmt.Println(utf8.RuneCountInString(name)) // 获取字符长度，输出：3

    //是否以xx开头
    result1 := strings.HasPrefix(name, "周")
    fmt.Println(result1) // 输出：true

    //是否以xx结尾
    result2 := strings.HasSuffix(name, "薇")
    fmt.Println(result2) // 输出：true

    //是否包含
    name = "zlw love cl"
    result3 := strings.Contains(name, "zlw")
    fmt.Println(result3)

    //变大写
    result4 := strings.ToUpper(name)
    fmt.Println(result4)
    //变小写
    result5 := strings.ToLower(result4)
    fmt.Println(result5)

    //去两边
    result6 := strings.TrimRight(name, "cl") // 去除右边的
    result7 := strings.TrimLeft(name, "zlw") // 去除左边的w
    result8 := strings.Trim(name, "zlw")

    fmt.Println(result6, result7, result8)

    //替换
    name = "zlw love love cl"
    result9 := strings.Replace(name, "love", "LOVE", 1)   // 找到love替换为LOVE，从左到右找第一个替换
    result10 := strings.Replace(name, "love", "LOVE", 2)  // 找到love替换为LOVE，从左到右找前两个替换
    result11 := strings.Replace(name, "love", "LOVE", -1) // 找到love替换为LOVE，替换所有
    fmt.Println(result9, result10, result11)

    //分割
    name = "抬老子的意大利的炮来"
    result := strings.Split(name, "的")
    // 根据`的`进行切割，获取一个切片（类似于一个数组）
    fmt.Println(result) // [ 抬老子, 意大利, 炮来 ]
}

package main

import (
    "bytes"
    "fmt"
    "strconv"
    "strings"
    "unicode/utf8"
)

func main() {
    // 不建议
    message := "zlw love" + " cl"
    fmt.Println(message)

    // 建议：效率高一些
    dataList := []string{"zlw love", " cl"}
    result := strings.Join(dataList, "")
    fmt.Println(result) //zlw love cl

    // 建议：效率更高一些（go 1.10之前）
    var buffer bytes.Buffer
    buffer.WriteString("zlw ")
    buffer.WriteString("love ")
    buffer.WriteString("cl")
    //data := buffer.String()
    //fmt.Println(data)

    // 建议：效率更更更更高一些（go 1.10之后）
    var builder strings.Builder
    builder.WriteString("zlw love ")
    builder.WriteString("cl")
    value := builder.String()
    fmt.Println(value)

    //string转换为int
    name := "666"
    var data, _ = strconv.Atoi(name)
    fmt.Println(data)
    result1, err := strconv.ParseInt(name, 10, 0)
    fmt.Println(result1, err)

    //int转换为String
    result2 := strconv.Itoa(888)
    fmt.Println(result2)

    // 字符串 和 “字节集合”
    name = "周洛薇"
    // 字符串转换为一个"字节集合"
    byteSet := []byte(name)
    fmt.Println(byteSet) // [230,173,166,230,178,155,233,189,144]

    // 字节的集合转换为字符串
    byteList := []byte{229, 145, 168, 230, 180, 155, 232, 150, 135}
    targetString := string(byteList)
    fmt.Println(targetString)

    tempSet := []rune(name)
    fmt.Println(tempSet) //[21608 27931 34183]
    fmt.Println(tempSet[0], strconv.FormatInt(int64(tempSet[0]), 16))
    fmt.Println(tempSet[1], strconv.FormatInt(int64(tempSet[1]), 16))
    fmt.Println(tempSet[2], strconv.FormatInt(int64(tempSet[2]), 16))

    // 6. "rune集合" 转换 为字符串
    runeList := []rune{21608, 27931, 34183}
    targetName := string(runeList)
    fmt.Println(targetName)

    //string 和 字符
    v1 := string(65)
    fmt.Println(v1) // A

    v2 := string(21608)
    fmt.Println(v2) // 周

    // 字符串转数字
    v3, size := utf8.DecodeRuneInString("A")
    fmt.Println(v3, size) // 65    1

    v4, size := utf8.DecodeRuneInString("周")
    fmt.Println(v4, size) // 21608 3
}

5.数组

数组，定长且元素类型一致的数据集合。

5.1 可变和拷贝

package main

import "fmt"

func main() {
    // 1. 长度
    //name := [2]string{"周洛薇", "zlw"}
    //fmt.Println(len(name))

    // 2. 索引
    //name := [2]string{"周洛薇", "zlw"}
    //data := name[0]
    //fmt.Println(data)
    //name[0] = "eric"
    //fmt.Println(name)

    // 3. 切片
    //nums := [3]int32{11, 22, 33}
    //data := nums[0:2] // 获取   0 <= 下标 < 2
    //fmt.Println(data)

    // 4. 循环
    //nums := [3]int32{11, 22, 33}
    //for i:=0;i<len(nums);i++{
    //    fmt.Println(i, nums[i] )
    //}

    // 5.for range 循环
    nums := [3]int32{11, 22, 33}
    for key, item := range nums {
        fmt.Println(key, item)
    }

    for key := range nums {
        fmt.Println(key)
    }

    for _, item := range nums {
        fmt.Println(item)
    }

}

5.2 数组嵌套

// [0,0,0]
//var nestData [3]int

// [ [  [0,0,0],[0,0,0]  ],[  [0,0,0],[0,0,0]  ],[  [0,0,0],[0,0,0]  ], ]
//var nestData [3][2][3]int

// [  [0,0,0],[0,0,0]  ]
//var nestData [2][3]int
//nestData[0] = [3]int{11, 22, 33}
//nestData[1][1] = 666
//fmt.Println(nestData)

//nestData := [2][3]int{[3]int{11, 22, 33}, [3]int{44, 55, 66}}
//fmt.Println(nestData)

LOADING