Collections.Array, module (F#)

Article
08/10/2011

Fournit des opérations de base sur les tableaux.

Espace de noms/Chemin du module : Microsoft.FSharp.Collections

Assembly : FSharp.Core (in FSharp.Core.dll)

module Array

Notes

Pour une vue d'ensemble des tableaux dans F#, consultez Tableaux (F#).

Valeurs

Valeur	Description
append : 'T [] -> 'T [] -> 'T []	Crée un tableau qui contient les éléments d'un tableau suivi des éléments d'un autre tableau.
average : ^T [] -> ^T	Retourne la moyenne des éléments du tableau.
averageBy : ('T -> ^U) -> 'T [] -> ^U	Retourne la moyenne des éléments générés en appliquant la 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.
choose : ('T ->'U option) -> 'T [] -> 'U []	Applique une fonction fournie à chaque élément d'un tableau. Retourne un tableau qui contient les résultats x pour chaque élément pour lequel la fonction retourne Some(x).
collect : ('T -> 'U []) -> 'T [] -> 'U []	Applique la fonction fournie à chaque élément d'un tableau, concatène les résultats et retourne le tableau combiné.
concat : seq<'T []> -> 'T []	Crée un tableau qui contient les éléments de chacune des séquences de tableaux fournies.
copy : '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 ont tous initialement la valeur fournie.
empty : 'T []	Retourne un tableau vide du type donné.
exists : ('T -> bool) -> 'T [] -> bool	Teste si un élément d'un tableau répond au prédicat fourni.
exists2 : ('T1 -> 'T2 -> bool) -> 'T1 [] -> 'T2 [] -> bool	Teste si une paire d'éléments correspondants de deux tableaux remplissent la condition fournie.
fill : 'T [] -> int -> int -> 'T -> unit	Remplit une plage d'éléments du tableau avec la valeur fournie.
filter : ('T -> bool) -> 'T [] -> 'T []	Retourne une collection qui contient uniquement les éléments du tableau fourni pour lequel la condition fournie retourne true.
find : ('T -> bool) -> 'T [] -> 'T	Retourne le premier élément pour lequel la fonction fournie retourne true. En l'absence d'élément de ce type, lève KeyNotFoundException.
findIndex : ('T -> bool) -> 'T [] -> int	Retourne l'index du premier élément dans un tableau qui répond à 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 du tableau, en créant ainsi un thread d'un argument d'accumulation par l'intermédiaire du calcul. Si la fonction d'entrée est f et que les éléments du tableau sont i0...iN, cette fonction calcule f (...(f s i0)...) iN.
fold2 : ('State -> 'T1 -> 'T2 -> 'State) -> 'State -> 'T1 [] -> 'T2 [] -> 'State	Applique une fonction aux paires d'éléments de deux tableaux, de gauche à droite, en créant ainsi un thread d'un argument d'accumulation par l'intermédiaire du calcul. Les deux tableaux d'entrée doivent avoir les mêmes longueurs, sinon une ArgumentException est levée.
foldBack : ('T -> 'State -> 'State) -> 'T [] -> 'State -> 'State	Applique une fonction à chaque élément du tableau, en créant ainsi un thread d'un argument d'accumulation par l'intermédiaire du calcul. Si la fonction d'entrée est f et que les éléments du tableau sont i0...iN, cette fonction calcule f i0 (...(f iN s)).
foldBack2 : ('T1 -> 'T2 -> 'State -> 'State) -> 'T1 [] -> 'T2 [] -> 'State -> 'State	Applique une fonction aux paires d'éléments de deux tableaux, de droite à gauche, en créant ainsi un thread d'un argument d'accumulation par l'intermédiaire du calcul. Les deux tableaux d'entrée doivent avoir les mêmes longueurs, sinon une ArgumentException est levée.
forall : ('T -> bool) -> 'T [] -> bool	Teste si tous les éléments d'un tableau remplissent la condition fournie.
forall2 : ('T1 -> 'T2 -> bool) -> 'T1 [] -> 'T2 [] -> bool	Teste si tous les éléments correspondants de deux tableaux fournis remplissent une condition fournie.
get : '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	Teste si un tableau possède 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 obtenue en faisant correspondre les index de deux tableaux. Les deux tableaux doivent avoir les mêmes longueurs, sinon une ArgumentException est levé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 obtenue en faisant correspondre les index de deux tableaux, en passant également l'index des éléments. Les deux tableaux doivent avoir les mêmes longueurs, sinon une ArgumentException est levée.
length : 'T [] -> int	Retourne la longueur d'un tableau. La propriété Length effectue la même chose.
map : ('T -> 'U) -> 'T [] -> 'U []	Crée un tableau dont les éléments sont le résultat de l'application de la fonction fournie à chacun des éléments du tableau fourni.
map2 : ('T1 -> 'T2 -> 'U) -> 'T1 [] -> 'T2 [] -> 'U []	Crée un tableau dont les éléments sont le résultat de l'application de la fonction fournie aux éléments correspondants des deux tableaux fournis. Les deux tableaux d'entrée doivent avoir les mêmes longueurs, sinon une ArgumentException est levée.
mapi : (int -> 'T -> 'U) -> 'T [] -> 'U []	Crée un tableau dont les éléments sont le résultat de l'application de la fonction fournie à chacun des éléments du tableau fourni. Un index d'entiers passé à la fonction indique l'index de l'élément transformé.
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, en passant également l'index des éléments. Les deux tableaux d'entrée doivent avoir les mêmes longueurs, sinon une ArgumentException est levée.
max : 'T [] -> 'T	Retourne 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	Retourne le plus grand de tous les éléments d'un tableau, comparé via Operators.max sur le résultat de fonction.
min : ('T [] -> 'T	Retourne 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	Retourne le plus petit de tous les éléments d'un tableau. Operators.min est utilisé pour comparer les éléments.
ofList : 'T list -> '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) -> 'T [] -> 'T [] * 'T []	Fractionne un tableau en deux, un contenant les éléments pour lesquels la condition fournie retourne true et l'autre contenant ceux pour lesquels il retourne false.
permute : (int -> int) -> 'T [] -> 'T []	Permute les éléments d'un tableau en fonction de la permutation spécifiée.
pick : ('T -> 'U option) -> 'T [] -> 'U	Applique la fonction fournie aux éléments consécutifs d'un tableau fourni, en retournant le premier résultat où la fonction retourne Some(x) pour un x. Si la fonction ne retourne jamais Some(x), KeyNotFoundException est levée.
reduce : ('T -> 'T -> 'T) -> 'T [] -> 'T	Applique une fonction à chaque élément du tableau, en créant ainsi un thread d'un argument d'accumulation par l'intermédiaire du calcul. Si la fonction d'entrée est f et que 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 levé.
reduceBack : ('T -> 'T -> 'T) -> 'T [] -> 'T	Applique une fonction à chaque élément du tableau, en créant ainsi un thread d'un argument d'accumulation par l'intermédiaire du calcul. Si la fonction d'entrée est f et que 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 levé.
rev : 'T [] -> 'T []	Inverse l'ordre des éléments dans un tableau fourni.
scan : ('State -> 'T -> 'State) -> 'State -> 'T [] -> 'State [])	Se comporte comme le pli, mais retourne les résultats intermédiaires ainsi que les résultats finaux.
scanBack : ('T -> 'State -> 'State) -> 'T [] -> 'State -> 'State []	Se comporte comme foldBack, mais retourne les résultats intermédiaires ainsi que les résultats finaux.
set : 'T [] -> int -> 'T -> unit	Définit un élément d'un tableau.
sort : 'T[] -> 'T []	Trie les éléments d'un tableau et retourne un nouveau tableau. Operators.compare est utilisé pour comparer les éléments..
sortBy : ('T -> 'Key) -> 'T [] -> 'T []	Trie les éléments d'un tableau en utilisant la fonction fournie pour transformer les éléments sur le type sur lequel l'opération de tri est basée et retourne un nouveau tableau. Operators.compare est utilisé pour comparer les éléments..
sortInPlace : 'T [] -> unit	Trie les éléments d'un tableau en utilisant la fonction de comparaison fournie pour modifier le tableau en place. Operators.compare est utilisé pour comparer les éléments..
sortInPlaceBy : ('T -> 'Key) -> 'T [] -> unit	Trie les éléments d'un tableau en faisant muter le tableau sur place, à l'aide de la projection donnée 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 en utilisant 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 retourne un nouveau tableau.
sub : 'T [] -> int -> int -> 'T []	Crée un tableau qui contient la sous-plage fournie, spécifiée par l'index de départ et la longueur.
sum : 'T [] -> ^T	Retourne la somme des éléments dans le tableau.
sumBy : ('T -> ^U) -> 'T [] -> ^U	Retourne la somme des résultats générés en appliquant la fonction à chaque élément d'un tableau.
toList : 'T [] -> 'T list	Convertit le tableau fourni en liste.
toSeq : 'T [] -> seq<'T>	Affiche le tableau fourni sous la forme d'une séquence.
tryFind : ('T -> bool) -> 'T [] -> 'T option	Retourne le premier élément du tableau fourni pour lequel la fonction fournie retourne true. Si aucun élément de ce type n'existe, il retourne None.
tryFindIndex : ('T -> bool) -> 'T [] -> int option	Retourne l'index du premier élément dans un tableau qui répond à la condition fournie.
tryPick : ('T -> 'U option) -> 'T [] -> 'U option	Applique la fonction fournie aux éléments consécutifs du tableau fourni et retourne le premier résultat où la fonction retourne Some(x) pour un x. Si la fonction ne retourne jamais Some(x), alors None est retourné.
unzip : ('T1 * 'T2) [] -> 'T1 [] * 'T2 []	Fractionne un tableau de paires de tuples en un tuple de deux tableaux.
unzip3 : ('T1 * 'T2 * 'T3) [] -> 'T1 [] * 'T2 [] * 'T3 []	Fractionne 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 ayant deux éléments. Les deux tableaux doivent avoir les mêmes longueurs, sinon une ArgumentException est levée.
zip3 : 'T1 [] -> 'T2 [] -> 'T3 [] -> ('T1 * 'T2 * 'T3) []	Combine trois tableaux en un tableau de tuples ayant trois éléments. Les trois tableaux doivent avoir les mêmes longueurs, sinon une ArgumentException est levée.