Comparable

Overview 概要

The Comparable protocol is used for types that have an inherent order, such as numbers and strings. Many types in the standard library already conform to the Comparable protocol. Add Comparable conformance to your own custom types when you want to be able to compare instances using relational operators or use standard library methods that are designed for Comparable types. Comparableプロトコルは、本来備わっている順番を持つ型、例えば数や文字列などで使われます。標準ライブラリの多くの型はすでにComparableプロトコルに準拠します。あなたが関係演算子を使ってインスタンスの比較ができること、または Comparable型のために設計される標準ライブラリメソッドを使うことを望む場合は、Comparable準拠をあなた独自のあつらえの型に加えてください。

The most familiar use of relational operators is to compare numbers, as in the following example: 最もよく知られている関係演算子の使用は、数の比較に対してです、以下の例でのように：

let currentTemp = 73


if currentTemp >= 90 {
    print("It's a scorcher!")
} else if currentTemp < 65 {
    print("Might need a sweater today.")
} else {
    print("Seems like picnic weather!")
}
// Prints "Seems like picnic weather!"

You can use special versions of some sequence and collection operations when working with a Comparable type. For example, if your array’s elements conform to Comparable, you can call the sort() method without using arguments to sort the elements of your array in ascending order. あなたは、特別版のなんらかのシーケンスやコレクション演算をあるComparable型を扱うときに使用できます。例えば、あなたの配列のもつ要素がComparableに準拠するならば、あなたはsort()メソッドを引数を使うことなく呼び出して、あなたの配列の要素を昇順にソートすることができます。

var measurements = [1.1, 1.5, 2.9, 1.2, 1.5, 1.3, 1.2]
measurements.sort()
print(measurements)
// Prints "[1.1, 1.2, 1.2, 1.3, 1.5, 1.5, 2.9]"

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

Types with Comparable conformance implement the less-than operator (<) and the equal-to operator (==). These two operations impose a strict total order on the values of a type, in which exactly one of the following must be true for any two values a and b: Comparable準拠を持つ型は、より少ない演算子（<）と同等演算子（==）を実装します。これら２つの演算子は、ある型の値に全順序を課します、そこにおいて任意の２つの値aとbに対して、厳密に以下のうちの１つが真でなければなりません：

• a == b

• a < b

• b < a

In addition, the following conditions must hold: 加えて、以下の条件が保持されなければなりません：

• a < a is always false (Irreflexivity) a < aは常にfalse（非反射）

• a < b implies !(b < a) (Asymmetry) a < bは!(b < a)を意味する（非対称）

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

To add Comparable conformance to your custom types, define the < and == operators as static methods of your types. The == operator is a requirement of the Equatable protocol, which Comparable extends—see that protocol’s documentation for more information about equality in Swift. Because default implementations of the remainder of the relational operators are provided by the standard library, you’ll be able to use !=, >, <=, and >= with instances of your type without any further code. Comparable準拠をあなたのあつらえの型に加えるには、<および==演算子をあなたの型の静的メソッドとして定義してください。==演算子は、Comparableが拡張するEquatableプロトコルの要件です — そのプロトコルの文書をSwiftにおける同等性についてのさらなる情報のために見てください。関係演算子の残りの省略時の実装は標準ライブラリによって提供されることから、あなたは!=、>、<=、そして>=をあなたの型のインスタンスにおいてなんらこれ以上のコード無しに使うことができます。

As an example, here’s an implementation of a Date structure that stores the year, month, and day of a date: 例として、ある日付の年、月、そして日を格納するあるDate構造体の実装がここにあります：

struct Date {
    let year: Int
    let month: Int
    let day: Int
}

To add Comparable conformance to Date, first declare conformance to Comparable and implement the < operator function. Comparable準拠をDateに加えるには、最初にComparableへの準拠を宣言して、<演算子関数を実装してください。

extension Date: Comparable {
    static func < (lhs: Date, rhs: Date) -> Bool {
        if lhs.year != rhs.year {
            return lhs.year < rhs.year
        } else if lhs.month != rhs.month {
            return lhs.month < rhs.month
        } else {
            return lhs.day < rhs.day
        }
    }

This function uses the least specific nonmatching property of the date to determine the result of the comparison. For example, if the two year properties are equal but the two month properties are not, the date with the lesser value for month is the lesser of the two dates. この関数は、比較の結果を判定するのに、最小量となる特定の不一致日付プロパティを使います。例えば、２つのyearプロパティは等しいけれども２つのmonthプロパティは異なるならば、monthに対してより少ない値を持つ日付は２つの日付のうちより少ないものです。

Next, implement the == operator function, the requirement inherited from the Equatable protocol. 次に、==演算子関数、Equatableプロトコルから継承される要件を実装してください。

    static func == (lhs: Date, rhs: Date) -> Bool {
        return lhs.year == rhs.year && lhs.month == rhs.month
            && lhs.day == rhs.day
    }
}

Two Date instances are equal if each of their corresponding properties is equal. ２つのDateインスタンスは、それらの対応するプロパティの各々が等しいならば等しいです。

Now that Date conforms to Comparable, you can compare instances of the type with any of the relational operators. The following example compares the date of the first moon landing with the release of David Bowie’s song “Space Oddity”: 今やDateはComparableに準拠します、あなたはこの型のインスタンスを関係演算子のどれででも比較できます。以下の例は、最初の月面着陸の日付をデビッド・ボウイの歌「Space Oddity」のリリース日と比較します：

let spaceOddity = Date(year: 1969, month: 7, day: 11)   // July 11, 1969
let moonLanding = Date(year: 1969, month: 7, day: 20)   // July 20, 1969
if moonLanding > spaceOddity {
    print("Major Tom stepped through the door first.")
} else {
    print("David Bowie was following in Neil Armstrong's footsteps.")
}
// Prints "Major Tom stepped through the door first."

Note that the > operator provided by the standard library is used in this example, not the < operator implemented above. 標準ライブラリによって提供される>演算子がこの例で使われることに注意してください、上で実装される<演算子ではなしに。