ios - Es algo en Swift como LINQ en C#

dsl

Question

Sé que Swift es relativamente nuevo todavía, pero me gustaría saber si Swift tiene algo como LINQ en C #?

Con LINQ me refiero a todas las herramientas excelentes como operadores de consultas estándar , tipos anónimos , inicializador de objetos , etc.

Answer 1

Personalmente utilizaría CoreData o NSPredicate para alguna funcionalidad similar a LINQ. Se engrana con Swift, estoy seguro. Solo lo he usado en Objective-C, pero he visto artículos que lo implementan con Swift.

http://nshipster.com/nspredicate/

Answer 2

Swift incorpora varias de las características que están agrupadas en .net como LINQ, aunque posiblemente no en un sentido inmediato.

Los tipos anónimos están bastante cerca de las tuplas con valores nombrados en Swift.

Cía#:

   var person = new { firstName = "John", lastName = "Smith" };
   Console.WriteLine(person.lastName);

Salida: Smith

En Swift:

var person = (firstName: "John", lastName: "Smith")
person.firstName = "Fred"
print(person.lastName)

Salida: Smith

Las consultas de LINQ son, por supuesto, muy poderosas / expresivas, pero puede replicar una gran parte de lo que hacen usando map , filter y reduce en Swift. Con lazy , puede obtener la misma funcionalidad en la que crea un objeto que puede repetirse antes de tiempo, y solo evaluarlo cuando realmente ocurre el bucle:

Cía#:

var results =
 SomeCollection
    .Where(c => c.SomeProperty < 10)
    .Select(c => new {c.SomeProperty, c.OtherProperty});

foreach (var result in results)
{
    Console.WriteLine(result.ToString());
}

En Swift:

// just so you can try this out in a playground...
let someCollection = [(someProperty: 8, otherProperty: "hello", thirdProperty: "foo")]

let results =
  someCollection.lazy
    .filter { c in c.someProperty < 10 }
    // or instead of "c in", you can use $0:
    .map { ($0.someProperty, $0.otherProperty) }

for result in results {
    print(result)
}

Los genéricos Swift hacen que las operaciones de escritura similares a la funcionalidad LINQ existente sean bastante sencillas. Por ejemplo, del artículo de LINQ wikipedia :

Count El operador Count cuenta el número de elementos en la colección dada. Una sobrecarga que toma un predicado, cuenta el número de elementos que coinciden con el predicado.

Podría escribirse en Swift así (sintaxis de extensión de protocolo 2.0):

extension SequenceType {
    // overload for count that takes a predicate
    func count(match: Generator.Element -> Bool) -> Int {
        return reduce(0) { n, elem in match(elem) ? n + 1 : n }
    }
}

// example usage
let isEven = { $0 % 2 == 0 }

[1,1,2,4].count(isEven)  // returns 2

También puede sobrecargarlo para tomar un elemento en particular para contar si el elemento cumple con Equatable :

extension SequenceType where Generator.Element: Equatable {
    // overload for count that takes a predicate
    func count(element: Generator.Element) -> Int {
        return count { $0 == element }
    }
}

[1,1,2,4].count(1)

Las estructuras por defecto tienen una sintaxis similar a un inicializador de objetos:

struct Person { let name: String; let age: Int; }

let person = Person(name: "Fred Bloggs", age: 37)

y a través de ArrayLiteralConvertible , cualquier tipo de colección puede tener una sintaxis similar a la sintaxis del inicializador de colección:

let list: MyListImplementation = [1,2,3,4]

Answer 3

Ver también:

github.com/slazyk/SINQ

A pesar de que está un poco desactualizado, ya que Swift ahora incluye funcionalidad nativa perezosa ().