当前位置：首页 > news >正文

【Golang】：数据类型

news 2025/8/16 6:35:07

1. 基本数据类型

1.1 布尔类型

1.2 整数类型

1.3 浮点数类型

1.4 复数类型

1.5 字符类型

1.6 字符串类型

2. 类型转换

2.1 基本数据类型 → string

2.2 string → 基本数据类型

3. 常量

1. 基本数据类型

1.1 布尔类型

Go中的布尔类型取值为true或false，占用1字节大小。如下：

package mainimport ("fmt"
)func main() {// 布尔类型var flag bool = truefmt.Printf("flag value = %t\n", flag)               // flag value = truefmt.Printf("flag type = %T\n", flag)                // flag type = bool
}

说明一下：

布尔类型的默认值为false，变量声明后，如果没有给变量赋值，则保留默认值。
Go中在格式化字符串时，%t表示按布尔值true或false进行格式化。
关系运算符和逻辑运算符都会产生布尔类型的值，条件语句和循环语句的条件部分也都是布尔类型的值。

1.2 整数类型

类型	有无符号	占用存储空间
int8	有	1字节
int16	有	2字节
int32	有	4字节
int64	有	8字节
uint8	无	1字节
uint16	无	2字节
uint32	无	4字节
uint64	无	8字节
int	有	32位系统占用4字节，64位系统占用8字节
uint	无	32位系统占用4字节，64位系统占用8字节
rune	有	等价于int32，占用4字节
byte	无	等价于uint8，占用1字节

1. 整数类型

// 如果不指明类型，整数变量默认是 intvar a = 10 // 默认 int 类型// 默认值：整数类型默认值为 0var b 
int fmt.Println(b) // 输出 0

2. unsafe.Sizeof

// Sizeof 是 unsafe 包中的函数，用于获取数据所占用的字节数import "unsafe" 
var a int64 
fmt.Println(unsafe.Sizeof(a)) // 输出 8（字节）

3. 格式化字符串

// %d → 十进制整数// %T → 显示变量的类型a := 10 
fmt.Printf("值: %d, 类型: %T\n", a, a) // 输出：值: 10, 类型: int

4. 字符类型

// rune → 表示 Unicode 字符（实际是 int32）
// byte → 表示 ASCII 字符（实际是 uint8）var ch rune = '你' 
var b byte = 'A' 
fmt.Println(ch, b)    // 20320 65

1.3 浮点数类型

Go中的浮点数类型如下：

类型	占用存储空间	表示范围
`float32`	4 字节,单精度	−3.403 × 10³⁸ ~ 3.403 × 10³⁸
`float64`	8 字节,双精度	−1.798 × 10³⁰⁸ ~ 1.798 × 10³⁰⁸

1. 变量声明与默认类型

// 如果不指明类型，浮点数变量默认是 float64var a = 3.14 // 默认 float64// 默认值：浮点数变量未赋值时，默认值为 0
var b float64
fmt.Println(b)      // 0

2. 浮点数存储结构：浮点数在计算机中分为三部分：符号位（sign bit）、指数位（exponent）、尾数位/小数位（mantissa/fraction）

3. 格式化输出

// %f → 按浮点数格式输出
// %.2f → 保留两位小数a := 3.14159 
fmt.Printf("%f\n", a) // 输出 3.141590 
fmt.Printf("%.2f\n", a) // 输出 3.14

1.4 复数类型

Go中的复数类型如下：

类型	占用存储空间	表数范围
complex64	8字节	实部和虚部的范围与float32类型相同
complex128	16字节	实部和虚部的范围与float64类型相同

1.5 字符类型

Go中没有专门的字符类型，一般使用整数类型中的byte来存储单个字符。

package mainimport ("fmt"
)func main() {var a byte = 'A'fmt.Printf("类型：%T, 值:%c\n", a, a) // 类型：uint8, 值:Avar b rune = '牛'fmt.Printf("类型:%T, 值:%c\n", b, b) // 类型:int32, 值:牛
}

1.6 字符串类型

字符串就是一串固定长度的字符连接起来的字符序列，Go中的string是由单个字节连接起来的。string类型底层包含两个字段，一个字段是字符串指针，该指针指向对应的字符串，另一个字段记录着字符串的长度。

package mainimport ("fmt"
)func main() {var a string = "Hello World"fmt.Printf("类型:%T, 值:%s\n", a, a) // 类型:string, 值:Hello World// 1. string元素的访问// 注意：Go中的字符串是不可变的，因此在访问string元素时无法将元素修改为其他值。for i := 0; i < len(a); i++ {fmt.Printf("%c", a[i]) // Hello World}fmt.Println()// 2. 字符串的表示形式// 双引号表示：系统会识别字符串中的转义字符。// 反引号表示：系统不会识别字符串中的转义字符，可以实现防止攻击、输出源代码等效果。var s1 string = "Hello\nWorld"var s2 string = `Hello\nWorld`fmt.Println(s1) // Hello（换行）Worldfmt.Println(s2) // Hello\nWorld// 3. 字符串拼接var s = "hello" + "world"fmt.Println(s)       // helloworld
}

