Go编程指南

Appearance

Go语言基础语法 ​

本文档详细介绍Go语言的基础语法规则、关键字、标识符和程序结构等核心概念。

📋 目录 ​

程序结构 ​

Go程序由以下基本元素组成：

基本组成 ​

go
// 1. 包声明 - 每个Go文件都属于一个包
package main

// 2. 导入语句 - 引入需要使用的包
import "fmt"

// 3. 函数 - 程序的基本执行单元
func main() {
    // 4. 变量 - 存储数据的容器
    var message string = "Hello, Go!"
    
    // 5. 语句和表达式 - 程序的执行逻辑
    fmt.Println(message)
}

// 6. 注释 - 代码说明文档

程序执行流程 ​

  1. 包初始化 - 初始化导入的包
  2. 全局变量初始化 - 按声明顺序初始化
  3. init函数执行 - 执行所有init函数
  4. main函数执行 - 程序入口点
go
package main

import "fmt"

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

// init函数（可以有多个）
func init() {
    fmt.Println("init函数1执行")
}

func init() {
    fmt.Println("init函数2执行")
}

func main() {
    fmt.Println("main函数执行")
    fmt.Println(globalVar)
}

语法规则 ​

基本规则 ​

  1. 语句结束
    • Go语言以换行符作为语句结束标志
    • 通常不需要分号（;）
    • 编译器会自动在行末添加分号
go
// 正确写法
var a int = 10
var b string = "hello"

// 错误写法（不推荐）
var a int = 10; var b string = "hello"
  1. 大小写敏感
    • Go语言严格区分大小写
    • 首字母大写表示公开（可导出）
    • 首字母小写表示私有（包内可见）
go
var PublicVar int    // 公开变量
var privateVar int   // 私有变量

func PublicFunc() {} // 公开函数
func privateFunc() {} // 私有函数
  1. 空格使用
    • 变量声明、操作符等需要适当的空格分隔
    • 使用gofmt工具自动格式化代码
go
// 推荐格式
var result int = a + b * c
if x > 0 {
    fmt.Println("positive")
}

// 不推荐格式
var result int=a+b*c
if x>0{
    fmt.Println("positive")
}
  1. 代码块
    • 使用大括号 {} 定义代码块
    • 左大括号必须在同一行
    • 右大括号独占一行
go
// 正确写法
if condition {
    // 代码块
}

// 错误写法
if condition 
{
    // 代码块
}

分号规则 ​

Go编译器会在以下情况自动插入分号：

  1. 行末是标识符、数字、字符串字面值
  2. 行末是关键字：break、continue、fallthrough、return
  3. 行末是操作符：++、--、)、]、}
go
// 自动插入分号的例子
var a int     // 自动插入 ;
return 42     // 自动插入 ;
i++           // 自动插入 ;

关键字 ​

Go语言有25个关键字（保留字），不能用作标识符：

关键字分类 ​

类别关键字
程序声明package, import
实体声明var, const, type, func
流程控制if, else, for, range, break, continue
选择控制switch, case, default, fallthrough, goto
并发控制go, select, chan
函数控制defer, return
类型相关interface, map, struct

关键字详解 ​

1. 程序结构关键字 ​

go
// package - 包声明
package main

// import - 导入包
import (
    "fmt"
    "strings"
)

2. 声明关键字 ​

go
// var - 变量声明
var name string = "Go"

// const - 常量声明
const pi = 3.14159

// type - 类型声明
type Person struct {
    Name string
    Age  int
}

// func - 函数声明
func greet(name string) string {
    return "Hello, " + name
}

3. 控制流关键字 ​

go
// if/else - 条件控制
if age >= 18 {
    fmt.Println("成年人")
} else {
    fmt.Println("未成年人")
}

// for/range - 循环控制
for i := 0; i < 10; i++ {
    fmt.Println(i)
}

for index, value := range slice {
    fmt.Printf("索引: %d, 值: %v\n", index, value)
}

// switch/case/default - 选择控制
switch grade {
case 'A':
    fmt.Println("优秀")
case 'B':
    fmt.Println("良好")
default:
    fmt.Println("其他")
}

标识符 ​

命名规则 ​

  1. 组成规则
    • 由字母、数字、下划线组成
    • 不能以数字开头
    • 区分大小写
go
// 正确的标识符
var userName string
var user_id int
var count2 int
var _temp string

// 错误的标识符
// var 2name string    // 不能以数字开头
// var user-name string // 不能包含连字符
// var class string    // 不能使用关键字
  1. 可见性规则
    • 首字母大写：公开（可导出到其他包）
    • 首字母小写：私有（仅包内可见）
go
// 公开标识符
var PublicVariable int
func PublicFunction() {}
type PublicStruct struct{}

// 私有标识符
var privateVariable int
func privateFunction() {}
type privateStruct struct{}

命名约定 ​

  1. 驼峰命名法
    • 变量和函数使用小驼峰：userName, getUserInfo
    • 类型和常量使用大驼峰：UserInfo, MaxRetryCount
