go基础语法

80 次阅读
#go语法

Go 语言被设计成一门应用于搭载 Web 服务器，存储集群或类似用途的巨型中央服务器的系统编程语言。

对于高性能分布式系统领域而言，Go 语言无疑比大多数其它语言有着更高的开发效率。

Go 语言基础语法完整教程

目录

  1. Go 语言整体结构
  2. 基础数据类型
  3. 运算符
  4. 条件与循环语句
  5. 函数

一、Go 语言整体结构

1. 标准程序组成

一个完整可运行 Go 程序包含 4 个核心部分：

  1. package：包声明，区分库包/可执行程序
  2. import：导入依赖标准库或自定义包
  3. 全局变量、常量、自定义类型定义
  4. main() 入口函数（仅 package main 拥有）

2. HelloWorld 示例

// 1. 声明当前包为可执行程序入口包
package main

// 2. 导入格式化输出包
import "fmt"

// 程序入口函数
func main() {
	fmt.Println("Hello Golang")
}

3. 运行指令

# 直接运行代码
go run main.go
# 编译生成二进制可执行文件
go build main.go

4. 语法硬性规范

  1. 语句末尾不需要分号，编译器自动补充；
  2. { 大括号必须和同行关键字在一行，不能单独换行；
  3. 标识符首字母大写：外部包可访问（导出）；小写仅当前包可用；
  4. 定义的变量、导入的包必须使用，否则编译报错。

二、基础数据类型

1. 基本内置类型

（1）整型

类型 说明
int / uint 随系统32/64位自动适配长度
int8 / uint8 8位有符号/无符号整数
int16 / uint16 16位
int32 / uint32 32位
int64 / uint64 64位

（2）浮点型

  • float32：单精度浮点数
  • float64：双精度，默认浮点类型

（3）布尔型 bool

仅两个值：true / false，默认零值 false，不支持数字与布尔互转。

（4）字符串 string

  • UTF-8 编码，不可直接修改内部字符；
  • 零值为空字符串 ""；
  • 支持 + 拼接。

（5）字符类型

  • byte：等价 uint8，存储单字节 ASCII；
  • rune：等价 int32，存储中文、Unicode 字符。

2. 变量与常量

变量三种定义方式

package main
import "fmt"

func main() {
	// 方式1：先声明，后赋值
	var num int
	num = 10

	// 方式2：声明同时赋值
	var str string = "go"

	// 方式3：短变量声明（函数内专用，自动推导类型）
	flag := true
	fmt.Println(num, str, flag)
}

常量 const

编译期固定值，不可修改，支持 iota 自增枚举

const PI = 3.1415
const (
	A = iota // 0
	B        // 1
	C        // 2
)

3. 类型转换

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

a := 10
b := float64(a) // int 转 float64
c := int(b)     // float64 转 int

三、运算符

1. 算术运算符

+ - * / % ++ --
规则：

  1. ++、-- 只支持后置，无 ++i；
  2. 整数除法舍去小数，取模仅支持整数。

2. 关系运算符

== != > < >= <=

3. 逻辑运算符

&&（与） ||（或） !（非）

4. 位运算符

& 按位与 | 按位或 ^ 异或 << 左移 >> 右移

5. 赋值运算符

= += -= *= /= %= <<= >>= &= |= ^=

6. 取地址/解引用运算符

&：取变量内存地址
*：解引用指针，获取地址存储的值

四、条件和循环语句

1. if 条件判断

无需括号，{ 必须同行；支持前置变量语句

func main() {
	score := 85
	// 基础if else
	if score >= 60 {
		fmt.Println("及格")
	} else {
		fmt.Println("不及格")
	}

	// 前置语句写法
	if num := 20; num > 10 {
		fmt.Println(num)
	}
}

2. switch 分支语句

  • 匹配成功自动 break，不会穿透；
  • fallthrough 可强制执行下一个 case；
  • 无表达式 switch 可替代多分支 if。
func main() {
	grade := "B"
	switch grade {
	case "A":
		fmt.Println("优秀")
	case "B":
		fmt.Println("良好")
	default:
		fmt.Println("普通")
	}

	// 无表达式switch
	num := 70
	switch {
	case num >= 90:
		fmt.Println("高分")
	case num >= 60:
		fmt.Println("合格")
	}
}

3. for 循环（Go唯一循环，无while）

标准for循环

for i := 0; i < 5; i++ {
	fmt.Println(i)
}

等价 while 循环

i := 0
for i < 3 {
	i++
}

无限循环

for {
	break // 跳出循环
}

range 遍历（数组/切片/字符串/map）

s := []int{10,20,30}
for index, value := range s {
	fmt.Println(index, value)
}

4. 跳转关键字

  • break：跳出当前循环/switch；支持标签跳出多层循环；
  • continue：终止本次循环，进入下一轮。

五、函数

1. 函数基础定义格式

func 函数名(参数列表) 返回值列表 {
	函数体
}

2. 各类函数示例

无参无返回

func hello() {
	fmt.Println("hello")
}

单参单返回

func add(a int, b int) int {
	return a + b
}

多返回值

func calc(a, b int) (int, int) {
	return a+b, a-b
}

命名返回值（return可省略参数）

func sub(a, b int) (res int) {
	res = a - b
	return
}

3. 可变参数

接收任意个同类型参数，底层为切片

func sum(nums ...int) int {
	total := 0
	for _, v := range nums {
		total += v
	}
	return total
}
// 调用 sum(1,2,3,4)

4. defer 延迟执行关键字

函数结束前逆序执行，常用于关闭文件、释放资源

func main() {
	defer fmt.Println("最后执行")
	fmt.Println("先执行")
}

5. 匿名函数与闭包

// 立即执行匿名函数
func(x int) {
	fmt.Println(x)
}(10)

// 闭包：捕获外部变量
func counter() func() int {
	i := 0
	return func() int {
		i++
		return i
	}
}

6. 函数特性总结

  1. 支持多返回值，是Go标准错误处理方式；
  2. 参数、返回值类型后置；
  3. 函数是一等公民，可作为参数、返回值传递；
  4. 无函数重载。