Swift3 错误：不符合协议'；可均衡'；

我是swift的新手，我将学习更多教程

在下面的代码中，我定义了自定义运算符（<和==），但是代码运行良好，但是Xcode在第一行代码中显示了这些错误

Type 'SuitedCard' does not conform to protocol 'Equatable'
Type 'SuitedCard' does not conform to protocol 'Comparable'

代码如下：

struct SuitedCard: Equatable, Comparable {

    // a card can be ♥️, ♣️, ♦️, ♠️
    enum Suit {
        case hearts
        case spades
        case diamonds
        case clubs
    }

    // the possible values of a card
    enum Value: Int {
        case two = 2
        case three = 3
        case four = 4
        case five = 5
        case six = 6
        case seven = 7
        case eight = 8
        case nine = 9
        case ten = 10
        case jack = 11
        case queen = 12
        case king = 13
        case ace = 14
    }

    // properties
    let suit: Suit
    let value: Value
    var isFaceDown: Bool
}

var valueArray: [SuitedCard.Value] = [.ten, .jack, .queen, .king]


func ==(lhs: SuitedCard, rhs: SuitedCard) -> Bool {
    for cardValue in valueArray {
        if lhs.value == cardValue {
            for cardValue2 in valueArray {
                if rhs.value == cardValue2 {
                    return true
                }
            }
        }
    }
    if lhs.value == rhs.value {
        return true
    }
    return false
}

func <(lhs: SuitedCard, rhs: SuitedCard) -> Bool {
    var lhsRawValue: Int
    var rhsRawValue: Int
    if lhs.value == .jack || lhs.value == .queen || lhs.value == .king {
        lhsRawValue = 10
    } else {
        lhsRawValue = lhs.value.rawValue
    }
    if rhs.value == .jack || rhs.value == .queen || rhs.value == .king {
        rhsRawValue = 10
    } else {
        rhsRawValue = rhs.value.rawValue
    }
    return lhsRawValue < rhsRawValue
}

let smaller = SuitedCard(suit: .hearts, value: .five, isFaceDown: true)

let bigger = SuitedCard(suit: .diamonds, value: .six, isFaceDown: false)

smaller >= smaller

smaller < bigger

