比较两个结构体是否大于

哈喽！大家好，很高兴又见面了，我是golang学习网的一名作者，今天由我给大家带来一篇《比较两个结构体是否大于》，本文主要会讲到等等知识点，希望大家一起学习进步，也欢迎大家关注、点赞、收藏、转发! 下面就一起来看看吧！

我正在尝试比较两个扑克牌结构，看看哪一张扑克牌比另一张更好。我在网上能找到的用于比较 go 中结构的所有内容都是比较相等性，但在这种情况下，我想说黑桃 a 比梅花 7 更有价值。

鉴于 go 没有提供像 java 的开箱即用的比较器接口之类的功能，我想创建自己的函数来使用循环进行卡片比较，但我收到错误消息：

# cards/card
card/card.go:12:19: cannot use ranks (type [13]string) as type []string in argument to indexofslice
card/card.go:14:26: cannot use ranks (type [13]string) as type []string in argument to indexofslice
card/card.go:15:20: cannot use suits (type [4]string) as type []string in argument to indexofslice

这是我的卡包：

package card

var suits = [4]string {"hearts", "spades", "diamonds", "clubs"}
var ranks = [13]string {"2", "3", "4", "5", "6", "7", "8", "9", "10", "jack", "queen", "king", "ace"}

type card struct {
        value string
        suit string
}

// if the index in the slices is greater for a than for b, then a must be greater value
func cardisgreater(a card, b card) bool {
        if indexofslice(a.value, ranks) > indexofslice(b.value, ranks) {
                return true;
        } else if indexofslice(a.value, ranks) == indexofslice(b.value, ranks) {
                if indexofslice(a.suit, suits) > indexofslice(b.suit, suits) {
                        return true;
                }
        } else {
                return false;
        }
        // lets ignore for a second that invalid ranks or suits will break this comparator
        return false;
}

// finds the index of a suit or value in a slice
func indexofslice(element string, slice []string) int {
        for i, _ := range slice {
                if slice[i] == element {
                        return i;
                }
        }
        return -1;
}

这是我的主包：

package main

import (
    "fmt"
    "cards/card"
)

func main () {
    card := Card.Card{Suit: "hearts", Value: "ace"}
    card2 := Card.Card{Suit: "diamonds", Value: "queen"}
    fmt.Println(card)
    fmt.Println(card2)
    fmt.Println(Card.CardIsGreater(card, card2)
}

在这种情况下，如何让 indexofslice 辅助函数接受字符串切片作为其参数之一？如果我从谷歌搜索的首页阅读随机教程，它看起来应该可以工作：https://nanxiao.gitbooks.io/golang-101-hacks/content/posts/pass-slice-as-a-函数参数.html

这个堆栈溢出答案解释了 go 基本上是在强制类型安全，因为类型 []string 可以通过很多东西来满足：https://stackoverflow.com/a/44606795/7255394。如果是这样，那么我该如何解决这个问题？

此外，这是否是比较结构的正确方法？在将空格 ace 与红心 ace 进行比较的情况下，需要对 suits and ranks 切片进行 4 次循环 (!!) 才能真正进行比较。

解决方案

suits 和 ranks 不是切片。它们是数组。数组是固定大小的类型，它与切片不同。您无法将数组发送到需要切片的函数。因此，声明它们时不指定大小，它们将成为切片：

var suits=[]string{...}
var ranks=[]string{...}

或者，如果您想将它们保留为数组，则必须将切片传递给需要切片的函数：

indexofslice(str,suits[:])

关于更好的方法的问题：您可以使用地图：

var suits=map[string]int{"hearts":0, "spades":1, "diamonds":2, "clubs":3}

然后：

ranksuit=suits[str]

我会抽象您的类型，并向它们添加一些实用函数。

为 card、suit 和 rank 创建自定义类型，允许您为每个类型附加比较和有效性函数。

如果您想要一个与 java 中的 comparable 类似的接口，那么您也可以自己创建一个非常小的接口。为您的类型实现必要的 compareto 函数来满足接口是足够简单的，不过，我认为我提供的解决方案封装了类型更好一些并且更容易测试。

我添加了在两张卡的 rank 相等的情况下比较 card 的 suit 的逻辑，但我不完全确定这背后的原因，因为通常将具有相同等级的扑克牌视为同等牌。

祝你好运！

cards/card.go

func new(s suit, r rank) (*card, error) {
    if !s.valid() {
        return nil, errors.new("invalid suit")
    }

    if !r.valid() {
        return nil, errors.new("invalid rank")
    }

    return &card{suit: s, rank: r}, nil
}

type card struct {
    suit suit
    rank rank
}

func (c *card) cmp(c2 *card) int {
    rankcmp := c.rank.cmp(c2.rank)
    if rankcmp != 0 {
        return rankcmp
    }

    if c.suit < c2.suit {
        return -1
    }

    if c.suit > c2.suit {
        return 1
    }

    return 0
}

cards/rank.go

type rank string

var ranks = []rank{"2", "3", "4", "5", "6", "7", "8", "9", "10", "j", "q", "k", "a"}

func (r rank) cmp(r2 rank) int {
    for _, rank := range ranks {
        if rank == r {
            return -1
        }

        if rank == r2 {
            return 1
        }
    }

    return 0
}

func (r rank) valid() bool {
    for _, rank := range ranks {
        if r == rank {
            return true
        }
    }

    return false
}

cards/suit.go

type suit int

const (
    unknown  suit = 1
    hearts   suit = 2
    spades   suit = 3
    diamonds suit = 4
    clubs    suit = 5
    sentinel suit = 6
)

func (s suit) valid() bool {
    return s > unknown && s < sentinel
}

ma​​in.go

func main() {
    c1, err := cards.New(Hearts, "2")
    if err != nil {
        fmt.Println(err)
        return
    }

    c2, err := New(cards.Diamonds, "A")
    if err != nil {
        fmt.Println(err)
        return
    }

    c3, err := New(cards.Spades, "A")
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("c1 - c2: %d\n", c1.Cmp(c2))
    fmt.Printf("c2 - c3: %d\n", c2.Cmp(c3))
    fmt.Printf("c1 - c3: %d\n", c1.Cmp(c3))
}

(Go Playground)

到这里，我们也就讲完了《比较两个结构体是否大于》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！