1. 整数类型
类型 | 有无符号 | 占用存储空间 | 表示范围 | 备注 |
int8 | 有 | 1 字节 | -2**7~2**7-1 | |
int16 | 有 | 2 字节 | -2**15~2**15-1 | |
int32 | 有 | 4 字节 | -2**31~2**31-1 | |
int64 | 有 | 8, 字节 | -2**63~2**63-1 | |
uint8 | 无 | 1 字节 | 0~2**8-1 | |
uint16 | 无 | 2 字节 | 0~2**16-1 | |
uint32 | 无 | 4 字节 | 0~2**32-1 | |
uint64 | 无 | 8 字节 | 0~2**64-1 | |
int | 有 | 32 位系统 4 字节 64 位系统 8 字节 | -2**31~2**31-1 -2**63~2**63-1 | |
uint | 无 | 32 位系统 4 字节 64 位系统 8 字节 | 0~2**32-1 0~2**64-1 |
|
rune | 有 | 与 int32 一样 | -2**31~2**31-1 | 等价 int32,表示 一个 unicode 码 |
byte | 无 | 与 uint8 一样 | 0~2**8-1 | 当要存储字符时 使用 byte |
整型的使用细节:
(1)golang 整数类型分为: 有符号和无符号, int 和 uint 的大小和系统有关;
(2)golang 整型默认申明为 int;
(3) 如何在程序查看某个变量的数据类型?
- package main
- import (
- "fmt"
- "unsafe"
- )
- func main() {
- var num int64 = 10
- fmt.Printf("num 的数据类型是 %T, 占的字节数是 %d", num, unsafe.Sizeof(num))
- }
(4)golang 使用整数类型时, 遵从保小不保大原则, 即在保证程序正常运行的情况下, 尽量使用占用空间小的数据类型;
(5)bit: 计算机中最小的存储单位, byte: 计算机中基本的存储单元;
2. 浮点类型
类型 | 占用存储空间 | 表示范围 |
单精度 float32 | 4 字节 | -3.403E38~3.403E38 |
双精度 float64 | 8 字节 | -1.798E308~1.798E308 |
说明:
(1) 浮点数在机器中存在的形式: 浮点数 = 符号位 + 指数位 + 尾数位 (浮点数都是有符号的)11110000111.111111111111111111000
(2) 尾数部分可能丢失, 造成精度损失;
(3) 浮点型的存储分为三个部分: 符号位 + 指数位 + 尾数位;
浮点型的使用细节:
(1)golang 浮点类型有固定的范围和字段长度, 不受操作系统的影响;
(2) 默认为 float64 类别;
(3) 浮点型常用两种形式表示:
1) 十进制: 5.12,.512
2) 科学记数法形式: 5.1234E2,5.1234E-2
(4) 通常使用 float64, 它精度更高;
3. 字符类型
字符串是一串固定长度的字符连接起来的字符序列. golang 没有专门的存储字符类型, 如果要存储单个字符, 用 byte 来保存. go 的字符串是由单个字节连接起来的, 它与传统的字符串是由字符组成的不同.
- package main
- import (
- "fmt"
- )
- func main() {
- var c1 byte = 'a'
- fmt.Println(c1)
- }
当我们直接输出字符 c1,, 得到的是它的 ascII 值: 97. 要用格式化输出: fmt.Printf("%c",c1). 而当我们要存储中文时, 此时不能够用 byte 类型了, 即 ASCII 值大于 255 时, 会显示溢出, 我们要用 int 来存储:
- (补: 格式化输出代表含义 %d: 输出整型;%f: 输出浮点型;%c: 输出字符型;%v: 输出原变量值;%T: 输出变量的数据类型;%t: 输出布尔值:%q: 输出带双引号的字符串)
- package main
- import (
- "fmt"
- )
- func main() {
- var c1 byte = 'a'
- var c2 int = '被'
- fmt.Println(c1)
- fmt.Printf("c1 的值是:%c \n", c1)
- fmt.Printf("c2 的值是:%c, 它的 ASCii 值是:%d", c2, c2)
- }
字符类型使用细节:(再也不用担忧编码的问题了, 所有的编码都是 utf-8)
(1) 字符常量使用单引号括起来的单个字符;
(2)go 中允许使用转义字符'\'来将其后的字符转变为特殊字符型常量, 例如 var c int = '\n';
(3) 字符使用 utf-8 编码;
(4)go 中, 字符的本质是一个整数, 直接输出时, 会输出它对应的 UTF-8 编码的值;
(5) 可以直接给变量赋予某个数字, 然后格式化输出 %c, 会输出该数字对应的 unicode 字符;
(6) 字符类型是可以进行运算的, 相当于一个整数, 因为它都对应 unicode 码;
4. 布尔类型
只允许取两个值: true,false; 占用 1 个字节; 主要用在逻辑运算;
5. 字符串类型
go 的字符串是由字节连接而成;
- package main
- import (
- "fmt"
- )
- func main() {
- var address string = "北京长城"
- fmt.Println(address)
- }
字符串的使用细节:
(1)go 语言的字符串的字节使用 utf-8 编码;
(2) 与 python 一样, 一旦字符串赋值了, 就不能被更改;
(3) 两种表示形式
1) 双引号, 会识别转义字符;
2) 反引号, 以字符串的原生形式输出, 包括换行和特殊字符, 可以实现防止攻击, 输出源代码等
- package main
- import (
- "fmt"
- )
- func main() {
- var c = "abc\nabc"
- var d = `abc\nabc`
- fmt.Println(c)
- fmt.Println(d)
- }
3) 字符串的拼接, 当我们要拼接多行字符串时, 要将加号留在每行末尾:(注意单个字符进行拼接是指对 unicode 值进行相加)
- package main
- import (
- "fmt"
- )
- func main() {
- var str = "hello" + "world" +
- "!"
- fmt.Println(str)
- }
6. 基本数据类型的默认值
整型: 0
浮点型: 0
字符串:""
布尔类型: false
7. 基本数据类型之间的转换
golang 和 java,c 不同, Go 在不同类型变量之间赋值需要显示转换, 也就是 golang 中数据类型不能自动转换;
基本语法: T(v), 即将变量 v 转换成 T 数据类型
整数型之间的转换: 例如 var i int8 = 10; var n1 int64 = int64(i)
(1) 数据类型转换可以从范围小 --> 范围大, 范围大 --> 范围小;
(2) 被转换的是变量存储的数据 (即值), 变量本身的数据类型并没有变化;
(3) 在转换中, 比如将 int64 转成 int8, 编译时不会报错, 只是转换的结果是按溢出处理, 和我们希望的结果不一样;
基本数据类型和 string 之间的转换
(1)fmt.Sprintf("% 参数", 表达式): 参数和表达式的类型要匹配; 结果返回转换后的字符串;
- package main
- import (
- "fmt"
- )
- func main() {
- var num1 int = 99
- var num2 float64 = 23.456
- var b bool = false
- var c byte = 'g'
- var str1 = fmt.Sprintf("%d", num1)
- var str2 = fmt.Sprintf("%f", num2)
- var str3 = fmt.Sprintf("%t", b)
- var str4 = fmt.Sprintf("%c", c)
- fmt.Printf("%T--%q\n", str1, str1)
- fmt.Printf("%T--%q\n", str2, str2)
- fmt.Printf("%T--%q\n", str3, str3)
- fmt.Printf("%T--%q", str4, str4)
- }
(2) 使用 strconv 函数 package main
- import (
- "fmt"
- "strconv"
- )
- func main() {
- var num1 int = 99
- var num2 float64 = 23.456
- var b bool = false
- //FormatInt() 第一个参数必须转成 int64, 第二个是十进制表示
- var str1 = strconv.FormatInt(int64(num1), 10)
- //FormatFloat,'f'表示格式, 10 表示保留小数, 64 表示 float64
- var str2 = strconv.FormatFloat(num2, 'f', 10, 64)
- var str3 = strconv.FormatBool(b)
- // 将 int 转换成 string
- var str4 = strconv.Itoa(num1)
- fmt.Printf("%T--%q\n", str1, str1)
- fmt.Printf("%T--%q\n", str2, str2)
- fmt.Printf("%T--%q\n", str3, str3)
- fmt.Printf("%T--%q\n", str4, str4)
- }
string 和基本数据类型转换:
- package main
- import (
- "fmt"
- "strconv"
- )
- func main() {
- var s1 string = "true"
- var s2 string = "888"
- var s3 string = "23.45"
- var num1 int64
- var num2 float64
- var b bool
- b, _ = strconv.ParseBool(s1)
- num1, _ = strconv.ParseInt(s2, 10, 64)
- num2, _ = strconv.ParseFloat(s3, 64)
- fmt.Printf("%T--%t\n", b, b)
- fmt.Printf("%T--%d\n", num1, num1)
- fmt.Printf("%T--%f\n", num2, num2)
- }
注意: 要确保 string 类型要能够转换成有效的数据, 即 "hello" 不能转换成布尔值, 整型, 浮点型
来源: https://www.cnblogs.com/xiximayou/p/11826991.html