Wykonywanie operacji na listach

6 min

Podczas przechowywania wielu elementów na liście często wykonujesz operacje na części lub na całej liście. Moduł listy zawiera wiele przydatnych operacji, które pozwalają to zrobić.

Wyświetlanie listy funkcji modułu

Oprócz właściwości istnieje moduł listy, który jest pełen funkcji, które działają na liście. Funkcje mogą wykonywać często używane operacje, takie jak znajdowanie, filtrowanie, sortowanie, wykonywanie operacji matematycznych i nie tylko.

Iteracja

Iterowanie oznacza przejście przez każdy element w liście, od punktu początkowego do punktu końcowego. W przypadku iteracji istnieją dwie szczególnie interesujące funkcje:

iter(): Ta funkcja umożliwia iterowanie poszczególnych elementów na liście, jak pokazano poniżej:
```
let cards = [ 1 .. 5 ]
List.iter(fun i -> printfn "%i" i) cards // 1 2 3 4 5
```
Funkcja iter() przyjmuje funkcję. W poprzednim kodzie udostępniasz funkcję anonimową przy użyciu słowa kluczowego fun . Ta funkcja przyjmuje parametr, który reprezentuje bieżący element podczas iteracji. Poniższy kod jest odpowiednikiem pisania następującego kodu z pętlą:
```
for i in cards do printfn "%i" i
```

map(): Ta funkcja jest podobna do iter(), ale umożliwia przekształcenie tego, co posiadasz. Oto przykład:

type Person = { FirstName: string; LastName: string  }
let people = [
   { FirstName="Albert"; LastName= "Einstein" }
   { FirstName="Marie"; LastName="Curie" }
]
let nobelPrizeWinners = List.map (fun person -> person.FirstName + person.LastName) people 
printfn "%A" nobelPrizeWinners // ["Albert Einstein"; "Marie Curie"]

W poprzednim kodzie lista Person obiektów jest przekształcana w listę ciągów.

Filtr

Funkcja filter() przyjmuje również funkcję jako parametr, ale jej celem jest zdefiniowanie elementów do utrzymania. Jeśli wyrażenie zwróci wartość true, element zostanie zachowany. Jeśli wyrażenie to false, element nie będzie częścią filtrowanej listy. W poniższym przykładzie lista jest filtrowana tak, aby przechowywać tylko elementy, których wartość jest podzielna przez dwa:

let cards = [ 1 .. 5 ]
let filteredList = List.filter(fun i-> i % 2 = 0) cards
List.iter(fun i -> printfn "item %i" i) filteredList // item 2 item 4

Lista filteredList teraz zawiera tylko te elementy, które zwracają true po sprawdzeniu przez i % 2 = 0, czyli 2 i 4.

Sortuj

Sortowanie list to coś, co prawdopodobnie będziesz robić często. Poniżej przedstawiono trzy funkcje, które mogą okazać się przydatne podczas sortowania list:

sort(), sortuje w kolejności rosnącej. Oto przykład:

let list = [2; 1; 5; 3]
let sortedList = List.sort list // 1 2 3 5

sortBy(): Funkcja ma na celu wskazanie klucza, według którego można sortować. Załóżmy, że masz listę osób, a każdy rekord zawiera pola name i age. Następnie można wskazać sortowanie według age, na przykład. Ta funkcja przyjmuje funkcję, w której wskazujesz klucz. Innym kluczem może być długość ciągu, jak w tym przykładzie:
```
let fruits = ["Banana"; "Apple"; "Pineapple"]
let sortedFruits = List.sortBy (fun (fruit : string) -> fruit.Length) fruits // Apple, Banana, Pineapple
```

sortWith(): Za pomocą tej funkcji można podać funkcję komparatora, ponieważ może nie być widoczna na początku, która z kilku elementów powinna być sortowana przed jakimkolwiek innym elementem. Oto przykładowy kod:

// assume a type like so
type MagicCreature = { Name : string; Level: int; Attack: int }
let creatures = [
   { Name="Dragon"; Level=2; Attack=20 }
   { Name="Orc"; Level=1; Attack=5 }
   { Name="Demon"; Level=2; Attack=10 } 
]

// comparison function, -1 = less than, 1 = larger than, 0 = equal
let compareCreatures c1 c2 =
     if c1.Level < c2.Level then -1
     else if c1.Level > c2.Level then 1
     else if c1.Attack < c2.Attack then -1
     else if c1.Attack > c2.Attack then 1
     else 0

