Go 语言入门指南：基础语法 | 豆包MarsCode AI刷题

Go 语言入门指南：基础语法

1. 变量声明

// var 变量名 变量类型
var age int 

上面一行代码的意思是声明一个名为age的一个int类型的变量

2. 批量变量声明

package main
import "fmt"
var (
	a int
	b string
	c []float32
)

func main() {
	fmt.Printf("%d, %s, %v\n", a, b, c)
}

这样就可以批量变量声明了

3. 简短格式

var关键字能不能省略不写了，答案是当然可以！这就是go语言的简短格式，代码如下：

i := 1

注意：如果不指明变量类型的话，go它会自己自动推导变量的类型

4.作用域

一般我们会将变量的作用域分为三个类型：

• 函数内定义的变量称为局部变量
• 函数外定义的变量称为全局变量
• 函数定义中的变量称为形式参数

局部变量： 在函数体内声明的变量叫做局部变量，当函数调用完之后这个局部变量它就会被销毁掉。

package main
import (
    "fmt";
)
func main() {
    var a int = 1
    fmt.Printf("a = %d\n", a)
}

全局变量： 在函数体外声明的变量称之为全局变量,全局变量声明必须以 var 关键字开头。

package main
import "fmt"
// 声明全局变量
var count int = 0
func increment() {
    count++
}
func main() {
    fmt.Println("初始值：", count) 
    increment()
    fmt.Println("增加后的值：", count) 
}

5. 整型

Go 语言提供有符号和无符号整型：

• 有符号整型：int, int8, int16, int32, int64
• 无符号整型：uint, uint8, uint16, uint32, uint64, uintptr

范围：

• 有符号：-2^(n-1) 到 2^(n-1)-1
• 无符号：0 到 2^n-1

int 和 uint 的大小依赖于平台（32 位或 64 位）。rune（等价于 int32）用于表示 Unicode 码点，byte（等价于 uint8）用于表示字节。

6. 浮点型

Go 支持两种浮点数：

• float32：范围约 1.4e-45 到 3.4e38
• float64：范围约 4.9e-324 到 1.8e308

代码如下：

floatStr1 := 3.2
fmt.Printf("%.2f\n", floatStr1)

建议使用 float64，因为 float32 容易引入计算误差。

7. 布尔型

布尔型使用 bool 声明，只有 true 和 false。比较运算符如 ==, !=, >, < 等返回布尔值。

代码如下：

var aVar = 10
fmt.Println(aVar == 10) // true

布尔运算符 && 和 || 具有短路特性。

8. 字符类型

• byte：uint8，表示 ASCII 字符。
• rune：int32，表示 UTF-8 字符。

代码如下：

var ch byte = 'A'
fmt.Printf("%c\n", ch) // 输出 A

Unicode 字符使用 \u 或 \U 表示。

9. 字符串型

字符串是不可变的字节序列，支持 UTF-8 编码。

代码如下：

var mystr string = "hello"
fmt.Println(len(mystr)) // 输出 5

字符串拼接使用 +：

s := "hello, " + "world!"
fmt.Println(s) // 输出 hello, world!

10. 常量

常量使用 const 定义，值在编译时确定，只能是布尔、数字和字符串类型。

11. 指针

指针用于存储变量的内存地址，使用 & 获取地址，使用 * 取值。

代码如下：

var a int = 10
var ptr *int = &a // ptr 指向 a 的地址
fmt.Println(*ptr)  // 输出 10

12. 使用指针修改值

通过指针可以修改原变量的值。

代码如下：

func modify(num *int) {
    *num = 1000
}

func main() {
    n := 10
    modify(&n)
    fmt.Println(n) // 输出 1000
}

13. 变量的生命周期

• 全局变量：程序运行期间存在。
• 局部变量：函数调用时创建，调用结束后销毁。

14. 类型别名

使用 type 定义类型别名。

代码如下：

type NewInt int
type IntAlias = int

var a NewInt
var a2 IntAlias

15. 注释

• 单行注释：// 注释
• 多行注释：/* 注释 */

16. 数组

数组是固定长度的同类型元素的集合，长度在编译时确定。

声明：

var arr [3]int // 长度为3的整型数组

赋值与取值：

