[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)

 

posted @   风间悠香  阅读(197)  评论(0)  编辑  收藏  举报
编辑推荐：
· AI与.NET技术实操系列：向量存储与相似性搜索在 .NET 中的实现
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· Linux系列：如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
· SQL Server 2025 AI相关能力初探
阅读排行：
· winform 绘制太阳，地球，月球 运作规律
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· AI与.NET技术实操系列（五）：向量存储与相似性搜索在 .NET 中的实现
· 超详细：普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
历史上的今天：
2020-04-30 [Python自学] 爬虫（1）爬虫基础概念
2020-04-30 [计算机基础] 汇编学习（4）
2020-04-30 [计算机基础] 汇编学习（3）
点击右上角即可分享
微信分享提示
AI IDE Trae

目录导航

一、整型
1.整型
2.整型之间的转换
3.整型和字符串之间的转换
4.进制转换
二、常见数学运算
三、指针、声明变量、new
1.声明变量
2.指针
3.new关键字
四、超大整型
1.定义超大整型
2.写入数据
五、浮点型
1.浮点型变量
2.使用decimal精准浮点
六、字符串
1.golang中字符串的本质
2.字节集合与字符串
3.rune类型
4.字符串常见操作
七、数组
1.数组声明
2.数组指针
3.数组内存管理
 4.数组常用功能