Go语言中数据类型与变量的用法

数据类型详解

在Go语言中，数据类型分为以下几类：基本类型、复合类型和特殊类型。理解这些数据类型可以帮助我们更高效地操作数据和设计程序。

1. 基本数据类型

基本数据类型包含数值类型、布尔类型和字符串类型。

1.1 整数类型

Go支持多种整数类型，主要区别在于大小（字节数）和是否有符号：

有符号整数 ：int8（1字节）、int16（2字节）、int32（4字节）、int64（8字节）
无符号整数 ：uint8（1字节）、uint16（2字节）、uint32（4字节）、uint64（8字节）
平台相关整数 ：int 和 uint，它们的大小取决于平台（32位或64位）

Go 复制代码

var a int8 = -128  // int8取值范围：-128到127
var b uint8 = 255  // uint8取值范围：0到255

1.2 浮点数类型

浮点数用于存储带小数的数值，Go提供了两种浮点数类型：

float32：32位浮点数
float64：64位浮点数，通常使用float64，因为它精度更高

Go 复制代码

var pi float32 = 3.1415 
var e float64 = 2.718281828

1.3 布尔类型

布尔类型（bool）有两个值：true 和 false。布尔类型通常用于条件判断。

Go 复制代码

var isGoEasy bool = true

1.4 字符串类型

字符串是字符的集合，用双引号 " 包裹，可以包含任意Unicode字符。字符串是不可变的，修改字符串内容会生成新的字符串。

Go 复制代码

var greeting string = "Hello, Go!"

1.5 字符类型（rune 和 byte）

rune：等价于 int32，表示Unicode字符，常用于处理多字节字符。
byte：等价于 uint8，表示单字节字符，常用于操作二进制数据。

Go 复制代码

var ch rune = 'a' 
var b byte = 'b'

2. 复合数据类型

复合数据类型包含数组、切片、映射、结构体等。

2.1 数组

数组是具有固定长度、元素类型相同的集合。数组一旦定义长度不可改变。

Go 复制代码

var arr [5]int = [5]int{1, 2, 3, 4, 5}

2.2 切片

切片是动态数组，长度可以变化。切片是引用类型，底层数据由数组支撑。

Go 复制代码

var slice []int = []int{1, 2, 3, 4, 5} 
slice = append(slice, 6)

2.3 映射（Map）

映射是键值对的集合，键和值可以是任意类型，但键必须是支持相等比较的类型。

Go 复制代码

var m map[string]int = map[string]int{"one": 1, "two": 2}
m["three"] = 3

2.4 结构体（Struct）

结构体是将多个不同类型的字段组合在一起的复合数据类型。常用于定义实体对象。

Go 复制代码

type Person struct {
    Name string
    Age  int
}

var p Person = Person{Name: "Alice", Age: 30}

3. 指针

指针保存变量的内存地址。使用 * 表示指针类型，& 取变量地址。Go中没有指针运算。

Go 复制代码

var x int = 10
var p *int = &x

4. 接口（Interface）

接口定义了一组方法的集合，任何类型只要实现了这些方法就实现了该接口。接口是实现多态的基础。

Go 复制代码

type Speaker interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string {
    return "Woof!"
}

var s Speaker = Dog{}

5. 特殊数据类型

5.1 空类型（Nil）

Go中，指针、切片、映射、通道和接口类型的零值都是nil。nil表示空值。

5.2 空接口（interface{}）

空接口表示任意类型。因为Go是静态类型语言，空接口允许存储任何类型的值。

Go 复制代码

var anyType interface{}
anyType = "Hello"
anyType = 123
anyType = true

6. 类型转换

Go是强类型语言，不支持隐式类型转换。不同类型的数据只能通过显式转换来进行类型转换。

Go 复制代码

var a int = 10
var b float64 = float64(a)  // int 转 float64

7. 类型别名

类型别名是给现有类型起一个新的名字，用于代码可读性和扩展性。

Go 复制代码

type MyInt int

var num MyInt = 10

变量用法详解

在Go语言中，变量是通过 var 关键字进行声明的。变量是程序存储数据的命名空间，用于保存和操作不同类型的数据。下面是Go中变量的基础语法和几种常见的声明方式。

1. 变量的声明与初始化

在Go中，变量的声明通常使用 var 关键字。基本格式如下：

Go 复制代码

var 变量名 数据类型

可以通过多种方式声明和初始化变量。

1.1 声明变量但不赋值

在这种情况下，变量会被初始化为其类型的零值。例如：

Go 复制代码

var age int // age的零值为0 
var name string // name的零值为""

1.2 声明并赋值

声明的同时对变量进行初始化，可以这样写：

Go 复制代码

var age int = 25 
var name string = "Go语言"

1.3 类型推断

如果在声明变量时赋值，但没有指定类型，Go会自动根据值的类型进行推断：

Go 复制代码

var age = 25 // int类型 
var name = "Go语言" // string类型

1.4 简短声明（仅限函数内）

在函数内部，可以使用 := 进行简短声明，省略 var 关键字和类型，Go会自动推断变量类型：

Go 复制代码

age := 25 name := "Go语言"

注意：:= 只能在函数内部使用，不能用于全局变量的声明。

2. 零值

在Go中，如果变量声明后没有显式赋值，它会有一个默认的零值：

整数类型（int、int32、int64 等）：0
浮点数类型（float32、float64）：0
字符串类型（string）：""
布尔类型（bool）：false
指针、函数、切片、通道、接口等：nil

3. 多变量声明

Go支持多变量同时声明和赋值，有几种方式：

3.1 同类型多变量声明

可以声明多个相同类型的变量：

Go 复制代码

var x, y, z int

3.2 不同类型多变量声明

可以声明不同类型的多个变量，并分别赋值：

Go 复制代码

var (
    age int = 25
    name string = "Go语言"
    isStudent bool = false
)

3.3 多变量赋值

多变量赋值允许在一行中给多个变量赋值：

Go 复制代码

x, y, z := 1, 2, "Go语言"

4. 常量声明

常量使用 const 关键字声明，且值在声明时必须确定，之后不能更改：

Go 复制代码

const pi = 3.14 
const language = "Go语言"

多个常量声明

可以使用类似多变量声明的方法定义多个常量：

Go 复制代码

const (
    pi = 3.14
    language = "Go语言"
)

5. 变量的作用域

变量的作用域分为两种：

全局变量：在函数外部声明的变量，在整个包范围内有效。
局部变量：在函数内部声明的变量，作用域仅限于该函数内部。

示例代码

Go 复制代码

package main

import "fmt"

var globalVar = "我是全局变量" // 全局变量

func main() {
    var age int = 25
    name := "Alice"
    fmt.Println(globalVar) // 输出全局变量
    fmt.Println(age, name)

    const pi = 3.1415
    fmt.Println("常量pi的值为:", pi)
}