arr := [3]int{1, 2, 3} // 初始化
fmt.Println(arr[0])    // 输出 1

// 遍历
for index, value := range arr {
    fmt.Printf("索引:%d, 值：%d\n", index, value)
}

数组比较：

a := [2]int{1, 2}
b := [...]int{1, 2}
c := [2]int{1, 3}
fmt.Println(a == b, a == c) // 输出 true false

17. 多维数组

多维数组是数组的数组，常用于处理复杂数据结构。

声明：

var array [4][2]int // 二维数组
array = [4][2]int{{10, 11}, {20, 21}, {30, 31}, {40, 41}}

取值与赋值：

fmt.Println(array[1][0]) // 输出 20
array[0][0] = 100

18. 切片

切片是动态大小的数组，底层是数组。

声明与初始化：

var slice []int          // 声明
slice = []int{1, 2, 3}  // 初始化

从数组生成切片：

arr := [3]int{1, 2, 3}
subSlice := arr[1:3] // 生成切片
fmt.Println(subSlice) // 输出 [2 3]

使用 make() 函数：

slice := make([]int, 5, 10) // 创建长度为5，容量为10的切片

19. 切片复制

使用 copy() 函数复制切片。

示例：

slice1 := []int{1, 2, 3}
slice2 := make([]int, 3)
copy(slice2, slice1) // 复制
fmt.Println(slice2)  // 输出 [1 2 3]

20. Map

Map 是无序的键值对集合，通过键快速访问值。

声明与初始化：

var myMap map[string]int
myMap = make(map[string]int)
myMap["one"] = 1

遍历与删除：

for k, v := range myMap {
    fmt.Println(k, v)
}
delete(myMap, "one")

21. nil

Go 中的 nil 是指针、切片、映射、通道、函数和接口的零值。

示例：

var m map[int]string // nil map
fmt.Println(m == nil) // 输出 true

22. for 循环

Go 语言中只有 for 循环，支持多种写法。

基本用法：

sum := 0
for i := 0; i < 10; i++ {
    sum += i // 计算 0 到 9 的和
}

无限循环：

sum := 0
for {
    sum++
    if sum > 100 {
        break // 跳出循环
    }
}

条件循环：

n := 10
for n > 0 {
    n--
    fmt.Println(n) // 输出 9 到 0
}

省略初始值：

step := 2
for ; step > 0; step-- {
    fmt.Println(step) // 输出 2 到 1
}

2. 结束循环的方式

• return：结束函数，后面的代码不执行。
• break：跳出循环，继续执行循环外的代码。
• panic：触发错误，直接结束程序。
• goto：无条件跳转到指定标签。

23. for range

用于遍历数组、切片、字符串和 map。

遍历数组/切片：

arr := []int{1, 2, 3}
for index, value := range arr {
    fmt.Println(index, value) // 输出索引和值
}

遍历 map：

m := map[string]int{"hello": 100, "world": 200}
for key, value := range m {
    fmt.Println(key, value) // 输出键和值
}

遍历字符串：

str := "ms的go教程"
for pos, char := range str {
    fmt.Println(pos, char) // 输出字符及其位置
}

24. switch 语句

用于多条件选择，自动终止，不需显式 break。

无条件 switch：

switch {
case score >= 90:
    fmt.Println("优秀")
case score >= 80:
    fmt.Println("良好")
default:
    fmt.Println("及格")
}

25. goto 语句

用于无条件跳转，简化代码。

示例：

package main
import "fmt"

func main() {
    for x := 0; x < 10; x++ {
        for y := 0; y < 10; y++ {
            if y == 2 {
                goto breakHere // 跳转到标签
            }
        }
    }
    return
breakHere:
    fmt.Println("done") // 标签处的代码
}

26. break 和 continue

• break：结束循环。
• continue：跳过当前迭代，进入下一次循环。

代码如下：

OuterLoop:
for i := 0; i < 2; i++ {
    for j := 0; j < 5; j++ {
        if j == 2 {
            break OuterLoop // 跳出外层循环
        }
    }
}

OuterLoop:
for i := 0; i < 2; i++ {
    for j := 0; j < 5; j++ {
        if j == 2 {
            continue OuterLoop // 跳过当前外层循环
        }
    }
}