Golang 特别的语法和特性

田猿笔记

已于 2023-05-30 15:28:13 修改

阅读量112

点赞数

分类专栏： Golang 从零到高级架构文章标签： golang

于 2023-05-19 11:17:09 首次发布

本文链接：https://blog.csdn.net/canduecho/article/details/130762556

版权

Golang 从零到高级架构专栏收录该内容

28 篇文章 15 订阅 ¥9.90 ¥99.00

订阅专栏

超级会员免费看

本文介绍了Golang的一些独特语法和特性，包括并发编程、错误处理、接口、defer语句、参数传递、if语句的短变量声明，以及官方依赖管理工具go mod的使用方法。

摘要由CSDN通过智能技术生成

这一节讲一讲 Golang 一些特别的语法和特性

并发编程

func main() { 
    ch := make(chan int) 
    go func() { 
        ch <- 1 
        ch <- 2 
        ch <- 3 
    }() 
    fmt.Println(<-ch) 
    fmt.Println(<-ch) 
    fmt.Println(<-ch) }

上面的代码中，我们使用goroutine和channel实现了并发。在main函数中，我们创建了一个int类型的channel，并在一个goroutine中往这个channel中发送了三个值。在main函数中，我们通过<-ch语法从channel中接收这三个值，并打印出来。

错误处理

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(result)
    }
}

上面的代码中，我们定义了一个divide函数，用于计算两个浮点数的除法。如果除数为0，我们会返回一个error类型的值，表示除法操作失败。在main函数中，我们用divide函数并检查返回值，如果返回的err不为nil，说明除法操作失败，我们打印出err的值；否则说明除法操作成功，我们打印出结果。

接口

type Shape interface {
    Area() float64
}

type Circle struct {
    radius float64
}

func (c Circle) Area() float64 {
    return math.Pi * c.radius * c.radius
}

type Rectangle struct {
    width  float64
    height float64
}

func (r Rectangle) Area() float64 {
    return r.width * r.height
}

func main() {
    var s Shape
    s = Circle{radius: 5}
    fmt.Println(s.Area())
    s = Rectangle{width: 10, height: 5}
    fmt.Println(s.Area())
}

上面的代码中，我们定义了一个Shape接口，用于表示所有图形的面积。然后，我们实现了Circle和Rectangle两个类型，并分别实现了Area方法，用于计算圆形和矩形的面积。最后，在main函数中，我们定义一个Shape类型的变量s，分别将它赋值为Circle和Rectangle类型的值，并调用Area方法计算它们的面积。

defer语句

func main() {
    f, err := os.Open("test.txt")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer f.Close()
    // do something with the file
}

上面的代码中，我们使用defer语句来延迟文件的关闭操作。在main函数中，我们先打开一个文件，并在defer语句中指定关闭操作。然后，在文件的处理过程中，我们可以进行一些操作，最后程序结束时，文件会被动关闭。

如果您想更新一个函数的参数，必须将该参数作为指针传递，否则它将以只读方式传递

在 Go 中，函数参数可以是值类型或引用类型。对于值类型的参数，如果只传递参数的值，函数将接收该参数的副本，即使在函数内更新该参数的值，也不会更改原始参数的值。具体来说，函数不会对原始参数做出任何修改，因为它只针对参数值的副本进行操作。

例如，考虑以下代码片段：



func updateName(name string) {
  name = "Alice"
}

func main() {
  myName := "Bob"
  updateName(myName)
  fmt.Println(myName) // Output: "Bob"
}

这个程序将打印 "Bob"，因为在 updateName 函数中，我们更新参数的值，但这只会影响参数值的副本，而不是原始参数。因此，myName 的值保持不变。

相比之下，如果我们将参数作为指针类型传递给函数，则该函数将对原始参数进行更改。因为在 Go 中，指针允许我们访问变量本身，而不是它的副本。因此，如果我们在函数中通过指针访问并更新参数值，原始参数也将被更新。例如：

func updateName(name *string) {
  *name = "Alice"
}

func main() {
  myName := "Bob"
  updateName(&myName)
  fmt.Println(myName) // Output: "Alice"
}

这个程序将打印 "Alice"，因为我们将 myName 的地址传递给 updateName 函数，然后在函数内通过 *name 访问指针的值并将其更新为 "Alice"。由于我们使用指向 myName 的指针来调用 updateName，因此 myName 的值被更新为 "Alice"。

总之，如果希望在函数内部更改参数的值，应该将参数声明为指针类型，并传递指向变量的指针。这样，函数才能访问变量本身，并在函数中更新其值。

if 语句可以包含一个短变量声明

在 Go 中，if 语句可以包含一个短变量声明，这是 Go 1.9 引入的新特性。这样做的效果是将一个变量声明和赋值的操作与条件判断语句放在一起，可以使代码更加简洁。

这种方式的写法是：

if <短变量名> := <表达式>; <条件> {
// ...
}

在这个语法中，如果表达式的求值结果为 `true`，则执行 if 代码块内的语句，否则跳过 if 代码块。在求值表达式时，如果没有错误发生，会将表达式的结果赋值给短变量名。这种变量声明和赋值操作只在 if 的作用域内有效。

因此，在这个代码段中：

if err := c.ShouldBind(&user); err == nil {
// ...
}

`err := c.ShouldBind(&user)` 这个语句将会执行，变量 `err` 将在 if 代码块的作用域内创建。如果表达式的求值结果为 `true`，也就是没有错误发生，继续执行 if 代码块内的语句。如果 `err` 的值为 `nil`，则继续执行 if 代码块；否则跳过 if 代码块。

总之，在 Go 中，在 if 语句中声明变量并进行条件判断是非常常见的语法，它可以让代码更加简洁易懂。