F # - Arrays

Arrays sind auf Null basierende, veränderbare Sammlungen aufeinanderfolgender Datenelemente fester Größe, die alle vom gleichen Typ sind.

Arrays erstellen

Sie können Arrays mit verschiedenen Syntaxen und Methoden oder mithilfe der Funktionen des Array-Moduls erstellen. In diesem Abschnitt wird das Erstellen von Arrays ohne Verwendung der Modulfunktionen erläutert.

Es gibt drei syntaktische Möglichkeiten, Arrays ohne Funktionen zu erstellen:

Durch Auflisten aufeinanderfolgender Werte zwischen [| und |] und durch Semikolons getrennt.
Indem Sie jedes Element in eine separate Zeile setzen. In diesem Fall ist das Semikolon-Trennzeichen optional.
Durch Verwendung von Sequenzausdrücken.

Sie können auf Array-Elemente zugreifen, indem Sie einen Punktoperator (.) Und Klammern ([und]) verwenden.

Das folgende Beispiel zeigt das Erstellen von Arrays -

//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" "

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

1 2 3 4 5 6
1 2 3 4 5
1 4 9 16 25 36 49 64 81 100

Grundlegende Operationen auf Arrays

Das Bibliotheksmodul Microsoft.FSharp.Collections.Array unterstützt Operationen an eindimensionalen Arrays.

Die folgende Tabelle zeigt die grundlegenden Operationen für Arrays -

