Go 基础语法

Go 是一种开源的编程语言，由 Google 开发。它具有简单、快速和高效的特点，适用于构建各种类型的应用程序。

Go 语言的特点：

  1. 简洁高效：Go 语言的语法很像 C 语言，编写起来又很像 Python，熟悉之后开发效率也很高。
  2. 并发支持：Go 语言内置了 goroutine（轻量协程） 和 channel（通道），使得编写并发程序非常简单。
  3. 跨平台支持：可以跨平台编译，可以直接在 Windows 上跨平台编译出 linux 系统的可执行文件，目标系统完全不需要安装 go 环境。
  4. 标准库强大：内置了 http 库，可以非常方便的开发 web 服务。还有加密、json 等这些好用的库。
  5. 静态类型：在编译器里面编辑的时候，静态语言开发体验很方便，后期方便维护。

一、第一个 Go 程序

1
2
3
4
5
6
7
package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
}
  • package main — 每个 Go 文件都属于一个包，main 包是程序的入口
  • import "fmt" — 引入标准库中的 fmt 包，用于格式化输入输出
  • func main() — 程序执行的入口函数

二、命名

Go 语言中的函数名、变量名、常量名、类型名、语句标号和包名等所有的命名，都遵循一个简单的命名规则：一个名字必须以一个字母（Unicode 字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线。

Go 语言中的关键字不能用于命名。Go 语言共有 25 个关键字：

1
2
3
4
5
break       default     func        interface   select
case        defer       go          map         struct
chan        else        goto        package     switch
const       fallthrough if          range       type
continue    for         import      return      var

此外还有一些预声明的标识符：

1
2
3
4
5
6
7
8
9
10
内建常量: true false iota nil

内建类型: int int8 int16 int32 int64
          uint uint8 uint16 uint32 uint64 uintptr
          float32 float64 complex128 complex64
          bool byte rune string error

内建函数: make len cap new append copy close delete
          complex real imag
          panic recover

三、声明

Go 语言中主要有四种声明语句：

  1. 变量声明：var
  2. 常量声明：const
  3. 类型声明：type
  4. 函数声明：func

四、变量与常量

Go 语言中要求：

  • 变量必须声明后才能使用
  • 变量必须使用，否则编译器会报错
  • 同一作用域内不能重复声明同名变量

4.1 变量声明

1
2
3
4
5
6
7
8
9
10
11
12
13
// var 声明
var name string = "Go"
var version = 1.21  // 类型推断

// 批量声明
var (
    x int
    y string = "hello"
)

// 短变量声明（只能在函数内使用）
count := 10
msg := "short"

4.2 常量声明

1
2
3
4
5
6
7
8
9
10
11
12
const Pi = 3.14159
const (
    StatusOK = 200
    StatusNotFound = 404
)

// iota 常量计数器
const (
    A = iota  // 0
    B         // 1
    C         // 2
)

4.3 匿名变量

匿名变量 _ 用于占位，表示我们不关心这个值。

1
2
3
for i := 0; i < 5; i++ {
    _ = i // 不使用 i，避免编译错误
}

4.4 总结

声明方式 适用范围 是否可省略类型 是否可批量声明
var 包级、函数内 可（类型推断） 可
:= 函数内 可 不可
const 包级、函数内 不可 可

4.4 全局变量与局部变量

4.4.1 全局变量

在函数外部声明的变量，作用域为整个包内，可以被包内所有函数访问。

声明变量只能用 var 或 const ，不能使用 :=。

1
2
3
4
5
6
7
8
9
package main

import "fmt"

var globalVar = "I am a global variable"

func main() {
    fmt.Println(globalVar) // 可以访问全局变量
}

4.4.2 局部变量

在函数 func {} 内部声明的变量，作用域仅限于该函数内部，函数外无法访问。

可使用 var、const 或 := 来声明局部变量。

1
2
3
4
5
6
7
8
package main

import "fmt"

func main() {
    localVar := "I am a local variable"
    fmt.Println(localVar) // 可以访问局部变量
}

遮蔽（Shadowing）：如果在局部作用域内声明了一个与外部同名的变量，那么在该局部作用域内访问这个变量时，会优先使用局部变量，外部同名变量被遮蔽。