F # - Tableaux
Les tableaux sont des collections de taille fixe, de base zéro et modifiables d'éléments de données consécutifs qui sont tous du même type.
Création de tableaux
Vous pouvez créer des tableaux en utilisant diverses syntaxes et méthodes ou en utilisant les fonctions du module Array. Dans cette section, nous aborderons la création de tableaux sans utiliser les fonctions du module.
Il existe trois manières syntaxiques de créer des tableaux sans fonctions -
- En listant les valeurs consécutives entre [| et |] et séparés par des points-virgules.
- En mettant chaque élément sur une ligne distincte, auquel cas le séparateur point-virgule est facultatif.
- En utilisant des expressions de séquence.
Vous pouvez accéder aux éléments du tableau en utilisant un opérateur point (.) Et des crochets ([et]).
L'exemple suivant illustre la création de tableaux -
//using semicolon separator
let array1 = [| 1; 2; 3; 4; 5; 6 |]
for i in 0 .. array1.Length - 1 do
printf "%d " array1.[i]
printfn" "
// without semicolon separator
let array2 =
[|
1
2
3
4
5
|]
for i in 0 .. array2.Length - 1 do
printf "%d " array2.[i]
printfn" "
//using sequence
let array3 = [| for i in 1 .. 10 -> i * i |]
for i in 0 .. array3.Length - 1 do
printf "%d " array3.[i]
printfn" "Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -
1 2 3 4 5 6
1 2 3 4 5
1 4 9 16 25 36 49 64 81 100Opérations de base sur les tableaux
Le module de bibliothèque Microsoft.FSharp.Collections.Array prend en charge les opérations sur les tableaux unidimensionnels.
Le tableau suivant présente les opérations de base sur les baies -
| Valeur | La description |
|---|---|
| ajouter: 'T [] →' T [] → 'T [] | Crée un tableau qui contient les éléments d'un tableau suivis des éléments d'un autre tableau. |
| moyenne: ^ T [] → ^ T | Renvoie la moyenne des éléments d'un tableau. |
| averageBy: ('T → ^ U) →' T [] → ^ U | Renvoie la moyenne des éléments générés en appliquant une fonction à chaque élément d'un tableau. |
| blit: 'T [] → int →' T [] → int → int → unité | Lit une plage d'éléments d'un tableau et les écrit dans un autre. |
| choisissez: ('T → U option) →' T [] → 'U [] | Applique une fonction fournie à chaque élément d'un tableau. Renvoie un tableau qui contient les résultats x pour chaque élément pour lequel la fonction renvoie Some (x). |
| recueillir: ('T →' U []) → T [] → 'U [] | Applique la fonction fournie à chaque élément d'un tableau, concatène les résultats et renvoie le tableau combiné. |
| concat: seq <'T []> →' T [] | Crée un tableau contenant les éléments de chacune des séquences de tableaux fournies. |
| copie: 'T →' T [] | Crée un tableau qui contient les éléments du tableau fourni. |
| créer: int → 'T →' T [] | Crée un tableau dont les éléments sont tous initialement la valeur fournie. |
| vide: 'T [] | Renvoie un tableau vide du type donné. |
| existe: ('T → bool) →' T [] → bool | Teste si un élément d'un tableau satisfait le prédicat fourni. |
| existe2: ('T1 →' T2 → booléen) → 'T1 [] →' T2 [] → booléen | Teste si une paire d'éléments correspondants de deux tableaux satisfait la condition fournie. |
| fill: 'T [] → int → int →' T → unité | Remplit une plage d'éléments d'un tableau avec la valeur fournie. |
| filtre: ('T → booléen) →' T [] → 'T [] | Renvoie une collection qui contient uniquement les éléments du tableau fourni pour lesquels la condition fournie renvoie true. |
| trouver: ('T → booléen) →' T [] → 'T | Renvoie le premier élément pour lequel la fonction fournie renvoie true. Déclenche KeyNotFoundException si aucun élément de ce type n'existe. |
| findIndex: ('T → booléen) →' T [] → int | Renvoie l'index du premier élément d'un tableau qui satisfait la condition fournie. Déclenche KeyNotFoundException si aucun des éléments ne satisfait la condition. |
| fold: ('State →' T → 'State) →' State → 'T [] →' State | Applique une fonction à chaque élément d'un tableau, en enfilant un argument d'accumulateur dans le calcul. Si la fonction d'entrée est f et les éléments du tableau sont i0 ... iN, cette fonction calcule f (... (fs i0) ...) iN. |
| fold2: ('État →' T1 → 'T2 →' État) → 'État →' T1 [] → 'T2 [] →' État | Applique une fonction à des paires d'éléments de deux tableaux fournis, de gauche à droite, en faisant passer un argument d'accumulateur dans le calcul. Les deux tableaux d'entrée doivent avoir les mêmes longueurs; sinon, ArgumentException est déclenchée. |
| foldBack: ('T →' État → 'État) →' T [] → 'État →' État | Applique une fonction à chaque élément d'un tableau, en enfilant un argument d'accumulateur dans le calcul. Si la fonction d'entrée est f et les éléments du tableau sont i0 ... iN, cette fonction calcule f i0 (... (f iN s)). |
| foldBack2: ('T1 →' T2 → 'État →' État) → 'T1 [] →' T2 [] → 'État →' État | Applique une fonction aux paires d'éléments de deux tableaux fournis, de droite à gauche, en passant un argument d'accumulateur dans le calcul. Les deux tableaux d'entrée doivent avoir les mêmes longueurs; sinon, ArgumentException est déclenchée. |
| forall: ('T → bool) →' T [] → bool | Teste si tous les éléments d'un tableau satisfont à la condition fournie. |
| forall2: ('T1 →' T2 → booléen) → 'T1 [] →' T2 [] → bool | Teste si tous les éléments correspondants de deux tableaux fournis satisfont à une condition fournie. |
| obtenir: 'T [] → int →' T | Obtient un élément d'un tableau. |
| init: int → (int → 'T) →' T [] | Utilise une fonction fournie pour créer un tableau de la dimension fournie. |
| isEmpty: 'T [] → booléen | Teste si un tableau contient des éléments. |
| iter: ('T → unité) →' T [] → unité | Applique la fonction fournie à chaque élément d'un tableau. |
| iter2: ('T1 →' T2 → unité) → 'T1 [] →' T2 [] → unité) | Applique la fonction fournie à une paire d'éléments à partir d'index correspondants dans deux tableaux. Les deux tableaux doivent avoir les mêmes longueurs; sinon, ArgumentException est déclenchée. |
| iteri: (int → 'T → unité) →' T [] → unité | Applique la fonction fournie à chaque élément d'un tableau. L'entier passé à la fonction indique l'index de l'élément. |
| iteri2: (int → 'T1 →' T2 → unité) → 'T1 [] →' T2 [] → unité | Applique la fonction fournie à une paire d'éléments à partir d'index correspondants dans deux tableaux, en passant également l'index des éléments. Les deux tableaux doivent avoir les mêmes longueurs; sinon, une ArgumentException est déclenchée. |
| longueur: 'T [] → int | Renvoie la longueur d'un tableau. La propriété Length fait la même chose. |
| carte: ('T →' U) → 'T [] →' U [] | Crée un tableau dont les éléments sont les résultats de l'application de la fonction fournie à chacun des éléments d'un tableau fourni. |
| map2: ('T1 →' T2 → 'U) →' T1 [] → 'T2 [] →' U [] | Crée un tableau dont les éléments sont les résultats de l'application de la fonction fournie aux éléments correspondants de deux tableaux fournis. Les deux tableaux d'entrée doivent avoir les mêmes longueurs; sinon, ArgumentException est déclenchée. |
| mapi: (int → 'T →' U) → 'T [] →' U [] | Crée un tableau dont les éléments sont les résultats de l'application de la fonction fournie à chacun des éléments d'un tableau fourni. Un index entier passé à la fonction indique l'index de l'élément en cours de transformation. |
| mapi2: (int → 'T1 →' T2 → 'U) →' T1 [] → 'T2 [] →' U [] | Crée un tableau dont les éléments sont les résultats de l'application de la fonction fournie aux éléments correspondants des deux collections par paires, en passant également l'index des éléments. Les deux tableaux d'entrée doivent avoir les mêmes longueurs; sinon, ArgumentException est déclenchée. |
| max: 'T [] →' T | Renvoie le plus grand de tous les éléments d'un tableau. Operators.max est utilisé pour comparer les éléments. |
| maxBy: ('T →' U) → 'T [] →' T | Renvoie le plus grand de tous les éléments d'un tableau, comparé via Operators.max sur le résultat de la fonction. |
| min: ('T [] →' T | Renvoie le plus petit de tous les éléments d'un tableau. Operators.min est utilisé pour comparer les éléments. |
| minBy: ('T →' U) → 'T [] →' T | Renvoie le plus petit de tous les éléments d'un tableau. Operators.min est utilisé pour comparer les éléments. |
| ofList: 'T liste →' T [] | Crée un tableau à partir de la liste fournie. |
| ofSeq: seq <'T> →' T [] | Crée un tableau à partir de l'objet énumérable fourni. |
| partition: ('T → booléen) →' T [] → 'T [] *' T [] | Divise un tableau en deux tableaux, l'un contenant les éléments pour lesquels la condition fournie renvoie true, et l'autre contenant ceux pour lesquels il retourne false. |
| permute: (int → int) → 'T [] →' T [] | Permute les éléments d'un tableau selon la permutation spécifiée. |
| choisir: (option 'T →' U) → 'T [] →' U | Applique la fonction fournie aux éléments successifs d'un tableau fourni, renvoyant le premier résultat où la fonction renvoie Some (x) pour certains x. Si la fonction ne renvoie jamais Some (x), KeyNotFoundException est déclenchée. |
| réduire: ('T →' T → 'T) →' T [] → 'T | Applique une fonction à chaque élément d'un tableau, en enfilant un argument d'accumulateur dans le calcul. Si la fonction d'entrée est f et les éléments du tableau sont i0 ... iN, cette fonction calcule f (... (f i0 i1) ...) iN. Si le tableau a une taille zéro, ArgumentException est déclenchée. |
| réduireBack: ('T →' T → 'T) →' T [] → 'T | Applique une fonction à chaque élément d'un tableau, en enfilant un argument d'accumulateur dans le calcul. Si la fonction d'entrée est f et les éléments sont i0 ... iN, cette fonction calcule f i0 (... (f iN-1 iN)). Si le tableau a une taille zéro, ArgumentException est déclenchée. |
| rev: 'T [] →' T [] | Inverse l'ordre des éléments dans un tableau fourni. |
| scan: ('Etat →' T → 'Etat) →' Etat → 'T [] →' Etat []) | Se comporte comme un pli, mais renvoie les résultats intermédiaires avec les résultats finaux. |
| scanBack: ('T →' État → 'État) →' T [] → 'État →' État [] | Se comporte comme foldBack, mais renvoie les résultats intermédiaires avec les résultats finaux. |
| set: 'T [] → int →' T → unité | Définit un élément d'un tableau. |
| trier: 'T [] →' T [] | Trie les éléments d'un tableau et renvoie un nouveau tableau. Operators.compare est utilisé pour comparer les éléments. |
| sortBy: (Clé 'T →') → 'T [] →' T [] | Trie les éléments d'un tableau à l'aide de la fonction fournie pour transformer les éléments dans le type sur lequel l'opération de tri est basée, et renvoie un nouveau tableau. Operators.compare est utilisé pour comparer les éléments. |
| sortInPlace: 'T [] → unité | Trie les éléments d'un tableau en modifiant le tableau en place, à l'aide de la fonction de comparaison fournie. Operators.compare est utilisé pour comparer les éléments. |
| sortInPlaceBy: (touche 'T →') → 'T [] → unité | Trie les éléments d'un tableau en modifiant le tableau en place, en utilisant la projection fournie pour les clés. Operators.compare est utilisé pour comparer les éléments. |
| sortInPlaceWith: ('T →' T → int) → 'T [] → unité | Trie les éléments d'un tableau à l'aide de la fonction de comparaison fournie pour modifier le tableau en place. |
| sortWith: ('T →' T → int) → 'T [] →' T [] | Trie les éléments d'un tableau à l'aide de la fonction de comparaison fournie et renvoie un nouveau tableau. |
| sub: 'T [] → int → int →' T [] | Crée un tableau qui contient la sous-plage fournie, qui est spécifiée par l'index de départ et la longueur. |
| somme: 'T [] → ^ T | Renvoie la somme des éléments du tableau. |
| sommeBy: ('T → ^ U) →' T [] → ^ U | Renvoie la somme des résultats générés en appliquant une fonction à chaque élément d'un tableau. |
| toList: 'T [] →' T liste | Convertit le tableau fourni en liste. |
| toSeq: 'T [] → seq <' T> | Affiche le tableau fourni sous forme de séquence. |
| tryFind: ('T → bool) →' T [] → 'T option | Renvoie le premier élément du tableau fourni pour lequel la fonction fournie renvoie true. RetourNone si aucun élément de ce type n'existe. |
| tryFindIndex: ('T → bool) →' T [] → option int | Renvoie l'index du premier élément d'un tableau qui satisfait la condition fournie. |
| tryPick: (option 'T →' U) → option 'T [] →' U | Applique la fonction fournie aux éléments successifs du tableau fourni et renvoie le premier résultat où la fonction renvoie Some (x) pour certains x. Si la fonction ne renvoie jamais Some (x),None est retourné. |
| décompresser: ('T1 *' T2) [] → 'T1 [] *' T2 [] | Divise un tableau de paires de tuple en un tuple de deux tableaux. |
| unzip3: ('T1 *' T2 * 'T3) [] →' T1 [] * 'T2 [] *' T3 [] | Divise un tableau de tuples de trois éléments en un tuple de trois tableaux. |
| zeroCreate: int → 'T [] | Crée un tableau dont les éléments sont initialement définis sur la valeur par défaut Unchecked.defaultof <'T>. |
| zip: 'T1 [] →' T2 [] → ('T1 *' T2) [] | Combine deux tableaux en un tableau de tuples qui ont deux éléments. Les deux tableaux doivent avoir des longueurs égales; sinon, ArgumentException est déclenchée. |
| zip3: 'T1 [] →' T2 [] → 'T3 [] → (' T1 * 'T2 * 113' T3) [] | Combine trois tableaux en un tableau de tuples qui ont trois éléments. Les trois tableaux doivent avoir des longueurs égales; sinon, ArgumentException est déclenchée. |
Dans la section suivante, nous verrons les utilisations de certaines de ces fonctionnalités.
Création de tableaux à l'aide de fonctions
Le module Array fournit plusieurs fonctions qui créent un tableau à partir de zéro.
le Array.empty crée un nouveau tableau vide.
le Array.create La fonction crée un tableau d'une taille spécifiée et définit tous les éléments sur des valeurs données.
le Array.init function crée un tableau, à partir d'une dimension et d'une fonction pour générer les éléments.
le Array.zeroCreate La fonction crée un tableau dans lequel tous les éléments sont initialisés à la valeur zéro.
le Array.copy crée un nouveau tableau contenant des éléments copiés à partir d'un tableau existant.
le Array.sub La fonction génère un nouveau tableau à partir d'une sous-plage d'un tableau.
le Array.append crée un nouveau tableau en combinant deux tableaux existants.
le Array.choose La fonction sélectionne les éléments d'un tableau à inclure dans un nouveau tableau.
le Array.collect function exécute une fonction spécifiée sur chaque élément de tableau d'un tableau existant, puis collecte les éléments générés par la fonction et les combine dans un nouveau tableau.
le Array.concat function prend une séquence de tableaux et les combine en un seul tableau.
le Array.filter function prend une fonction de condition booléenne et génère un nouveau tableau qui contient uniquement les éléments du tableau d'entrée pour lesquels la condition est vraie.
le Array.rev La fonction génère un nouveau tableau en inversant l'ordre d'un tableau existant.
Les exemples suivants illustrent ces fonctions -
Exemple 1
(* using create and set *)
let array1 = Array.create 10 ""
for i in 0 .. array1.Length - 1 do
Array.set array1 i (i.ToString())
for i in 0 .. array1.Length - 1 do
printf "%s " (Array.get array1 i)
printfn " "
(* empty array *)
let array2 = Array.empty
printfn "Length of empty array: %d" array2.Length
let array3 = Array.create 10 7.0
printfn "Float Array: %A" array3
(* using the init and zeroCreate *)
let array4 = Array.init 10 (fun index -> index * index)
printfn "Array of squares: %A" array4
let array5 : float array = Array.zeroCreate 10
let (myZeroArray : float array) = Array.zeroCreate 10
printfn "Float Array: %A" array5Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -
0 1 2 3 4 5 6 7 8 9
Length of empty array: 0
Float Array: [|7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0|]
Array of squares: [|0; 1; 4; 9; 16; 25; 36; 49; 64; 81|]
Float Array: [|0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0|]Exemple 2
(* creating subarray from element 5 *)
(* containing 15 elements thereon *)
let array1 = [| 0 .. 50 |]
let array2 = Array.sub array1 5 15
printfn "Sub Array:"
printfn "%A" array2
(* appending two arrays *)
let array3 = [| 1; 2; 3; 4|]
let array4 = [| 5 .. 9 |]
printfn "Appended Array:"
let array5 = Array.append array3 array4
printfn "%A" array5
(* using the Choose function *)
let array6 = [| 1 .. 20 |]
let array7 = Array.choose (fun elem -> if elem % 3 = 0 then
Some(float (elem))
else
None) array6
printfn "Array with Chosen elements:"
printfn "%A" array7
(*using the Collect function *)
let array8 = [| 2 .. 5 |]
let array9 = Array.collect (fun elem -> [| 0 .. elem - 1 |]) array8
printfn "Array with collected elements:"
printfn "%A" array9Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -
Sub Array:
[|5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15; 16; 17; 18; 19|]
Appended Array:
[|1; 2; 3; 4; 5; 6; 7; 8; 9|]
Array with Chosen elements:
[|3.0; 6.0; 9.0; 12.0; 15.0; 18.0|]
Array with collected elements:
[|0; 1; 0; 1; 2; 0; 1; 2; 3; 0; 1; 2; 3; 4|]Recherche de tableaux
le Array.find function prend une fonction booléenne et retourne le premier élément pour lequel la fonction renvoie true, sinon déclenche une KeyNotFoundException.
le Array.findIndex La fonction fonctionne de la même manière sauf qu'elle renvoie l'index de l'élément au lieu de l'élément lui-même.
L'exemple suivant illustre cela.
Microsoft fournit cet exemple de programme intéressant, qui trouve le premier élément dans la plage d'un nombre donné qui est à la fois un carré parfait et un cube parfait -
let array1 = [| 2 .. 100 |]
let delta = 1.0e-10
let isPerfectSquare (x:int) =
let y = sqrt (float x)
abs(y - round y) < delta
let isPerfectCube (x:int) =
let y = System.Math.Pow(float x, 1.0/3.0)
abs(y - round y) < delta
let element = Array.find (fun elem -> isPerfectSquare elem && isPerfectCube elem) array1
let index = Array.findIndex (fun elem -> isPerfectSquare elem && isPerfectCube elem) array1
printfn "The first element that is both a square and a cube is %d and its index is %d." element indexLorsque vous compilez et exécutez le programme, il produit la sortie suivante -
The first element that is both a square and a cube is 64 and its index is 62.