Go 语言介绍

Go 语言（Go），简称 Golang，是一种静态类型的编程语言，由Google公司的Robert Griesemer、Rob Pike和Ken Thompson在2009年开发。Go 语言旨在提供一个高效、简洁、可靠的编程语言，用于构建网络协议、分布式系统、云计算和其他高性能应用。

语法特点

Go 语言的语法特点如下：

• 简洁：Go 语言的语法简洁易懂，减少了编写代码的时间和复杂度。
• 静态类型：Go 语言是静态类型语言，编译时会检查变量的类型，避免了在运行时出现类型错误。
• ** goroutine**：Go 语言提供了 goroutine 机制，允许开发者轻松地创建并发执行的线程。
• ** channels**：Go 语言提供了 channels 机制，允许开发者在 goroutine 之间传递数据和同步执行。
• 结构体：Go 语言提供了结构体（struct）机制，用于定义复杂的数据结构。

语法基本结构

Go 语言的语法基本结构如下：

package main

import "fmt"

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

在上面的代码中：

• package main 声明了当前文件的包名为 main。
• import "fmt" 导入了 fmt 包，用于格式化输出。
• func main() 声明了 main 函数，用于执行程序的入口点。
• fmt.Println("Hello, World!") 使用 fmt 包的 Println 函数将字符串 "Hello, World!" 输出到控制台。

语言特性

Go 语言具有以下语言特性：

并发编程

Go 语言提供了 goroutine 机制，允许开发者轻松地创建并发执行的线程。goroutine 是一种轻量级的线程，运行在同一个地址空间中，可以共享变量和数据结构。

package main

import "fmt"
import "time"

func main() {
    go func() {
        for i := 0; i < 5; i++ {
            fmt.Println(i)
            time.Sleep(time.Second)
        }
    }()

    for {
        fmt.Println("main goroutine")
        time.Sleep(time.Second)
    }
}

在上面的代码中，我们创建了一个 goroutine，运行了一个循环，输出数字 0 到 4，然后休眠 1 秒。主 goroutine 也输出了一些信息，休眠 1 秒。

channels

Go 语言提供了 channels 机制，允许开发者在 goroutine 之间传递数据和同步执行。channels 是一种 buffered 或 unbuffered 的队列，可以用于 goroutine 之间的通信。

package main

import "fmt"
import "time"

func main() {
    ch := make(chan int)

    go func() {
        for i := 0; i < 5; i++ {
            ch <- i
            time.Sleep(time.Second)
        }
    }()

    for {
        fmt.Println(<-ch)
        time.Sleep(time.Second)
    }
}

在上面的代码中，我们创建了一个 channels，goroutine 将数字 0 到 4 发送到 channels 中，主 goroutine 接收并输出这些数字。

error handling

Go 语言提供了错误处理机制，可以使用 err 类型变量来表示错误。开发者可以使用 err 变量来处理错误，例如：

package main

import "fmt"

func main() {
    _, err := fmt.Println("Hello, World!")
    if err != nil {
        fmt.Println(err)
    }
}

在上面的代码中，我们使用 _, err := 语法来调用 Println 函数，获取错误结果。如果错误不为 nil，则输出错误信息。

代码示例

HTTP 服务器

下面是一个简单的 HTTP 服务器示例：

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "Hello, World!")
    })
    http.ListenAndServe(":8080", nil)
}

在上面的代码中，我们使用 net/http 包创建了一个 HTTP 服务器，监听 8080 端口，处理所有请求，并输出 "Hello, World!" 到客户端。

数据库操作

下面是一个简单的数据库操作示例：

package main

import (
    "database/sql"
    "fmt"
)

func main() {
    db, err := sql.Open("mysql", "user:password@tcp(localhost:3306)/database")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer db.Close()

    rows, err := db.Query("SELECT * FROM users")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer rows.Close()

    for rows.Next() {
        var username string
        err = rows.Scan(&username)
        if err != nil {
            fmt.Println(err)
            return
        }
        fmt.Println(username)
    }
}

在上面的代码中，我们使用 database/sql 包连接到 MySQL 数据库，执行查询语句，并输出查询结果。

并发编程

下面是一个简单的并发编程示例：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(i int) {
            fmt.Println(i)
            wg.Done()
        }(i)
    }
    wg.Wait()
}

在上面的代码中，我们使用 sync 包创建了一个 WaitGroup 对象，用于同步 goroutine 的执行。然后，我们创建了 5 个 goroutine，每个 goroutine 输出一个数字，并使用 wg.Done() 函数通知 WaitGroup 对象执行完成。最后，我们使用 wg.Wait() 函数等待所有 goroutine 执行完成。