Collections.Array-Modul (F#)

Artikel
06/10/2015

Stellt grundlegende Vorgänge in Arrays bereit.

Namespace/Modulpfad: Microsoft.FSharp.Collections

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

module Array

Hinweise

Eine Übersicht über Arrays in F# finden Sie unter Arrays (F#).

Werte

Wert	Description
append : 'T [] -> 'T [] -> 'T []	Erstellt ein Array, das die Elemente eines Arrays enthält, gefolgt von den Elementen eines anderen Arrays.
average : ^T [] -> ^T	Gibt den Durchschnitt der Elemente in einem Array zurück.
averageBy : ('T -> ^U) -> 'T [] -> ^U	Gibt den Durchschnitt der Elemente zurück, die durch Anwenden einer Funktion auf die einzelnen Elemente eines Arrays generiert wurden.
blit : 'T [] -> int -> 'T [] -> int -> int -> unit	Liest einen Bereich von Elementen aus einem Array und schreibt sie in ein anderes.
choose : ('T ->'U option) -> 'T [] -> 'U []	Wendet eine angegebene Funktion auf jedes Element eines Arrays an. Gibt ein Array zurück, das die Ergebnisse x für jedes Element enthält, für das die Funktion Some(x) zurückgibt.
collect : ('T -> 'U []) -> 'T [] -> 'U []	Wendet die angegebene Funktion auf jedes Element in einem Array an, verkettet die Ergebnisse und gibt das kombinierte Array zurück.
concat : seq<'T []> -> 'T []	Erstellt ein Array, das die Elemente aller angegebenen Sequenzen von Arrays enthält.
copy : 'T -> 'T []	Erstellt ein Array mit den Elementen des angegebenen Arrays.
create : int -> 'T -> 'T []	Erstellt ein Array, dessen sämtliche Elemente zunächst den angegebenen Wert aufweisen.
empty : 'T []	Gibt ein leeres Array des angegebenen Typs zurück.
exists : ('T -> bool) -> 'T [] -> bool	Überprüft, ob ein Element eines Arrays das angegebene Prädikat erfüllt.
exists2 : ('T1 -> 'T2 -> bool) -> 'T1 [] -> 'T2 [] -> bool	Überprüft, ob alle Paare der entsprechenden Elemente der beiden Arrays die angegebene Bedingung erfüllen.
fill : 'T [] -> int -> int -> 'T -> unit	Füllt einen Bereich von Elementen eines Arrays mit dem angegebenen Wert.
filter : ('T -> bool) -> 'T [] -> 'T []	Gibt eine Auflistung zurück, die nur die Elemente des angegebenen Arrays enthält, für die die angegebene Bedingung true zurückgibt.
find : ('T -> bool) -> 'T [] -> 'T	Gibt das erste Element zurück, für das die angegebene Funktion true zurückgibt. Löst KeyNotFoundException aus, wenn kein solches Element vorhanden ist.
findIndex : ('T -> bool) -> 'T [] -> int	Gibt den Index des ersten Elements in einem Array zurück, das die angegebene Bedingung erfüllt. Löst KeyNotFoundException aus, wenn keines der Elemente die Bedingung erfüllt.
fold : ('State -> 'T -> 'State) -> 'State -> 'T [] -> 'State	Wendet eine Funktion auf jedes Element eines Arrays an, wobei ein Akkumulatorargument in der Berechnung mitgeführt wird. Ist die Eingabefunktion f und sind die Arrayelemente i0...iN, wird f (...(f s i0)...) iN von der Funktion berechnet.
fold2 : ('State -> 'T1 -> 'T2 -> 'State) -> 'State -> 'T1 [] -> 'T2 [] -> 'State	Wendet eine Funktion auf Paare von Elementen aus zwei bereitgestellten Arrays an, von links nach rechts, wobei ein Akkumulatorargument in der Berechnung mitgeführt wird. Beide Eingabearrays müssen dieselbe Länge haben. Andernfalls wird eine ArgumentException ausgelöst.
foldBack : ('T -> 'State -> 'State) -> 'T [] -> 'State -> 'State	Wendet eine Funktion auf jedes Element eines Arrays an, wobei ein Akkumulatorargument in der Berechnung mitgeführt wird. Ist die Eingabefunktion f und sind die Arrayelemente i0...iN, wird f i0 (...(f iN s)) von der Funktion berechnet.
foldBack2 : ('T1 -> 'T2 -> 'State -> 'State) -> 'T1 [] -> 'T2 [] -> 'State -> 'State	Wendet eine Funktion auf Paare von Elementen aus zwei bereitgestellten Arrays an, von rechts nach links, wobei ein Akkumulatorargument in der Berechnung mitgeführt wird. Beide Eingabearrays müssen dieselbe Länge haben. Andernfalls wird eine ArgumentException ausgelöst.
forall : ('T -> bool) -> 'T [] -> bool	Prüft, ob alle Elemente eines Arrays die angegebene Bedingung erfüllen.
forall2 : ('T1 -> 'T2 -> bool) -> 'T1 [] -> 'T2 [] -> bool	Prüft, ob alle zugehörigen Elemente von zwei angegebenen Arrays eine angegebene Bedingung erfüllen.
abrufen : 'T [] -> int -> 'T	Ruft ein Element aus einem Array ab.
init : int -> (int -> 'T) -> 'T []	Verwendet eine bereitgestellte Funktion, um ein Array der angegebenen Dimension zu erstellen.
isEmpty : 'T [] -> bool	Überprüft, ob ein Array über Elemente verfügt.
iter : ('T -> unit) -> 'T [] -> unit	Wendet die bereitgestellte Funktion auf jedes Element eines Arrays an.
iter2 : ('T1 -> 'T2 -> unit) -> 'T1 [] -> 'T2 [] -> unit)	Wendet die bereitgestellte Funktion auf ein Paar von Elementen von übereinstimmenden Indizes in zwei Arrays an. Beide Arrays müssen dieselbe Länge haben. Andernfalls wird eine ArgumentException ausgelöst.
iteri : (int -> 'T -> unit) -> 'T [] -> unit	Wendet die bereitgestellte Funktion auf jedes Element eines Arrays an. Die an die Funktion übergebene Ganzzahl gibt den Index des Elements an.
iteri2 : (int -> 'T1 -> 'T2 -> unit) -> 'T1 [] -> 'T2 [] -> unit	Wendet die bereitgestellte Funktion auf ein Paar von Elementen von übereinstimmenden Indizes in zwei Arrays an und übergibt den Index der Elemente. Beide Arrays müssen dieselbe Länge haben. Andernfalls wird eine ArgumentException ausgelöst.
length : 'T [] -> int	Gibt die Länge eines Arrays zurück. Die Length-Eigenschaft dient demselben Zweck.
map : ('T -> 'U) -> 'T [] -> 'U []	Erstellt ein Array, dessen Elemente das Ergebnis der Anwendung der angegebenen Funktion auf jedes Element eines angegebenen Arrays sind.
map2 : ('T1 -> 'T2 -> 'U) -> 'T1 [] -> 'T2 [] -> 'U []	Erstellt ein Array, dessen Elemente die Ergebnisse der Anwendung der angegebenen Funktion auf die entsprechenden Elemente vom zwei angegebenen Arrays sind. Beide Eingabearrays müssen dieselbe Länge haben. Andernfalls wird eine ArgumentException ausgelöst.
mapi : (int -> 'T -> 'U) -> 'T [] -> 'U []	Erstellt ein Array, dessen Elemente das Ergebnis der Anwendung der angegebenen Funktion auf jedes Element eines angegebenen Arrays sind. Ein ganzzahliger Index, der an die Funktion übergeben wird, gibt den Index des zu transformierenden Elements an.
mapi2 : (int -> 'T1 -> 'T2 -> 'U) -> 'T1 [] -> 'T2 [] -> 'U []	Erstellt eine Array, dessen Elemente das Ergebnis einer paarweisen Anwendung der angegebenen Funktion auf die zugehörigen Elemente der beiden Auflistungen sind, und übergibt den Index der Elemente. Beide Eingabearrays müssen dieselbe Länge haben. Andernfalls wird eine ArgumentException ausgelöst.
max : 'T [] -> 'T	Gibt das größte Element eines Arrays zurück. Operators.max wird verwendet, um die Elemente zu vergleichen.
maxBy : ('T -> 'U) -> 'T [] -> 'T	Gibt das Element eines Arrays zurück, das bei einem Vergleich des Funktionsergebnisses mit Operators.max am größten ist.
min : ('T [] -> 'T	Gibt das kleinste Element eines Arrays zurück. Operators.min wird verwendet, um die Elemente zu vergleichen.
minBy : ('T -> 'U) -> 'T [] -> 'T	Gibt das kleinste Element eines Arrays zurück. Operators.min wird verwendet, um die Elemente zu vergleichen.
ofList : 'T list -> 'T []	Erstellt ein Array aus der angegebenen Liste.
ofSeq : seq<'T> -> 'T []	Erstellt ein Array aus dem angegebenen aufzählbaren Objekt.
Partition : ('T -> bool) -> 'T [] -> 'T [] * 'T []	Teilt ein Array in zwei Arrays, von denen eines die Elemente enthält, für die die angegebene Bedingung true zurückgibt, und das andere die Elemente enthält, für die sie false zurückgibt.
permute : (int -> int) -> 'T [] -> 'T []	Permutiert die Elemente eines Arrays entsprechend der angegebenen Permutation.
pick : ('T -> 'U option) -> 'T [] -> 'U	Wendet die bereitgestellte Funktion auf aufeinander folgende Elemente eines angegebenen Arrays an und gibt das erste Ergebnis zurück, bei dem die Funktion Some(x) für bestimmte x zurückgibt. Wenn die Funktion nie Some(x) zurückgibt, wird KeyNotFoundException ausgelöst.
reduce : ('T -> 'T -> 'T) -> 'T [] -> 'T	Wendet eine Funktion auf jedes Element eines Arrays an, wobei ein Akkumulatorargument in der Berechnung mitgeführt wird. Ist die Eingabefunktion f und sind die Arrayelemente i0...iN, wird f (...(f i0 i1)...) iN von der Funktion berechnet. Wenn das Array die Größe 0 (null) hat, wird ArgumentException ausgelöst.
reduceBack : ('T -> 'T -> 'T) -> 'T [] -> 'T	Wendet eine Funktion auf jedes Element eines Arrays an, wobei ein Akkumulatorargument in der Berechnung mitgeführt wird. Ist die Eingabefunktion f und sind die Elemente i0...iN, wird f i0 (...(f iN-1 iN)) von der Funktion berechnet. Wenn das Array die Größe 0 (null) hat, wird ArgumentException ausgelöst.
rev : 'T [] -> 'T []	Kehrt die Reihenfolge der Elemente in einem angegebenen Array um.
scan : ('State -> 'T -> 'State) -> 'State -> 'T [] -> 'State [])	Verhält sich wie fold, gibt jedoch die Zwischenergebnisse zusammen mit den Endergebnissen zurück.
scanBack : ('T -> 'State -> 'State) -> 'T [] -> 'State -> 'State []	Verhält sich wie foldBack, gibt jedoch die Zwischenergebnisse zusammen mit den Endergebnissen zurück.
set : 'T [] -> int -> 'T -> unit	Legt ein Element in einem Array fest.
sort : 'T[] -> 'T []	Sortiert die Elemente eines Arrays und gibt ein neues Array zurück. Elemente werden mithilfe von Operators.compare verglichen.
sortBy : ('T -> 'Key) -> 'T [] -> 'T []	Sortiert die Elemente eines Arrays mit der angegebenen Funktion, um die Elemente in den Typ umzuwandeln, auf dem die Sortierung basiert, und gibt ein neues Array zurück. Elemente werden mithilfe von Operators.compare verglichen.
sortInPlace : 'T [] -> unit	Sortiert die Elemente eines Arrays durch Ändern des vorhandenen Arrays unter Verwendung der angegebenen Vergleichsfunktion. Elemente werden mithilfe von Operators.compare verglichen.
sortInPlaceBy : ('T -> 'Key) -> 'T [] -> unit	Sortiert die Elemente eines Arrays durch Ändern des vorhandenen Arrays unter Verwendung der angegebenen Projektion für die Schlüssel. Elemente werden mithilfe von Operators.compare verglichen.
sortInPlaceWith : ('T -> 'T -> int) -> 'T [] -> unit	Sortiert die Elemente eines Arrays unter Verwendung der angegebenen Vergleichsfunktion, um das vorhandene Array zu ändern.
sortWith : ('T -> 'T -> int) -> 'T [] -> 'T []	Sortiert die Elemente eines Arrays unter Verwendung der angegebenen Vergleichsfunktion, und gibt ein neues Array zurück.
sub : 'T [] -> int -> int -> 'T []	Erstellt ein Array, das den angegebenen Unterbereich enthält, der durch Startindex und Länge angegeben wird.
sum : 'T [] -> ^T	Gibt die Summe der Elemente im Array zurück.
sumBy : ('T -> ^U) -> 'T [] -> ^U	Gibt die Summe der Ergebnisse zurück, die durch Anwenden einer Funktion auf die einzelnen Elemente eines Arrays generiert wird.
toList : 'T [] -> 'T list	Konvertiert das angegebene Array in eine Liste.
toSeq : 'T [] -> seq<'T>	Zeigt das angegebene Array als Sequenz an.
tryFind : ('T -> bool) -> 'T [] -> 'T option	Gibt das erste Element im angegebenen Array zurück, für das die angegebene Funktion true zurückgibt. Wenn kein solches Element vorhanden ist, wird None zurückgegeben.
tryFindIndex : ('T -> bool) -> 'T [] -> int option	Gibt den Index des ersten Elements in einem Array zurück, das die angegebene Bedingung erfüllt.
tryPick : ('T -> 'U option) -> 'T [] -> 'U option	Wendet die bereitgestellte Funktion auf aufeinander folgende Elemente des angegebenen Arrays an und gibt das erste Ergebnis zurück, bei dem die Funktion Some(x) für bestimmte x zurückgibt. Wenn die Funktion nie Some(x) zurückgibt, wird None zurückgegeben.
unzip : ('T1 * 'T2) [] -> 'T1 [] * 'T2 []	Teilt ein Array von Tupelpaaren in ein Tupel mit zwei Arrays.
unzip3 : ('T1 * 'T2 * 'T3) [] -> 'T1 [] * 'T2 [] * 'T3 []	Teilt ein Array von Tupeln mit drei Elementen in ein Tupel mit drei Arrays.
zeroCreate : int -> 'T []	Erstellt ein Array, dessen Elemente anfänglich auf den Standardwert Unchecked.defaultof<'T> festgelegt sind.
zip : 'T1 [] -> 'T2 [] -> ('T1 * 'T2) []	Kombiniert zwei Arrays in ein Array von Tupeln mit zwei Elementen. Die beiden Arrays müssen die gleiche Länge aufweisen, andernfalls wird eine ArgumentException ausgelöst.
zip3 : 'T1 [] -> 'T2 [] -> 'T3 [] -> ('T1 * 'T2 * 'T3) []	Kombiniert drei Arrays in ein Array von Tupeln mit drei Elementen. Die drei Arrays müssen die gleiche Länge aufweisen, andernfalls wird eine ArgumentException ausgelöst.