Toute programmation sérieuse dans n'importe quelle langue inclura toujours des listes. Ainsi, vous serez heureux de savoir que F # supporte très, très bien les listes en utilisant son module List. Une liste en F # est une série ordonnée et immuable d'éléments du même type.
Créer une liste
Il existe plusieurs façons dans F # de créer une liste.
- Créer une liste vide
- Créez une liste simple avec des éléments de 1 à 10
- Créer une liste avec des nombres impairs compris entre 1 et 10
- Utilisez la boucle for pour créer une liste.
let prettyPrint desc list = printfn desc printfn "%A" list //empty list let listEmpty = [] //simple list let list1 = [1 .. 10 ] //simple list, with step value let list2 = [1 ..2..10 ] //using for loops to create lists let list3 = [for i in 1 .. 10 -> i*2 ] prettyPrint "let listEmpty = []" listEmpty prettyPrint "let list1 = [ 1 .. 10 ]" list1 prettyPrint "let list2 = [ 1 .. 2..10 ]" list2 prettyPrint "[ for i in 1 .. 10 -> i*2 ]" list3
Le dernier exemple montré ci-dessus montre comment utiliser la boucle for pour créer une liste, ce qui est très cool, mais il y a quelque chose d'encore plus cool et puissant dans la boîte à outils F #, à savoir List Comprehensions.
List Comprehensions est une méthode puissante qui vous permet de créer des listes en utilisant à peu près le F # standard, qui comprend des fonctions / boucles / conditions, etc.
Continuons à regarder un exemple de la façon dont nous pourrions créer des listes.
let is2 x = match x with | 2 -> "YES" | _ -> "NO" //yield directly let list1 = [ yield 1; yield 2; yield 3; ] //yield numbers between 1 and 20 where we use the //Math.Pow function to return a new number let list2 = [for i in 1.0 .. 20.0 do yield Math.Pow(i,2.0) ] //yield only numbers between 1 and 20 that //can be divided by 5 let list3 = [ for i in 1 .. 20 do if i
Quelques opérateurs de liste utiles
Opérateur
Nous pouvons utiliser l'opérateur cons «::» pour ajouter des valeurs à une liste existante, supposons donc que nous avions cette liste:
let list1 = [1;2;3;4] let list2 = 42 :: list1
Opérateur de concaténation
Un autre opérateur très utile est l'opérateur "@", qui vous permet de combiner des listes du même type. Ainsi, par exemple, si nous avions ceci:
let list1 = [1;2;3;4] let list2 = [5;6;7;8] let list3 = list1 @ list2
Module de liste
Je ne pense pas que j'en fais trop quand je dis que le module List est un module clé en F #. En fait, la documentation MSDN est très bonne par rapport aux autres en F #. Par conséquent, je ne pense pas pouvoir ajouter beaucoup d'utilité aux exemples trouvés sur MSDN, mais je vais en donner quelques-uns pour votre commodité,
mais vous devriez étudier MSDN pour plus d'informations .
Les propriétés
Head
'T
Premier élément
Empty
'T list
Renvoie une liste vide du type spécifié
Isemptybooltrue - s'il n'y a aucun élément dans la liste
Objet«T
Un élément qui est à un index spécifique
La longueurintNombre d'articles
QueueListe T
Liste sans premier élément:
let list1 = [ 1; 2; 3 ] // Properties printfn "list1.IsEmpty is %b" (list1.IsEmpty) printfn "list1.Length is %d" (list1.Length) printfn "list1.Head is %d" (list1.Head) printfn "list1.Tail.Head is %d" (list1.Tail.Head) printfn "list1.Tail.Tail.Head is %d" (list1.Tail.Tail.Head) printfn "list1.Item(1) is %d" (list1.Item(1))
Filtrer
Renvoie une nouvelle collection contenant uniquement les éléments de la collection pour lesquels le prédicat donné renvoie true. Voici un exemple trivial qui sélectionne uniquement les nombres pairs dans une liste pour créer une nouvelle liste
let evenOnlyList = List.filter (fun x -> x
Rechercher (trouver)
Renvoie le premier élément pour lequel cette fonction renvoie true. Dans cet exemple, puisque la liste de 1 à 100 contient 5, 5 est le 1er nombre, qui est divisé par 5, c'est donc la valeur de retour:
Pour tous (pour tous)
Vérifie si tous les éléments de la collection satisfont un prédicat donné. Dans cet exemple, la liste entière doit contenir 0 afin d'obtenir la vraie valeur de retour.
let isAllZeroes list = List.forall (fun elem -> elem = 0.0) list printfn "%b" (isAllZeroes [0.0; 0.0]) printfn "%b" (isAllZeroes [0.0; 1.0])
Appliquer à tous (Iteri)
Applique cette fonction à chaque élément de la collection. L'entier passé à la fonction indique l'index de l'élément.
let data = ["Cats";"Dogs";"Mice";"Elephants"] data |> List.iteri (fun ix -> printfn "item %d: %s" ix)
Trier par (SortWith)
Trie la liste spécifiée à l'aide de cette fonction de comparaison.
let list1 = [ ""; "&"; "&&"; "&&&"; ""; "|"; "||"; "|||" ] printfn "Before sorting: " list1 |> printfn "%A" //custom sorting function let sortFunction (string1:string) (string2:string) = if (string1.Length > string2.Length) then 1 else if (string1.Length printfn "After sorting:\n%A"
Il existe de nombreuses fonctions utiles dans le module de liste, ce n'est qu'une petite partie de ce que vous pouvez trouver.
Un petit aperçu de la récursivité sur les listes
Aucune discussion sur les listes ne serait complète sans parler de récursivité. La récursivité est ce à quoi tout le post sera dédié, mais pour l'instant, regardons ce qu'il faut pour écrire une fonction récursive qui fonctionne sur une liste en F #.
let printIt desc x = printfn "%A %A" desc x let rec printList list = match list with | h :: t -> printIt "head=" h printIt "tail=" t printList t | [] -> () printList [1;2;3;4;5]
Notez l'utilisation du mot clé
rec , qui indique au compilateur F # que cette fonction sera récursive. Sans ce mot-clé, un appel de fonction récursif - vous recevrez un message d'erreur de compilation, bien qu'avec un texte d'erreur pas très clair.
Voyons donc les résultats de l'exemple montré un peu plus haut avec la liste suivante [1; 2; 3; 4; 5]
Vous pouvez voir que tout fonctionne très bien et que cela ne fonctionne plus lorsque la valeur correspond à une liste vide, comme prévu.