struct SuitedCard：可平衡、可比较{
//一张卡片可以是♥️, ♣️, ♦️, ♠️
枚举诉讼{
箱心
黑桃
表壳钻石
案例俱乐部
}
//卡片的可能值
枚举值：Int{
案例二=2
案例三=3
案例四=4
案例五=5
案例六=6
案例七=7
案例八=8
案例九=9
案例10=10
箱子千斤顶=11
案例皇后=12
案例王=13
案例ace=14
}
//性质
穿西装
让价值：价值
变量isFaceDown:Bool
}
var valueArray:[SuitedCard.Value]=[0.10、.jack、.queen、.king]
func==（左：SuitedCard，右：SuitedCard）->Bool{
对于valueArray中的cardValue{
如果lhs.value==cardValue{
对于valueArray中的cardValue2{
如果rhs.value==cardValue2{
返回真值
}
}
}
}
如果lhs.value==rhs.value{
返回真值
}
返回错误
}
func Bool{
var lhsRawValue:Int
var rhsRawValue:Int
如果lhs.value=.jack | | lhs.value==.queen | lhs.value==.king{
lhsRawValue=10
}否则{
lhsRawValue=lhs.value.rawValue
}
如果rhs.value=.jack | | rhs.value==.queen | | rhs.value==.king{
rhsRawValue=10
}否则{
rhsRawValue=rhs.value.rawValue
}
返回lhsRawValue=更小
小的<大的

---

怎么了？

在Swift 3中，协议所需的运算符被声明为静态成员

使用此类协议的一种方法是将运算符定义作为静态成员移动到结构中：

struct SuitedCard: Comparable { //### Comparable implies Equatable

    //...

    // function for custom operator ==
    static func ==(lhs: SuitedCard, rhs: SuitedCard) -> Bool {
        //...
        return false
    }
    // function for custom operator <
    static func <(lhs: SuitedCard, rhs: SuitedCard) -> Bool {
        //...
        return false
    }
}

struct SuitedCard:Comparable{/####Comparable意味着相等
//...
//自定义运算符的函数==
静态函数==（左：SuitedCard，右：SuitedCard）->Bool{
//...
返回错误
}
//自定义运算符的函数<
静态函数布尔{
//...
返回错误
}
}

---

另一种方法是，您可以使用扩展声明与协议的一致性：

struct SuitedCard {

    //...
}

// function for custom operator ==
func ==(lhs: SuitedCard, rhs: SuitedCard) -> Bool {
    //...
    return false
}
// function for custom operator <
func <(lhs: SuitedCard, rhs: SuitedCard) -> Bool {
    //...
    return false
}

extension SuitedCard: Comparable {}

struct SuitedCard{
//...
}
//自定义运算符的函数==
func==（左：SuitedCard，右：SuitedCard）->Bool{
//...
返回错误
}
//自定义运算符的函数<
func Bool{
//...
返回错误
}
扩展适配卡：可比{}

OOPer的答案解决了这个问题，但在Swift 3中，运算符方法也可以在类/结构体之外定义。因此，在本例中，只需将valueArray声明移动到==方法的主体中即可解决问题。以下是更正后的代码：

struct SuitedCard: Equatable, Comparable {

    // a card can be ♥️, ♣️, ♦️, ♠️
    enum Suit {
        case hearts
        case spades
        case diamonds
        case clubs
    }

    // the possible values of a card
    enum Value: Int {
        case two = 2
        case three = 3
        case four = 4
        case five = 5
        case six = 6
        case seven = 7
        case eight = 8
        case nine = 9
        case ten = 10
        case jack = 11
        case queen = 12
        case king = 13
        case ace = 14
    }

    // properties
    let suit: Suit
    let value: Value
    var isFaceDown: Bool
}


func ==(lhs: SuitedCard, rhs: SuitedCard) -> Bool {

//valueArray声明移到此处：

    let valueArray: [SuitedCard.Value] = [.ten, .jack, .queen, .king]
    for cardValue in valueArray {
        if lhs.value == cardValue {
            for cardValue2 in valueArray {
                if rhs.value == cardValue2 {
                    return true
                }
            }
        }
    }
    if lhs.value == rhs.value {
        return true
    }
    return false
}

func <(lhs: SuitedCard, rhs: SuitedCard) -> Bool {
    var lhsRawValue: Int
    var rhsRawValue: Int
    if lhs.value == .jack || lhs.value == .queen || lhs.value == .king {
        lhsRawValue = 10
    } else {
        lhsRawValue = lhs.value.rawValue
    }
    if rhs.value == .jack || rhs.value == .queen || rhs.value == .king {
        rhsRawValue = 10
    } else {
        rhsRawValue = rhs.value.rawValue
    }
    return lhsRawValue < rhsRawValue
}

let smaller = SuitedCard(suit: .hearts, value: .five, isFaceDown: true)

let bigger = SuitedCard(suit: .diamonds, value: .six, isFaceDown: false)

smaller >= smaller

smaller < bigger

let valueArray:[SuitedCard.Value]=[10、.jack、.queen、.king]
对于valueArray中的cardValue{
如果lhs.value==cardValue{
对于valueArray中的cardValue2{
如果rhs.value==cardValue2{
返回真值
}
}
}
}
如果lhs.value==rhs.value{
返回真值
}
返回错误
}
func Bool{
var lhsRawValue:Int
var rhsRawValue:Int
如果lhs.value=.jack | | lhs.value==.queen | lhs.value==.king{
lhsRawValue=10
}否则{
lhsRawValue=lhs.value.rawValue
}
如果rhs.value=.jack | | rhs.value==.queen | | rhs.value==.king{
rhsRawValue=10
}否则{
rhsRawValue=rhs.value.rawValue
}
返回lhsRawValue=更小
小的<大的

Swift 5同等和可比协议：

// Car Model
struct Car {
    let name: String
    let id: Int
    let weight: Double
}

// MARK: - Compare if to object are equal if specific parameter(s) are equal.
extension Car: Equatable {
    static func == (lhs: Car, rhs: Car) -> Bool {
        if lhs.id == rhs.id {
            return true
        } else {
            return false
        }
    }
}

相等的例子

let carsList: [Car] = []
let favouriteCar: Car = Car(name: "Brand", id: 1, weight: 4000)

// Ex. 1
if carsList.contains(favouriteCar) {
    print("Favourite car is ready to be delivered!")
}

// Ex. 2
if carsList.first == favouriteCar {
    print("Favourite car is first to be delivered!")
}

可比协议

// MARK: - Compare to object from specific parameter(s) using the relational operators <, <=, >=, and >.
extension Car: Comparable {
    static func < (lhs: Car, rhs: Car) -> Bool {
        if lhs.weight < rhs.weight {
            return true
        } else {
            return false
        }
    }
}

//标记：-使用关系运算符与特定参数中的对象进行比较。
扩展车：可比{
静态功能<（左：车，右：车）->Bool{
如果左侧重量<右侧重量{
返回真值
}否则{
返回错误
}
}
}

可比较的例子

let carsList: [Car] = []
let favouriteCar: Car = Car(name: "Brand", id: 1, weight: 4000)

if carsList.first < favouriteCar {
    print("First car in the lighter compare to favourite car!")
} else if carsList.first > favouriteCar {
    print("First car in the heavier compare to favourite car!")
} else {
    print("First car and favourite car have the same weight!")
}

let carsList:[Car]=[]
let FavoriteCar:Car=Car（名称：“品牌”，id:1，重量：4000）
如果车是第一辆<最喜欢的车{
打印（“打火机中的第一辆车与喜爱的车相比！”）
}否则，如果carsList.first>FavoriteCar{
打印（“较重车型中的第一辆车与喜爱的车型进行比较！”）
}否则{
打印（“第一辆车和最喜欢的车重量相同！”）
}