Go语言基础语法

---

Go语言是一种简洁、高效、并发的编程语言，具有强大的标准库和丰富的生态系统。在本篇文章中，我们将介绍Go语言的基础语法，并提供相应的源代码示例。

1. Hello, World!

---

让我们从经典的 “Hello, World!” 程序开始。在Go语言中，打印输出可以通过使用标准库中的 fmt 包实现。

package main

import "fmt"

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

2. 变量和类型

---

在Go语言中，我们可以使用 var 关键字声明变量。Go是一种静态类型语言，变量的类型在声明时就需要指定。

package main

import "fmt"

func main() {
    var message string
    message = "Hello, Go!"
    fmt.Println(message)

    var number int = 10
    fmt.Println(number)

    var isTrue bool
    isTrue = true
    fmt.Println(isTrue)
}

除了使用 var 关键字外，我们还可以使用短变量声明 := 来进行变量声明和初始化的简写。

package main

import "fmt"

func main() {
    message := "Hello, Go!"
    fmt.Println(message)

    number := 10
    fmt.Println(number)

    isTrue := true
    fmt.Println(isTrue)
}

Go语言支持多种基本数据类型，包括整数类型(int、int8、int16、int32、int64)、无符号整数类型(uint、uint8、uint16、uint32、uint64)、浮点数类型(float32、float64)、布尔类型(bool)、字符串类型(string)等。

3. 流程控制

---

Go语言提供了常见的流程控制语句，如条件语句(if-else)、循环语句(for)和选择语句(switch)。

package main

import "fmt"

func main() {
    // 条件语句
    number := 10
    if number > 0 {
        fmt.Println("Number is positive")
    } else if number < 0 {
        fmt.Println("Number is negative")
    } else {
        fmt.Println("Number is zero")
    }

    // 循环语句
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
    }

    // 选择语句
    day := "Sunday"
    switch day {
    case "Monday":
        fmt.Println("It's Monday")
    case "Tuesday":
        fmt.Println("It's Tuesday")
    case "Wednesday":
        fmt.Println("It's Wednesday")
    case "Thursday":
        fmt.Println("It's Thursday")
    case "Friday":
        fmt.Println("It's Friday")
    case "Saturday":
        fmt.Println("It's Saturday")
    default:
        fmt.Println("It's Sunday")
    }
}

4. 函数和包

---

在Go语言中，函数是基本的代码块，用于执行特定的任务。我们可以使用 func 关键字定义函数，并指定参数和返回值的类型。

package main

import "fmt"

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

func main() {
    result := add(10, 20)
    fmt.Println(result)
}

Go语言通过包（package）来组织代码。一个包可以包含多个源文件，并且通过 import 关键字引入其他包。

5. 数组和切片

---

Go语言提供了数组（array）和切片（slice）两种数据结构来存储多个相同类型的元素。

package main

import "fmt"

func main() {
    // 数组
    var numbers [3]int
    numbers[0] = 1
    numbers[1] = 2
    numbers[2] = 3
    fmt.Println(numbers)

    // 切片
    fruits := []string{"apple", "banana", "orange"}
    fmt.Println(fruits)
}

切片是动态数组，具有动态大小和灵活的操作。我们可以使用内置的 make 函数来创建切片，并使用索引和切片操作来访问和修改元素。

package main

import "fmt"

func main() {
    // 创建切片
    numbers := make([]int, 3)
    numbers[0] = 1
    numbers[1] = 2
    numbers[2] = 3
    fmt.Println(numbers)

    // 切片操作
    fruits := []string{"apple", "banana", "orange"}
    fmt.Println(fruits[0])        // 输出：apple
    fmt.Println(fruits[1:3])      // 输出：[banana orange]
    fmt.Println(fruits[:2])       // 输出：[apple banana]
    fmt.Println(fruits[1:])       // 输出：[banana orange]

    // 修改切片元素
    fruits[0] = "pear"
    fmt.Println(fruits)           // 输出：[pear banana orange]

    // 添加元素到切片末尾
    fruits = append(fruits, "grape")
    fmt.Println(fruits)           // 输出：[pear banana orange grape]
}

6. 结构体和方法

---

Go语言支持面向对象编程的概念，可以通过结构体（struct）和方法（method）来定义自定义类型和关联的行为。

package main

import "fmt"

type Person struct {
    name string
    age  int
}

func (p Person) sayHello() {
    fmt.Printf("Hello, my name is %s and I'm %d years old\n", p.name, p.age)
}

func main() {
    p := Person{name: "Alice", age: 25}
    p.sayHello()
}

在上面的例子中，我们定义了一个 Person 结构体，包含 name 和 age 两个字段。然后，我们为 Person 结构体定义了一个 sayHello 方法，用于输出个人信息。

7. 并发编程

---

Go语言内置了并发编程的支持，通过 goroutine 和 channel 实现并发执行和通信。

package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
        time.Sleep(1 * time.Second)
    }
}

func printLetters() {
    for i := 'a'; i <= 'e'; i++ {
        fmt.Println(string(i))
        time.Sleep(1 * time.Second)
    }
}

func main() {
    go printNumbers()
    go printLetters()

    time.Sleep(6 * time.Second)
}

在上面的例子中，我们定义了两个函数 printNumbers 和 printLetters，分别用于打印数字和字母。通过使用 go 关键字，我们可以启动两个并发的 goroutine 来同时执行这两个函数。为了确保主程序不会在两个 goroutine 执行完之前退出，我们在主函数中使用 time.Sleep 函数进行等待。

这只是Go语言基础语法的一个简要介绍。Go语言还有许多其他特性和功能，例如错误处理、接口、包管理等。希望本篇文章能够帮助你入门Go语言，并激发你进一步探索和学习的兴趣。