sorting - objects - Ordenar NSArray con sortedArrayUsingComparator

swift 4 sort array of objects

Question

En Objective-C puedo ordenar una NSArray usando esta declaración:

NSArray *sortedArray = [persons sortedArrayUsingComparator:^NSComparisonResult(Person *p1, Person *p2) {
    return [p1.name compare:p2.name];
}];

No puedo reproducir la misma declaración con Swift . Todo lo que encontré fue usando Array .

Answer 1

Así que trata de escribir lo mismo con Swift:

var sortedArray:NSArray = 
persons.sortedArrayUsingComparator(){(p1:AnyObject!, p2:AnyObject!) -> NSComparisonResult in

    if (p1 as Person).name > (p2 as Person).name {
       return NSComparisonResult.OrderedDescending
    }
    if (p1 as Person).name < (p2 as Person).name {
        return NSComparisonResult.OrderedAscending
    }
    return NSComparisonResult.OrderedAscending
 }

Prueba (Zona de juegos):

class Person{
  var name:String?
}

var p1:Person = Person()
p1.name = "a"    

var p3:Person = Person()
p3.name = "c"

var p2:Person = Person()
p2.name = "b"

var persons:NSArray = [p1,p3,p2]

var sortedArray:NSArray = persons.sortedArrayUsingComparator(){

    (p1:AnyObject!, p2:AnyObject!) -> NSComparisonResult in

    if (p1 as Person).name > (p2 as Person).name {
       return NSComparisonResult.OrderedDescending
    }
    if (p1 as Person).name < (p2 as Person).name {
        return NSComparisonResult.OrderedAscending
    }
    return NSComparisonResult.OrderedAscending
    }

for item:AnyObject in sortedArray{
    println((item as Person).name)
}

Salida:

Optional("a")
Optional("b")
Optional("c")

Answer 2

En Swift puedes usar un nuevo enfoque. Trate de usar el método ordenado en lugar de ordenado ArrayUsingComparator como este ...

var sortedArray = results.sorted {
    (obj1, obj2) -> Bool in 
    return obj1.count! > obj2.count!
}

Answer 3

En caso de que tengas un objeto personalizado y quieras ordenar por fecha.

let sortedArray = self.posts.sorted {
            (obj1, obj2) -> Bool in
            return (obj1 as! PostModel).orderCancellionDate.compare( (obj2 as! PostModel).orderCancellionDate) == .orderedDescending
        }

Answer 4

No hay necesidad de evitar Swift Array .

Se une en ambas direcciones con NSArray , por lo que para obtener un código más seguro, es mejor hacer su trabajo con arrays Swift y puente solo cuando sea necesario para interoperar con las API de ObjC. (Y en la mayoría de las API importadas, Swift convierte automáticamente NSArray a [AnyObject] , por lo que ni siquiera necesita un puente muy a menudo).

Suponiendo que la matriz de persons es un [AnyObject] que obtuviste de otra API, puedes reducir la cantidad de conversión de tipos en relación con otras respuestas lanzando primero la matriz:

let sortedPersons = sorted(persons as [Person]) { $0.name < $1.name }
// sortedPersons has inferred type [Person]

Además, dado que está utilizando un bloque de comparación solo para ordenar en una propiedad específica de su clase de Person , podría hacer mejor uso de descriptores de clasificación:

let sortedPersons = (persons as NSArray).sortedArrayUsingDescriptors([
    NSSortDescriptor(key: "name", ascending: true)
])

(Las persons as NSArray parte de persons as NSArray pueden no ser necesarias si las persons provienen de una API de ObjC).

Dependiendo de cómo se implementa la clase Person , la clasificación con descriptores puede producir una clasificación más eficiente en el backend. Por ejemplo, si se trata de un objeto administrado de Core Data, la clasificación con descriptores puede producir una consulta SQL que se ejecuta rápidamente en la base de datos y utiliza poca memoria, mientras que la clasificación con un cierre de comparador requiere la creación de instancias de cada objeto de la base de datos solo para evaluar el cierre de cada base. .

Answer 5

Puede usar las funciones de clasificación incorporadas de Swift o, dado que una matriz Swift está enlazada a NSArray , puede llamar a sortedArrayUsingComparator desde swift directamente.

Usando la función sorted de Swift:

var sortedArray = sorted(persons) {
    (obj1, obj2) in

    // The downcast to Person is only needed if persons is an NSArray or a Swift Array of AnyObjects
    let p1 = obj1 as Person
    let p2 = obj2 as Person
    return p1.name < p2.name
}

O, usando el sortedArrayUsingComparator uso sortedArrayUsingComparator NSArray :

var sortedArray = persons.sortedArrayUsingComparator {
    (obj1, obj2) -> NSComparisonResult in

    let p1 = obj1 as Person
    let p2 = obj2 as Person
    let result = p1.name.compare(p2.name)
    return result
}