2. 类型转换

2.1 基本数据类型 → string

1. 使用 fmt.Sprintf:fmt.Sprintf 可以按照格式化规则把任意类型转换成字符串：

package mainimport "fmt"func main() {var a int = 100var b float64 = 3.1415926var c bool = truevar a1 string = fmt.Sprintf("%d", a)var b1 string = fmt.Sprintf("%.2f", b)var c1 string = fmt.Sprintf("%t", c)fmt.Println(a1, b1, c1)   // 100 3.14 true
}

2. strconv 包也能做类型转字符串，更高效

FormatInt函数：将int64类型的变量转换为string类型。
FormatFloat函数：将float64类型的变量转换为string类型。
FormatBool函数：将bool类型的变量转换为string类型。
FormatUint函数：将uint64类型的变量转换为string类型。
Itoa函数：将int类型变量转换为string类型，Itoa函数底层实际就是调用FormatInt函数实现的，在内部设置了按十进制进行转换。

package mainimport ("fmt""strconv"
)func main() {var a int = 100var b float64 = 3.1415926var c bool = truevar a1 string = strconv.FormatInt(int64(a), 10)var b1 string = strconv.FormatFloat(b, 'f', -1, 64)var c1 string = strconv.FormatBool(c)fmt.Println(a1, b1, c1)
}

如果是 简单数值转 string → 用 strconv（性能好）
如果需要 格式化输出 → 用 fmt.Sprintf（灵活）

2.2 string → 基本数据类型

ParseInt函数：将string类型变量转换为int64类型。
ParseFloat函数：将string类型变量转换为float64类型。
ParseBool函数：将string类型变量转换为bool类型。
ParseUint函数：将string类型变量转换为uint64类型。
Atoi函数：将string类型变量转换为int类型， Atoi函数底层实际就是调用ParseInt函数实现的，在内部设置了按十进制进行转换。

package mainimport ("fmt""strconv"
)func main() {// 1. 字符串 → 有符号整数// "123" → 要转换的字符串// 10    → 原字符串的进制（2~36）// 64    → 返回值的位数（64 表示 int64）a, err1 := strconv.ParseInt("123", 10, 64)fmt.Println(a, err1)a1, err := strconv.Atoi("520")fmt.Println(a1, err)// 2. 字符串 → 无符号整数// "255" → 需转换的字符串// 16    → 原字符串进制（这里按十六进制解析）// 64    → 返回 uint64u, err2 := strconv.ParseUint("255", 16, 64)fmt.Println(u, err2)// 3. 字符串 → 浮点数// "3.14159" → 要解析的字符串// 64        → 返回 float64；如果是 32 则返回 float32f, err := strconv.ParseFloat("3.14159", 64)fmt.Println(f, err)// 4. 字符串 → 布尔值// 支持的字符串（不区分大小写）：// "1", "t", "T", "true", "TRUE", "True"// "0", "f", "F", "false", "FALSE", "False"b, err := strconv.ParseBool("t")fmt.Println(b, err)
}

3. 常量

编译期确定 → 不能在运行时通过计算或函数结果赋值给常量。
不可修改 → 一旦定义，值就不能改变。
类型推导 → 可不写类型，编译器会根据值推导。
可以是无类型常量 → 没有明确类型的常量，可以在需要时自动转换：

const x = 5   // 无类型常量
var y float64 = x // 自动转换为 float64

1. 定义方式

const 常量名 [类型] = 值const Pi = 3.14159 // 类型推导 
const Version string = "1.0.0" // 显式声明类型

类型可以省略，编译器会根据值自动推导类型。
常量的值必须在编译期就能确定。

2. 多个常量一起声明

const ( A = 1 BC = 3 DE
)fmt.Println(A, B, C, D , E)  // 1 1 3 3 3

3. iota 枚举常量

iota 是一个常量计数器，从 0 开始，每新增一行常量声明，iota 自动加 1。
常用于定义枚举值：

const (Sunday  = iota // 0Monday         // 1Tuesday        // 2
)
fmt.Println(Sunday, Monday, Tuesday) // 0 1 2// 也可以用在位运算：
const (_  = iota       // 忽略 0KB = 1 << (10 * iota) // 1 << 10 = 1024MB               // 1 << 20 = 1048576GB               // 1 << 30
)

查看全文

http://www.xdnf.cn/news/1301167.html