Nehmen wir an, wir haben eine benutzerdefinierte Klasse namens imageFile und diese Klasse enthält zwei Eigenschaften.

class imageFile  {
    var fileName = String()
    var fileID = Int()
}

viele von ihnen in Array gespeichert

var images : Array = []

var aImage = imageFile()
aImage.fileName = "image1.png"
aImage.fileID = 101
images.append(aImage)

aImage = imageFile()
aImage.fileName = "image1.png"
aImage.fileID = 202
images.append(aImage)

Die Frage ist: Wie kann ich das Bildarray nach 'fileID' ASC oder DESC sortieren?

Deklarieren Sie zunächst Ihr Array als typisiertes Array, damit Sie beim Iterieren Methoden aufrufen können:

var images : [imageFile] = []

Dann können Sie einfach tun:

Swift 2

images.sorted({ $0.fileID > $1.fileID })

Swift 3+

images.sorted(by: { $0.fileID > $1.fileID })

Das obige Beispiel gibt die Reihenfolge der Sortierung ab

[ Aktualisiert für Swift 3 mit sort (by :) ] Dies nutzt einen nachfolgenden Abschluss aus:

images.sorted { $0.fileID < $1.fileID }

wo Sie verwenden <oder >abhängig von ASC bzw. DESC. Wenn Sie das imagesArray ändern möchten , verwenden Sie Folgendes:

images.sort { $0.fileID < $1.fileID }

Wenn Sie dies wiederholt tun und lieber eine Funktion definieren möchten, haben Sie folgende Möglichkeiten:

func sorterForFileIDASC(this:imageFile, that:imageFile) -> Bool {
  return this.fileID > that.fileID
}

und dann verwenden als:

images.sort(by: sorterForFileIDASC)

Fast jeder gibt an, wie direkt, lassen Sie mich die Entwicklung zeigen:

Sie können die Instanzmethoden von Array verwenden:

// general form of closure
images.sortInPlace({ (image1: imageFile, image2: imageFile) -> Bool in return image1.fileID > image2.fileID })

// types of closure's parameters and return value can be inferred by Swift, so they are omitted along with the return arrow (->)
images.sortInPlace({ image1, image2 in return image1.fileID > image2.fileID })

// Single-expression closures can implicitly return the result of their single expression by omitting the "return" keyword
images.sortInPlace({ image1, image2 in image1.fileID > image2.fileID })

// closure's argument list along with "in" keyword can be omitted, $0, $1, $2, and so on are used to refer the closure's first, second, third arguments and so on
images.sortInPlace({ $0.fileID > $1.fileID })

// the simplification of the closure is the same
images = images.sort({ (image1: imageFile, image2: imageFile) -> Bool in return image1.fileID > image2.fileID })
images = images.sort({ image1, image2 in return image1.fileID > image2.fileID })
images = images.sort({ image1, image2 in image1.fileID > image2.fileID })
images = images.sort({ $0.fileID > $1.fileID })

Ausführliche Erläuterungen zum Funktionsprinzip der Sortierung finden Sie unter Die sortierte Funktion .

Swift 3

people = people.sorted(by: { $0.email > $1.email })

Mit Swift 5 Arrayhat zwei Methoden aufgerufen sorted()und sorted(by:). Die erste Methode sorted()hat die folgende Deklaration:

Gibt die Elemente der Sammlung sortiert zurück.

func sorted() -> [Element]

Die zweite Methode sorted(by:)hat die folgende Deklaration:

Gibt die Elemente der Sammlung zurück, sortiert nach dem angegebenen Prädikat als Vergleich zwischen Elementen.

