Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais
Cette documentation est archivée et n’est pas conservée.

Collections.Array, module (F#)

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

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

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.

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

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.

Windows 8, Windows 7, Windows Server 2012, Windows Server 2008 R2

Versions de bibliothèque principale F#

Prise en charge dans : 2,0, 4,0, portables

Afficher: