文章目录
- 变量定义
- 1. 整数类型
- 2. 浮点类型
- 3. 字符类型
- 4. 布尔类型
- 5. 字符串类型
- 5.1 字符串的本质
- 5.2 常用字符串处理函数(strings包)
- 5.3 修改字符串的方式
- 6. 数据默认值
- 7. 类型转换
变量定义
代码如下：
package main
import "fmt"
var i1 = 1000
var i2 int
var(
i5 = "hello"
i6 = "world"
)
func main(){
var i int
fmt.Println("i = ", i)
i = 10
fmt.Println("i = ", i)
var num = 10.01
fmt.Println("num = ", num)
num = 100.01
fmt.Println("num = ", num)
Name := "MikeSun"
fmt.Println("Name = ", Name)
var n1 , n2 , n3 int
fmt.Println("n1 = ", n1, "n2 = ", n2, "n3 = ", n3)
var n4 , name1 , n5 = 100, "MikeSun", 200
fmt.Println("n4 = ", n4, "name1 = ", name1, "n5 = ", n5)
n6, name2, n7 := 1000, "joke", 2000
fmt.Println("n6 = ", n6, "name2 = ", name2, "n7 = ", n7)
fmt.Println("i1 = ", i1, "i2 = ", i2)
fmt.Println("i5、i6 = ", i5, i6)
}
1、从main函数上面的全局变量开始分析：
全局变量定义，定义时不声明类型，只定义数值，自动分配类型：
var i1 = 1000
全局变量定义：
var i2 int
全局变量定义，同时定义多个对象：
var(
i5 = “hello”
i6 = “world”
)
2、再来看main函数中的变量定义方式
定义变量不赋值：
var i int
3、对已定义的变量赋值：
i = 10
4、定义变量，不声明类型，默认匹配类型：
var num = 10.01
5、定义并且赋值：
Name := “MikeSun”
上面代码等价于
var Name string
Name = “MikeSun”
6、一次定义多个变量
var n1 , n2 , n3 int
7、一次性定义多个变量并且赋值
var n4 , name1 , n5 = 100, “MikeSun”, 200
8、一次性定义多个变量并且赋值
n6, name2, n7 := 1000, “joke”, 2000
1. 整数类型
| 类型 | 位数 | 取值范围 | 说明 |
|---|---|---|---|
| int | 32/64 | -2³¹ 到 2³¹-1（32位）或 -2⁶³ 到 2⁶³-1（64位） | 平台相关，32位或64位取决于系统 |
| int8 | 8 | -128 到 127 | 8位有符号整数 |
| int16 | 16 | -32,768 到 32,767 | 16位有符号整数 |
| int32 | 32 | -2,147,483,648 到 2,147,483,647 | 32位有符号整数（同 rune） |
| int64 | 64 | -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 | 32位有符号整数 |
| int | 32/64 | 0 到 2³²-1（32位）或 0 到 2⁶⁴-1（64位） | 平台相关，32位或64位取决于系统 |
| uint8 | 8 | -128 到 127 | 8位无符号整数（同byte） |
| uint16 | 16 | -32,768 到 32,767 | 16位无符号整数 |
| uint32 | 32 | -2,147,483,648 到 2,147,483,647 | 32位无符号整数 |
| uint64 | 64 | -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 | 32位无符号整数 |
| byte | 8 | -128 到 127 | uint8 的别名，用于字节数据 |
| rune | 32 | -2,147,483,648 到 2,147,483,647 | int32 的别名，表示 Unicode 码点 |
2. 浮点类型
| 类型 | 位数 | 取值范围（近似） | 精度 | 说明 |
|---|---|---|---|---|
| float32 | 32 | ±1.18e⁻³⁸ 到 ±3.4e³⁸ | 6-7位小数 | 单精度浮点数，占用4字节 |
| float64 | 64 | ±2.23e⁻³⁰⁸ 到 ±1.8e³⁰⁸ | 15-16位小数 | 双精度浮点数，占用8字节 |
| 代码示例如下： | ||||
| 下面代码有介绍科学计数法、省略整数部分写法。 |
package main
import (
"fmt"
"reflect"
)
func main(){
var price float32 = 89.12
fmt.Println("price = ", price)
var num1 float32 = -0.00089
var num2 float64 = -7809656.09
fmt.Println("num1 = ", num1, "num2 = ", num2)
//尾部部分精度丢失，造成精度损失
var num3 float32 = -123.0000901
var num4 float64 = -123.0000901
fmt.Println("num3 = ", num3, "num4 = ", num4)
//Golang的浮点类型默认声明为float64 类型
var num5 = 1.1
fmt.Println("typeof num5 is ", reflect.TypeOf(num5))
//十进制数形式：如：5.12 .512（必须有小数点）
num6 := 5.12
num7 := .123
fmt.Println("num6 = ", num6, "num7 = ", num7)
//科学计数法
num8 := 5.1234e2
num9 := 5.1234E2
num10 := 5.1234E-2
fmt.Println("num8 = ", num8, "num9 = ", num9, "num10 = ", num10)
}
3. 字符类型
Go语言统一使用Unicode编码。
字符类型的本质就是一个整数型，一个整数对应Unicode中的一个字符，从而可以使用特地的输出格式输出，如%c。
Unicode编码是包含ASCII码的，所以前面的256个字符仍然可以当作ASCII码来输出或转换。
package main
import (
"fmt"
)
func main(){
var c1 byte = 'a'
var c2 byte = '0'
fmt.Println("c1 = ", c1)
fmt.Println("c2 = ", c2)
// 要输出ASCII值必须要格式化输出
fmt.Printf("c1 = %c c2 = %c", c1, c2)
var c3 int = '孙'
fmt.Printf("c3 = %c c3 = %d", c3, c3)
var c4 int = 22269
fmt.Printf("\nc4 = %c", c4)
var c5 int = 65
fmt.Printf("\nc5 = %c", c5)
}
运行结果：
c1 = 97
c2 = 48
c1 = a c2 = 0c3 = 孙 c3 = 23385
c4 = 国
c5 = A
4. 布尔类型
代码示例如下：
package main
import (
"fmt"
"unsafe"
)
func main(){
var bflag = false
fmt.Println("bflag = ", bflag)
//注意事项
//1.bool类型占用存储空间是1个字节
fmt.Println("bflag 的占用空间 = ", unsafe.Sizeof(bflag))
//2.bool类型只能取true或者false
}
运行结果：
bflag = false
bflag 的占用空间 = 1
注意：
1、bool类型不能参加±运算，可以参加逻辑运算。
| 运算符 | 说明 | 示例 |
|---|---|---|
| && | 逻辑与（AND） | true && false → false |
| || | 逻辑或（OR） | true |
| ! | 逻辑非（NOT） | !true → false |
| 错误示例： |
b := true
// fmt.Println(b + 1) // 错误：bool 不能参与数学运算
2、Go 是强类型语言，其他类型不能隐式转为 bool
// 错误示例
i := 1
if i { // 编译错误：non-bool i (type int) used as if condition
fmt.Println("True")
}
3、必须显式比较
b := true
// fmt.Println(b + 1) // 错误：bool 不能参与数学运算
5. 字符串类型
5.1 字符串的本质
1、底层结构：Go 的字符串是一个 只读的字节切片（[]byte），存储的是 UTF-8 编码的 Unicode 字符。
2、不可变性：字符串一旦创建，内容不可修改（若需修改需转为 []byte 或 []rune）。
代码示例如下：
package main
import (
"fmt"
"reflect"
)
//演示golang中string 的类型使用
func main(){
var str1 = "北京欢迎您"
fmt.Println("1、", str1)
fmt.Println("sizeof(strl) is", len(str1))
fmt.Println("typeof(strl) is", reflect.TypeOf(str1))
// 字符串拼接方式
str1 += "为您开天辟地"
fmt.Println("2、", str1)
// 字符串拼接需要换行的时候，需要将操作符，例如+，保留在上面一行否则报错
str1 += "hello" + "world" +
"666"
fmt.Println("3、", str1)
// 反引号引用无需转义，原样输出
str1 = `
var str1 = "北京欢迎您"
fmt.Println("1、", str1)
fmt.Println("sizeof(strl) is", len(str1))
fmt.Println("typeof(strl) is", reflect.TypeOf(str1))
`
fmt.Println("4、", str1)
// str1[0] = 'A'
}
运行结果：
1、 北京欢迎您
sizeof(strl) is 15
typeof(strl) is string
2、 北京欢迎您为您开天辟地
3、 北京欢迎您为您开天辟地helloworld666
4、
var str1 = "北京欢迎您"
fmt.Println("1、", str1)
fmt.Println("sizeof(strl) is", len(str1))
fmt.Println("typeof(strl) is", reflect.TypeOf(str1))
5.2 常用字符串处理函数(strings包)
| 函数 | 说明 | 示例 |
|---|---|---|
| strings.Contains(s, substr) | 检查是否包含子串 | Contains(“Hello”, “ell”) → true |
| strings.HasPrefix(s, prefix) | 检查是否以某前缀开头 | HasPrefix(“Go”, “G”) → true |
| strings.HasSuffix(s, suffix) | 检查是否以某后缀结尾 | HasSuffix(“World”, “ld”) → true |
| strings.Split(s, sep) | 按分隔符拆分字符串 | Split(“a,b,c”, “,”) → [“a”,“b”,“c”] |
| strings.Join(slice, sep) | 将字符串切片连接 | Join([]string{“a”,“b”}, “-”) → “a-b” |
| strings.ToUpper(s) | 转为大写 | ToUpper(“go”) → “GO” |
| strings.ToLower(s) | 转为小写 | ToLower(“GO”) → “go” |
| strings.TrimSpace(s) | 去除首尾空白字符 | TrimSpace(" Hi ") → “Hi” |
5.3 修改字符串的方式
若需频繁操作字节/字符，可先转为 []byte 或 []rune：
s := "Hello"
bytes := []byte(s)
bytes[0] = 'h' // 修改后转回字符串
s = string(bytes) // "hello"
6. 数据默认值
Go语言数据默认值均为0（字符串空，nil，false均为0的别名）。
| 类型 | 默认值（零值） | 说明 |
|---|---|---|
| 整数类型 | 0 | 包括 int, int8, int16, int32, int64, uint, uint8 等。 |
| 浮点类型 | 0.0 | 包括 float32, float64。 |
| 布尔类型 | false | bool 类型的零值。 |
| 字符串类型 | “” | （空字符串） |
| 指针类型 | nil | 所有指针（如 *int, *string）的零值。 |
| 引用类型 | nil | 包括 slice（切片）、map（映射）、channel（通道）、func（函数）。 |
| 结构体类型 | 所有字段的零值 | 结构体的每个字段会递归初始化为其类型的零值。 |
| 数组类型 | 所有元素为对应零值 | 如 var arr [3]int 的零值是 [0, 0, 0]。 |
| 接口类型 | nil | 接口变量在未赋值时的零值。 |
| 错误类型 | nil | error 类型的零值。 |
| 代码示例： |
package main
import (
"fmt"
)
func main(){
var a int // 0
var b float32 // 0
var c float64 // 0
var d bool // flase
var name string // ""
//%v 表示按照变量的值输出
fmt.Printf("a = %v, b = %v, c = %v, d = %v, name = %v", a, b, c, d, name)
}
运行结果：
a = 0, b = 0, c = 0, d = false, name =
7. 类型转换
Go语言在不同类型的变量之间赋值时需要显示转换。也就是说Go语言数据类型不会自动转换。
1、强制类型转换既可以从小范围数据类型转换到大范围数据类型(上行转换)、也可以从大范围数据类型转换到小范围数据类型(下行转换)
2、被转换的是变量存储的数据(数值),变量本身的数据类型并没有发生改变
3、在转换中，可能出现意想不到的结果，特别是下行转换的时候。
示例代码如下：
从代码很容易看出转换语法：type(var)，这里需要注意，和C语言不同，C语言是(type)var。
当转换溢出时，数据会错误。
如int64的变量转换为int8，则需要取余256.（网上某个培训班网课说无法计算，实际是可计算的，数据溢出之后从0开始，是一个循环）
package main
import (
"fmt"
)
func main(){
var i int32 = 100
var n1 float32 = float32(i)
var n2 int8 = int8(i)
var n3 int64 = int64(i)
fmt.Printf("i = %v n1 = %v n2 = %v n3 = %v", i, n1, n2, n3)
// 被转换的是变量的数据，而不是变量的类型
fmt.Printf("i type is %T", i)
var num1 int64 = 999999
var num2 int8 = int8(num1)
fmt.Println("num2 = ", num2)
num1 = 257
num2 = int8(num1)
fmt.Println("num2 = ", num2)
}
