10分钟学会Golang，你真的可以！

Golang是一种开源的编程语言，由Google团队开发。它是一种快速、可靠、简单的语言，适合于编写各种类型的应用程序。以下是12个Golang语言的要点，每个要点配以详细的使用范例

1. 变量声明

变量是一种存储特定类型的值的容器。在Go中，变量声明必须显示地指定类型，可以使用var关键字进行声明。变量在声明时会自动初始化为其类型的零值。

// 声明一个字符串变量
var str string

// 声明一个整型变量
var num int

// 声明一个布尔类型变量
var flag bool

2. 循环语句

循环语句是一种执行相同代码块多次的结构。在Go中，支持for、while和无限循环三种循环语句。

// for循环
for i := 0; i < 10; i++ {
    fmt.Println("i:", i)
}

// while循环
j := 0
while j < 10 {
    fmt.Println("j:", j)
    j++
}

// 无限循环
for {
    fmt.Println("无限循环")
}

3. 分支语句

分支语句是一种根据条件执行不同代码块的结构。在Go中，支持if和switch两种分支语句。

// if语句
if x > 10 {
    fmt.Println("x大于10")
} else {
    fmt.Println("x不大于10")
}

// switch语句
switch x {
case 1:
    fmt.Println("x等于1")
case 2:
    fmt.Println("x等于2")
default:
    fmt.Println("x不等于1或2")
}

4. 数组

数组是一种按照一定顺序存储相同类型数据的容器。在Go中，支持固定长度的数组。

在for循环中，i和v是用来存储数组的索引和值的。i表示数组中当前元素的索引，v表示当前元素的值。代码中的range关键字用来迭代数组中的元素，每次迭代会返回当前元素的索引和值。

以下是完整的代码：

// 声明一个字符串数组
var arr [3]string

// 初始化数组
arr[0] = "张三"
arr[1] = "李四"
arr[2] = "王五"

// 遍历数组
for i, v := range arr {
    fmt.Println(i, v)
}

5. 切片

切片是一种动态数组，可以根据需要动态增加或缩小容量。在Go中，切片是由数组建立的一种方便、灵活且强大的包装器。

// 声明一个切片
var slice []int

// 初始化切片
slice = append(slice, 1)
slice = append(slice, 2)

// 遍历切片
for i, v := range slice {
    fmt.Println(i, v)
}

6. Map

Map是一种无序的键值对集合。在Go中，使用make关键字来创建一个新的Map。

// 声明一个Map
var m map[string]int

// 初始化Map
m = make(map[string]int)
m["张三"] = 20
m["李四"] = 30

// 遍历Map
for k, v := range m {
    fmt.Println(k, v)
}

7. 函数

函数是一段可重复使用的代码块，完成特定的任务。在Go中，函数是一等公民，可以作为参数传递和返回值返回。

// 声明一个函数
func add(x, y int) int {
    return x + y
}

// 调用函数
result := add(1, 2)
fmt.Println("result:", result)

8. 结构体

结构体是一种用户自定义的数据类型，它是由一组不同类型的值组成的。在Go中，可以通过声明一个结构体来定义一个自定义的数据类型。

// 声明一个结构体
type Person struct {
    Name string
    Age  int
}

// 初始化结构体
p := Person{Name: "张三", Age: 20}

// 访问结构体属性
fmt.Println("Name:", p.Name)
fmt.Println("Age:", p.Age)

以上代码定义了一个名为Person的结构体，包含两个属性：Name和Age。在主函数中，创建了一个Person类型的变量p，并分别为其属性赋值。最后，通过.运算符访问了变量p的Name和Age属性，并将其打印输出到控制台。

9. 接口

接口是一种抽象类型，它定义了一组方法，但没有实现。在Go中，接口是一种强大的工具，可以用来实现多态和依赖注入等设计模式。

// 声明一个接口
type Animal interface {
    Eat()
}

// 实现接口
type Cat struct{}

func (c Cat) Eat() {
    fmt.Println("猫在吃鱼")
}

// 调用接口
var animal Animal
animal = Cat{}
animal.Eat()

以上的代码定义了一个Animal接口和一个Cat结构体。Cat结构体实现了Animal接口的Eat()方法。在主函数中，创建一个Animal类型的变量，并将它赋值为一个Cat类型的实例。最后，调用该变量的Eat()方法，程序会输出"猫在吃鱼"这句话。

10. 并发

并发是一种同时执行多个独立的任务的能力。在Go中，使用goroutine和channel来实现并发编程。

// 声明一个goroutine
go func() {
    fmt.Println("Hello, world!")
}()

// 使用channel通信
ch := make(chan int)

go func() {
    ch <- 1
}()

num := <-ch
fmt.Println("num:", num)

以上示例演示了如何在Go中使用goroutine和channel来实现并发编程。

在第一个示例中，使用go关键字声明了一个goroutine，并在其中打印了Hello, world!。因为goroutine是异步执行的，所以这条语句不会阻止程序的执行。

在第二个示例中，使用make函数创建了一个int类型的channel，并在一个goroutine中将值1发送到该channel中。在主goroutine中，使用<-运算符从channel中接收值，并将其赋值给变量num。最后，打印输出变量num的值。

11. 引用库

在Go中，可以使用import语句来引用其他库。可以引用标准库、第三方库或者自己写的库。下面是一些库的引用方式和使用方法：

引用标准库

Go标准库是Go语言自带的一组库，可以通过import语句直接引用。例如，上文中的fmt库就是Go标准库中的一部分。

import "fmt"

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

在上面的示例中，通过import语句引用了fmt库，并在main函数中使用了其中的Println函数。

引用第三方库

Go语言拥有丰富的第三方库，可以通过go get命令下载并安装。例如，下面的示例演示了如何使用github.com/gin-gonic/gin库创建一个Web服务器：

import "github.com/gin-gonic/gin"
func main() {
    r := gin.Default()
    r.GET("/", func(c *gin.Context) {
        c.String(200, "Hello, world!")
    })
    r.Run(":8080")
}

在上面的示例中，通过import语句引用了github.com/gin-gonic/gin库，并在main函数中使用了其中的函数和结构体。

引用自己写的库

在Go中，可以创建自己的库，并通过import语句引用。例如，下面的示例演示了如何创建一个名为mylib的库，并在另一个文件中引用它：

// mylib.go
package mylib
func Add(a, b int) int {
    return a + b
}
// main.go
package main
import (
    "fmt"
    "mylib"
)
func main() {
    result := mylib.Add(1, 2)
    fmt.Println(result)
}

在上面的示例中，mylib.go文件中定义了一个名为Add的函数，并指定了它所在的包名为mylib。main.go文件中引用了mylib包，并调用了其中的Add函数。

12. 异常捕获

在程序开发中，排查和修复错误是非常重要的一环。在Go中，可以使用以下方法来排查和修复错误：

使用fmt包的Println函数输出调试信息

使用panic函数抛出异常

使用recover函数捕获异常

// 使用fmt包输出调试信息
fmt.Println("debug info")

// 使用panic函数抛出异常
if err != nil {
    panic(err)
}

// 使用recover函数捕获异常
defer func() {
    if err := recover(); err != nil {
        fmt.Println("捕获到异常：", err)
    }
}()

在上面的示例中，使用fmt包的Println函数输出调试信息，使用panic函数抛出异常，使用recover函数捕获异常。其中，defer语句用来在函数返回前执行某个函数，可以用来捕获异常。