Go语言基本语法入门
以下是一些 Go 语言的基本语法介绍，用于复习Go语言基础语法：
go 语言入门
Go 程序的基本结构: 在package 后写当前的包名, 在要运行的主函数写func main() {}作为程序入口,并将该函数所在的包名写为package main, 通过import 来导入go语言的其他包
package main
import "fmt"
func main() {
fmt.Println("Hello, World!!")
}
package main：指定这是一个可执行程序import "fmt"：导入标准库中的fmt包，用于输出函数。func main()：main是程序的入口点。
变量的声明
Go 有多种方式来声明变量：
- 使用
var声明变量：
var x int
var y string
x = 10
y = "Hello"
- 使用简短声明方式：
x := 10
y := "Hello"
这种方式不需要提前指定类型，Go 会根据赋值推断出类型。
- 多变量声明：
var x, y int = 1, 2
a, b := 3, "world"
需要注意的是全局变量只能使用 var 来进行声明, 不能直接使用 := 来自动推导
常见的数据类型
Go 是静态类型语言，但也有类型推导。常见的数据类型包括：
- 基本数据类型：
int,float64,string,bool - 复合数据类型：数组、切片、映射（map）、结构体（struct）、通道（channel）
函数
Go 语言的函数定义使用 func 关键字。
例如:
不带参数的函数:
func MyFunc() {
fmt.Println("Hello World!!")
}
带参数的函数：
func add(a int, b int) int {
return a + b
}
Go 支持多个返回值：
func divide(a, b int) (int, int) {
return a / b, a % b
}
数组和切片
数组
数组是固定长度的，可以通过 [...] 来定义长度。
var arr [3]int = [3]int{1, 2, 3}
切片
切片是动态数组，可以自动扩展。
slice := []int{1, 2, 3} // 声明并初始化切片
slice = append(slice, 4) // 向切片添加元素
map映射
Go 的 map 是一个哈希表，支持通过键值对存取数据。
m := make(map[string]int)
m["orange"] = 5
m["banana"] = 3
fmt.Println(m["orange"]) // 输出: 5
注意: 在使用 map 前必须先 make 一块空间
结构体 (struct)
结构体是 Go 中的一种复合数据类型，类似于其他语言中的类。
type Person struct {
Name string
Age int
}
func main() {
p := Person{Name: "Alice", Age: 25}
fmt.Println(p.Name) // 输出: Alice
fmt.Println(p.Age) // 输出: 25
}
注意: go 语言可以在结构体上定义对应的方法,类似于类
接口
Go 中的接口定义了一组方法，但不需要实现它们。这使得 Go 支持面向接口编程。
type Speaker interface {
Speak() string
}
type Person struct {
Name string
}
func (p Person) Speak() string {
return "Hello, my name is " + p.Name
}
func introduce(s Speaker) {
fmt.Println(s.Speak())
}
func main() {
p := Person{Name: "Alice"}
introduce(p)
}
go 语言的并发操作
Go 内建对并发的支持，最常用的工具是 Goroutines 和 Channels。
Goroutines
Goroutines 是轻量级线程，通过 go 关键字启动。 (其实相当于协程)
go func() {
fmt.Println("This is running concurrently.")
}()
Channels
Channels 是 Go 中用于在 Goroutines 之间传递数据的管道。
ch := make(chan int)
go func() {
ch <- 42 // 发送数据到通道
}()
value := <-ch // 从通道接收数据
fmt.Println(value) // 输出: 42
注意: go 语言的管道可以有缓冲或者没有缓冲, 取决于是否进行 make 空间
错误处理的方法
Go 通过返回值而非异常来处理错误。常见的做法是返回一个 error 类型的值。
func divide(a, b int) (int, error) {
if b == 0 {
return 0, fmt.Errorf("cannot divide by zero")
}
return a / b, nil
}
result, err := divide(10, 0)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("Result:", result)
}
error可以通过 errors下的方法来自定义 : errors.New()
