Golang 变量与数据类型

变量声明

Go 语言提供了多种变量声明方式。

1. 使用 var 关键字

package main

import "fmt"

func main() {
    // 声明单个变量
    var name string = "Jackson"
    var age int = 25

    // 类型推断
    var city = "Beijing"

    // 声明多个变量
    var (
        username string = "admin"
        password string = "123456"
        isActive bool   = true
    )

    fmt.Println(name, age, city)
    fmt.Println(username, password, isActive)
}

2. 短变量声明（:=）

在函数内部，可以使用 := 进行简短声明：

func main() {
    // 短变量声明
    name := "Jackson"
    age := 25
    score := 98.5

    // 多变量声明
    x, y, z := 1, 2, 3

    fmt.Println(name, age, score)
    fmt.Println(x, y, z)
}

基本数据类型

整型

func integerTypes() {
    // 有符号整型
    var i8 int8 = 127           // -128 到 127
    var i16 int16 = 32767       // -32768 到 32767
    var i32 int32 = 2147483647
    var i64 int64 = 9223372036854775807

    // 无符号整型
    var ui8 uint8 = 255         // 0 到 255
    var ui16 uint16 = 65535
    var ui32 uint32 = 4294967295
    var ui64 uint64 = 18446744073709551615

    // int 和 uint（根据平台自动选择 32 或 64 位）
    var num int = 100
    var unum uint = 200

    fmt.Println(i8, i16, i32, i64)
    fmt.Println(ui8, ui16, ui32, ui64)
    fmt.Println(num, unum)
}

浮点型

func floatTypes() {
    var f32 float32 = 3.14
    var f64 float64 = 3.141592653589793

    // 科学计数法
    var scientific = 1.23e5  // 123000

    fmt.Printf("float32: %.2f\n", f32)
    fmt.Printf("float64: %.15f\n", f64)
    fmt.Printf("scientific: %.0f\n", scientific)
}

字符串

func stringTypes() {
    // 普通字符串
    str1 := "Hello, World!"

    // 多行字符串（原始字符串）
    str2 := `这是一个
多行字符串
可以包含换行`

    // 字符串拼接
    firstName := "Jackson"
    lastName := "Wang"
    fullName := firstName + " " + lastName

    // 字符串长度
    length := len(str1)

    fmt.Println(str1)
    fmt.Println(str2)
    fmt.Println(fullName)
    fmt.Printf("字符串长度: %d\n", length)
}

布尔型

func booleanTypes() {
    var isTrue bool = true
    var isFalse bool = false

    // 逻辑运算
    result1 := isTrue && isFalse  // false
    result2 := isTrue || isFalse  // true
    result3 := !isTrue            // false

    fmt.Println(isTrue, isFalse)
    fmt.Println(result1, result2, result3)
}

常量

常量使用 const 关键字声明，值不可改变：

func constants() {
    // 单个常量
    const PI = 3.14159
    const AppName = "JacksonBlog"

    // 多个常量
    const (
        StatusOK = 200
        StatusNotFound = 404
        StatusError = 500
    )

    // iota 枚举
    const (
        Sunday = iota     // 0
        Monday            // 1
        Tuesday           // 2
        Wednesday         // 3
        Thursday          // 4
        Friday            // 5
        Saturday          // 6
    )

    fmt.Println(PI, AppName)
    fmt.Println(StatusOK, StatusNotFound, StatusError)
    fmt.Println(Sunday, Monday, Tuesday)
}

类型转换

Go 语言不支持隐式类型转换，必须显式转换：

func typeConversion() {
    var i int = 42
    var f float64 = float64(i)
    var u uint = uint(f)

    // 字符串转换
    str := fmt.Sprintf("%d", i)

    fmt.Printf("int: %d, float64: %.2f, uint: %d\n", i, f, u)
    fmt.Printf("string: %s\n", str)
}

零值

Go 语言中，声明但未初始化的变量会被赋予零值：

func zeroValues() {
    var i int        // 0
    var f float64    // 0.0
    var b bool       // false
    var s string     // ""

    fmt.Printf("int: %d\n", i)
    fmt.Printf("float64: %.1f\n", f)
    fmt.Printf("bool: %t\n", b)
    fmt.Printf("string: '%s'\n", s)
}

完整示例

package main

import "fmt"

func main() {
    // 变量声明
    name := "Jackson"
    age := 25
    height := 1.75
    isStudent := false

    // 常量
    const PI = 3.14159

    // 输出
    fmt.Println("=== 个人信息 ===")
    fmt.Printf("姓名: %s\n", name)
    fmt.Printf("年龄: %d\n", age)
    fmt.Printf("身高: %.2f米\n", height)
    fmt.Printf("是否学生: %t\n", isStudent)
    fmt.Printf("圆周率: %.5f\n", PI)

    // 类型转换
    ageFloat := float64(age)
    fmt.Printf("\n年龄（浮点型）: %.1f\n", ageFloat)

    // 零值演示
    var score int
    fmt.Printf("未初始化的分数: %d\n", score)
}

运行结果

=== 个人信息 ===
姓名: Jackson
年龄: 25
身高: 1.75米
是否学生: false
圆周率: 3.14159

年龄（浮点型）: 25.0
未初始化的分数: 0

小结

• Go 语言支持多种变量声明方式：var、:=
• 基本数据类型包括：整型、浮点型、布尔型、字符串
• 常量使用 const 声明，支持 iota 枚举
• 类型转换必须显式进行
• 未初始化的变量会被赋予零值