Arrays (F#)
Arrays sind nullbasierte, änderbare Sequenzen fester Größe von aufeinander folgenden Datenelementen, die alle den gleichen Typ aufweisen.
Erstellen von Arrays
Sie können Arrays auf verschiedene Arten erstellen. Sie können ein kleines Array erstellen, indem Sie aufeinanderfolgende, durch Semikolons getrennte Werte zwischen [| und |] aufführen, wie in den folgenden Beispielen gezeigt.
let array1 = [| 1; 2; 3 |]
Sie können auch jedes Element in einer eigenen Zeile anordnen. In diesem Fall ist das Semikolontrennzeichen optional.
let array1 =
[|
1
2
3
|]
Der Typ der Arrayelemente wird von den verwendeten Literalen abgeleitet, und er muss konsistent sein.
// This is an array of 3 integers.
let array1 = [| 1; 2; 3 |]
// This is an array of a tuple of 3 integers.
let array2 = [| 1, 2, 3 |]
Somit verursacht der folgende Code einen Fehler, da 3.0 ein Gleitkommawert ist und 1 und 2 ganze Zahlen sind.
// Causes an error. The 3.0 (float) cannot be converted to integer implicitly.
// let array3 = [| 1; 2; 3.0 |]
Der folgende Code verursacht auch einen Fehler, da 1,2 ein Tupel und 3 eine ganze Zahl ist.
// Causes an error too. The 3 (integer) cannot be converted to tuple implicitly.
// let array4 = [| 1, 2; 3 |]
Sie können Arrays mithilfe von Sequenzausdrücken erstellen. Im folgenden Beispiel wird ein Array aus den Quadraten von ganzen Zahlen zwischen 1 und 10 erstellt.
let array3 = [| for i in 1 .. 10 -> i * i |]
Verwenden Sie Array.zeroCreate, um ein Array zu erstellen, dessen sämtliche Elemente mit 0 (null) initialisiert sind.
let arrayOfTenZeroes : int array = Array.zeroCreate 10
Zugreifen auf Elemente
Sie können mithilfe von Klammern ([ und ]) auf Arrayelemente zugreifen. Die ursprüngliche Punktsyntax (.[index]) wird weiterhin unterstützt, aber ab F# 6.0 nicht mehr empfohlen.
array1[0]
Arrayindizes beginnen bei 0.
Der Zugriff auf Arrayelemente kann auch mit Slicenotation erfolgen, die es Ihnen ermöglicht, einen Teilbereich des Arrays anzugeben. Im Folgenden erhalten Sie Beispiele für Slicenotation.
// Accesses elements from 0 to 2.
array1[0..2]
// Accesses elements from the beginning of the array to 2.
array1[..2]
// Accesses elements from 2 to the end of the array.
array1[2..]
Bei Verwendung von Slicenotation wird eine neue Kopie des Arrays erstellt.
Arraytypen und Module
Alle F#-Arrays sind vom .NET Framework-Typ System.Array. Daher unterstützen F#-Arrays alle in System.Array verfügbaren Funktionen.
Das Array-Modul unterstützt Vorgänge in eindimensionalen Arrays. Die Module Array2D, Array3D und Array4D enthalten Funktionen, die Operationen für Arrays mit zwei, drei bzw. vier Dimensionen unterstützen. Mit System.Array können Sie Arrays mit einem Rang größer vier erstellen.
Einfache Funktionen
Array.get ruft ein -Element ab. Array.length gibt die Länge eines Arrays an. Array.set legt ein Element auf einen angegebenen Wert fest. Im folgenden Codebeispiel wird die Verwendung dieser Funktionen veranschaulicht.
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)
Die Ausgabe lautet wie folgt.
0 1 2 3 4 5 6 7 8 9
Funktionen, die Arrays erstellen
Mehrere Funktionen erstellen Arrays, ohne ein vorhandenes Array zu erfordern. Array.empty erstellt ein neues Array ohne Elemente. Array.create erstellt ein Array einer angegebenen Größe und legt alle Elemente auf bereitgestellte Werte fest. Array.init erstellt ein Array unter Verwendung einer Dimensionen und einer Funktion zur Erstellung von Elementen. Array.zeroCreate erstellt ein Array, in dem alle Elemente auf den Wert Null für den Typ des Arrays initialisiert werden. Dieser Code demonstriert die Funktionen.
let myEmptyArray = Array.empty
printfn "Length of empty array: %d" myEmptyArray.Length
printfn "Array of floats set to 5.0: %A" (Array.create 10 5.0)
printfn "Array of squares: %A" (Array.init 10 (fun index -> index * index))
let (myZeroArray : float array) = Array.zeroCreate 10
Die Ausgabe lautet wie folgt.
Length of empty array: 0
Area of floats set to 5.0: [|5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0|]
Array of squares: [|0; 1; 4; 9; 16; 25; 36; 49; 64; 81|]
Array.copy erstellt ein neues Array, das Elemente enthält, die aus einem vorhandenen Array kopiert werden. Beachten Sie, dass die Kopie eine flache Kopie ist, d. h., wenn der Elementtyp ein Verweistyp ist, wird nur der Verweis, nicht das zugrunde liegende Objekt kopiert. Dies wird im folgenden Codebeispiel veranschaulicht.
open System.Text
let firstArray : StringBuilder array = Array.init 3 (fun index -> new StringBuilder(""))
let secondArray = Array.copy firstArray
// Reset an element of the first array to a new value.
firstArray[0] <- new StringBuilder("Test1")
// Change an element of the first array.
firstArray[1].Insert(0, "Test2") |> ignore
printfn "%A" firstArray
printfn "%A" secondArray
Der obige Code gibt Folgendes aus:
[|Test1; Test2; |]
[|; Test2; |]
Die Zeichenfolge Test1 wird nur im ersten Array angezeigt, da der Vorgang der Erstellung eines neuen Elements, den Verweis in firstArray überschreibt, aber sich nicht auf den ursprünglichen Verweis auf eine leere Zeichenfolge auswirkt, die immer noch im secondArray vorhanden ist. Die Zeichenfolge Test2 wird in beiden Arrays angezeigt, da sich die Insert-Operation für den System.Text.StringBuilder-Typ auf das zugrundeliegende System.Text.StringBuilder-Objekt auswirkt, auf das in beiden Arrays verwiesen wird.
Array.sub generiert ein neues Array aus einem Teilbereich eines Arrays. Sie geben den Teilbereich an, indem Sie den Startindex und die Länge bereitstellen. Das folgende Codebeispiel veranschaulicht die Verwendung von Array.sub.
let a1 = [| 0 .. 99 |]
let a2 = Array.sub a1 5 10
printfn "%A" a2
Die Ausgabe zeigt an, dass das Unterfeld bei Element "5" beginnt und 10 Elemente enthält.
[|5; 6; 7; 8; 9; 10; 11; 12; 13; 14|]
Array.append erstellt ein neues Array, indem zwei vorhandene Arrays kombiniert werden.
Der folgende Code zeigt Array.append.
printfn "%A" (Array.append [| 1; 2; 3|] [| 4; 5; 6|])
Die Ausgabe des vorhergehenden Codes entspricht dem Folgenden.
[|1; 2; 3; 4; 5; 6|]
Array.choose wählt Elemente eines Arrays aus, die in einem neuen Array enthalten sein sollen. Der folgende Code stellt Array.choose dar. Beachten Sie, dass der Elementtyp des Arrays nicht zum Typ des Werts passen muss, der im Optionstyp zurückgegeben wurde. In diesem Beispiel ist der Elementtyp int, und die Option ist das Ergebnis einer Polynomfunktion (elem*elem - 1) als Gleitkommazahl.
printfn "%A" (Array.choose (fun elem -> if elem % 2 = 0 then
Some(float (elem*elem - 1))
else
None) [| 1 .. 10 |])
Die Ausgabe des vorhergehenden Codes entspricht dem Folgenden.
[|3.0; 15.0; 35.0; 63.0; 99.0|]
Array.collect führt für jedes Arrayelement eines vorhandenen Arrays eine angegebene Funktion aus, sammelt dann die von der Funktion generierten Elemente und kombiniert sie zu einem neuen Array. Der folgende Code stellt Array.collect dar.
printfn "%A" (Array.collect (fun elem -> [| 0 .. elem |]) [| 1; 5; 10|])
Die Ausgabe des vorhergehenden Codes entspricht dem Folgenden.
[|0; 1; 0; 1; 2; 3; 4; 5; 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10|]
Array.concat nimmt eine Sequenz von Arrays an und kombiniert sie in einem einzelnen Array. Der folgende Code stellt Array.concat dar.
Array.concat [ [|0..3|] ; [|4|] ]
//output [|0; 1; 2; 3; 4|]
Array.concat [| [|0..3|] ; [|4|] |]
//output [|0; 1; 2; 3; 4|]
Array.filter nimmt eine boolesche Bedingungsfunktion und generiert ein neues Array, das nur die Elemente des Eingabearrays enthält, für die die Bedingung den Wert TRUE hat. Der folgende Code stellt Array.filter dar.
printfn "%A" (Array.filter (fun elem -> elem % 2 = 0) [| 1 .. 10|])
Die Ausgabe des vorhergehenden Codes entspricht dem Folgenden.
[|2; 4; 6; 8; 10|]
Array.rev generiert ein neues Array, indem die Reihenfolge eines vorhandenen Arrays umgekehrt wird. Der folgende Code stellt Array.rev dar.
let stringReverse (s: string) =
System.String(Array.rev (s.ToCharArray()))
printfn "%A" (stringReverse("!dlrow olleH"))
Die Ausgabe des vorhergehenden Codes entspricht dem Folgenden.
"Hello world!"
Wie im folgenden Beispiel gezeigt wird, können Sie Funktionen im Arraymodul, das Arrays mit dem Pipelineoperator (|>) transformiert, leicht kombinieren.
[| 1 .. 10 |]
|> Array.filter (fun elem -> elem % 2 = 0)
|> Array.choose (fun elem -> if (elem <> 8) then Some(elem*elem) else None)
|> Array.rev
|> printfn "%A"
Ausgabe:
[|100; 36; 16; 4|]
Mehrdimensionale Arrays
Ein mehrdimensionales Array kann erstellt werden, jedoch gibt es keine Syntax zum Schreiben eines mehrdimensionalen Arrayliterals. Verwenden Sie den array2D-Operator, um ein Array aus einer Sequenz von Sequenzen von Arrayelementen zu erstellen. Die Sequenzen können Array- oder Listenliterale sein. Im folgenden Code wird z. B. ein zweidimensionales Array erstellt.
let my2DArray = array2D [ [ 1; 0]; [0; 1] ]
Sie können mithilfe der Funktion Array2D.init auch Arrays mit zwei Dimensionen initialisieren. Ähnliche Funktionen sind für Arrays mit drei und vier Dimensionen verfügbar. Diese Funktionen nehmen eine Funktion, die zum Erstellen der Elemente verwendet wird. Zum Erstellen eines zweidimensionalen Arrays mit Elementen, die auf einen Anfangswert festgelegt sind, anstatt eine Funktion anzugeben, verwenden Sie die Array2D.create-Funktion, die auch für Arrays mit bis zu vier Dimensionen verfügbar ist. Im folgenden Codebeispiel wird die Erstellung eines Arrays von Arrays mit den gewünschten Elementen veranschaulicht, und dann wird mit Array2D.init das gewünschte zweidimensionale Array generiert.
let arrayOfArrays = [| [| 1.0; 0.0 |]; [|0.0; 1.0 |] |]
let twoDimensionalArray = Array2D.init 2 2 (fun i j -> arrayOfArrays[i][j])
Arrayindizierung und das Aufteilen von Syntax in Slices werden für Arrays bis zu Rang 4 unterstützt. Wenn Sie einen Index in mehreren Dimensionen angeben, trennen Sie die Indizes mithilfe von Kommas, wie im folgenden Codebeispiel gezeigt.
twoDimensionalArray[0, 1] <- 1.0
Der Typ eines zweidimensionalen Arrays wird als <type>[,] (z. B.,int[,], double[,]) geschrieben, und der Typ eines dreidimensionalen Arrays wird als <type>[,,] usw. für Arrays mit mehr Dimensionen geschrieben.
Nur eine Teilmenge der Funktionen für eindimensionale Arrays ist auch für mehrdimensionale Arrays verfügbar.
Arraysegmentierung und mehrdimensionale Arrays
In ein zweidimensionales Array (eine Matrix) können Sie eine Sub-Matrix extrahieren, indem Sie Bereiche angeben und ein Platzhalterzeichen (*) verwenden, um ganze Zeilen oder Spalten anzugeben.
// Get rows 1 to N from an NxM matrix (returns a matrix):
matrix[1.., *]
// Get rows 1 to 3 from a matrix (returns a matrix):
matrix[1..3, *]
// Get columns 1 to 3 from a matrix (returns a matrix):
matrix[*, 1..3]
// Get a 3x3 submatrix:
matrix[1..3, 1..3]
Sie können ein mehrdimensionales Array in Unterarrays derselben oder einer niedrigeren Dimension zerlegen. Beispielsweise können Sie einen Vektor aus einer Matrix abrufen, indem Sie eine einzelne Zeile oder eine Spalte angeben.
// Get row 3 from a matrix as a vector:
matrix[3, *]
// Get column 3 from a matrix as a vector:
matrix[*, 3]
Sie können diese segmentierende Syntax für Typen verwenden, die die Elementzugriffsoperatoren und die überladenen GetSlice-Methoden implementieren. Beispielsweise erstellt der folgende Code einen Matrixtyp, der das F# 2D-Array umschließt, eine Elementeigenschaft implementiert, um Unterstützung für die Arrayindizierung bereitzustellen, und drei Versionen von GetSlice implementiert. Wenn Sie diesen Code als Vorlage für Ihre Matrixtypen verwenden können, können Sie alle in diesem Abschnitt beschriebenen Segmentierungsvorgänge verwenden.
type Matrix<'T>(N: int, M: int) =
let internalArray = Array2D.zeroCreate<'T> N M
member this.Item
with get(a: int, b: int) = internalArray[a, b]
and set(a: int, b: int) (value:'T) = internalArray[a, b] <- value
member this.GetSlice(rowStart: int option, rowFinish : int option, colStart: int option, colFinish : int option) =
let rowStart =
match rowStart with
| Some(v) -> v
| None -> 0
let rowFinish =
match rowFinish with
| Some(v) -> v
| None -> internalArray.GetLength(0) - 1
let colStart =
match colStart with
| Some(v) -> v
| None -> 0
let colFinish =
match colFinish with
| Some(v) -> v
| None -> internalArray.GetLength(1) - 1
internalArray[rowStart..rowFinish, colStart..colFinish]
member this.GetSlice(row: int, colStart: int option, colFinish: int option) =
let colStart =
match colStart with
| Some(v) -> v
| None -> 0
let colFinish =
match colFinish with
| Some(v) -> v
| None -> internalArray.GetLength(1) - 1
internalArray[row, colStart..colFinish]
member this.GetSlice(rowStart: int option, rowFinish: int option, col: int) =
let rowStart =
match rowStart with
| Some(v) -> v
| None -> 0
let rowFinish =
match rowFinish with
| Some(v) -> v
| None -> internalArray.GetLength(0) - 1
internalArray[rowStart..rowFinish, col]
module test =
let generateTestMatrix x y =
let matrix = new Matrix<float>(3, 3)
for i in 0..2 do
for j in 0..2 do
matrix[i, j] <- float(i) * x - float(j) * y
matrix
let test1 = generateTestMatrix 2.3 1.1
let submatrix = test1[0..1, 0..1]
printfn $"{submatrix}"
let firstRow = test1[0,*]
let secondRow = test1[1,*]
let firstCol = test1[*,0]
printfn $"{firstCol}"
Boolesche Funktionen für Arrays
Die Funktionen Array.exists und Array.exists2 testen Elemente in einem bzw. zwei Arrays. Diese Funktionen akzeptieren eine Testfunktion und geben true zurück, wenn die Bedingung von einem Element (oder Elementpaaren für Array.exists2) erfüllt wird.
Das folgende Codebeispiel veranschaulicht die Verwendung von Array.exists und Array.exists2. In diesen Beispielen werden neue Funktionen durch das Übernehmen von nur einem der Argumente, in diesen Fällen das Funktionsargument, erstellt.
let allNegative = Array.exists (fun elem -> abs (elem) = elem) >> not
printfn "%A" (allNegative [| -1; -2; -3 |])
printfn "%A" (allNegative [| -10; -1; 5 |])
printfn "%A" (allNegative [| 0 |])
let haveEqualElement = Array.exists2 (fun elem1 elem2 -> elem1 = elem2)
printfn "%A" (haveEqualElement [| 1; 2; 3 |] [| 3; 2; 1|])
Die Ausgabe des vorhergehenden Codes entspricht dem Folgenden.
true
false
false
true
Auf ähnliche Weise testet die Array.forall-Funktion ein Array, um zu bestimmen, ob jedes Element eine boolesche Bedingung erfüllt. Der Variation Array.forall2 erfüllt denselben Zweck mit einer booleschen Funktion, die Elemente zweier Arrays gleicher Länge enthält. Im folgenden Code wird die Verwendung dieser Funktionen veranschaulicht.
let allPositive = Array.forall (fun elem -> elem > 0)
printfn "%A" (allPositive [| 0; 1; 2; 3 |])
printfn "%A" (allPositive [| 1; 2; 3 |])
let allEqual = Array.forall2 (fun elem1 elem2 -> elem1 = elem2)
printfn "%A" (allEqual [| 1; 2 |] [| 1; 2 |])
printfn "%A" (allEqual [| 1; 2 |] [| 2; 1 |])
Die Ausgabe dieser Beispiele lautet folgendermaßen.
false
true
true
false
Sucharrays
Array.find nimmt eine boolesche Funktion an und gibt das erste Element zurück, für das die Funktion true zurückgibt, oder löst eine System.Collections.Generic.KeyNotFoundException aus, wenn kein entsprechendes Element für die Bedingung gefunden wird. Array.findIndex entspricht Array.find, nur wird der Index des Elements anstelle des Elements selbst zurückgegeben.
Der folgende Code sucht mithilfe von Array.find und Array.findIndex eine Zahl, die sowohl ein perfektes Quadrat als auch perfekter Cube ist.
let arrayA = [| 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) arrayA
let index = Array.findIndex (fun elem -> isPerfectSquare elem && isPerfectCube elem) arrayA
printfn "The first element that is both a square and a cube is %d and its index is %d." element index
Die Ausgabe lautet wie folgt.
The first element that is both a square and a cube is 64 and its index is 62.
Array.tryFind entspricht Array.find, nur ist das Ergebnis ein Optionstyp, und es wird None zurückgegeben, wenn kein Element gefunden wird. Array.tryFind sollte statt Array.find verwendet werden, wenn nicht bekannt ist, ob ein entsprechendes Element im Array vorhanden ist. Array.tryFindIndexentspricht Array.findIndex, nur ist der Optionstyp der Rückgabewert. Wenn kein Element gefunden wird, lautet die Option None.
Das folgende Codebeispiel veranschaulicht die Verwendung von Array.tryFind. Dieser Code hängt vom vorherigen Code ab.
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 lookForCubeAndSquare array1 =
let result = Array.tryFind (fun elem -> isPerfectSquare elem && isPerfectCube elem) array1
match result with
| Some x -> printfn "Found an element: %d" x
| None -> printfn "Failed to find a matching element."
lookForCubeAndSquare [| 1 .. 10 |]
lookForCubeAndSquare [| 100 .. 1000 |]
lookForCubeAndSquare [| 2 .. 50 |]
Die Ausgabe lautet wie folgt.
Found an element: 1
Found an element: 729
Failed to find a matching element.
Verwenden Sie Array.tryPick, wenn Sie zusätzlich zum Auffinden ein Element transformieren müssen. Das Ergebnis ist das erste Element, für das die Funktion das transformierte Element als Optionswert zurückgibt, oder None, wenn kein solches Element gefunden wird.
Im folgenden Code wird die Verwendung von Array.tryPick veranschaulicht: In diesem Fall werden statt eines Lambdaausdrucks mehrere lokale Hilfsfunktionen definiert, um den Code zu vereinfachen.
let findPerfectSquareAndCube array1 =
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
// intFunction : (float -> float) -> int -> int
// Allows the use of a floating point function with integers.
let intFunction function1 number = int (round (function1 (float number)))
let cubeRoot x = System.Math.Pow(x, 1.0/3.0)
// testElement: int -> (int * int * int) option
// Test an element to see whether it is a perfect square and a perfect
// cube, and, if so, return the element, square root, and cube root
// as an option value. Otherwise, return None.
let testElement elem =
if isPerfectSquare elem && isPerfectCube elem then
Some(elem, intFunction sqrt elem, intFunction cubeRoot elem)
else None
match Array.tryPick testElement array1 with
| Some (n, sqrt, cuberoot) -> printfn "Found an element %d with square root %d and cube root %d." n sqrt cuberoot
| None -> printfn "Did not find an element that is both a perfect square and a perfect cube."
findPerfectSquareAndCube [| 1 .. 10 |]
findPerfectSquareAndCube [| 2 .. 100 |]
findPerfectSquareAndCube [| 100 .. 1000 |]
findPerfectSquareAndCube [| 1000 .. 10000 |]
findPerfectSquareAndCube [| 2 .. 50 |]
Die Ausgabe lautet wie folgt.
Found an element 1 with square root 1 and cube root 1.
Found an element 64 with square root 8 and cube root 4.
Found an element 729 with square root 27 and cube root 9.
Found an element 4096 with square root 64 and cube root 16.
Did not find an element that is both a perfect square and a perfect cube.
Ausführen von Berechnungen für Arrays
Die Array.average-Funktion gibt den Durchschnitt jedes Elements in einem Array zurück. Sie ist auf Elementtypen beschränkt, die die exakte Division durch eine ganze Zahl unterstützen, wozu Gleitkommatypen aber keine ganzzahligen Typen gehören. Die Array.averageBy-Funktion gibt den Durchschnitt der Ergebnisse zurück, die eine Funktion für jedes Element aufrufen. Für ein Array eines ganzzahligen Typs können Sie Array.averageBy verwenden und für die Berechnung die Funktion jedes Element in einen Gleitkommatyp konvertieren lassen.
Verwenden Sie Array.max oder Array.min, um das maximale oder minimale Element abzurufen, wenn der Elementtyp dies unterstützt. Auf ähnliche Weise erlauben Array.maxBy und Array.minBy zunächst die Ausführung einer Funktion, ggf. zur Transformation eines Typs, der Vergleiche unterstützt.
Array.sum fügt die Elemente eines Arrays hinzu, und Array.sumBy ruft für jedes Element eine Funktion auf und fügt die Ergebnisse zusammen.
Verwenden Sie Array.iter, um eine Funktion für jedes Element in einem Array auszuführen, ohne dabei die Rückgabewerte zu speichern. Verwenden Sie für eine Funktion mit zwei Arrays gleicher Länge Array.iter2. Wenn Sie auch ein Array mit den Ergebnissen der Funktion benötigen, verwenden Sie Array.map oder Array.map2, die mit zwei Arrays gleichzeitig arbeiten.
Die Variationen Array.iteri und Array.iteri2 ermöglichen dem Index des Elements die Beteiligung an der Berechnung. Dasselbe gilt für Array.mapi und Array.mapi2.
Die Funktionen Array.fold, Array.foldBack, Array.reduce, Array.reduceBack, Array.scanund Array.scanBack führen Algorithmen aus, die alle Elemente eines Arrays betreffen. Ebenso führen die Variationen Array.fold2 und Array.foldBack2 Berechnungen für zwei Arrays durch.
Diese Funktionen zum Ausführen von Berechnungen entsprechen den Funktionen mit dem gleichen Namen im Listenmodul. Verwendungsbeispiele finden Sie unter Listen.
Ändern von Arrays
Array.set legt ein Element auf einen angegebenen Wert fest. Array.fill legt einen Bereich von Elementen in einem Array auf einen angegebenen Wert fest. Das folgende Codebeispiel enthält ein Beispiel für Array.fill.
let arrayFill1 = [| 1 .. 25 |]
Array.fill arrayFill1 2 20 0
printfn "%A" arrayFill1
Die Ausgabe lautet wie folgt.
[|1; 2; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 23; 24; 25|]
Sie können mithilfe von Array.blit einen Unterabschnitt eines Arrays in ein anderes Array kopieren.
Konvertieren in andere und aus anderen Typen
Array.ofList erstellt ein Array aus einer Liste. Array.ofSeq erstellt ein Array aus einer Sequenz. Array.toList und Array.toSeq konvertieren aus dem Arraytyp in diese anderen Sammlungstypen.
Sortieren von Arrays
Verwenden Sie Array.sort, um ein Array mit der generischen Vergleichsfunktion zu sortieren. Verwenden Sie Array.sortBy, um eine Funktion anzugeben, die einen Wert mit der Bezeichnung Schlüssel generiert, um die generische Vergleichsfunktion auf den Schlüssel anzuwenden und so zu sortieren. Verwenden Sie Array.sortWith, wenn Sie eine benutzerdefinierte Vergleichsfunktion bereitstellen möchten. Array.sort, Array.sortBy und Array.sortWith geben das sortierte Array als neues Array zurück. Die Variationen Array.sortInPlace, Array.sortInPlaceBy und Array.sortInPlaceWith ändern das vorhandene Array, anstatt ein neues Array zurückzugeben.
Arrays und Tupel
Die Funktionen Array.zip und Array.unzip konvertieren Arrays von Tupelpaaren in Tupel von Arrays und umgekehrt. Array.zip3 und Array.unzip3 sind ähnlich, nur arbeiten sie mit Tupeln aus drei Elementen oder Tupeln aus drei Arrays.
Parallele Berechnungen für Arrays
Das Modul Array.Parallel enthält Funktionen zum Ausführen paralleler Berechnungen für Arrays. Dieses Modul ist in Anwendungen nicht verfügbar, die auf Versionen vor Version 4 von .NET Framework abzielen.
