【Golang】：数据类型

目录

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 main

import (
	"fmt"
)

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

说明一下：

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

1.2 整数类型

1. 整数类型

// 如果不指明类型，整数变量默认是 int

var a = 10 // 默认 int 类型

// 默认值：整数类型默认值为 0

var 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中的浮点数类型如下：

1. 变量声明与默认类型

// 如果不指明类型，浮点数变量默认是 float64

var 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中的复数类型如下：

1.5 字符类型

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

package main

import (
	"fmt"
)

func main() {
	var a byte = 'A'
	fmt.Printf("类型：%T, 值:%c\n", a, a) // 类型：uint8, 值:A

	var b rune = '牛'
	fmt.Printf("类型:%T, 值:%c\n", b, b) // 类型:int32, 值:牛
}

1.6 字符串类型

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

package main

import (
	"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（换行）World
	fmt.Println(s2) // Hello\nWorld

	// 3. 字符串拼接
	var s = "hello" + "world"
	fmt.Println(s)       // helloworld
}

2. 类型转换

2.1 基本数据类型 → string

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

package main

import "fmt"

func main() {
	var a int = 100
	var b float64 = 3.1415926
	var c bool = true

	var 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 main

import (
	"fmt"
	"strconv"
)

func main() {
	var a int = 100
	var b float64 = 3.1415926
	var c bool = true

	var 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 main

import (
	"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    → 返回 uint64
	u, err2 := strconv.ParseUint("255", 16, 64)
	fmt.Println(u, err2)

	// 3. 字符串 → 浮点数
	// "3.14159" → 要解析的字符串
	// 64        → 返回 float64；如果是 32 则返回 float32
	f, 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 
    B
    C = 3 
    D
    E
)

fmt.Println(A, B, C, D , E)  // 1 1 3 3 3

3. iota 枚举常量

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

const (
	Sunday  = iota // 0
	Monday         // 1
	Tuesday        // 2
)
fmt.Println(Sunday, Monday, Tuesday) // 0 1 2

// 也可以用在位运算：
const (
    _  = iota       // 忽略 0
    KB = 1 << (10 * iota) // 1 << 10 = 1024
    MB               // 1 << 20 = 1048576
    GB               // 1 << 30
)