GO语句和关键字

点击名片关注 阿尘blog，一起学习，一起成长

本文主要分享Go语言的一些常用语句和关键字！

GO 控制语句

1 for语句

for语句是GO语言中的最常用的语句，表达式如下

for 初始语句;条件语句;后续语句{
    //循环体
}

初始语句在循环开始前执行一次，用于初始化循环变量

条件语句，每次循环进行判断，为TRUE就继续

后续语句，每次循环结束后执行，用于更新循环变量

2 Switch语句

switch语句用于根据不同的条件执行不同的代码块

switch 表达式 {
    case 表达式1:
        //执行代码块1
    case 表达式2:
        //执行表达式2
    ...
    default:
        //执行默认代码块
}

3 fallthrough关键字

fallthrough关键字是switch语句中开支代码流向的语句

case后面的代码执行完就会跳出switch，不再执行其他case，如果加上了fallthrough,程序执行完case继续执行下一个case，不用判断条件

package main  

import "fmt"  

func main() {  
    x := 2  

    switch x {  
    case 1:  
        fmt.Println("x is 1")  
    case 2:  
        fmt.Println("x is 2")  
        fallthrough // 执行下一个case分支  
    case 3:  
        fmt.Println("x is 3")  
    default:  
        fmt.Println("x is not 1, 2, or 3")  
    }  
}

4 if 语句

这个就不多说了

if condition {
    // 当condition为true时执行的代码
} else if anotherCondition {
    // 当condition为false，但anotherCondition为true时执行的代码
} else {
    // 当上述所有条件都为false时执行的代码
}

5 25个关键字的简单说明和举例

Go语言的常用关键字及其作用如下：

break：用于终止循环或switch语句，并继续执行后续的代码。

case：在switch语句中用于指定一个或多个可能的条件。

chan：用于定义通道（channel），它是Go语言中用于在goroutine之间进行通信的机制。

const：用于声明常量，即不可变的值。

continue：用于跳过当前循环的剩余部分，并直接开始下一次迭代。

default：在switch语句中，当所有case条件都不满足时，执行default子句。

defer：用于延迟执行一个函数调用，通常用于清理资源或执行一些需要在函数返回前完成的逻辑。

else：与if语句一起使用，当if条件不满足时执行else子句。

fallthrough：在switch语句中，用于指示程序继续执行下一个case子句，而不是跳出switch语句。

for：用于开始一个for循环，它可以是传统的循环（带有初始化、条件和后置语句），也可以是range循环，用于迭代数组、切片、映射等。

func：用于声明函数或方法。

go：用于启动一个新的goroutine，它是Go语言中实现并发的方式之一。

goto：用于无条件地跳转到程序中指定的行，通常与标签（label）一起使用。

if：用于条件判断，根据条件是否满足执行不同的代码块。

import：用于导入外部包（package），以便在当前文件中使用包中提供的函数、变量等。

interface：用于声明一个接口，接口指定了一组方法，任何实现了这些方法的类型都被认为实现了该接口。

map：用于声明一个映射（map），映射是一个无序的键值对集合。

package：用于声明当前文件的所属包，包是Go语言中的代码组织方式。

range：用于迭代数组、切片、映射等集合类型的元素。

return：用于从函数中返回一个或多个值。

select：用于在多个通信操作中选择可用的操作，通常与通道（channel）一起使用。

struct：用于声明一个结构体类型，结构体可以包含多个字段，每个字段都有名称和类型。

type：用于声明自定义类型，可以是基于现有类型的别名类型，也可以是结构体、接口等复合类型。

var：用于声明变量，并可以指定变量的类型和初始值。

这些关键字在Go语言中扮演着重要的角色，它们帮助程序员编写结构清晰、易于理解的代码，并实现各种控制流程、并发和类型安全等特性。需要注意的是，Go语言的关键字是保留的，不能用作变量名、函数名或其他标识符。

package main

import (
    "fmt"
    "time"
)

// 定义一个简单的结构体
type Person struct {
    Name string
    Age  int
}

// 定义一个函数，用于模拟长时间运行的任务
func longRunningTask() {
    time.Sleep(2 * time.Second)
    fmt.Println("Long running task completed!")
}

func main() {
    // 使用var关键字声明变量
    var name string = "Alice"
    var age int = 30

    // 使用const关键字声明常量
    const pi = 3.14

    // 使用type关键字定义自定义类型
    type MyMap map[string]int
    myMap := MyMap{
        "apple":  5,
        "banana": 10,
    }

    // 使用func关键字声明函数
    fmt.Println("Hello, World!")
    fmt.Println("Name:", name)
    fmt.Println("Age:", age)
    fmt.Println("Pi:", pi)
    fmt.Println("My Map:", myMap)

    // 使用if关键字进行条件判断
    if age >= 18 {
        fmt.Println("Adult")
    } else {
        fmt.Println("Teenager")
    }

    // 使用for关键字进行循环
    for i := 0; i < 5; i++ {
        fmt.Println("Loop iteration:", i)
    }

    // 使用range关键字迭代map
    for fruit, count := range myMap {
        fmt.Println("Fruit:", fruit, "Count:", count)
    }

    // 使用select和chan进行通信
    ch := make(chan string)
    go func() {
        time.Sleep(1 * time.Second)
        ch <- "Message from goroutine"
    }()

    select {
    case msg := <-ch:
        fmt.Println("Received:", msg)
    case <-time.After(3 * time.Second):
        fmt.Println("Timeout waiting for message")
    }

    // 使用defer关键字延迟执行
    defer fmt.Println("World")
    fmt.Println("Hello")

    // 使用struct关键字定义结构体并创建实例
    person := Person{Name: "Bob", Age: 25}
    fmt.Println("Person:", person.Name, person.Age)

    // 使用interface关键字定义接口
    type Shape interface {
        Area() float64
    }

    // 实现接口的矩形结构体
    type Rectangle struct {
        Width  float64
        Height float64
    }

    // 实现Area方法
    func (r Rectangle) Area() float64 {
        return r.Width * r.Height
    }

    // 使用switch关键字进行多路选择
    shape := Rectangle{Width: 3, Height: 4}
    switch s := shape.(type) {
    case Shape:
        fmt.Println("Area of shape:", s.Area())
    default:
        fmt.Println("Unknown shape")
    }

    // 使用fallthrough关键字在switch中执行下一个case
    grade := "B"
    switch grade {
    case "A":
        fmt.Println("Excellent!")
        fallthrough
    case "B", "C":
        fmt.Println("Well done!")
    default:
        fmt.Println("You need to work harder.")
    }

    // 使用goto关键字进行无条件跳转
    i := 0
    here := func() { fmt.Println("Here") }
    if i == 0 {
        goto label
    } else {
        here()
    }

label:
    fmt.Println("Label reached")

    // 使用package关键字声明包
    // (已经在文件开头声明，这里不再重复)

    // 使用import关键字导入包
    // (已经在文件开头导入，这里不再重复)

    // 使用const、chan、go、map、package、type、var等关键字已在上面示例中使用

    // 启动一个goroutine来执行长时间运行的任务
    go longRunningTask()

    // 等待足够的时间以便看到长时间运行任务的结果
    time.Sleep(3 * time.Second)
}

这个示例代码包含了Go语言中大部分关键字的用法。当然，有些关键字（如goto）在实际编程中并不常用，因为它们可能导致代码难以理解和维护。通常，建议尽量避免使用goto，并寻找其他更结构化的控制流程方法。同样，interface和type等关键字在更复杂的程序中会有更多的用法和场景。

欢迎大家一起交流学习！

扫描二维码关注阿尘blog，一起交流学习