Go 语言结构 2

Go 语言是一种静态类型的编程语言，具有以下结构：

Package

Go 语言中，每个文件都是一个包（package），包名是文件名的前缀。包名可以是大小写混用，例如 main、math 等。

Import

Go 语言中，可以使用 import 语句将其他包引入当前包。例如：

import "fmt"
import "math"

Type

Go 语言中，有三种基本类型：

• int：整数类型
• float：浮点数类型
• bool：布尔类型

Variable

Go 语言中，可以使用 var 语句声明变量。例如：

var x int
x = 10

Constant

Go 语言中，可以使用 const 语句声明常量。例如：

const pi = 3.14

Function

Go 语言中，可以使用 func 语句声明函数。例如：

func add(x int, y int) int {
    return x + y
}

Struct

Go 语言中，可以使用 struct 语句声明结构体。例如：

type Person struct {
    name string
    age  int
}

Array

Go 语言中，可以使用 array 语句声明数组。例如：

var arr [5]int
arr[0] = 1
arr[1] = 2

Slice

Go 语言中，可以使用 slice 语句声明切片。例如：

var s []int
s = []int{1, 2, 3}

Map

Go 语言中，可以使用 map 语句声明映射。例如：

var m map[string]int
m = map[string]int{"a": 1, "b": 2}

Interface

Go 语言中，可以使用 interface 语句声明接口。例如：

type Printable interface {
    Print()
}

Goroutine

Go 语言中，可以使用 go 语句创建 goroutine。例如：

go func() {
    fmt.Println("Hello, World!")
}()

Channel

Go 语言中，可以使用 chan 语句声明通道。例如：

ch := make(chan int)
ch <- 1

Waitgroup

Go 语言中，可以使用 sync.WaitGroup 语句声明等待组。例如：

wg := &sync.WaitGroup{}
wg.Add(1)
go func() {
    defer wg.Done()
    fmt.Println("Hello, World!")
}()
wg.Wait()

Mutex

Go 语言中，可以使用 sync.Mutex 语句声明互斥锁。例如：

mu := &sync.Mutex{}
mu.Lock()
//  critical section
mu.Unlock()

Condition

Go 语言中，可以使用 sync.Cond 语句声明条件变量。例如：

cond := &sync.Cond{L: &mu}
cond.Wait()

Timer

Go 语言中，可以使用 time.Timer 语句声明定时器。例如：

t := time.NewTimer(1 * time.Second)
<-t.C

Select

Go 语言中，可以使用 select 语句选择多个通道中的一个。例如：

ch1 := make(chan int)
ch2 := make(chan string)
select {
case x := <-ch1:
    fmt.Println(x)
case y := <-ch2:
    fmt.Println(y)
}

Switch

Go 语言中，可以使用 switch 语句选择多个值中的一个。例如：

x := 1
switch x {
case 1:
    fmt.Println("x is 1")
case 2:
    fmt.Println("x is 2")
default:
    fmt.Println("x is other")
}

For

Go 语言中，可以使用 for 语句循环遍历数组、切片、映射等。例如：

arr := [5]int{1, 2, 3, 4, 5}
for i := 0; i < len(arr); i++ {
    fmt.Println(arr[i])
}

Range

Go 语言中，可以使用 range 语句遍历数组、切片、映射等。例如：

arr := [5]int{1, 2, 3, 4, 5}
for i, v := range arr {
    fmt.Println(i, v)
}

Closure

Go 语言中，可以使用 closure 语句创建闭包。例如：

add := func(x int) int {
    return x + 1
}
fmt.Println(add(1)) // Output: 2

Anonymous Function

Go 语言中，可以使用 anonymous function 语句创建匿名函数。例如：

add := func(x int) int {
    return x + 1
}(1) // Output: 2

Lambda Function

Go 语言中，可以使用 lambda function 语句创建 lambda 函数。例如：

add := func(x int) int {
    return x + 1
}(1) // Output: 2

Go 语言中，可以使用 timer 语句声明定时器。例如：

cond := &sync.Cond{L: &mu}
cond.Wait()