Go 基本数据类型
文章目录
前言
上一篇介绍了常量的定义,涉及了各种数据类型。这里我们介绍 Go 语言中提供的基本数据类型
一 Go 数据类型
数据类型 是编程中的一个重要概念。数据类型指定 变量值的大小 和 支持的运算。
Go 是 静态类型的,这意味着 一旦定义了变量类型,它就只能存储该类型的数据。
Go 有三种基本的数据类型
bool
类型:表示布尔值,只有true
或false
两个取值- 数值:、 整数类型、浮点类型、复数类型 和 字符类型
string
:字符串值
这个例子展示了 Go 中一些不同的数据类型:
package main
import "fmt"
func main() {
var a bool = true // Boolean
var b int = 5 // Integer
var c float32 = 3.14 // Floating point number
var d string = "Hi!" // String
fmt.Println("Boolean: ", a)
fmt.Println("Integer: ", b)
fmt.Println("Float: ", c)
fmt.Println("String: ", d)
}
二 布尔类型 bool
布尔数据类型 使用 bool
关键字声明,并且 只能采用值 true
或 false
布尔数据类型的 默认值为
false
此示例显示了声明布尔变量的一些不同方法:
package main
import "fmt"
func main() {
var b1 bool = true //带有初始值的 类型声明
var b2 = true // 带初始值的 无类型声明
var b3 bool // 不带初始值的类型声明 默认为 false
b4 := true // 自动类型推断
fmt.Println(b1) // true
fmt.Println(b2) // true
fmt.Println(b3) // false
fmt.Println(b4) // true
}
布尔值主要用于条件测试
Go 中
bool
类型仅仅是布尔类型,不像其他语言中那样bool
类型是int
的子类型
三 整数
整数数据类型 用于 存储没有小数的整数,如 35
、-50
或 1345000
Go 语言提供了两种类型的整数
- 有符号整数——可以存储正负两种值,即 [ − 2 n − 1 , 2 n − 1 − 1 ] [-2^{n-1}, 2^{n-1}-1] [−2n−1,2n−1−1],其中 n n n 表示位模式的长度
- 无符号整数——只能存储非负值,即 [ 0 , 2 n − 1 ] [0, 2^{n}-1] [0,2n−1]
3.1 有符号整数 int
用 int
关键字之一声明的有符号整数可以存储正数和负数。Go 有五种关键字/类型的有符号整数:
类型 | 大小 | 范围 | 备注 |
---|---|---|---|
int | 取决于平台 | 32 32 32 位平台占 32 32 32 位; 64 64 64 位平台占 64 64 64 位 | |
int8 | 8 8 8 位 | [ − 128 , 127 ] [-128, 127] [−128,127] | |
int16 | 16 16 16 位 | [ − 32768 , 32767 ] [-32768, 32767] [−32768,32767] | |
int32 | 32 32 32 位 | [ − 2147483648 , 2147482647 ] [-2147483648, 2147482647] [−2147483648,2147482647] | |
int64 | 64 64 64 位 | [ − 2 63 , 2 63 − 1 ] [-2^{63}, 2^{63}-1] [−263,263−1] | |
rune | 32 32 32 位 | 是 int32 的别名,用于处理 Unicode字符 |
package main
import "fmt"
func main() {
var x int = 500
var y int = -4500
fmt.Printf("Type: %T, value: %v\n", x, x)
fmt.Printf("Type: %T, value: %v\n", y, y)
}
3.2 无符号整数 uint
使用 uint
关键字之一声明的无符号整数只能存储非负值
类型 | 大小 | 范围 | 备注 |
---|---|---|---|
uint | 取决于平台 | 32 32 32 位平台占 32 32 32 位; 64 64 64 位平台占 64 64 64 位 | |
uint8 | 8 8 8 位 | [ 0 , 255 ] [0, 255] [0,255] | |
uint16 | 16 16 16 位 | [ 0 , 65535 ] [0, 65535] [0,65535] | |
uint32 | 32 32 32 位 | [ 0 , 2 32 − 1 ] [0, 2^{32}-1] [0,232−1] | |
uint64 | 64 64 64 位 | [ 0 , 2 64 − 1 ] [0, 2^{64}-1] [0,264−1] | |
byte | 8 8 8 位 | 它是 uint8 的一个 别名 | |
uintptr | 取决于平台 | 表示指针类型 |
3.3 整数字面值
整数字面值是表示整数常量的数字序列。可选前缀设置非十进制基数
0b
或0B
表示二进制序列0o
或0O
表示八进制序列0x
或0X
表示十六进制。在十六进制文字中,字母a
到f
和A
到F
表示值 10 10 10 到 15 15 15- 单个
0
被视为十进制零
为了便于阅读,下划线字符 _
可能出现在 基本前缀之后 或 连续数字之间;这样的下划线不会改变字面值
整数字面值定义语法如下
int_lit = decimal_lit | binary_lit | octal_lit | hex_lit .
decimal_lit = "0" | ( "1" … "9" ) [ [ "_" ] decimal_digits ] .
binary_lit = "0" ( "b" | "B" ) [ "_" ] binary_digits .
octal_lit = "0" [ "o" | "O" ] [ "_" ] octal_digits .
hex_lit = "0" ( "x" | "X" ) [ "_" ] hex_digits .
decimal_digits = decimal_digit { [ "_" ] decimal_digit } .
binary_digits = binary_digit { [ "_" ] binary_digit } .
octal_digits = octal_digit { [ "_" ] octal_digit } .
hex_digits = hex_digit { [ "_" ] hex_digit } .
下面是整数类型变量声明与初始化的示例
package main
import "fmt"
func main() {
var binary uint8 = 0b10100101
fmt.Printf("Type: %T, value: %#b\n", binary, binary)
var octal uint8 = 0337 // 0o337 0O337
fmt.Printf("Type: %T, value: %#o\n", octal, octal)
var hex uint8 = 0xaf
fmt.Printf("Type: %T, value: %#x\n", hex, hex)
}
整数字面值的默认类型是
int
。如果未指定类型,则该类型为int
四 浮点类型
浮点数据类型 用于 存储带小数点的正数和负数,如 35.3
、-2.34
或 3597.34987
Go 语言提供两种浮点类型。这两种浮点型数据格式 遵循 IEEE 754
标准:
类型 | 大小 | 范围 | 备注 |
---|---|---|---|
float32 | 32 32 32 位 | [ − 3.4 × 1 0 38 , 3.4 × 1 0 38 ] [-3.4\times 10^{38}, 3.4\times 10^{38}] [−3.4×1038,3.4×1038] | 最大值定义在 math.MaxFloat32 |
float64 | 64 64 64 位 | [ − 1.8 × 1 0 308 , 1.8 × 1 0 308 ] [-1.8 \times 10^{308}, 1.8 \times 10^{308}] [−1.8×10308,1.8×10308] | 最大值定义在 mat.MaxFloat64 |
浮点类型的 默认类型是
float64
。如果不指定类型,则类型为float64
float32
与float64
类型的变量不能相互赋值。是两个不同的数据类型
下面的例子展示了如何声明 float32
类型的变量:
package main
import (
"fmt"
"math")
func main() {
var x float32 = 123.78
var y float32 = 3.4e+38
var max_flaot32 = math.MaxFloat32
fmt.Printf("Type: %T, value: %v\n", x, x)
fmt.Printf("Type: %T, value: %v\n", y, y)
fmt.Printf("Type: %T, value: %v", max_flaot32, max_flaot32)
}
4.1 字面值
浮点字面值是浮点常量的 十进制 或 十六进制 表示形式
4.1.1 十进制浮点字面值
十进制浮点字面值由 整数部分、小数点、小数部分 和 指数部分
- 整数部分 和 小数部分 采用 十进制数表示,其中的某个部分可以省略
- 指数部分由
e
或E
后的 可选符号(-
或+
) 和 十进制数 组成。指数值exp
将尾数(整数和小数部分)缩放 1 0 exp 10^{\text{exp}} 10exp
正式定义如下
float_lit = decimal_float_lit | hex_float_lit .
decimal_float_lit = decimal_digits "." [ decimal_digits ] [ decimal_exponent ] |
decimal_digits decimal_exponent |
"." decimal_digits [ decimal_exponent ] .
decimal_exponent = ( "e" | "E" ) [ "+" | "-" ] decimal_digits .
下面给出了几个十进制浮点字面值示例
0.
72.40
072.40 // == 72.40
2.71828
1.e+0
6.67428e-11
1E6 // == 1 * 10 ^ 6
.25
.12345E+5 // == 12345.0
1_5. // == 15.0
0.15e+0_2 // == 15.0
4.1.2 十六进制浮点字面值
从 Go 1.13+ 开始支持
十六进制浮点字面值 由 0x
或 0X
前缀、整数部分(十六进制数字)、小数点、小数部分(十六进制数字) 和 指数部分 组成( p
或 P
后跟可选的符号和十进制数)
- 整数部分或小数部分之一可以省略;小数点也可以省略,但 指数部分是必需的
- 指数值
exp
将尾数(整数和小数部分)缩放 2 exp 2^{\text{exp}} 2exp
{0x | 0X} {0-9 a-f} . {0-9 a-f} p {[+ | -] 0-9}
正式的定义如下
hex_float_lit = "0" ( "x" | "X" ) hex_mantissa hex_exponent .
hex_mantissa = [ "_" ] hex_digits "." [ hex_digits ] |
[ "_" ] hex_digits |
"." hex_digits .
hex_exponent = ( "p" | "P" ) [ "+" | "-" ] decimal_digits .
下面是几个十六进制浮点字面值的示例
0x1p-2 // == 0.25
0x2.p10 // == 2048.0
0x1.Fp+0 // == 1.9375
0X.8p-0 // == 0.5
0X_1FFFP-16 // == 0.1249847412109375
0x15e-2 // == 0x15e - 2 (integer subtraction)
五 复数类型
Go 提供了两种复数类型:complex64
和 complex128
。复数有 实部 和 虚部
complex64
的实部和虚部为32
位complex128
的实部和虚部为64
位
package main
import (
"fmt"
)
func main(){
// 复数
var c1 complex64 // 实部和虚部均为32为
c1 = 1 + 2i
fmt.Println(c1) // (1+2i)
var c2 complex128 // 实部和虚部均为64为
c2 = 2 + 3i
fmt.Println(c2) // (2+3i)
}
六 字符类型
Go 对字符的处理和 C 语言一样,都是 把字符当作整数进行处理。然而,Go 提供了两种类型表示字符
byte
类型,它是uint8
的一个类型别名,用于处理 8 8 8 位编码的字符集。例如,ASCII
和Latin-1
rune
类型,它是int32
的类型别名,用于处理Unicode
。由于 Go 对Unicode
字符的处理采用UTF-8
编码方式,因此,可以是rune
类型处理UTF-8
字符
字符默认的类型为
rune
Go 使用了特殊的 rune
类型来处理 Unicode
,让基于 Unicode
的文本处理更为方便,也可以使用 byte
型进行默认字符串处理,性能和扩展性都有照顾
package main
import "fmt"
func main() {
var ch rune = '你'
fmt.Println(ch) // 20320
fmt.Printf("Type: %T value: %c\n", ch, ch) // Type: int32 value: 你
var as byte = 'a'
fmt.Println(as) // 97
fmt.Printf("Type: %T value: %c\n", as, as) // Type: uint8 value: a
}
6.1 字符字面值
Go 中字符的字面值使用单引号 '.'
标识。默认采用 rune
类型进行处理。例如
var ch = 'a' // 英文字符
var ch2 = '天' // 中文字符
6.2 转义字符序列
有一些 特殊符号,例如换行符,无法采用上述规则书写,因为它们是 不可见 的(非打印字符)或者是 无法从键盘输入 的。因此,为了使程序可以处理字符集中的每一个字符,Go语言同样提供了特殊的字符表示方法:转义字符序列。转义字符序列共有两种形式:字符转义序列 和 数字转义序列。转义字符使用 \
开头。
6.2.1 字符转义序列
字符转义序列使用 反斜杠(\
) 和 一个 基本符号 表示。字符转义序列存在几个局限
- 没有包含所有的非打印字符
- 无法用于表示基本的
128
128
128 个
ASCII
字符以外的字符
名字 | 转义序列 |
---|---|
响铃符 | \a |
回退符 | \b |
换页符 | \f |
换行符 | \n |
回车符 | \r |
水平制表符 | \t |
垂直制表符 | \v |
反斜杠 | \\ |
问号 | \? |
单引号 | \' |
双引号 | \" |
6.2.2 数字转义序列
从字符集中查找字符编码对应的八进制数和十六进制数。然后,使用 \
和跟随其后的字符编码表示。因此,数字转义序列有 八进制转义序列 和 十六进制转义序列 两种
八进制转移序列格式为 \ooo
,ooo
表示三个数字的八进制数,它表示为一个无符号字符。这个八进制数的最大值通常是 377
ASCII 码中的 ESC
字符的八进制值为 33
,所以他的八进制数字转义序列为 \33
或 \033
转义序列中的八进制数不必以 0 0 0 开头
十进制转义序列格式为 \xh...
,h...
表示至少有
1
1
1 十六进制数
- 十六进制转义序列的数字的个数是任意的,但必须表示成无符号字符
- 如果字符类型尺寸是
8
8
8 位,那么十六进制数不能超过
FF
\xh...
的x
必须小写,h...
中的十六进制数不限制大小写
var esc byte = '\033'
fmt.Printf("%c\n", '\141') // a
fmt.Printf("%c\n", '\x61') // a
七 字符串类型
string
数据类型 用于 存储字符(文本)序列。字符串值必须用 双引号 引起来
package main
import "fmt"
func main() {
var txt1 string = "Hello!"
var txt2 string
txt3 := "你好" // 非 ASCII 字符
fmt.Printf("Type: %T, value: %v\n", txt1, txt1)
fmt.Printf("Type: %T, value: %v\n", txt2, txt2)
fmt.Printf("Type: %T, value: %v\n", txt3, txt3)
}
string
类型的默认值位空字符串(""
)
原生类型:内建的基本类型
Go 语言中的字符串以 原生数据类型 出现,使用字符串就像使用其他原生数据类型一样
Go
语言里的字符串的 内部实现使用UTF-8
编码。 字符串的值为 双引号 ("...."
) 中的内容, 可以在Go
语言的源码中直接添加非ASCII
码字符
7.1 多行字符串
有时后我们希望输出多行字符的字符,我们可以使用 反引号 ` 标识
var mutiline string = `
白日依山尽,
黄河入海流
`
fmt.Println(mutiline)
7.2 字符串的底层实现
Go 语言实现字符串是通过字节数组实现。为了表示字符串结束,Go 还存储了字符串的长度。Go 语言的字符串实现为
type stringStruct struct {
str unsafe.Pointer
len int
}
str
是一个指向只读内存区域的字节数组len
表示字节数组的长度
7.3 字符串占用的字节数
内置函数 len
可以计算字符串占用的总字节数
- 字节:
1 byte = 8 bit
(八位二进制表示一个字节)
package main
import "fmt"
func main() {
/* 内置函数 len */
var str string = "hello小飞"
fmt.Printf("Type: %T, value: %v, len: %v\n", str, str, len(str))
// Type: string, value: hello小飞, len: 11
}
很明显,我们的字符串并没有
11
11
11 个字符。因为 UTF-8
编码下一个中文汉字由 3~4
个字节组成
八 类型转换
Go 只提供了 强制类型转换,没有隐式类型转换。该语法只能在 两个类型之间支持相互转换 的时候使用
强制类型转换的基本语法如下
object_type(expr)
object_type
表示目标数据类型expr
表达式包括 变量,复杂的表达式和函数的返回值等
package main
import "fmt"
func main() {
var a int8 = 0x7f
var b int16 = int16(a) // 不能直接用 int8 的变量赋值给 int16
fmt.Println(a)
fmt.Println(b)
}
总结
本节我们列出了 Go 中基本数据类型
标签:基本,字符,32,fmt,数据类型,var,类型,Go From: https://blog.csdn.net/weixin_42470629/article/details/139218466