Go 基本数据类型

编程进阶之路

已于 2024-05-27 22:42:41 修改

阅读量902

点赞数 33

文章标签： golang 开发语言后端

于 2024-05-26 18:59:36 首次发布

本文链接：https://blog.csdn.net/weixin_42470629/article/details/139218466

版权

Go 基本数据类型

上一篇：Go 常量
下一篇：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]$ ，其中 $n$ 表示位模式的长度
无符号整数——只能存储非负值，即 $0, 2^{n}-1]$

3.1 有符号整数 `int`

用 int 关键字之一声明的有符号整数可以存储正数和负数。Go 有五种关键字/类型的有符号整数:

类型	大小	范围	备注
`int`	取决于平台		$32$ 位平台占 $32$ 位； $64$ 位平台占 $64$ 位
`int8`	$8$ 位	$[- 128, 127]$
`int16`	$16$ 位	$[- 32768, 32767]$
`int32`	$32$ 位	$[- 2147483648, 2147482647]$
`int64`	$64$ 位	$2^{63}, 2^{63}-1]$
`rune`	$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$ 位； $64$ 位平台占 $64$ 位
`uint8`	$8$ 位	$[0, 255]$
`uint16`	$16$ 位	$[0, 65535]$
`uint32`	$32$ 位	$0, 2^{32}-1]$
`uint64`	$64$ 位	$0, 2^{64}-1]$
`byte`	$8$ 位		它是 `uint8` 的一个别名
`uintptr`	取决于平台		表示指针类型

3.3 整数字面值

整数字面值是表示整数常量的数字序列。可选前缀设置非十进制基数

0b 或 0B 表示二进制序列
0o 或 0O 表示八进制序列
0x 或 0X 表示十六进制。在十六进制文字中，字母 a 到 f 和 A 到 F 表示值 $10$ 到 $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$ 位	$[-3.4\times 10^{38}, 3.4\times 10^{38}]$	最大值定义在 `math.MaxFloat32`
`float64`	$64$ 位	$−1.8 \times 10^{308}, 1.8 \times 10^{308}]$	最大值定义在 `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 将尾数（整数和小数部分）缩放 $10^{\text{exp}}$

正式定义如下

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^{\text{exp}}$

{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$ 位编码的字符集。例如，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$ 个 ASCII 字符以外的字符

名字	转义序列
响铃符	`\a`
回退符	`\b`
换页符	`\f`
换行符	`\n`
回车符	`\r`
水平制表符	`\t`
垂直制表符	`\v`
反斜杠	`\\`
问号	`\?`
单引号	`\'`
双引号	`\"`

6.2.2 数字转义序列

从字符集中查找字符编码对应的八进制数和十六进制数。然后，使用 \ 和跟随其后的字符编码表示。因此，数字转义序列有 八进制转义序列 和 十六进制转义序列 两种

八进制转移序列格式为 \ooo，ooo 表示三个数字的八进制数，它表示为一个无符号字符。这个八进制数的最大值通常是 377

ASCII 码中的 ESC 字符的八进制值为 33，所以他的八进制数字转义序列为 \33 或 \033

转义序列中的八进制数不必以 $0$ 开头

十进制转义序列格式为 \xh...，h...表示至少有 $1$ 十六进制数

十六进制转义序列的数字的个数是任意的，但必须表示成无符号字符
如果字符类型尺寸是 $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$ 个字符。因为 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)  
}