func sorted(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> [Element]

# 1. Sortieren Sie in aufsteigender Reihenfolge nach vergleichbaren Objekten

Wenn der Elementtyp in Ihrer Sammlung dem ComparableProtokoll entspricht , können Sie sorted()Ihre Elemente in aufsteigender Reihenfolge sortieren. Der folgende Spielplatzcode zeigt die Verwendung sorted():

class ImageFile: CustomStringConvertible, Comparable {

    let fileName: String
    let fileID: Int
    var description: String { return "ImageFile with ID: \(fileID)" }

    init(fileName: String, fileID: Int) {
        self.fileName = fileName
        self.fileID = fileID
    }

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

    static func <(lhs: ImageFile, rhs: ImageFile) -> Bool {
        return lhs.fileID < rhs.fileID
    }

}

let images = [
    ImageFile(fileName: "Car", fileID: 300),
    ImageFile(fileName: "Boat", fileID: 100),
    ImageFile(fileName: "Plane", fileID: 200)
]

let sortedImages = images.sorted()
print(sortedImages)

/*
 prints: [ImageFile with ID: 100, ImageFile with ID: 200, ImageFile with ID: 300]
 */

# 2. Sortieren Sie in absteigender Reihenfolge nach vergleichbaren Objekten

Wenn der Elementtyp in Ihrer Sammlung dem ComparableProtokoll entspricht , müssen Sie ihn verwenden sorted(by:), um Ihre Elemente in absteigender Reihenfolge zu sortieren.

class ImageFile: CustomStringConvertible, Comparable {

    let fileName: String
    let fileID: Int
    var description: String { return "ImageFile with ID: \(fileID)" }

    init(fileName: String, fileID: Int) {
        self.fileName = fileName
        self.fileID = fileID
    }

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

    static func <(lhs: ImageFile, rhs: ImageFile) -> Bool {
        return lhs.fileID < rhs.fileID
    }

}

let images = [
    ImageFile(fileName: "Car", fileID: 300),
    ImageFile(fileName: "Boat", fileID: 100),
    ImageFile(fileName: "Plane", fileID: 200)
]

let sortedImages = images.sorted(by: { (img0: ImageFile, img1: ImageFile) -> Bool in
    return img0 > img1
})
//let sortedImages = images.sorted(by: >) // also works
//let sortedImages = images.sorted { $0 > $1 } // also works
print(sortedImages)

/*
 prints: [ImageFile with ID: 300, ImageFile with ID: 200, ImageFile with ID: 100]
 */

#3. Für nicht vergleichbare Objekte in aufsteigender oder absteigender Reihenfolge sortieren

Wenn der Elementtyp in Ihrer Sammlung NICHT dem ComparableProtokoll entspricht, müssen Sie ihn verwenden sorted(by:), um Ihre Elemente in aufsteigender oder absteigender Reihenfolge zu sortieren.

class ImageFile: CustomStringConvertible {

    let fileName: String
    let fileID: Int
    var description: String { return "ImageFile with ID: \(fileID)" }

    init(fileName: String, fileID: Int) {
        self.fileName = fileName
        self.fileID = fileID
    }

}

let images = [
    ImageFile(fileName: "Car", fileID: 300),
    ImageFile(fileName: "Boat", fileID: 100),
    ImageFile(fileName: "Plane", fileID: 200)
]

let sortedImages = images.sorted(by: { (img0: ImageFile, img1: ImageFile) -> Bool in
    return img0.fileID < img1.fileID
})
//let sortedImages = images.sorted { $0.fileID < $1.fileID } // also works
print(sortedImages)

/*
 prints: [ImageFile with ID: 300, ImageFile with ID: 200, ImageFile with ID: 100]
 */

Beachten Sie, dass Swift auch zwei Methoden bereitstellt, die als sort()und sort(by:)als Gegenstücke zu sorted()und sorted(by:)wenn Sie Ihre Sammlung direkt sortieren müssen.

In Swift 3.0

images.sort(by: { (first: imageFile, second: imageFile) -> Bool in
    first. fileID < second. fileID
})

Sie können auch so etwas tun

images = sorted(images) {$0.fileID > $1.fileID}

So wird Ihr Bildarray sortiert gespeichert

Swift 2 bis 4

In der ursprünglichen Antwort wurde versucht, ein Array von benutzerdefinierten Objekten mithilfe einer Eigenschaft zu sortieren. Im Folgenden werde ich Ihnen einige praktische Möglichkeiten zeigen, wie Sie dasselbe Verhalten mit schnellen Datenstrukturen ausführen können!

Kleinigkeiten aus dem Weg, ich habe ImageFile ganz leicht verändert. In diesem Sinne erstelle ich ein Array mit drei Bilddateien. Beachten Sie, dass Metadaten ein optionaler Wert sind und als Parameter nil übergeben wird.

 struct ImageFile {
      var name: String
      var metadata: String?
      var size: Int
    }

    var images: [ImageFile] = [ImageFile(name: "HelloWorld", metadata: nil, size: 256), ImageFile(name: "Traveling Salesmen", metadata: "uh this is huge", size: 1024), ImageFile(name: "Slack", metadata: "what's in this stuff?", size: 2048) ]

ImageFile hat eine Eigenschaft namens size. In den folgenden Beispielen werde ich Ihnen zeigen, wie Sie Sortieroperationen mit Eigenschaften wie Größe verwenden.

kleinste bis größte Größe (<)

    let sizeSmallestSorted = images.sorted { (initial, next) -> Bool in
      return initial.size < next.size
    }

größte bis kleinste (>)

    let sizeBiggestSorted = images.sorted { (initial, next) -> Bool in
      return initial.size > next.size
    }

Als nächstes sortieren wir nach dem Namen der String-Eigenschaft. Verwenden Sie auf die gleiche Weise sort, um Zeichenfolgen zu vergleichen. Beachten Sie jedoch, dass der innere Block ein Vergleichsergebnis zurückgibt. Dieses Ergebnis definiert die Sortierung.

AZ (.orderedAscending)

    let nameAscendingSorted = images.sorted { (initial, next) -> Bool in
      return initial.name.compare(next.name) == .orderedAscending
    }

ZA (.orderedDescending)

    let nameDescendingSorted = images.sorted { (initial, next) -> Bool in
      return initial.name.compare(next.name) == .orderedDescending
    }

Als nächstes sortiere ich am liebsten. In vielen Fällen verfügt man über optionale Eigenschaften. Jetzt mach dir keine Sorgen, wir werden auf die gleiche Weise wie oben sortieren, außer dass wir mit Null umgehen müssen! In Produktion;

Ich habe diesen Code verwendet, um zu erzwingen, dass alle Instanzen in meinem Array mit Null-Eigenschaftswerten zuletzt sind. Ordnen Sie dann Metadaten unter Verwendung der angenommenen nicht verpackten Werte.

    let metadataFirst = images.sorted { (initial, next) -> Bool in
      guard initial.metadata != nil else { return true }
      guard next.metadata != nil else { return true }
      return initial.metadata!.compare(next.metadata!) == .orderedAscending
    }

Es ist möglich, eine sekundäre Sortierung für Optionen zu haben. Zum Beispiel; man könnte Bilder mit Metadaten zeigen und nach Größe sortieren.

Zwei Alternativen

1) Bestellen des ursprünglichen Arrays mit sortInPlace

