GO基本语法

一、程序结构

 

package main        // 包声明

import "fmt"        // 导入包

func main() {       // 主函数，程序入口
    // 代码
}

 

二、注释

 

 

// 单行注释

/*
多行注释
多行注释
*/

 

三、变量声明

package main

import "fmt"

func main() {
    // 方式1：var声明
    var name string = "张三"
    var age int = 25
    
    // 方式2：类型推断
    var city = "北京"  // 自动推断为string
    
    // 方式3：短变量声明（最常用）
    country := "中国"
    
    // 同时声明多个变量
    var a, b, c int = 1, 2, 3
    
    fmt.Println(name, age, city, country)
    fmt.Println(a, b, c)
}

三种变量声明方式对比

方式	语法	特点	使用场景
var显式类型	var name string = "张三"	明确指定类型	需要零值或包级变量
var类型推断	var city = "北京"	省略类型，自动推断	显式声明但不关心类型
短变量声明	country := "中国"	最简洁	函数内最常用

批量声明（更优雅的写法）

var (
    name string = "张三"
    age  int    = 25
    city string = "北京"
)

零值初始化

var score int      // 默认0
var isActive bool  // 默认false
var ptr *int       // 默认nil

使用new函数（较少用）

p := new(int)  // p是*int类型，指向0值
fmt.Println(*p) // 输出0

多变量短声明（你已实现）

x, y := 10, "hello"  // 不同类型也可以

四、常量

package main　　　　　　　　　　　　　　　　　　　　

import "fmt"

func main() {
    // 常量声明
    const PI = 3.14159
    const MAX_SIZE = 100
    
    // 同时声明多个常量
    const (
        Monday = 1
        Tuesday = 2
        Wednesday = 3
    )
    
    // iota枚举
    const (
        A = iota  // 0
        B         // 1
        C         // 2
    )
    
    fmt.Println(PI, MAX_SIZE)
    fmt.Println(A, B, C)
}

📦 包声明和导入

package main              // 声明这是可执行程序的主包，Go程序必须从main包开始执行
import "fmt"             // 导入fmt包（format的缩写），用于格式化输入输出，比如打印到控制台

🔧 main函数（程序入口）

func main() {            // 程序执行的入口函数，Go会自动调用这个函数

📌 单行常量声明

 // 常量声明
    const PI = 3.14159    // 声明一个名为PI的常量，值为3.14159
                          // const关键字表示值不可修改，PI是圆周率
                          // 没有指定类型，Go会自动推断为float64
    
    const MAX_SIZE = 100  // 声明整数常量MAX_SIZE，值为100
                          // 常用于定义数组大小、缓冲区限制等

📝 批量常量声明

// 同时声明多个常量
    const (               // 使用括号批量声明常量，提高代码可读性
        Monday = 1        // 声明Monday常量为1，代表星期一
        Tuesday = 2       // 声明Tuesday常量为2，代表星期二  
        Wednesday = 3     // 声明Wednesday常量为3，代表星期三
    )

🔢 iota枚举器（重点）

// iota枚举
    const (               // 新的const块，iota会重置为0
        A = iota          // iota是Go内置的常量计数器，从0开始
                          // 所以A = 0
        B                 // 省略了 = iota，会自动继承上一行的iota表达式
                          // 此时iota隐式加1，所以B = 1
        C                 // 继续继承，iota再加1，所以C = 2
    )

 

🖨️ 输出打印

 fmt.Println(PI, MAX_SIZE)    // 打印PI和MAX_SIZE的值
                                 // 输出：3.14159 100
    
    fmt.Println(A, B, C)         // 打印A、B、C的值
                                 // 输出：0 1 2

📊 iota工作原理详解

iota在每次遇到const关键字时重置为0，在同一个const块内每行自动递增1：

// 更复杂的iota示例
const (
    _ = iota              // 0，用_忽略第一个值
    KB = 1 << (10 * iota) // 1 << 10 = 1024
    MB = 1 << (10 * iota) // 1 << 20 = 1048576  
    GB = 1 << (10 * iota) // 1 << 30 = 1073741824
)

💡 关键知识点

1. 常量不可修改：编译时就确定，运行时不能改变

2. 类型可选：可以指定类型 const PI float64 = 3.14159

3. iota实用场景：枚举值、位掩码、偏移量计算

4. 命名规范：Go常量通常使用驼峰式或全大写（导出常量）