Rapide comment sortinger le tableau des objects personnalisés par valeur de propriété

Disons que nous avons une classe personnalisée nommée imageFile et que cette classe contient deux propriétés.

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

beaucoup d’entre eux stockés dans Array

 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) 

La question est la suivante: comment puis-je sortinger le tableau d’images par ASCII fichier ou par fichier?

Tout d’abord, déclarez votre tableau comme un tableau typé pour pouvoir appeler des méthodes lorsque vous effectuez une itération:

 var images : [imageFile] = [] 

Ensuite, vous pouvez simplement faire:

Swift 2

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

Swift 3 & 4

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

L’exemple ci-dessus donne l’ordre de sorting desc

[ Mise à jour pour Swift 3 avec sort (by 🙂 ] Ceci, en exploitant une clôture finale:

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

où vous utilisez < ou > selon ASC ou DESC, respectivement. Si vous souhaitez modifier le tableau d' images , utilisez ce qui suit:

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

Si vous allez le faire à plusieurs resockets et que vous préférez définir une fonction, une solution est:

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

puis utiliser comme:

 images.sort(by: sorterForFileIDASC) 

Presque tout le monde donne comment directement, laissez-moi montrer l’évolution:

vous pouvez utiliser les méthodes d’instance de Array:

 // 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 }) 

Pour une explication détaillée du principe de fonctionnement du sorting, voir La fonction sortingée .

Swift 3

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

Dans Swift 3.0

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

Deux alternatives

1) Commande du tableau d’origine avec sortInPlace

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

2) Utilisation d'un tableau alternatif pour stocker le tableau ordonné

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

Vous pouvez aussi faire quelque chose comme

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

de sorte que votre tableau d’images sera stocké comme sortingé

Avec Swift 4, Array dispose de deux méthodes appelées sorted() et sorted(by:) . La première méthode, sorted() , a la déclaration suivante:

Renvoie les éléments de la collection, sortingés.

 func sorted() -> [Element] 

La seconde méthode, sorted(by:) , a la déclaration suivante:

Retourne les éléments de la collection, sortingés en utilisant le prédicat donné comme comparaison entre les éléments.

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

1. Trier par ordre croissant pour des objects comparables

Si le type d’élément dans votre collection est conforme au protocole Comparable , vous pourrez utiliser sort sorted() pour sortinger vos éléments dans l’ordre croissant. Le code Playground suivant montre comment utiliser sorted() :

 class ImageFile: CustomSsortingngConvertible, Comparable { let fileName: Ssortingng let fileID: Int var description: Ssortingng { return "ImageFile with ID: \(fileID)" } init(fileName: Ssortingng, 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. Trier par ordre décroissant pour des objects comparables

Si le type d'élément dans votre collection est conforme au protocole Comparable , vous devrez utiliser sorted(by:) pour sortinger vos éléments dans un ordre décroissant.

 class ImageFile: CustomSsortingngConvertible, Comparable { let fileName: Ssortingng let fileID: Int var description: Ssortingng { return "ImageFile with ID: \(fileID)" } init(fileName: Ssortingng, 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. Trier par ordre croissant ou décroissant pour des objects non comparables

Si le type d'élément dans votre collection ne correspond PAS au protocole Comparable , vous devrez utiliser sorted(by:) pour sortinger vos éléments par ordre croissant ou décroissant.

 class ImageFile: CustomSsortingngConvertible { let fileName: Ssortingng let fileID: Int var description: Ssortingng { return "ImageFile with ID: \(fileID)" } init(fileName: Ssortingng, 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] */ 

Notez que Swift fournit également deux méthodes appelées sort() et sort(by:) en contrepartie de sort(by:) sorted() et sorted(by:) si vous devez sortinger votre collection sur place.

Swift 2 à 4

La réponse originale visait à sortinger un tableau d’objects personnalisés en utilisant une propriété. Ci-dessous, je vais vous montrer quelques façons pratiques de faire ce même comportement avec des structures de données rapides!

De petites choses en dehors, j’ai changé légèrement d’ImageFile. Dans cet esprit, je crée un tableau avec trois fichiers image. Notez que les métadonnées sont une valeur facultative, le passage à nil en tant que paramètre est attendu.

  struct ImageFile { var name: Ssortingng var metadata: Ssortingng? 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 a une propriété nommée size. Pour les exemples suivants, je vais vous montrer comment utiliser les opérations de sorting avec des propriétés telles que la taille.

plus petit à la plus grande taille (<)

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

plus grand au plus petit (>)

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

Ensuite, nous allons sortinger en utilisant le nom de la propriété Ssortingng. De la même manière, utilisez sort pour comparer des chaînes. Mais notez que le bloc interne renvoie un résultat de comparaison. Ce résultat définira le sorting.

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 } 

Suivant est ma façon préférée de sortinger, dans de nombreux cas, on aura des propriétés facultatives. Maintenant, ne vous inquiétez pas, nous allons sortinger de la même manière que ci-dessus, sauf que nous devons gérer zéro! En production;

J'ai utilisé ce code pour forcer toutes les instances de mon tableau dont les valeurs de propriété étaient nulles. Ensuite, commandez les métadonnées en utilisant les valeurs supposées non développées.

  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 } 

Il est possible d'avoir un sorting secondaire pour les optionnels. Par exemple; on pouvait montrer des images avec des métadonnées et classées par taille.

Si vous devez sortinger ce tableau à plusieurs endroits, il peut être judicieux de définir le type de tableau Comparable.

 class MyImageType: Comparable, Printable { var fileID: Int // For Printable var description: Ssortingng { 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]" 

Swift 4.0. Tout d’abord, j’ai créé un tableau mutable de type imageFile () comme indiqué ci-dessous.

 var arr = [imageFile]() 

Créer une image d’object mutable de type imageFile () et atsortingbuer une valeur aux propriétés, comme indiqué ci-dessous

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

Maintenant, ajoutez cet object au tableau arr

  arr.append(image) 

Maintenant, atsortingbuez les différentes propriétés à un même object mutable, c’est-à-dire une image

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

Maintenant, à nouveau, ajoutez un object image au tableau arr

  arr.append(image) 

Nous allons maintenant appliquer l’ ordre croissant sur la propriété fileId dans les objects tableau arr. Utiliser pour l’ordre croissant

  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 

Maintenant, nous appliquerons l' ordre Descending sur la propriété fileId dans les objects tableau arr. Utiliser > symbole pour Ordre décroissant

  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 

Dans Swift 4.1. Pour une utilisation sortingée

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

Si vous n’utilisez pas d’objects personnalisés, mais plutôt des types de valeur qui implémentent un protocole comparable (Int, Ssortingng, etc.), vous pouvez simplement faire ceci:

 myArray.sort(>) //sort descending order 

Un exemple:

 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 

Si vous souhaitez sortinger le tableau original d’objects personnalisés. Voici une autre façon de le faire dans Swift 2.1

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

id est un entier. Vous pouvez également utiliser le même opérateur < pour les propriétés Ssortingng .

Vous pouvez en apprendre plus sur son utilisation en regardant un exemple ici: Swift2: Clients à proximité

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

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

Je le fais comme ça et ça marche:

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