self.assignments.sortInPlace({ $0.order < $1.order })
self.printAssignments(assignments)

2) Verwenden eines alternativen Arrays zum Speichern des geordneten Arrays

var assignmentsO = [Assignment] ()
assignmentsO = self.assignments.sort({ $0.order < $1.order })
self.printAssignments(assignmentsO)

Swift 4.0, 4.1 & 4.2 Zuerst habe ich ein veränderliches Array vom Typ imageFile () erstellt, wie unten gezeigt

var arr = [imageFile]()

Erstellen Sie ein veränderbares Objektbild vom Typ imageFile () und weisen Sie den Eigenschaften wie unten gezeigt einen Wert zu

   var image = imageFile()
   image.fileId = 14
   image.fileName = "A"

Hängen Sie dieses Objekt nun an das Array arr an

    arr.append(image)

Weisen Sie nun die verschiedenen Eigenschaften demselben veränderlichen Objekt zu, dh dem Bild

   image = imageFile()
   image.fileId = 13
   image.fileName = "B"

Fügen Sie nun erneut das Bildobjekt an das Array arr an

    arr.append(image)

Jetzt wenden wir aufsteigende Reihenfolge auf die fileId- Eigenschaft in Array-Arr-Objekten an. Verwenden Sie das Symbol < für aufsteigende Reihenfolge

 arr = arr.sorted(by: {$0.fileId < $1.fileId}) // arr has all objects in Ascending order
 print("sorted array is",arr[0].fileId)// sorted array is 13
 print("sorted array is",arr[1].fileId)//sorted array is 14

Jetzt wenden wir die absteigende Reihenfolge auf die Eigenschaft fileId in Array-Arr-Objekten an. Verwenden Sie das Symbol> für absteigende Reihenfolge

 arr = arr.sorted(by: {$0.fileId > $1.fileId}) // arr has all objects in Descending order
 print("Unsorted array is",arr[0].fileId)// Unsorted array is 14
 print("Unsorted array is",arr[1].fileId)// Unsorted array is 13

In Swift 4.1. & 4.2 Für sortierte Bestellungen verwenden

