基本 Golang - 相等比较

这篇文章是我打算分享使用 golang 进行开发的基本知识系列的一部分。

使用 == 或 != 运算符的逻辑比较并没有太多神秘之处。或者你的代码比较值是否相同或不同。
但有一些重要的细节需要了解您所比较的内容。

类似的接口

首先要知道什么可以与这些运算符进行比较，最明显的地方是 go 文档：关于比较器的部分

另一个选择是查看可比较的接口，它是与 go 的泛型实现一起添加的，所有实现该接口的类型都是可比较的。

所以基本上go定义的所有原始类型都是可以比较的，比如：字符串、数字（int、float、complex）、bool。

复杂类型比较

某些类型具有可比较或不可比较的条件。这是以下情况：结构体、切片和通道。
只有当它们的元素也具有可比性时，它们才具有可比性。
有趣的是，go 在编译级别验证了这一点，帮助您避免运行时错误，例如：

//esse código compila e a comparação funciona:
func main() {
    test1 := struct {
        name       string
    }{}
    test2 := struct {
        name       string
    }{}
    if test1 == test2 {
        fmt.println("funciona")
    }
}

在上面的代码中，我创建了两个具有等效属性的结构，并且比较有效。

//esse código não compila
func main() {
    test1 := struct {
        name       string
        attributes map[string]string
    }{}
    test2 := struct {
        name       string
        attributes map[string]string
    }{}
    if test1 == test2 {
        fmt.println("cade?")
    }
}

此代码将无法编译，并出现无效操作错误。

发生这种情况是因为 map 不是 go 中的可比较类型。

有关结构和映射的详细信息

能够使用 == 比较结构非常方便，因为这些是我们自定义建模的类型。
但即使使用不可比较的类型，也有一些方法可以简化代码，并且了解这一点将使您免于编写非常无聊的条件。

好吧，让我们想象一下我们正在学校系统中工作，并且我们有以下不可比较的结构：

type student struct {
    id         int
    name       string
    age        int
    course     string
    attributes map[string]string
}

好的一点是，这个结构体有一个 id 字段，如果您正在处理持久数据，这会变得更加容易。

现在想象一下，如果您正在处理仍然瞬态的数据，例如，如果您正在读取文件并且需要在保留此数据之前进行某种类型的处理。

您始终可以选择逐个字段进行比较，这一点都不方便，但它确实有效。但您可以按如下方式使用结构组合：

func main() {
    type identity struct {
        name   string
        age    int
        course string
    }
    type student struct {
        id int
        identity
        attributes map[string]string
    }

    s1 := student{
        identity: identity{
            name:   "chuck",
            age:    10,
            course: "golang",
        },
        attributes: map[string]string{
            "last_score": "10",
        },
    }
    s2 := student{
        identity: identity{
            name:   "chuck",
            age:    10,
            course: "golang",
        },
        attributes: map[string]string{
            "last_score": "20",
        },
    }

    s3 := student{
        identity: identity{
            name:   "chuck",
            age:    12,
            course: "golang",
        },
        attributes: map[string]string{
            "last_score": "20",
        },
    }

    if s1.identity == s2.identity {
        fmt.println("achou", s1)
    }

    if s1.identity != s3.identity {
        fmt.println("não achou")
    }
}

此代码的替代方法是创建如下条件：

    if s1.name == s2.name && s1.age == s2.age && s1.course == s2.course {
        fmt.Println("Achou", s1)
    }

您可以将其提取到一个函数中，以减少混乱，但您仍然需要维护这些比较。

充分利用组合，这可以极大地简化你的代码！

概括

• 了解类似的界面
• 原始类型是可比较的
• 复杂类型可能具有可比性，也可能不具有可比性
• 利用组合来发挥你的优势。

以上就是基本 Golang - 相等比较的详细内容，更多请关注其它相关文章！