Go 语言 数据类型的介绍
一、整数类型：
1. int 有符号：
| 类型 | 有无符号 | 占用存储空间 | 表数范围 |
|---|---|---|---|
| int8 | 有 | 1字节 | -128~127 |
| int16 | 有 | 2字节 | -2^15 ~ 2^15 -1 |
| int32 | 有 | 4字节 | -2^31 ~ 2^31 -1 |
| int64 | 有 | 8字节 | -2^63 ~ 2^63 -1 |
举个栗子：说明超出范围会报错
package main
import "fmt"
func main(){
var i int8 = 129
fmt.Println("i=", i)
}
// 报错信息：
# command-line-arguments
.\hello.go:6:15: constant 129 overflows int8
2. int 无符号：
| 类型 | 有无符号 | 占用存储空间 | 表数范围 |
|---|---|---|---|
| uint8 | 无 | 1字节 | 0 ~ 255 |
| uint16 | 无 | 2字节 | 0 ~ 2^16 -1 |
| uint32 | 无 | 4字节 | 0 ~ 2^32 -1 |
| uint64 | 无 | 8字节 | 0 ~ 2^64 -1 |
举个栗子：超出 int无符号的范围
package main
import "fmt"
func main(){
var i uint8 = -1
fmt.Println("i=", i)
}
// 报错信息：
# command-line-arguments
.\hello.go:6:16: constant -1 overflows uint8
3. 其他整数类型：
| 类型 | 有无符号 | 占用存储空间 | 表数范围 | 备注 |
|---|---|---|---|---|
| rune | 有 | 与int32一样 | -2^31 ~ 2^31 -1 | 等价int32，表示一个Unicode码 |
| byte | 无 | 与uint8一样 | 0 ~ 255 | 当要存储字符时选用byte |
4. 整数的使用细节：
fmt.Printf()：可以用于做格式化输出
-
go 的整数默认声明为 int 型，举个栗子：
fmt.Printf("%T")：可以查看类型package main import "fmt" func main(){ var i = 100 // 使用fmt.Printf() 可以用于做格式化输出 fmt.Printf("i的类型为：%T", i) } // 输出结果：i的类型为：int -
如何在程序中，查看某个变量的字节大小、数据类型，举个栗子：
unsafe.Sizeof()：是unsafe包的一个函数，可以返回变量占用的字节数
package main // 推荐方式导包 import ( "fmt" "unsafe" ) func main(){ var i int64 = 10 // 使用fmt.Printf() 可以用于做格式化输出 // unsafe.Sizeof(i) 是unsafe包的一个函数, 可以返回i变量占用的字节数 fmt.Printf("i的类型为：%T i占用的字节数是：%d", i, unsafe.Sizeof(i)) } // 输出结果：i的类型为：int64 i占用的字节数是：8 -
在保证程序正常运行情况下，尽量使用占用空间小的数据类型：
func main(){ // var age int64 // 不建议使用, 因为年龄不可能有这么大的范围, 占用8个字节 var age byte // 范围在 0 ~ 255 byte 占用 1个字节 }
二、小数类型(浮点型)：
| 类型 | 占用存储空间 | 表数范围 |
|---|---|---|
| 单精度float32 | 4字节 | -3.403E38 ~ 3.403E38 |
| 双精度float64 | 8字节 | -1.798E308 ~ 1.798E308 |
举个栗子：
package main
import (
"fmt"
)
func main(){
var price1 float32 = -123.4567890123
var price2 float64 = -123.4567890123
fmt.Println("price1:", price1,"price2:",price2)
}
// 输出结果:price1: -123.45679 price2: -123.4567890123
从输出结果可以看出，float64 精确度要比 float32 准确；
如果我们要存储一个精度高的数，尽量使用 float64；
浮点数使用细节：
-
go 的浮点数默认声明为 float64 类型：
package main import ( "fmt" "unsafe" ) func main(){ var price = 6.66 fmt.Printf("price默认的数据类型:%T 占用的字节为:%d",price, unsafe.Sizeof(price)) } // 输出结果：price默认的数据类型:float64 占用的字节为:8 -
十进制数形式：
i := 6.66 j := .66 // 等于0.66 fmt.Println("i=", i, "j=", j) // 输出结果：i=6.66 j=0.66 -
科学计数法形式:
package main import ( "fmt" ) func main(){ num1 := 1.2345e2 // 1.2345 * 10的2次方 num2 := 1.2345E2 // 1.2345 * 10的2次方 num3 := 1.2345E-2 // 1.2345 / 10 * 次方 fmt.Println("num1=", num1, "num2=", num2, "num3=", num3) } // 输出结果: num1= 123.45 num2= 123.45 num3= 0.012345
三、字符类型：
go 中 没有专门的字符类型，如果要存储单个字符（字母），一般使用 byte 来保存。
go 的字符串，是由单个字节 连接起来的。也就是说，传统的字符串是有字符组成的。
而 go 的字符串不同，它是由字节组成。
举个栗子：
当我们直接输出byte值, 就是输出了对应的字符的码值(对应ASCII码)
package main
import (
"fmt"
)
func main(){
// 当我们直接输出byte值, 就是输出了对应的字符的码值(对应ASCII码)
var c1 byte = 'a'
var c2 byte = '0'
fmt.Println("c1=", c1)
fmt.Println("c2=", c2)
// 输出对应字符, 使用格式化输出
fmt.Printf("c1=%c c2=%c", c1, c2)
}
// 输出结果如下：
c1= 97
c2= 48
c1=a c2=0
字符的使用细节：
-
go 语言的字符使用UTF-8：
英文字母 = 1个字节； 汉字 = 3个 字节； -
go 字符的本质是一个整数，直接输出时，字符对应的 UTF-8 编码的码值：
package main import ( "fmt" ) func main(){ var c1 byte = '6' fmt.Println("输出的是UTF-8编码值:", c1) } // 输出结果：输出的是UTF-8编码值: 54可以对照ASCII码表，找到图形为 ‘6’ ，十进制是54；
-
可以直接给某个变量赋值一个数字，然后按格式化输出 %c，输出该数字对应的unicode字符：
package main import ( "fmt" ) func main(){ var c1 int = 29275 // 牛 ---> 29275 对应的码值 fmt.Printf("输出对应的Unicode %c", c1) } // 输出结果：输出对应的Unicode 牛 -
查看Unicode对应的码值，格式化输出 %d：
package main import ( "fmt" ) func main(){ var c1 int = '牛' fmt.Printf("查看unicode对应的码值：%d", c1) } // 输出结果：查看unicode对应的码值：29275 -
字符类型是可以进行运算，相当于一个整数，因为它都有对应的Unicode码：
package main import ( "fmt" ) func main(){ var c1 int = 10 + 'a' // a ---> 97 ASCII码对应的十进制为 97 fmt.Println("输出结果:", c1) } // 输出结果: 107
总结：
-
字符型存储到计算中，需要将字符对应的码值(整数)取出来；
存储过程：
字符 —> 对应码值 —> 二进制 —> 存储
读取过程：
二进制 —> 对应码值 —> 字符 —> 读取
-
字符和码值，对应关系是通过字符编码表决定；
-
go 语言的编码都统一成utf-8。非常方便、统一、解决乱码的问题；
四、布尔类型：
布尔类型也叫bool类型，bool 类型数据仅允许true、false。
bool类型，占1个字节。
举个栗子：
package main
import (
"fmt"
"unsafe"
)
func main(){
var b = false
fmt.Println("b=", b)
// 1.bool类型仅占用存储空间1个字节
fmt.Println("b 占用空间=", unsafe.Sizeof(b))
// 2.bool 类型仅有true、false
}
// 输出结果如下：
b= false
b 占用空间= 1
注意：
不可以用 0 或者 非0 的整数代替 false 、true，这点跟很多语言是不一样的。
五、字符串类型：
字符串就是一串固定长度的字符连接起来的字符序列。
go 的字符串是由单个字节连接起来，go 语言的字符串字节使用UTF-8编码标识 Unicode文本。
举个栗子：
package main
import (
"fmt"
)
func main(){
var fe_cow string = "hello world!"
fmt.Println(fe_cow)
}
// 输出结果：hello world!
字符串类型的使用细节：
-
字符串一旦赋值，字符串就不能修改。在go 中 字符串是不可变的。
package main import ( "fmt" ) func main(){ var fe_cow string = "hello world!" fe_cow[0] = "c" // 这里就不能去修改fe_cow的内容，在go中字符串是不可变的 } -
双引号，会识别转义字符：
package main import ( "fmt" ) func main(){ fe_cow := "hello\nworld!" fmt.Println(fe_cow) } // 输出结果如下： hello world! -
反引号，以字符串的原生形式输出，包括换行和特殊字符：
package main import ( "fmt" ) func main(){ fe_cow := `package main import ( "fmt" ) func main(){ fe_cow := "hello\nworld!" fmt.Println(fe_cow) }` fmt.Println(fe_cow) } // 输出结果如下： package main import ( "fmt" ) func main(){ fe_cow := "hello\nworld!" fmt.Println(fe_cow) } -
字符串的拼接方式：
package main import ( "fmt" ) func main(){ fe_cow := "hello world! " fe_cow += "dog" fmt.Println(fe_cow) } // 输出结果：hello world! dog -
字符串太长时，需要使用多行字符串，把 “+” 号放到上面：
package main import ( "fmt" ) func main(){ fe_cow := "hello world! " + "hello world! " + "hello world! " + "hello world! " + "hello world! " + "hello world! " + "hello world! " fmt.Println(fe_cow) } // 输出结果如下： hello world! hello world! hello world! hello world! hello world! hello world! hello world!错误示例：// 错误示例： package main import ( "fmt" ) func main(){ fe_cow := "hello world! " + "hello world! " + "hello world! " + "hello world! " + "hello world! " + "hello world! " + "hello world! " fmt.Println(fe_cow) }在换行时，一定要把符号赋予上面，然后再进行换行；