let sortedArr = arr.sorted { (id1, id2) -> Bool in
  return id1.fileId < id2.fileId // Use > for Descending order
}

Wenn Sie dieses Array an mehreren Stellen sortieren, ist es möglicherweise sinnvoll, Ihren Array-Typ vergleichbar zu machen.

class MyImageType: Comparable, Printable {
    var fileID: Int

    // For Printable
    var description: String {
        get {
            return "ID: \(fileID)"
        }
    }

    init(fileID: Int) {
        self.fileID = fileID
    }
}

// For Comparable
func <(left: MyImageType, right: MyImageType) -> Bool {
    return left.fileID < right.fileID
}

// For Comparable
func ==(left: MyImageType, right: MyImageType) -> Bool {
    return left.fileID == right.fileID
}

let one = MyImageType(fileID: 1)
let two = MyImageType(fileID: 2)
let twoA = MyImageType(fileID: 2)
let three = MyImageType(fileID: 3)

let a1 = [one, three, two]

// return a sorted array
println(sorted(a1)) // "[ID: 1, ID: 2, ID: 3]"

var a2 = [two, one, twoA, three]

// sort the array 'in place'
sort(&a2)
println(a2) // "[ID: 1, ID: 2, ID: 2, ID: 3]"

Wenn Sie keine benutzerdefinierten Objekte verwenden, sondern stattdessen Werttypen, die das vergleichbare Protokoll (Int, String usw.) implementieren, können Sie dies einfach tun:

myArray.sort(>) //sort descending order

Ein Beispiel:

struct MyStruct: Comparable {
    var name = "Untitled"
}

func <(lhs: MyStruct, rhs: MyStruct) -> Bool {
    return lhs.name < rhs.name
}
// Implementation of == required by Equatable
func ==(lhs: MyStruct, rhs: MyStruct) -> Bool {
    return lhs.name == rhs.name
}

let value1 = MyStruct()
var value2 = MyStruct()

value2.name = "A New Name"

var anArray:[MyStruct] = []
anArray.append(value1)
anArray.append(value2)

anArray.sort(>) // This will sort the array in descending order

Sie geben ein sortiertes Array aus der fileID-Eigenschaft folgendermaßen zurück:

Swift 2

let sortedArray = images.sorted({ $0.fileID > $1.fileID })

Swift 3 ODER 4

let sortedArray = images.sorted(by: { $0.fileID > $1.fileID })

Swift 5.0

let sortedArray = images.sorted {
    $0.fileID < $1.fileID
}

Ich mache es so und es funktioniert:

var images = [imageFile]() images.sorted(by: {$0.fileID.compare($1.fileID) == .orderedAscending })

Wenn Sie das ursprüngliche Array von benutzerdefinierten Objekten sortieren möchten. Hier ist eine andere Möglichkeit, dies in Swift 2.1 zu tun

var myCustomerArray = [Customer]()
myCustomerArray.sortInPlace {(customer1:Customer, customer2:Customer) -> Bool in
    customer1.id < customer2.id
}

Wo idist eine ganze Zahl? Sie können denselben <Operator auch für StringEigenschaften verwenden.

Weitere Informationen zur Verwendung finden Sie in einem Beispiel hier: Swift2: Kunden in der Nähe

var students = ["Kofi", "Abena", "Peter", "Kweku", "Akosua"]

students.sort(by: >)

print(students)

Drucke: "["Peter", "Kweku", "Kofi", "Akosua", "Abena"]"

Schnelle 3 & 4 & 5

Ich hatte ein Problem mit Klein- und Großbuchstaben

Also habe ich diesen Code gemacht

let sortedImages = images.sorted(by: { $0.fileID.lowercased() < $1.fileID.lowercased() })

und verwenden Sie danach sortierte Bilder

Sortieren mit KeyPath

Sie können folgendermaßen sortieren KeyPath:

myArray.sorted(by: \.fileName, <) /* using `<` for ascending sorting */

Durch die Implementierung dieser kleinen hilfreichen Erweiterung.

extension Collection{
    func sorted<Value: Comparable>(
        by keyPath: KeyPath<Element, Value>,
        _ comparator: (_ lhs: Value, _ rhs: Value) -> Bool) -> [Element] {
        sorted { comparator($0[keyPath: keyPath], $1[keyPath: keyPath]) }
    }
}

Hoffe, Swift fügt dies in naher Zukunft in den Kern der Sprache ein.