Go语言教程

📚 教程目录

查看完整目录 →

2.1 变量与常量

2.1 变量与常量

变量和常量是编程语言的基础。本节将详细介绍Go语言中变量和常量的声明、使用和特点。

变量

变量声明

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

方式一：标准声明

var name string
var age int
var isStudent bool

方式二：声明并初始化

var name string = "张三"
var age int = 25
var isStudent bool = true

方式三：类型推导

var name = "张三"      // 自动推导为string
var age = 25          // 自动推导为int
var isStudent = true  // 自动推导为bool

方式四：短变量声明（最常用）

name := "张三"
age := 25
isStudent := true

注意：短变量声明只能在函数内部使用。

方式五：批量声明

var (
    name      string = "张三"
    age       int    = 25
    isStudent bool   = true
)

完整示例

package main

import "fmt"

func main() {
    // 标准声明
    var x int
    x = 10
    fmt.Println("x =", x)

    // 声明并初始化
    var y int = 20
    fmt.Println("y =", y)

    // 类型推导
    var z = 30
    fmt.Println("z =", z)

    // 短变量声明
    w := 40
    fmt.Println("w =", w)

    // 批量声明
    var (
        a = 1
        b = 2
        c = 3
    )
    fmt.Println("a, b, c =", a, b, c)
}

零值

未初始化的变量会被赋予零值：

var i int       // 0
var f float64   // 0.0
var b bool      // false
var s string    // ""（空字符串）
var p *int      // nil

示例：

package main

import "fmt"

func main() {
    var i int
    var f float64
    var b bool
    var s string

    fmt.Printf("int: %d\n", i)       // 0
    fmt.Printf("float64: %f\n", f)   // 0.000000
    fmt.Printf("bool: %t\n", b)      // false
    fmt.Printf("string: %q\n", s)    // ""
}

多变量声明

// 同类型多变量
var a, b, c int
var x, y, z = 1, 2, 3

// 不同类型多变量
var (
    name   string = "Go"
    age    int    = 14
    active bool   = true
)

// 短变量声明
name, age := "Go", 14

变量赋值

// 单个赋值
x := 10
x = 20

// 多重赋值
a, b := 1, 2
a, b = b, a  // 交换值

// 使用函数返回值
func getValues() (int, string) {
    return 42, "answer"
}

num, str := getValues()

匿名变量

使用下划线_忽略不需要的值：

func getValues() (int, string, bool) {
    return 1, "hello", true
}

// 只需要第一个和第三个值
num, _, flag := getValues()

变量作用域

局部变量

func main() {
    x := 10  // 局部变量，仅在main函数内可见
    fmt.Println(x)
}

全局变量

package main

import "fmt"

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

func main() {
    fmt.Println(globalVar)
}

func otherFunc() {
    fmt.Println(globalVar)  // 其他函数也可以访问
}

块级作用域

func main() {
    x := 10
    
    if true {
        y := 20  // y只在if块内可见
        fmt.Println(x, y)
    }
    
    // fmt.Println(y)  // 错误：y在此处不可见
}

常量

常量是在编译时就确定的值，运行时不能改变。

常量声明

const PI = 3.14159
const GREETING = "Hello, World!"
const MAX_SIZE = 100

批量声明常量

const (
    StatusOK       = 200
    StatusNotFound = 404
    StatusError    = 500
)

常量的特点

  1. 必须在声明时初始化

const x = 10     // 正确
const y int      // 错误：常量必须初始化

  1. 值不可修改

const x = 10
x = 20  // 错误：不能修改常量

  1. 可以是任意基本类型

const (
    name    = "Go"
    version = 1.21
    active  = true
)

iota枚举器

iota是Go的常量计数器，用于创建枚举值。

基本用法

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

跳过某些值

const (
    a = iota  // 0
    b         // 1
    _         // 2（跳过）
    c         // 3
)

从1开始

const (
    January = iota + 1  // 1
    February            // 2
    March               // 3
    April               // 4
)

位运算

const (
    Read   = 1 << iota  // 1 << 0 = 1
    Write               // 1 << 1 = 2
    Execute             // 1 << 2 = 4
)

复杂表达式

const (
    KB = 1 << (10 * iota)  // 1 << 0 = 1
    MB                      // 1 << 10 = 1024
    GB                      // 1 << 20 = 1048576
    TB                      // 1 << 30 = 1073741824
)

完整示例

package main

import "fmt"

// 定义常量
const (
    PI     = 3.14159
    E      = 2.71828
    AUTHOR = "Go Team"
)

// 使用iota定义枚举
const (
    Sunday = iota
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
)

// 文件权限
const (
    Read   = 1 << iota  // 1
    Write               // 2
    Execute             // 4
)

func main() {
    fmt.Println("PI =", PI)
    fmt.Println("E =", E)
    fmt.Println("AUTHOR =", AUTHOR)

    fmt.Println("\n星期枚举:")
    fmt.Println("Sunday =", Sunday)
    fmt.Println("Monday =", Monday)
    fmt.Println("Saturday =", Saturday)

    fmt.Println("\n文件权限:")
    fmt.Println("Read =", Read)
    fmt.Println("Write =", Write)
    fmt.Println("Execute =", Execute)
    fmt.Println("Read+Write =", Read|Write)
}

变量 vs 常量

特性 变量 常量
声明关键字 var const
是否可修改 可以 不可以
是否必须初始化 否 是
作用域 局部/全局 局部/全局
类型推导 支持 支持

命名规范

变量命名

// 驼峰命名法
userName := "张三"
userAge := 25
isActive := true

// 首字母大写表示导出（公开）
var UserName string  // 可被其他包访问
var userName string  // 仅包内可访问

常量命名

// 全大写（可选）
const MAX_SIZE = 100
const DEFAULT_TIMEOUT = 30

// 驼峰命名法（推荐）
const MaxSize = 100
const DefaultTimeout = 30

命名建议

  1. 使用有意义的名称

  2. 避免使用单字母（除了循环变量）

  3. 缩写要全部大写或全部小写：userID、HTTPServer

  4. 包级别的变量和常量首字母大写表示导出

类型转换

Go不支持隐式类型转换，必须显式转换。

var i int = 42
var f float64 = float64(i)
var u uint = uint(f)

// 字符串转换
s := string(65)  // "A"

// 数值转字符串
import "strconv"
str := strconv.Itoa(42)  // "42"

练习

练习1：变量声明

声明并初始化以下变量：

  • 姓名（字符串）

  • 年龄（整数）

  • 身高（浮点数）

  • 是否学生（布尔值）

练习2：变量交换

不使用第三个变量，交换两个变量的值。

a := 10
b := 20
// 交换a和b的值

练习3：常量定义

定义一个表示一周七天的常量枚举。

练习4：文件大小

使用iota定义文件大小单位（B, KB, MB, GB, TB）。

小结

本节我们学习了：

  • 变量的多种声明方式

  • 变量的零值和作用域

  • 常量的声明和使用

  • iota枚举器的用法

  • 变量和常量的命名规范

  • 类型转换

掌握变量和常量是学习Go语言的基础。下一节，我们将学习Go语言的数据类型。

上一节: 1.3 第一个Go程序 | 下一节: 2.2 数据类型

返回目录 | 返回首页

顶部导航