Equatable

Overview 概要

Types that conform to the Equatable protocol can be compared for equality using the equal-to operator (==) or inequality using the not-equal-to operator (!=). Most basic types in the Swift standard library conform to Equatable. Equatableプロトコルに準拠する型は、同等性を同等演算子（==）を使って、または不等性を不等演算子（!=）を使って比較されることができます。Swift標準ライブラリの基本的な型のほとんどはEquatableに準拠します。

Some sequence and collection operations can be used more simply when the elements conform to Equatable. For example, to check whether an array contains a particular value, you can pass the value itself to the contains(_:) method when the array’s element conforms to Equatable instead of providing a closure that determines equivalence. The following example shows how the contains(_:) method can be used with an array of strings. いくつかのシーケンスとコレクションの演算子は、要素がEquatableに準拠する時はより簡単に使われることができます。例えば、ある配列がある特定の値を含むかどうか調べるには、あなたはその値自体をcontains(_:)メソッドに渡すことが、その配列の要素がEquatableに準拠する場合には、同等を判定するクロージャを提供する代わりに可能です。以下の例は、contains(_:)メソッドが文字列からなる配列で使われるのを示します。

let students = ["Kofi", "Abena", "Efua", "Kweku", "Akosua"]


let nameToCheck = "Kofi"
if students.contains(nameToCheck) {
    print("\(nameToCheck) is signed up!")
} else {
    print("No record of \(nameToCheck).")
}
// Prints "Kofi is signed up!"

Conforming to the Equatable Protocol Equatableプロトコルに準拠する

Adding Equatable conformance to your custom types means that you can use more convenient APIs when searching for particular instances in a collection. Equatable is also the base protocol for the Hashable and Comparable protocols, which allow more uses of your custom type, such as constructing sets or sorting the elements of a collection. Equatable準拠をあなたのあつらえの型に追加することが意味するのは、あなたがより便利なAPIを特定のインスタンスをあるコレクションの中で探す時に使用できるということです。Equatableはまた、HashableとComparableプロトコルのための基盤プロトコルです、それらはあなたのあつらえの型のさらなる利用を可能します、例えば集合の組み立てやコレクション要素のソートなど。

You can rely on automatic synthesis of the Equatable protocol’s requirements for a custom type when you declare Equatable conformance in the type’s original declaration and your type meets these criteria: あなたはEquatableプロトコルの要件の自動合成をあつらえの型のために当てにすることが、あなたがEquatable準拠をその型のもつ元々の宣言において宣言してあなたの型がそれらの基準に沿う場合に可能です。

• For a struct, all its stored properties must conform to Equatable. structに対して、すべてのそれの格納プロパティはEquatableに準拠しなければなりません。

• For an enum, all its associated values must conform to Equatable. (An enum without associated values has Equatable conformance even without the declaration.) enumに対して、すべてのそれの関連値はEquatableに準拠しなければなりません。（関連値なしでのenumは、Equatable準拠をたとえ宣言なしでも持ちます。）

To customize your type’s Equatable conformance, to adopt Equatable in a type that doesn’t meet the criteria listed above, or to extend an existing type to conform to Equatable, implement the equal-to operator (==) as a static method of your type. The standard library provides an implementation for the not-equal-to operator (!=) for any Equatable type, which calls the custom == function and negates its result. あなたの型のもつEquatableable準拠をカスタマイズするため、Equatableを上でリストされる基準に沿わない型において採用するため、または既存の型を拡張してEquatableに準拠するためには、同等演算子（==）をあなたの型の静的メソッドとして実装してください。標準ライブラリは、不等演算子（!=）のある実装をあらゆるEquatable型に対して実装します、それはあつらえの==関数を呼び出してそれの結果を逆にします。

As an example, consider a StreetAddress class that holds the parts of a street address: a house or building number, the street name, and an optional unit number. Here’s the initial declaration of the StreetAddress type: 例として、StreetAddressクラスを考えてください、それは通り住所の部分；家またはビル番地、通りの名、そして随意に戸番号を保持します。ここにStreetAddress型の初期宣言があります：

class StreetAddress {
    let number: String
    let street: String
    let unit: String?


    init(_ number: String, _ street: String, unit: String? = nil) {
        self.number = number
        self.street = street
        self.unit = unit
    }
}

