Freigeben über

Arrays (F#)

Arrays sind nullbasierte, veränderbare Auflistungen aufeinander folgender Datenelemente, die alle denselben Typ aufweisen.

Erstellen von Arrays

Sie können Arrays auf verschiedene Arten erstellen. Sie können ein kleines Array erstellen, indem Sie aufeinander folgende Werte zwischen [| und |] getrennt durch Semikolons auflisten, wie in den folgenden Beispielen gezeigt.

let array1 = [| 1; 2; 3 |]

Sie können jedes Element auch in eine separate Zeile einfügen, in diesem Fall ist das Semikolontrennzeichen optional.

let array1 =
    [|
        1
        2
        3
     |]

Der Typ der Arrayelemente wird von den verwendeten Literalen abgeleitet und 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 |]

Der folgende Code verursacht einen Fehler, da 3,0 eine Gleitkomma 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 es sich um 1,2 ein Tupel handelt 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 auch Sequenzausdrücke verwenden, um Arrays zu erstellen. Nachfolgend sehen Sie ein Beispiel, das ein Array von Quadraten mit ganzen Zahlen von 1 bis 10 erstellt.

let array3 = [| for i in 1 .. 10 -> i * i |]

Verwenden Sie Array.zeroCreatezum Erstellen eines Arrays, in dem alle Elemente auf Null initialisiert werden.

let arrayOfTenZeroes : int array = Array.zeroCreate 10

Access-Elemente

Sie können auf Arrayelemente zugreifen, indem Sie eckige Klammern ([ und ]) verwenden. Die ursprüngliche Punktsyntax (.[index]) wird weiterhin unterstützt, wird aber ab F# 6.0 nicht mehr empfohlen.

array1[0]

Arrayindizes beginnen bei 0.

Sie können auch mithilfe der Segmentnotation auf Arrayelemente zugreifen, wodurch Sie eine Unterrange des Arrays angeben können. Beispiele für die Datenschnittnotation folgen.

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

Wenn die Segmentnotation verwendet wird, wird eine neue Kopie des Arrays erstellt.

Arraytypen und Module

Der Typ aller F#-Arrays ist der .NET Framework-Typ System.Array. Daher unterstützen F#-Arrays alle funktionen, die in System.Array.

Das Array Modul unterstützt Vorgänge in eindimensionalen Arrays. Die Module Array2D, Array3Dund Array4D enthalten Funktionen, die Vorgänge auf Arrays von zwei, drei und vier Dimensionen unterstützen. Sie können Arrays der Rangfolge größer als vier erstellen, indem Sie dies verwenden System.Array.

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 zum Erstellen von Arrays

Mehrere Funktionen erstellen Arrays, ohne dass ein vorhandenes Array erforderlich ist. Array.empty erstellt ein neues Array, das keine Elemente enthält. Array.create erstellt ein Array einer angegebenen Größe und legt alle Elemente auf bereitgestellte Werte fest. Array.init erstellt ein Array mit einer Dimension und einer Funktion, um die Elemente zu generieren. Array.zeroCreate erstellt ein Array, in dem alle Elemente für den Arraytyp auf den Nullwert initialisiert werden. Der folgende Code veranschaulicht diese 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 es sich bei der Kopie um eine flache Kopie handelt, was bedeutet, dass, wenn der Elementtyp ein Verweistyp ist, nur der Verweis kopiert wird, nicht das zugrunde liegende Objekt. Im folgenden Codebeispiel wird dies 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

Die Ausgabe des vorherigen Codes lautet wie folgt:

[|Test1; Test2; |]
[|; Test2; |]

Die Zeichenfolge Test1 wird nur im ersten Array angezeigt, da der Vorgang zum Erstellen eines neuen Elements den Verweis firstArray überschreibt, aber nicht den ursprünglichen Verweis auf eine leere Zeichenfolge beeinflusst, die noch vorhanden secondArrayist. Die Zeichenfolge Test2 wird in beiden Arrays angezeigt, da sich der Insert Vorgang auf den System.Text.StringBuilder Typ auf das zugrunde liegende System.Text.StringBuilder Objekt auswirkt, auf das in beiden Arrays verwiesen wird.