let sorted = List.sortWith compareCreatures creatures // { Name="Orc"; Level=1; Attack=5 }, { Name="Demon"; Level=2; Attack=10 }, { Name="Dragon"; Level=2; Attack=20 }

Funkcja porównania compareCreatures() najpierw próbuje porównać za pomocą Level. Jeśli poziom jest równy, próbuje porównać przy użyciu polecenia Attack. Zwraca wartość -1 , jeśli coś jest uznawane za mniejsze, 1 jeśli jest większe, a 0 jeśli jest równe.

Search

Inną rzeczą, którą możesz zrobić, jest znalezienie określonego elementu. W tym celu można wybrać jedną z następujących funkcji:

find(): Ta funkcja znajduje pierwszy element, który pasuje do określonego warunku. Aby użyć find()metody , należy podać funkcję (predykat), która wyraża sposób znajdowania elementu. Oto przykład:
```
let list = [1; 2; 3; 4]
let found = List.find( fun x -> x % 2 = 0) list // 2 - Only the first element that matches the condition is returned.
```
tryFind(). Ta funkcja przyjmuje funkcję (predykat), która określa sposób znalezienia wartości oraz listę do przeszukania. Zwraca opcję. Oto jak można go używać:
```
let findValue aValue aList =
     let found = aList |> List.tryFind(fun item -> item = aValue)

     match found with
     | Some value -> printfn "%i" value
     | None -> printfn "Not found"

findValue 1 list // 1
findValue 5 list // Not found
```
W poprzednim kodzie wysyłasz wartość, aby porównać ją z listą. Jeśli zostanie znaleziona, zwraca wartość Some. Jeśli nie zostanie znaleziony, zwraca wartość None.
tryFindIndex(). Podobnie jak tryFind(), ta funkcja zwraca opcję i przyjmuje funkcję (predykat), która oblicza wartość logiczną. Oto jak może wyglądać kod:
```
let found = List.tryFindIndex(fun x -> x = 4) list
match found with
   | Some index -> printfn "%i" index
   | None -> printfn "Not found"
```

Operacje arytmetyczne

Wykonywanie operacji matematycznych na liście może być przydatne. Spośród wielu funkcji do wyboru w interfejsie API listy przedstawiono trzy najbardziej przydatne:

sum(): za pomocą tej funkcji iterujesz poszczególne elementy, aby zsumować wszystkie wartości na liście. Oto jak można go używać:
```
let sum = List.sum [1 .. 5] // sum = 15 
```
sumBy(): W przypadku tej funkcji chodzi o wskazanie sposobu sumowania wartości. Jednym ze sposobów wykonania tej czynności jest wskazanie pól do zsumowania, jak w poniższym przykładzie:
```
type OrderItem = { Name: string; Cost:int }

let orderItems = [
       { Name="XBox"; Cost=500 }
       { Name="Book"; Cost=10 }
       { Name="Movie ticket"; Cost=7 }
     ]

let sum = List.sumBy(fun item -> item.Cost) orderItems
printfn "%i" sum // 517
```
W poprzednim kodzie Cost pole jest wskazywane, a każdy element w tym polu jest dodany do sumy.
average(): Ta funkcja jest podobna do sum() tego, że działa na liście liczb, ale z dwiema różnicami:
- Oczekuje się, że dane będą liczbami zmiennoprzecinkowami, a nie liczbami całkowitymi.
- Oblicza średnią, a nie sumę.
Oto przykład:
```
let numbers = [ 1.0; 2.5; 3.0 ]
let avg = List.average numbers
printfn "%f" avg // 2.166667
```

averageBy(): Podobnie jak sumBy(), averageBy() przyjmuje funkcję, w której określasz, jaką wartość chcesz otrzymać. Oto przykład:

type WeatherMeasurement = { Date: string; Temperature: float }
let measurements = [
    { Date="07/20/2021"; Temperature=21.3 }
    { Date="07/21/2021"; Temperature=23.2 }
    { Date="07/22/2021"; Temperature=20.7 }
]

let avgBy = List.averageBy(fun m -> m.Temperature) measurements
printfn "%f" avgBy // 21.733333

Opinia

Czy ta strona była pomocna?