Now suppose you have an array of addresses that you need to check for a particular address. To use the contains(_:) method without including a closure in each call, extend the StreetAddress type to conform to Equatable. 今あなたがいくらかの住所からなる配列、あなたがある特定の住所を確認する必要があるものを持つと仮定します。contains(_:)メソッドを各呼び出しにクロージャを含めることなく使うには、StreetAddress型をEquatableに準拠するように拡張してください。

extension StreetAddress: Equatable {
    static func == (lhs: StreetAddress, rhs: StreetAddress) -> Bool {
        return
            lhs.number == rhs.number &&
            lhs.street == rhs.street &&
            lhs.unit == rhs.unit
    }
}

The StreetAddress type now conforms to Equatable. You can use == to check for equality between any two instances or call the Equatable-constrained contains(_:) method. StreetAddress型は、今やEquatableに準拠します。あなたは==を使って何でも２つのインスタンス間の同等性を調べたり、Equatable制約のcontains(_:)メソッドを呼び出すことができます。

let addresses = [StreetAddress("1490", "Grove Street"),
                 StreetAddress("2119", "Maple Avenue"),
                 StreetAddress("1400", "16th Street")]
let home = StreetAddress("1400", "16th Street")


print(addresses[0] == home)
// Prints "false"
print(addresses.contains(home))
// Prints "true"

Equality implies substitutability—any two instances that compare equally can be used interchangeably in any code that depends on their values. To maintain substitutability, the == operator should take into account all visible aspects of an Equatable type. Exposing nonvalue aspects of Equatable types other than class identity is discouraged, and any that are exposed should be explicitly pointed out in documentation. 同等性は代替可能性を暗黙的に意味します—同等性を比較されるあらゆる２つのインスタンスは、それらの値に影響を受けるあらゆるコードにおいて入れ替えて使われることができます。代替可能性を維持するために、==演算子はあるEquatable型の全ての目に見える面を考慮しなければならないでしょう。Equatable型の非値の面を露出することはクラス識別子を除いて推奨されません、そして露出されるものは何でも、明白に文書において指摘されるべきです。

Since equality between instances of Equatable types is an equivalence relation, any of your custom types that conform to Equatable must satisfy three conditions, for any values a, b, and c: Equatable型のインスタンス間の同等性は等値関係であることから、Equatableに準拠するあなたのあつらえの型は何であれ、任意の値a、b、そしてcに対して、３つの条件を満たす必要があります：

• a == a is always true (Reflexivity) a == aは、常にtrue（反射）

• a == b implies b == a (Symmetry) a == bは、b == aを意味する（対称）

• a == b and b == c implies a == c (Transitivity) a == bかつb == cは、a == cを意味する（推移）

Moreover, inequality is the inverse of equality, so any custom implementation of the != operator must guarantee that a != b implies !(a == b). The default implementation of the != operator function satisfies this requirement. その上に、不等性は同等性の逆です、それで!=演算子のあらゆるあつらえの実装は、a != bが!(a == b)を意味することを保証しなければなりません。!=演算子関数の省略時の実装は、この要件を満たします。

Equality is Separate From Identity 同等性は同一性と別個のものです

The identity of a class instance is not part of an instance’s value. Consider a class called IntegerRef that wraps an integer value. Here’s the definition for IntegerRef and the == function that makes it conform to Equatable: クラスインスタンスの同一性は、インスタンスの持つ値の部分のことではありません。IntegerRefと呼ばれるクラスを考えてください、それはある整数値をラップします。ここにIntegerRefとそれをEquatableに準拠させる==関数の定義があります：

class IntegerRef: Equatable {
    let value: Int
    init(_ value: Int) {
        self.value = value
    }


    static func == (lhs: IntegerRef, rhs: IntegerRef) -> Bool {
        return lhs.value == rhs.value
    }
}

The implementation of the == function returns the same value whether its two arguments are the same instance or are two different instances with the same integer stored in their value properties. For example: ==関数の実装は、それの２つの引数が同じインスタンスであろうと、それらのvalueプロハティの中に格納される同じ整数を持つ２つの異なるインスタンスであろうと、同じ値を返します。例えば：

let a = IntegerRef(100)
let b = IntegerRef(100)


print(a == a, a == b, separator: ", ")
// Prints "true, true"

Class instance identity, on the other hand, is compared using the triple-equals identical-to operator (===). For example: 一方、クラスインスタンス同一性は、３つの等号の同一性演算子（===）を使って比較されます。例えば：

let c = a
print(c === a, c === b, separator: ", ")
// Prints "true, false"