Array.sub generiert ein neues Array aus einer Unterrange eines Arrays. Sie geben den Unterbereich an, indem Sie den Anfangsindex und die Länge angeben. Der folgende Code veranschaulicht die Verwendung von Array.sub.

let a1 = [| 0 .. 99 |]
let a2 = Array.sub a1 5 10
printfn "%A" a2

Die Ausgabe zeigt, dass das Unterarray 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 veranschaulicht Array.append.

printfn "%A" (Array.append [| 1; 2; 3|] [| 4; 5; 6|])

Die Ausgabe des vorherigen Codes lautet wie folgt.

[|1; 2; 3; 4; 5; 6|]

Array.choose wählt Elemente eines Arrays aus, die in ein neues Array eingeschlossen werden sollen. Der folgende Code veranschaulicht Array.choose. Beachten Sie, dass der Elementtyp des Arrays nicht mit dem Typ des im Optionstyp zurückgegebenen Werts übereinstimmen muss. In diesem Beispiel ist int der Elementtyp und die Option ist das Ergebnis einer Polynomfunktion, elem*elem - 1als Gleitkommazahl.

printfn "%A" (Array.choose (fun elem -> if elem % 2 = 0 then
                                            Some(float (elem*elem - 1))
                                        else
                                            None) [| 1 .. 10 |])

Die Ausgabe des vorherigen Codes lautet wie folgt.

[|3.0; 15.0; 35.0; 63.0; 99.0|]

Array.collect führt eine angegebene Funktion für jedes Arrayelement eines vorhandenen Arrays aus und sammelt dann die von der Funktion generierten Elemente und kombiniert sie in einem neuen Array. Der folgende Code veranschaulicht Array.collect.

printfn "%A" (Array.collect (fun elem -> [| 0 .. elem |]) [| 1; 5; 10|])

Die Ausgabe des vorherigen Codes lautet wie folgt.

[|0; 1; 0; 1; 2; 3; 4; 5; 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10|]

Array.concat verwendet eine Abfolge von Arrays und kombiniert sie in einem einzigen Array. Der folgende Code veranschaulicht Array.concat.

Array.concat [ [|0..3|] ; [|4|] ]
//output [|0; 1; 2; 3; 4|]

Array.concat [| [|0..3|] ; [|4|] |]
//output [|0; 1; 2; 3; 4|]

Array.filter verwendet eine boolesche Bedingungsfunktion und generiert ein neues Array, das nur die Elemente aus dem Eingabearray enthält, für das die Bedingung wahr ist. Der folgende Code veranschaulicht Array.filter.

printfn "%A" (Array.filter (fun elem -> elem % 2 = 0) [| 1 .. 10|])

Die Ausgabe des vorherigen Codes lautet wie folgt.

[|2; 4; 6; 8; 10|]

Array.rev generiert ein neues Array, indem die Reihenfolge eines vorhandenen Arrays umgekehrt wird. Der folgende Code veranschaulicht Array.rev.

let stringReverse (s: string) =
    System.String(Array.rev (s.ToCharArray()))

printfn "%A" (stringReverse("!dlrow olleH"))

Die Ausgabe des vorherigen Codes lautet wie folgt.

"Hello world!"

Sie können Funktionen im Arraymodul, die Arrays transformieren, ganz einfach mithilfe des Pipelineoperators (|>), wie im folgenden Beispiel gezeigt, 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"

Die Ausgabe lautet

[|100; 36; 16; 4|]

Mehrdimensionale Arrays

Ein multidimensionales Array kann erstellt werden, es gibt jedoch keine Syntax zum Schreiben eines multidimensionalen Arrayliterals. Verwenden Sie den Operator array2D , um ein Array aus einer Abfolge von Sequenzen von Arrayelementen zu erstellen. Die Sequenzen können Array- oder Listenliterale sein. Der folgende Code erstellt beispielsweise ein zweidimensionales Array.

let my2DArray = array2D [ [ 1; 0]; [0; 1] ]

