Instance Method インスタンスメソッド

sort(by:)

Sorts the collection in place, using the given predicate as the comparison between elements. コレクションをその場でソートします、与えられた述部を要素間の比較として使います。

Declaration 宣言

mutating func sort(by areInIncreasingOrder: (UInt8, UInt8) throws -> Bool) rethrows

Parameters パラメータ

areInIncreasingOrder: A predicate that returns true if its first argument should be ordered before its second argument; otherwise, false. If areInIncreasingOrder throws an error during the sort, the elements may be in a different order, but none will be lost. ある述部、それはそれの最初の引数がそれの２番目の引数の前に並べられるべきならばtrueを返します；そうでなければ、false。areInIncreasingOrderがエラーをソートの間にスローするならば、要素は異なる順番になるかもしれません、しかし何１つとしてなくさないでしょう。

Discussion 解説

When you want to sort a collection of elements that don’t conform to the Comparable protocol, pass a closure to this method that returns true when the first element should be ordered before the second. あなたがComparableプロトコルに準拠しない要素からなるコレクションをソートしたい場合、最初の要素が２番目の前に並べられるべき場合はtrueを返すクロージャをこのメソッドに渡してください。

In the following example, the closure provides an ordering for an array of a custom enumeration that describes an HTTP response. The predicate orders errors before successes and sorts the error responses by their error code. 以下の例では、そのクロージャは、あるHTTP応答を記述するあつらえ列挙の配列に対してある順序付けを提供します。この述部はエラーを成功の前に並べて、そしてそれらエラー応答をそのエラーコードによってソートします。

enum HTTPResponse {
    case ok
    case error(Int)
}


var responses: [HTTPResponse] = [.error(500), .ok, .ok, .error(404), .error(403)]
responses.sort {
    switch ($0, $1) {
    // Order errors by code
    case let (.error(aCode), .error(bCode)):
        return aCode < bCode


    // All successes are equivalent, so none is before any other
    case (.ok, .ok): return false


    // Order errors before successes
    case (.error, .ok): return true
    case (.ok, .error): return false
    }
}
print(responses)
// Prints "[.error(403), .error(404), .error(500), .ok, .ok]"

Alternatively, use this method to sort a collection of elements that do conform to Comparable when you want the sort to be descending instead of ascending. Pass the greater-than operator (>) operator as the predicate. そうではなくて、あなたが昇順ではなく降順でソートしたい場合は、このメソッドを使ってComparableに準拠する要素からなるコレクションをソートしてください。より大きい（>）演算子を述部として渡してください。

var students = ["Kofi", "Abena", "Peter", "Kweku", "Akosua"]
students.sort(by: >)
print(students)
// Prints "["Peter", "Kweku", "Kofi", "Akosua", "Abena"]"

areInIncreasingOrder must be a strict weak ordering over the elements. That is, for any elements a, b, and c, the following conditions must hold: areInIncreasingOrderは、それら要素に対して厳密弱順序でなければなりません。すなわち、何らかの要素a、b、そしてcに対して、以下の条件が保持されなければなりません：

areInIncreasingOrder(a, a) is always false. (Irreflexivity) areInIncreasingOrder(a, a)は常にfalseである。（非反射）
If areInIncreasingOrder(a, b) and areInIncreasingOrder(b, c) are both true, then areInIncreasingOrder(a, c) is also true. (Transitive comparability) areInIncreasingOrder(a, b)とareInIncreasingOrder(b, c)が両方ともtrueならば、そのときareInIncreasingOrder(a, c)もまたtrueである。（推移的比較性）
Two elements are incomparable if neither is ordered before the other according to the predicate. If a and b are incomparable, and b and c are incomparable, then a and c are also incomparable. (Transitive incomparability) ２つの要素は、述部によるとどちらもが他の前に並べられるならば比較できない。aとbが比較できないならば、そしてbとcが比較できないならば、そのときaとcもまた比較できない。（推移的比較不能性）

The sorting algorithm is not guaranteed to be stable. A stable sort preserves the relative order of elements for which areInIncreasingOrder does not establish an order. このソートアルゴリズムは、安定であることを保証されません。安定ソートは、それに対してareInIncreasingOrderが順序を確立しない要素らの相対順序を保存します。

Complexity: O(n log n), where n is the length of the collection. 計算量：O(n log n)、ここでnはコレクションの長さです。