Go 语言编程基础：顺序编程

最新推荐文章于 2024-10-01 17:42:46 发布

悟生啊

最新推荐文章于 2024-10-01 17:42:46 发布

阅读量435

点赞数 4

分类专栏： Golang 文章标签： golang

本文链接：https://blog.csdn.net/wushengT/article/details/142328814

版权

Golang 专栏收录该内容

29 篇文章 0 订阅

订阅专栏

Go 语言编程基础：顺序编程

1. 变量

1.1 变量声明

Go 语言中的变量声明使用 var 关键字。
基本格式：
```
var name type
```
示例：
```
var x int
var y string
```

1.2 变量初始化

声明变量的同时可以进行初始化：
```
var x int = 10
var y string = "Hello"
```
使用 := 符号可以简化声明和初始化过程（仅用于函数内部）：
```
x := 10
y := "Hello"
```

1.3 变量赋值

已声明的变量可以通过赋值操作进行更新：
```
x = 20
y = "Go"
```

1.4 匿名变量

匿名变量用 _ 表示，用于忽略不需要的返回值：
```
_, err := someFunction()
```

2. 常量

2.1 字面常量

字面常量直接赋值，不使用 var 声明：
```
const Pi = 3.1415
```

2.2 常量定义

常量的类型可以是布尔型、数字型或字符串类型：
```
const True = true
const Greeting = "Hello"
```

2.3 预定义常量

Go 语言提供了一些内置常量，如 true、false 和 iota（用于自动生成连续的常量值）。

2.4 枚举

使用 iota 实现常量的枚举：

const (
    Sunday = iota
    Monday
    Tuesday
)

3. 类型

3.1 布尔类型

布尔型只接受 true 和 false 两个值：
```
var isReady bool = true
```

3.2 整型

整数类型有不同的大小，如 int, int8, int16, int32, int64。
- 默认 int 类型与平台位数相关（32 位或 64 位）。
```
var num int = 100
```

3.3 浮点型

Go 支持单精度和双精度浮点数类型：float32 和 float64。
```
var pi float64 = 3.14159
```

3.4 复数类型

Go 提供了复数类型 complex64 和 complex128，可以直接使用复数操作。
```
var c complex128 = 1 + 2i
```

3.5 字符串

字符串是不可变的 Unicode 文本序列。
```
var str string = "Go语言"
```

3.6 字符类型

字符类型是 rune（实际上是 int32 的别名），用于表示 Unicode 码点。
```
var char rune = 'G'
```

3.7 数组

数组是具有固定大小的元素序列，所有元素类型相同。
```
var arr [5]int
```

3.8 切片

切片（Slice） 是 Go 中灵活的动态数组。
```
var s []int = []int{1, 2, 3}
```

3.9 Map

Map 是键值对的无序集合，用于存储关联数据。
```
var m map[string]int = make(map[string]int)
```

4. 流程控制

4.1 条件语句

if 语句用于条件判断：

if x > 10 {
    fmt.Println("x is greater than 10")
}

4.2 选择语句

switch 语句是 Go 的多条件分支语句：

switch day {
case "Monday":
    fmt.Println("It's Monday")
default:
    fmt.Println("It's another day")
}

4.3 循环语句

Go 只有一种循环结构：for 循环：

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

4.4 跳转语句

使用 break 和 continue 来控制循环跳出或继续下一次迭代。

5. 函数

5.1 函数定义

Go 函数使用 func 关键字定义：

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

5.2 函数调用

通过函数名和参数来调用函数：
```
result := add(1, 2)
```

5.3 不定参数

函数可以接收不定数量的参数，使用 ... 语法：

func sum(nums ...int) int {
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}

5.4 多返回值

Go 支持返回多个值：

func swap(x, y string) (string, string) {
    return y, x
}

5.5 匿名函数与闭包

匿名函数是没有名字的函数，闭包是能够访问其外层变量的函数。
```
func() {
    fmt.Println("Hello")
}()
```

6. 错误处理

6.1 `error` 接口

Go 使用 error 类型处理错误，通常作为函数的最后一个返回值：

f, err := os.Open("filename")
if err != nil {
    fmt.Println(err)
}

6.2 `defer`

defer 用于确保某个操作在函数返回前执行：
```
defer file.Close()
```

6.3 `panic` 和 `recover`

panic 用于中断程序，recover 用于捕获 panic 并恢复程序：

defer func() {
    if r := recover(); r != nil {
        fmt.Println("Recovered from", r)
    }
}()

7. 完整示例

这里展示了一个包含所有上述概念的完整示例代码，你可以自己编写和运行以加深理解。

package main

import "fmt"

func main() {
    // 变量声明和赋值
    var x int = 10
    y := "Hello"
    
    // 条件语句
    if x > 5 {
        fmt.Println("x is greater than 5")
    }
    
    // 函数调用
    result := add(3, 4)
    fmt.Println("Sum:", result)
    
    // 错误处理
    defer fmt.Println("Program Finished")
}

// 函数定义
func add(a int, b int) int {
    return a + b
}