Sie können die Funktion Array2D.init auch verwenden, um Arrays mit zwei Dimensionen zu initialisieren, und ähnliche Funktionen sind für Arrays mit drei und vier Dimensionen verfügbar. Diese Funktionen verwenden eine Funktion, die zum Erstellen der Elemente verwendet wird. Um ein zweidimensionales Array zu erstellen, das Elemente enthält, die auf einen Anfangswert festgelegt sind, anstatt eine Funktion anzugeben, verwenden Sie die Array2D.create Funktion, die auch für Arrays bis zu vier Dimensionen verfügbar ist. Im folgenden Codebeispiel wird zunächst gezeigt, wie Sie ein Array von Arrays erstellen, die die gewünschten Elemente enthalten, und anschließend Array2D.init das gewünschte zweidimensionale Array generieren.

let arrayOfArrays = [| [| 1.0; 0.0 |]; [|0.0; 1.0 |] |]
let twoDimensionalArray = Array2D.init 2 2 (fun i j -> arrayOfArrays[i][j])

Arrayindizierungs- und Slicingsyntax wird für Arrays bis rang 4 unterstützt. Wenn Sie einen Index in mehreren Dimensionen angeben, verwenden Sie Kommas, um die Indizes zu trennen, wie im folgenden Codebeispiel veranschaulicht.

twoDimensionalArray[0, 1] <- 1.0

Der Typ eines zweidimensionalen Arrays wird als <type>[,] (z int[,]. B. , double[,]), und der Typ eines dreidimensionalen Arrays als <type>[,,], usw. für Arrays höherer Dimensionen geschrieben.

Nur eine Teilmenge der funktionen, die für eindimensionale Arrays verfügbar sind, ist auch für mehrdimensionale Arrays verfügbar.

Arrayslicing und multidimensionale Arrays

In einem zweidimensionalen Array (einer Matrix) können Sie eine Untermatrix extrahieren, indem Sie Bereiche angeben und ein Wildcardzeichen (*) 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 niedrigeren Dimension dekompilieren. Sie können z. B. einen Vektor aus einer Matrix abrufen, indem Sie eine einzelne Zeile oder 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 Slicingsyntax für Typen verwenden, die die Elementzugriffsoperatoren und überladene GetSlice Methoden implementieren. Der folgende Code erstellt z. B. einen Matrixtyp, der das F#2D-Array umschließt, eine Item-Eigenschaft implementiert, um Unterstützung für die Arrayindizierung bereitzustellen und drei Versionen von GetSlice. Wenn Sie diesen Code als Vorlage für Ihre Matrixtypen verwenden können, können Sie alle in diesem Abschnitt beschriebenen Slicing-Vorgä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 auf Arrays

Die Funktionen Array.exists und Array.exists2 Testelemente in einem oder zwei Arrays. Diese Funktionen verwenden eine Testfunktion und geben zurück true , wenn ein Element (oder Elementpaar für Array.exists2) vorhanden ist, das die Bedingung erfüllt.

Der folgende Code veranschaulicht die Verwendung von Array.exists und Array.exists2. In diesen Beispielen werden neue Funktionen erstellt, indem nur eines der Argumente angewendet wird, in diesen Fällen das Funktionsargument.

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 vorherigen Codes lautet wie folgt.

true
false
false
true

Ebenso testet die Funktion Array.forall ein Array, um festzustellen, ob jedes Element eine boolesche Bedingung erfüllt. Die Variation Array.forall2 bewirkt dasselbe, indem eine boolesche Funktion verwendet wird, die Elemente von zwei Arrays gleicher Länge umfasst. Der folgende Code veranschaulicht die Verwendung dieser Funktionen.

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 für diese Beispiele lautet wie folgt.

false
true
true
false

Sucharrays

Array.find verwendet eine boolesche Funktion und gibt das erste Element zurück, für das die Funktion zurückgegeben truewird, oder löst ein System.Collections.Generic.KeyNotFoundException , wenn kein Element gefunden wird, das die Bedingung erfüllt. Array.findIndex ist wie Array.find, mit der Ausnahme, dass sie den Index des Elements anstelle des Elements selbst zurückgibt.

