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)