一、基础声明关键字

Go语言中的基础声明关键字包括package、import、var、const、type和func。这些关键字是构建Go程序的基础，用于声明包、变量、常量、类型和函数。

package与import

包管理机制

1. package声明

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

// 声明当前文件所属的包
package main    // 可执行程序的入口包
package models  // 普通包

包的特点：

一个目录下的所有Go文件必须使用相同的包名
包名通常与目录名一致（除了main包）
包提供了代码的命名空间隔离

2. 包的可见性规则

大写开头的标识符：包外可见（公开的）
小写开头的标识符：包内可见（私有的）

导入规则与最佳实践

import基本用法

// 单个导入
import "fmt"

// 分组导入（推荐）
import (
    "fmt"
    "strings"
    "time"
)

导入别名

// 包重命名
import str "strings"

// 点号导入(不推荐)
import . "fmt"

// 下划线导入(仅执行init)
import _ "github.com/go-sql-driver/mysql"

最佳实践

按类别分组导入（标准库、第三方库、项目内部包）
导入路径使用全限定路径
避免循环导入
及时清理未使用的导入

var与const

变量声明与初始化

1. var的基本用法

// 单个变量声明
var name string
var age int = 25

// 多个变量声明
var (
    name string
    age  int
    city string = "Beijing"
)

// 简短声明（函数内部）
name := "Tom"

2. 变量声明的特点

变量必须先声明后使用
未初始化的变量会获得零值
函数内部推荐使用简短声明
包级别变量必须使用var声明

常量定义与iota

1. const基本用法

// 单个常量
const PI = 3.14159

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

2. iota的使用

const (
    Sunday = iota  // 0
    Monday         // 1
    Tuesday        // 2
    Wednesday      // 3
)

const (
    _  = 1 << (10 * iota)
    KB // 1024
    MB // 1048576
    GB // 1073741824
)

type

类型定义与类型别名

1. 类型定义

// 定义新类型
type MyInt int
type User struct {
    Name string
    Age  int
}

// 定义接口
type Reader interface {
    Read(p []byte) (n int, err error)
}

2. 类型别名（Go 1.9+）

// 类型别名
type MyString = string  // MyString是string的别名

自定义类型与类型组合

1. 结构体组合

type Animal struct {
    Name string
}

type Dog struct {
    Animal  // 匿名嵌入
    Breed string
}

2. 接口组合

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

type ReadWriter interface {
    Reader
    Writer
}

func

函数声明与方法

1. 基本函数声明

// 普通函数
func Add(x, y int) int {
    return x + y
}

// 多返回值
func Divide(x, y float64) (float64, error) {
    if y == 0 {
        return 0, errors.New("divide by zero")
    }
    return x / y, nil
}

2. 方法声明

type Rectangle struct {
    Width, Height float64
}

// 值接收者的方法
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// 指针接收者的方法
func (r *Rectangle) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}

函数类型与闭包

1. 函数类型

// 函数类型定义
type HandlerFunc func(string) error

// 函数作为参数
func process(handler HandlerFunc, data string) error {
    return handler(data)
}

2. 闭包

func Counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

// 使用闭包
counter := Counter()
fmt.Println(counter()) // 1
fmt.Println(counter()) // 2

小结

基础声明关键字是Go语言的核心组成部分：

package和import管理代码组织和依赖
var和const处理变量和常量声明
type支持类型系统的扩展
func提供函数和方法的声明

掌握这些关键字的正确使用是编写优质Go代码的基础。建议：

遵循Go的命名和风格约定
合理使用可见性规则
理解值类型和引用类型的区别
适当使用类型组合而不是继承