Der folgende Code verwendet Array.find und Array.findIndex sucht eine Zahl, die sowohl ein perfektes Quadrat als auch ein perfekter Würfel 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 ist ähnlich Array.find, mit der Ausnahme, dass es sich bei dem Ergebnis um einen Optionstyp handelt, und es wird zurückgegeben None , wenn kein Element gefunden wird. Array.tryFind sollte nicht verwendet Array.find werden, wenn Sie nicht wissen, ob sich ein übereinstimmende Element im Array befindet. Ähnlich verhält es sich mit Array.findIndex der Ausnahme, Array.tryFindIndex dass der Optionstyp der Rückgabewert ist. Wenn kein Element gefunden wird, ist Nonedie Option .

Der folgende Code 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 diese Vorgehensweise, wenn Sie ein Element zusätzlich zur Suche 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.

Der folgende Code zeigt die Verwendung von Array.tryPick. In diesem Fall werden anstelle eines Lambda-Ausdrucks 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.

Durchführen von Berechnungen für Arrays

Die Array.average Funktion gibt den Mittelwert der einzelnen Elemente in einem Array zurück. Es ist auf Elementtypen beschränkt, die genaue Division durch eine ganze Zahl unterstützen, die Gleitkommatypen, aber keine integralen Typen enthält. Die Array.averageBy Funktion gibt den Mittelwert der Ergebnisse des Aufrufens einer Funktion für jedes Element zurück. Für ein Array von integralem Typ können Sie jedes Element in Array.averageBy einen Gleitkommatyp für die Berechnung konvertieren und die Funktion in einen Gleitkommatyp konvertieren.

Verwenden Array.max Oder Array.min um das maximale oder minimale Element abzurufen, wenn der Elementtyp es unterstützt. Array.maxBy Ebenso kann Array.minBy eine Funktion zuerst ausgeführt werden, z. B. eine Transformation in einen Typ, der den Vergleich unterstützt.

Array.sum fügt die Elemente eines Arrays hinzu und Array.sumBy ruft eine Funktion für jedes Element auf und fügt die Ergebnisse zusammen.

Um eine Funktion für jedes Element in einem Array auszuführen, ohne die Rückgabewerte zu speichern, verwenden Sie Array.iter. Verwenden Sie Array.iter2für eine Funktion mit zwei Arrays gleicher Länge . Wenn Sie auch ein Array der Ergebnisse der Funktion beibehalten müssen, verwenden Array.map oder Array.map2, die jeweils auf zwei Arrays ausgeführt wird.

Die Variationen Array.iteri und Array.iteri2 zulassen, dass der Index des Elements an der Berechnung beteiligt ist; das gleiche gilt für Array.mapi und Array.mapi2.

Die Funktionen Array.fold, Array.foldBack, , Array.reduce, Array.scanArray.reduceBackund Array.scanBack ausführen Algorithmen, die alle Elemente eines Arrays umfassen. Ebenso führen die Variationen Array.fold2 und Array.foldBack2 Berechnungen für zwei Arrays aus.

Diese Funktionen zum Ausführen von Berechnungen entsprechen den Funktionen desselben Namens 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. Der folgende Code 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 Array.blit einen Unterabschnitt eines Arrays in ein anderes Array kopieren.

Konvertieren in 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 Sie in diese anderen Sammlungstypen aus dem Arraytyp.

Sortieren von Arrays

Dient Array.sort zum Sortieren eines Arrays mithilfe der generischen Vergleichsfunktion. Dient Array.sortBy zum Angeben einer Funktion, die einen Wert generiert, der als Schlüssel bezeichnet wird, um mithilfe der generischen Vergleichsfunktion auf dem Schlüssel zu sortieren. Verwenden Sie Array.sortWith diese Funktion, wenn Sie eine benutzerdefinierte Vergleichsfunktion bereitstellen möchten. Array.sort, Array.sortByund Array.sortWith alle geben das sortierte Array als neues Array zurück. Die Variationen Array.sortInPlace, Array.sortInPlaceByund Array.sortInPlaceWith ändern sie das vorhandene Array, anstatt eine neue 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, außer dass sie mit Tupeln von drei Elementen oder Tupeln von drei Arrays arbeiten.

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, die auf Versionen von .NET Framework vor Version 4 abzielen, nicht verfügbar.

Siehe auch

  • Last updated on