目录
前言
本文将基于GO语言学习（3）数据类型概述，介绍如何声明数字类型，字符串类型，布尔类型的变量，以及对应的数据运算。
1.数据变量声明
1.1 基本声明方式
在GO语言中，使用var关键字进行变量声明。
var 变量名 数据类型 = 表达式 //带初始值的声明
var 变量名 数据类型 // 不带初始值的声明
// 也可以一次性声明多个同类型的变量
var 变量名1,变量名2 数据类型 = 表达式1，表达式2 // 变量名1的值为表达式1
var 变量名1,变量名2 数据类型变量的名字可不是随意取的，它得满足以下规则：
- 由字母、数字、下划线组成，但不能以数字开头
- 变量名不能与 Go 语言的保留字和关键字相同
- 变量名是区分大小写的，例如
age和Age是不同的变量
而在GO语言中，主要有以下25个关键字，下面这些关键字都不能作为变量名，否则会出现编译错误。
| 关键字 | 用途 |
|---|---|
break | 终止循环 |
case | switch 语句中的分支 |
chan | 声明通道类型 |
const | 声明常量 |
continue | 跳过当前循环的剩余部分，进入下一次迭代 |
default | switch 或 select 语句中的默认分支 |
defer | 延迟函数调用，通常用于资源清理 |
else | if 语句的分支 |
fallthrough | switch 语句中，跳过当前分支，进入下一个分支 |
for | 循环 |
func | 声明函数 |
go | 启动一个协程（goroutine） |
goto | 跳转到指定的标签 |
if | 条件语句 |
import | 导入包 |
interface | 声明接口类型 |
map | 声明映射类型 |
package | 声明包 |
range | 循环遍历数组、切片、映射等 |
return | 从函数返回 |
select | 选择通道操作 |
struct | 声明结构体类型 |
switch | 多分支选择 |
type | 声明类型 |
var | 声明变量 |
1.2 简短声明
对于局部变量，Go语言还提供了简短声明（短变量声明）语法:=，它可以在声明变量的同时完成初始化，且类型推断自右侧表达式：
变量名 := 表达式
// 对多个变量赋值
变量1,变量2 := 表达式1,表达式2 注意：
:=只能在函数内部使用，不能用于全局变量声明- 如果变量已经使用 var 声明过了，再使用 := 声明变量，就产生编译错误
以下是错误的例子：
var Val int
Val :=1 // 这时候会产生编译错误，因为 Val 已经声明，不需要重新声明
2. 数字类型
2.1 数字类型的变量声明
package main
import "fmt"
func main() {
var a int // 默认为0
var b, c int = 3, 4 // b为3，c为4
x, f := 5, 3.14 // 简短声明,x为int型，值为5；f为float型，值为3.14
fmt.Printf("a = %d, b = %d, c = %d,x=%d,f=%f\n", a, b, c, x, f)
}如果不确定一个变量的数据类型，可以使用%T占位符，进行输出，查看对应变量的数据类型
2.2 数字类型的基本运算
| 运算符 | 类型 | 描述 | 示例 | 结果 |
|---|---|---|---|---|
+ | 算术运算符 | 加法运算 | a + b | a + b 的结果 |
- | 算术运算符 | 减法运算 | a - b | a - b 的结果 |
* | 算术运算符 | 乘法运算 | a * b | a * b 的结果 |
/ | 算术运算符 | 除法运算（整数除法结果为整数，浮点数除法结果为浮点数） | a / b | a / b 的结果 |
% | 算术运算符 | 取模运算（仅适用于整数） | a % b | a 除以 b 的余数 |
++ | 自增运算符 | 变量值加 1（后缀） | a++ | a 的值加 1 |
-- | 自减运算符 | 变量值减 1（后缀） | a-- | a 的值减 1 |
+= | 复合赋值运算符 | 将右侧值加到左侧变量上，并赋值给左侧变量 | a += b | a = a + b |
-= | 复合赋值运算符 | 将右侧值从左侧变量中减去，并赋值给左侧变量 | a -= b | a = a - b |
*= | 复合赋值运算符 | 将右侧值与左侧变量相乘，并赋值给左侧变量 | a *= b | a = a * b |
/= | 复合赋值运算符 | 将右侧值除以左侧变量，并赋值给左侧变量 | a /= b | a = a / b |
%= | 复合赋值运算符 | 将右侧值对左侧变量取模，并赋值给左侧变量 | a %= b | a = a % b |
== | 比较运算符 | 比较两个值是否相等 | a == b | 如果 a 等于 b，返回 true，否则返回 false |
!= | 比较运算符 | 比较两个值是否不相等 | a != b | 如果 a 不等于 b，返回 true，否则返回 false |
> | 比较运算符 | 比较左侧值是否大于右侧值 | a > b | 如果 a 大于 b，返回 true，否则返回 false |
< | 比较运算符 | 比较左侧值是否小于右侧值 | a < b | 如果 a 小于 b，返回 true，否则返回 false |
>= | 比较运算符 | 比较左侧值是否大于或等于右侧值 | a >= b | 如果 a 大于或等于 b，返回 true，否则返回 false |
<= | 比较运算符 | 比较左侧值是否小于或等于右侧值 | a <= b | 如果 a 小于或等于 b，返回 true，否则返回 false |
- 示例代码：
package main
import "fmt"
func main() {
var a, b int = 10, 5
fmt.Println("a + b =", a+b) // 加法
fmt.Println("a - b =", a-b) // 减法
fmt.Println("a * b =", a*b) // 乘法
fmt.Println("a / b =", a/b) // 除法
fmt.Println("a % b =", a%b) // 取模
a++ // 自增
fmt.Println("a++ =", a)
b-- // 自减
fmt.Println("b-- =", b)
a += b // 复合赋值
fmt.Println("a += b =", a)
fmt.Println("a == b =", a == b) // 比较相等
fmt.Println("a != b =", a != b) // 比较不相等
fmt.Println("a > b =", a > b) // 比较大于
fmt.Println("a < b =", a < b) // 比较小于
fmt.Println("a >= b =", a >= b) // 比较大于等于
fmt.Println("a <= b =", a <= b) // 比较小于等于
}注意：整型中参与上述运算的数据类型必须一致，必须都为整型，或都为浮点型，否则则会出错。
2.3 整型与浮点型的转换
package main
import (
"fmt"
"math"
)
func main() {
var a, b int
f := 3.94
a = int(f)
b = int(math.Round(f)) // 四舍五入
fmt.Println(a, b) // 输出3与4
}GO语言中，浮点型转换为整型，只保留浮点数的整数部分。如果想要四舍五入，可以使用math库中的Round函数。
3. 字符串类型
3.1 字符串声明
声明方式
-
使用双引号：声明普通字符串，支持转义字符。
-
使用反引号：声明原始字符串，不支持转义字符，保留所有内容（包括换行符）。
package main import "fmt" func main() { // 使用双引号声明字符串 str1 := "Hello, World!" fmt.Println("str1:", str1) // 使用反引号声明原始字符串 str2 := `This is a raw string with multiple lines.` fmt.Println("str2:", str2) // 使用转义字符 str3 := "This is a \"quoted\" string." fmt.Println("str3:", str3) }3.2 字符串运算
| 操作 | 描述 |
|---|---|
+ | 字符串拼接 |
== | 比较字符串是否相等 |
!= | 比较字符串是否不相等 |
< | 比较字符串的字典顺序（小于） |
> | 比较字符串的字典顺序（大于） |
strconv.Atoi | 将字符串转换为整数（返回值和错误） |
strconv.ParseFloat | 将字符串转换为浮点数（返回值和错误） |
strconv.Itoa | 将整数转换为字符串 |
strconv.FormatFloat | 将浮点数转换为字符串（指定格式和精度） |
示例代码：
package main
import (
"fmt"
"strconv"
)
func main() {
// 字符串到整数
str := "123"
num, err := strconv.Atoi(str)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("String to int:", num)
}
// 字符串到浮点数
strFloat := "123.45"
numFloat, err := strconv.ParseFloat(strFloat, 64)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("String to float:", numFloat)
}
// 整数到字符串
numInt := 456
strInt := strconv.Itoa(numInt)
fmt.Println("Int to string:", strInt)
// 浮点数到字符串
numFloat2 := 789.01
strFloat2 := strconv.FormatFloat(numFloat2, 'f', -1, 64)
fmt.Println("Float to string:", strFloat2)
}注意：
-
字符串不可变：字符串一旦创建，其内容不能被修改。如果需要修改字符串，可以使用切片或重新拼接。
-
类型转换错误处理：在进行字符串到数字的类型转换时，需要处理可能的错误。
-
字典顺序比较：字符串的比较是基于字典顺序的，比较的是字符的 Unicode 码点值。
4. 布尔型
4.1 布尔型的声明
声明方式
-
直接赋值：直接将
true或false赋值给布尔变量。 -
使用条件表达式：通过条件表达式的结果来初始化布尔变量。
4.2 布尔型的运算
| 操作 | 描述 |
|---|---|
! | 逻辑非，对布尔值取反 |
&& | 逻辑与，只有两个操作数都为 true 时结果才为 true |
| || | 逻辑或，只要有一个操作数为 true，结果就为 true |
strconv.FormatBool | 将布尔值转换为字符串 |
strconv.ParseBool | 将字符串转换为布尔值（返回值和错误） |
示例代码：
package main
import "fmt"
func main() {
// 逻辑非
a := true
fmt.Println("!a:", !a) // false
// 逻辑与
b := false
fmt.Println("a && b:", a && b) // false
// 逻辑或
fmt.Println("a || b:", a || b) // true
}示例代码：
package main
import (
"fmt"
"strconv"
)
func main() {
// 布尔到字符串
isTrue := true
strTrue := strconv.FormatBool(isTrue)
fmt.Println("Bool to string:", strTrue) // "true"
// 字符串到布尔
str := "true"
boolVal, err := strconv.ParseBool(str)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("String to bool:", boolVal) // true
}
}注意：
-
布尔值的默认值：布尔变量的默认值为
false。 -
类型转换错误处理：在进行字符串到布尔的类型转换时，需要处理可能的错误。只有
"true"和"false"（不区分大小写）会被正确解析为布尔值，其他字符串会导致错误。 -
逻辑运算的短路特性：在逻辑与（
&&）和逻辑或（||）运算中，Go 语言会进行短路计算。例如，a && b中，如果a为false，则不会计算b，直接返回false。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
