GO语言-数据类型

变量定义

代码如下：

package mainimport "fmt"var i1 = 1000
var i2 intvar(i5 = "hello"i6 = "world"
)func main(){var i intfmt.Println("i = ", i)i = 10fmt.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 intfmt.Println("n1 = ", n1, "n2 = ", n2, "n3 = ", n3)var n4 , name1 , n5 = 100, "MikeSun", 200fmt.Println("n4 = ", n4, "name1 = ", name1, "n5 = ", n5)n6, name2, n7 := 1000, "joke", 2000fmt.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.12fmt.Println("price = ", price)var num1 float32 = -0.00089var num2 float64 = -7809656.09fmt.Println("num1 = ", num1, "num2 = ", num2)//尾部部分精度丢失，造成精度损失var num3 float32 = -123.0000901var num4 float64 = -123.0000901fmt.Println("num3 = ", num3, "num4 = ", num4)//Golang的浮点类型默认声明为float64 类型var num5 = 1.1fmt.Println("typeof num5 is ", reflect.TypeOf(num5))//十进制数形式：如：5.12      .512（必须有小数点）num6 := 5.12num7 := .123fmt.Println("num6 = ", num6, "num7 = ", num7)//科学计数法num8 := 5.1234e2num9 := 5.1234E2num10 := 5.1234E-2fmt.Println("num8 = ", num8, "num9 = ", num9, "num10 = ", num10)
}

3. 字符类型

Go语言统一使用Unicode编码。
字符类型的本质就是一个整数型，一个整数对应Unicode中的一个字符，从而可以使用特地的输出格式输出，如%c。
Unicode编码是包含ASCII码的，所以前面的256个字符仍然可以当作ASCII码来输出或转换。

package mainimport ("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 = 22269fmt.Printf("\nc4 = %c", c4)var c5 int = 65fmt.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 = falsefmt.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 conditionfmt.Println("True")
}

3、必须显式比较

b := true
// fmt.Println(b + 1) // 错误：bool 不能参与数学运算

5. 字符串类型

5.1 字符串的本质

1、底层结构：Go 的字符串是一个 只读的字节切片（[]byte），存储的是 UTF-8 编码的 Unicode 字符。
2、不可变性：字符串一旦创建，内容不可修改（若需修改需转为 []byte 或 []rune）。

代码示例如下：

package mainimport ("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 mainimport ("fmt"
)func main(){var a int // 0var b float32 // 0var c float64 // 0var d bool // flasevar 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 mainimport ("fmt"
)func main(){var i int32 = 100var 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 = 999999var num2 int8 = int8(num1)fmt.Println("num2 = ", num2)num1 = 257num2 = int8(num1)fmt.Println("num2 = ", num2)
}