go
// 推荐命名
var userAge int
var maxConnections int
func getUserName() string {}
func SetUserAge(age int) {}
type UserProfile struct {}
const DefaultTimeout = 30
  1. 特殊约定
    • 接收者使用类型首字母：func (u *User) GetName()
    • 错误变量使用err：if err != nil
    • 布尔变量使用is、has、can前缀
go
type User struct {
    name string
}

// 接收者命名
func (u *User) GetName() string {
    return u.name
}

// 错误处理
file, err := os.Open("file.txt")
if err != nil {
    log.Fatal(err)
}

// 布尔变量
var isActive bool
var hasPermission bool
var canEdit bool

预定义标识符 ​

Go语言预定义了36个标识符：

类别标识符
基本类型bool, byte, rune, int, int8, int16, int32, int64
uint, uint8, uint16, uint32, uint64, uintptr
float32, float64, complex64, complex128, string
常量true, false, nil, iota
函数make, new, append, copy, close, delete
len, cap, real, imag, panic, recover
print, println

注释 ​

注释类型 ​

  1. 单行注释
    • 使用 // 开始
    • 从 // 到行末的内容都是注释
go
// 这是单行注释
var count int // 行末注释
  1. 多行注释
    • 使用 /* */ 包围
    • 可以跨越多行
    • 不能嵌套
go
/*
这是多行注释
可以包含多行内容
用于详细说明
*/
var data map[string]interface{}

文档注释 ​

Go语言使用特殊的注释格式生成文档：

go
// Package main 演示Go语言基础语法
package main

// User 表示系统用户
type User struct {
    // Name 用户姓名
    Name string
    // Age 用户年龄
    Age int
}

// NewUser 创建新用户实例
// 参数 name 为用户姓名，age 为用户年龄
// 返回 User 指针
func NewUser(name string, age int) *User {
    return &User{
        Name: name,
        Age:  age,
    }
}

// GetInfo 获取用户信息
// 返回格式化的用户信息字符串
func (u *User) GetInfo() string {
    return fmt.Sprintf("姓名: %s, 年龄: %d", u.Name, u.Age)
}

注释最佳实践 ​

  1. 包注释

    go
    // Package calculator 提供基本的数学计算功能
// 
// 该包实现了加减乘除等基本运算，支持整数和浮点数计算。
// 使用示例：
//   calc := calculator.New()
//   result := calc.Add(1, 2)
package calculator

  2. 函数注释

    go
    // Divide 执行除法运算
// 
// 参数:
//   a: 被除数
//   b: 除数
// 
// 返回值:
//   float64: 运算结果
//   error: 当除数为0时返回错误
func Divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("除数不能为0")
    }
    return a / b, nil
}

包管理 ​

包的概念 ​

包是Go语言组织代码的基本单位：

  1. 包的作用

    • 代码组织和模块化
    • 命名空间管理
    • 访问控制
    • 代码复用

  2. 包的类型

    • 可执行包：package main，包含main函数
    • 库包：其他包名，提供功能给其他包使用

包的声明和导入 ​

go
// 包声明（必须在文件开头）
package main

// 导入单个包
import "fmt"

// 导入多个包
import (
    "fmt"
    "strings"
    "strconv"
)

// 包别名
import (
    f "fmt"           // 别名导入
    . "strings"       // 点导入（不推荐）
    _ "database/sql"  // 匿名导入（仅执行init函数）
)

包的使用 ​

go
package main

import (
    "fmt"
    "strings"
    "math"
)

func main() {
    // 使用fmt包
    fmt.Println("Hello, World!")
    
    // 使用strings包
    result := strings.ToUpper("hello")
    fmt.Println(result)
    
    // 使用math包
    sqrt := math.Sqrt(16)
    fmt.Printf("√16 = %.2f\n", sqrt)
}

自定义包 ​

创建自定义包的步骤：

  1. 创建包目录和文件

    myproject/
├── main.go
└── utils/
    ├── math.go
    └── string.go

  2. 定义包内容

    go
    // utils/math.go
package utils

// Add 加法运算（公开函数）
func Add(a, b int) int {
    return a + b
}

// multiply 乘法运算（私有函数）
func multiply(a, b int) int {
    return a * b
}

  3. 使用自定义包

    go
    // main.go
package main

import (
    "fmt"
    "./utils"  // 相对路径导入
)

func main() {
    result := utils.Add(3, 4)
    fmt.Printf("3 + 4 = %d\n", result)
}

Go Modules ​

现代Go项目使用Go Modules管理依赖：

bash
# 初始化模块
go mod init myproject

# 添加依赖
go get github.com/gin-gonic/gin

# 整理依赖
go mod tidy
go
// go.mod文件
module myproject

go 1.21

require (
    github.com/gin-gonic/gin v1.9.1
)

通过掌握这些基础语法规则，您就可以开始编写规范的Go程序了。下一步可以学习Go的数据类型和变量声明。

基于 MIT 许可发布

Copyright © 2024 Go编程指南