Wert	Beschreibung
anhängen: 'T [] →' T [] → 'T []	Erstellt ein Array, das die Elemente eines Arrays gefolgt von den Elementen eines anderen Arrays enthält.
Durchschnitt: ^ T [] → ^ T.	Gibt den Durchschnitt der Elemente in einem Array zurück.
Durchschnitt durch: ('T → ^ U) →' T [] → ^ U.	Gibt den Durchschnitt der Elemente zurück, die durch Anwenden einer Funktion auf jedes Element eines Arrays generiert wurden.
blit: 'T [] → int →' T [] → int → int → Einheit	Liest eine Reihe von Elementen aus einem Array und schreibt sie in ein anderes.
Wählen Sie: (Option 'T → U) →' T [] → 'U []	Wendet eine bereitgestellte 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.
sammle: ('T →' U []) → T [] → 'U []	Wendet die bereitgestellte Funktion auf jedes Element eines Arrays an, verkettet die Ergebnisse und gibt das kombinierte Array zurück.
concat: seq <'T []> →' T []	Erstellt ein Array, das die Elemente jeder der bereitgestellten Array-Sequenzen enthält.
Kopie: 'T →' T []	Erstellt ein Array, das die Elemente des bereitgestellten Arrays enthält.
create: int → 'T →' T []	Erstellt ein Array, dessen Elemente anfänglich alle der angegebene Wert sind.
leer: 'T []	Gibt ein leeres Array des angegebenen Typs zurück.
existiert: ('T → bool) →' T [] → bool	Testet, ob ein Element eines Arrays das angegebene Prädikat erfüllt.
existiert2: ('T1 →' T2 → Bool) → 'T1 [] →' T2 [] → Bool	Testet, ob ein Paar entsprechender Elemente von zwei Arrays die angegebene Bedingung erfüllt.
füllen: 'T [] → int → int →' T → Einheit	Füllt einen Bereich von Elementen eines Arrays mit dem angegebenen Wert.
Filter: ('T → bool) →' T [] → 'T []	Gibt eine Sammlung zurück, die nur die Elemente des angegebenen Arrays enthält, für die die angegebene Bedingung zurückgegeben wird true.
find: ('T → bool) →' T [] → 'T.	Gibt das erste Element zurück, für das die angegebene Funktion zurückgegeben wird true. Löst eine 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 eine KeyNotFoundException aus, wenn keines der Elemente die Bedingung erfüllt.
Falz: ('Zustand →' T → 'Zustand) →' Zustand → 'T [] →' Zustand	Wendet eine Funktion auf jedes Element eines Arrays an und führt ein Akkumulatorargument durch die Berechnung. Wenn die Eingabefunktion f ist und die Array-Elemente i0 ... iN sind, berechnet diese Funktion f (... (fs i0) ...) iN.
fold2: ('Zustand →' T1 → 'T2 →' Zustand) → 'Zustand →' T1 [] → 'T2 [] →' Zustand	Wendet eine Funktion auf Elementpaare aus zwei bereitgestellten Arrays von links nach rechts an, die ein Akkumulatorargument durch die Berechnung führen. Die beiden Eingabearrays müssen gleich lang sein. Andernfalls wird ArgumentException ausgelöst.
foldBack: ('T →' State → 'State) →' T [] → 'State →' State	Wendet eine Funktion auf jedes Element eines Arrays an und führt ein Akkumulatorargument durch die Berechnung. Wenn die Eingabefunktion f ist und die Array-Elemente i0 ... iN sind, berechnet diese Funktion f i0 (... (f iN s)).
foldBack2: ('T1 →' T2 → 'Zustand →' Zustand) → 'T1 [] →' T2 [] → 'Zustand →' Zustand	Wendet eine Funktion auf Elementpaare aus zwei bereitgestellten Arrays von rechts nach links an, die ein Akkumulatorargument durch die Berechnung führen. Die beiden Eingabearrays müssen gleich lang sein. Andernfalls wird ArgumentException ausgelöst.
forall: ('T → bool) →' T [] → bool	Testet, ob alle Elemente eines Arrays die angegebene Bedingung erfüllen.
forall2: ('T1 →' T2 → bool) → 'T1 [] →' T2 [] → bool	Testet, ob alle entsprechenden Elemente von zwei gelieferten Arrays eine gelieferte Bedingung erfüllen.
get: '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	Testet, ob ein Array Elemente enthält.
iter: ('T → Einheit) →' T [] → Einheit	Wendet die bereitgestellte Funktion auf jedes Element eines Arrays an.
iter2: ('T1 →' T2 → Einheit) → 'T1 [] →' T2 [] → Einheit)	Wendet die bereitgestellte Funktion auf ein Elementpaar aus übereinstimmenden Indizes in zwei Arrays an. Die beiden Arrays müssen gleich lang sein. Andernfalls wird ArgumentException ausgelöst.
iteri: (int → 'T → Einheit) →' T [] → Einheit	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 → Einheit) → 'T1 [] →' T2 [] → Einheit	Wendet die bereitgestellte Funktion auf ein Elementpaar aus übereinstimmenden Indizes in zwei Arrays an und übergibt auch den Index der Elemente. Die beiden Arrays müssen gleich lang sein. Andernfalls wird eine ArgumentException ausgelöst.
Länge: 'T [] → int	Gibt die Länge eines Arrays zurück. Die Length-Eigenschaft macht dasselbe.
Karte: ('T →' U) → 'T [] →' U []	Erstellt ein Array, dessen Elemente das Ergebnis der Anwendung der angegebenen Funktion auf jedes der Elemente eines bereitgestellten Arrays sind.
map2: ('T1 →' T2 → 'U) →' T1 [] → 'T2 [] →' U []	Erstellt ein Array, dessen Elemente das Ergebnis der Anwendung der angegebenen Funktion auf die entsprechenden Elemente von zwei bereitgestellten Arrays sind. Die beiden Eingabearrays müssen gleich lang sein. Andernfalls wird ArgumentException ausgelöst.
mapi: (int → 'T →' U) → 'T [] →' U []	Erstellt ein Array, dessen Elemente das Ergebnis der Anwendung der angegebenen Funktion auf jedes der Elemente eines bereitgestellten Arrays sind. Ein an die Funktion übergebener ganzzahliger Index gibt den Index des zu transformierenden Elements an.
mapi2: (int → 'T1 →' T2 → 'U) →' T1 [] → 'T2 [] →' U []	Erstellt ein Array, dessen Elemente das Ergebnis der paarweisen Anwendung der angegebenen Funktion auf die entsprechenden Elemente der beiden Sammlungen sind, wobei auch der Index der Elemente übergeben wird. Die beiden Eingabearrays müssen gleich lang sein. Andernfalls wird ArgumentException ausgelöst.
max: 'T [] →' T.	Gibt das größte aller Elemente eines Arrays zurück. Mit Operators.max werden die Elemente verglichen.
maxBy: ('T →' U) → 'T [] →' T.	Gibt das größte aller Elemente eines Arrays zurück, verglichen mit Operators.max für das Funktionsergebnis.
min: ('T [] →' T.	Gibt das kleinste aller Elemente eines Arrays zurück. Mit Operators.min werden die Elemente verglichen.
minBy: ('T →' U) → 'T [] →' T.	Gibt das kleinste aller Elemente eines Arrays zurück. Mit Operators.min werden die Elemente verglichen.
ofList: 'T Liste →' T []	Erstellt ein Array aus der bereitgestellten 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 auf, von denen eines die Elemente enthält, für die die angegebene Bedingung zurückgegeben wird true, und die andere enthält diejenigen, für die es zurückkehrt false.
permutieren: (int → int) → 'T [] →' T []	Permutiert die Elemente eines Arrays gemäß der angegebenen Permutation.
Wählen Sie: (Option 'T →' U) → 'T [] →' U.	Wendet die angegebene Funktion auf aufeinanderfolgende Elemente eines bereitgestellten Arrays an und gibt das erste Ergebnis zurück, bei dem die Funktion Some (x) für some x zurückgibt. Wenn die Funktion niemals Some (x) zurückgibt, wird KeyNotFoundException ausgelöst.
reduzieren: ('T →' T → 'T) →' T [] → 'T.	Wendet eine Funktion auf jedes Element eines Arrays an und führt ein Akkumulatorargument durch die Berechnung. Wenn die Eingabefunktion f ist und die Array-Elemente i0 ... iN sind, berechnet diese Funktion f (... (f i0 i1) ...) iN. Wenn das Array die Größe Null hat, wird ArgumentException ausgelöst.
reduBack: ('T →' T → 'T) →' T [] → 'T.	Wendet eine Funktion auf jedes Element eines Arrays an und führt ein Akkumulatorargument durch die Berechnung. Wenn die Eingabefunktion f ist und die Elemente i0 ... iN sind, berechnet diese Funktion f i0 (... (f iN-1 iN)). Wenn das Array die Größe Null hat, wird ArgumentException ausgelöst.
rev: 'T [] →' T []	Kehrt die Reihenfolge der Elemente in einem bereitgestellten Array um.
Scan: ('Status →' T → 'Status) →' Status → 'T [] →' Status [])	Benimmt sich wie Fold, gibt aber die Zwischenergebnisse zusammen mit den Endergebnissen zurück.
scanBack: ('T →' Status → 'Status) →' T [] → 'Status →' Status []	Verhält sich wie foldBack, gibt jedoch die Zwischenergebnisse zusammen mit den Endergebnissen zurück.
set: 'T [] → int →' T → Einheit	Legt ein Element eines Arrays fest.
sort: 'T [] →' T []	Sortiert die Elemente eines Arrays und gibt ein neues Array zurück. Mit Operators.compare werden die Elemente verglichen.
sortBy: ('T →' Taste) → 'T [] →' T []	Sortiert die Elemente eines Arrays mithilfe der angegebenen Funktion, um die Elemente in den Typ zu transformieren, auf dem die Sortieroperation basiert, und gibt ein neues Array zurück. Mit Operators.compare werden die Elemente verglichen.
sortInPlace: 'T [] → Einheit	Sortiert die Elemente eines Arrays, indem das Array mithilfe der mitgelieferten Vergleichsfunktion geändert wird. Mit Operators.compare werden die Elemente verglichen.
sortInPlaceBy: ('T →' Taste) → 'T [] → Einheit	Sortiert die Elemente eines Arrays, indem das Array mithilfe der mitgelieferten Projektion für die Schlüssel geändert wird. Mit Operators.compare werden die Elemente verglichen.
sortInPlaceWith: ('T →' T → int) → 'T [] → Einheit	Sortiert die Elemente eines Arrays mithilfe der mitgelieferten Vergleichsfunktion, um das Array an Ort und Stelle zu ändern.
sortWith: ('T →' T → int) → 'T [] →' T []	Sortiert die Elemente eines Arrays mithilfe der bereitgestellten 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.
Summe: '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 jedes Element eines Arrays generiert wurden.
toList: 'T [] →' T Liste	Konvertiert das bereitgestellte Array in eine Liste.
toSeq: 'T [] → seq <' T>	Zeigt das bereitgestellte 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 zurückgegeben wird true. Kehrt zurückNone wenn kein solches Element vorhanden ist.
tryFindIndex: (Option 'T → bool) →' T [] → int	Gibt den Index des ersten Elements in einem Array zurück, das die angegebene Bedingung erfüllt.
tryPick: (Option 'T →' U) → Option 'T [] →' U	Wendet die angegebene Funktion auf aufeinanderfolgende Elemente des angegebenen Arrays an und gibt das erste Ergebnis zurück, wobei die Funktion Some (x) für some x zurückgibt. Wenn die Funktion niemals Some (x) zurückgibt,None ist zurück gekommen.
entpacken: ('T1 ' T2) [] → 'T1 [] ' T2 []	Teilt ein Array von Tupelpaaren in ein Tupel von zwei Arrays auf.
unzip3: ('T1 ' T2 'T3) [] →' T1 [] * 'T2 [] *' T3 []	Teilt ein Array von Tupeln mit drei Elementen in ein Tupel mit drei Arrays auf.
zeroCreate: int → 'T []	Erstellt ein Array, dessen Elemente anfänglich auf den Standardwert Unchecked.defaultof <'T> gesetzt sind.
zip: 'T1 [] →' T2 [] → ('T1 *' T2) []	Kombiniert zwei Arrays zu einem Array von Tupeln mit zwei Elementen. Die beiden Arrays müssen gleich lang sein. Andernfalls wird ArgumentException ausgelöst.
zip3: 'T1 [] →' T2 [] → 'T3 [] → (' T1 * 'T2 * 113' T3) []	Kombiniert drei Arrays zu einem Array von Tupeln mit drei Elementen. Die drei Arrays müssen gleich lang sein. Andernfalls wird ArgumentException ausgelöst.

Im folgenden Abschnitt werden wir die Verwendung einiger dieser Funktionen sehen.

Erstellen von Arrays mithilfe von Funktionen

Das Array-Modul bietet verschiedene Funktionen, mit denen ein Array von Grund auf neu erstellt wird.

Das Array.empty Funktion erstellt ein neues leeres Array.
Das Array.create Die Funktion erstellt ein Array mit einer bestimmten Größe und setzt alle Elemente auf bestimmte Werte.
Das Array.init Funktion erstellt ein Array mit einer Dimension und einer Funktion zum Generieren der Elemente.
Das Array.zeroCreate Funktion erstellt ein Array, in dem alle Elemente auf den Nullwert initialisiert werden.
Das Array.copy Die Funktion erstellt ein neues Array, das Elemente enthält, die aus einem vorhandenen Array kopiert werden.
Das Array.sub Die Funktion generiert ein neues Array aus einem Unterbereich eines Arrays.
Das Array.append Die Funktion erstellt ein neues Array, indem zwei vorhandene Arrays kombiniert werden.
Das Array.choose Die Funktion wählt Elemente eines Arrays aus, die in ein neues Array aufgenommen werden sollen.
Das Array.collect function führt eine angegebene Funktion für jedes Array-Element eines vorhandenen Arrays aus und sammelt dann die von der Funktion generierten Elemente und kombiniert sie zu einem neuen Array.
Das Array.concat Die Funktion nimmt eine Folge von Arrays und kombiniert sie zu einem einzigen Array.
Das Array.filter Die Funktion verwendet eine boolesche Bedingungsfunktion und generiert ein neues Array, das nur die Elemente aus dem Eingabearray enthält, für die die Bedingung erfüllt ist.
Das Array.rev Die Funktion generiert ein neues Array, indem sie die Reihenfolge eines vorhandenen Arrays umkehrt.

Die folgenden Beispiele veranschaulichen diese Funktionen -

Beispiel 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" array5

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

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|]

Beispiel 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" array9

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

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|]

Arrays suchen

Das Array.find Die Funktion verwendet eine Boolesche Funktion und gibt das erste Element zurück, für das die Funktion true zurückgibt. Andernfalls wird eine KeyNotFoundException ausgelöst.

Das Array.findIndex Die Funktion funktioniert ähnlich, außer dass sie den Index des Elements anstelle des Elements selbst zurückgibt.

Das folgende Beispiel zeigt dies.

Microsoft bietet dieses interessante Programmbeispiel, bei dem das erste Element im Bereich einer bestimmten Zahl gefunden wird, das sowohl ein perfektes Quadrat als auch ein perfekter Würfel ist.

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 index

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

The first element that is both a square and a cube is 64 and its index is 62.