Tablice (F#)

Tablice są stałym rozmiarem, na podstawie zera, modyfikowalnymi kolekcjami kolejnych elementów danych, które są tego samego typu.

Tworzenie tablic

Tablice można tworzyć na kilka sposobów. Można utworzyć małą tablicę, wyświetlając kolejne wartości między [| i |] rozdzielone średnikami, jak pokazano w poniższych przykładach.

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

Można również umieścić każdy element w osobnym wierszu, w którym przypadku separator średnika jest opcjonalny.

let array1 =
    [|
        1
        2
        3
     |]

Typ elementów tablicy jest wnioskowany z używanych literałów i musi być spójny.

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

Poniższy kod powoduje błąd, ponieważ 3.0 jest zmiennoprzecinkowym i 1 i 2 są liczbami całkowitymi.

// Causes an error. The 3.0 (float) cannot be converted to integer implicitly.
// let array3 = [| 1; 2; 3.0 |]

Poniższy kod powoduje też błąd, ponieważ 1,2 jest krotką i 3 jest liczbą całkowitą.

// Causes an error too. The 3 (integer) cannot be converted to tuple implicitly.
// let array4 = [| 1, 2; 3 |]

Do tworzenia tablic można również użyć wyrażeń sekwencji. Poniżej przedstawiono przykład, który tworzy tablicę kwadratów liczb całkowitych z zakresu od 1 do 10.

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

Aby utworzyć tablicę, w której wszystkie elementy są inicjowane do zera, użyj polecenia Array.zeroCreate.

let arrayOfTenZeroes : int array = Array.zeroCreate 10

Elementy dostępu

Dostęp do elementów tablicy można uzyskać przy użyciu nawiasów kwadratowych ([ i ]). Oryginalna składnia kropki (.[index]) jest nadal obsługiwana, ale nie jest już zalecana w wersji F# 6.0.

array1[0]

Indeksy tablic zaczynają się od 0.

Dostęp do elementów tablicy można również uzyskać przy użyciu notacji wycinków, co umożliwia określenie podgrupy tablicy. Poniżej przedstawiono przykłady notacji wycinków.

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

Gdy jest używana notacja wycinka, zostanie utworzona nowa kopia tablicy.

Typy tablic i moduły

Typ wszystkich tablic języka F# to typ System.Arrayprogramu .NET Framework. W związku z tym tablice języka F# obsługują wszystkie funkcje dostępne w programie System.Array.

Moduł Array obsługuje operacje na tablicach jednowymiarowych. Moduły Array2D, Array3Di Array4D zawierają funkcje, które obsługują operacje na tablicach dwóch, trzech i czterech wymiarów, odpowiednio. Tablice rangi większej niż cztery można utworzyć przy użyciu polecenia System.Array.

Proste funkcje

Array.get pobiera element. Array.length daje długość tablicy. Array.set ustawia element na określoną wartość. Poniższy przykład kodu ilustruje użycie tych funkcji.

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)

Dane wyjściowe są następujące:

0 1 2 3 4 5 6 7 8 9

Funkcje tworzące tablice

Kilka funkcji tworzy tablice bez konieczności posiadania istniejącej tablicy. Array.empty tworzy nową tablicę, która nie zawiera żadnych elementów. Array.create Tworzy tablicę o określonym rozmiarze i ustawia wszystkie elementy na podane wartości. Array.init tworzy tablicę, mając wymiar i funkcję do generowania elementów. Array.zeroCreate Tworzy tablicę, w której wszystkie elementy są inicjowane do wartości zerowej dla typu tablicy. Poniższy kod demonstruje te funkcje.

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

Dane wyjściowe są następujące:

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 Tworzy nową tablicę zawierającą elementy skopiowane z istniejącej tablicy. Należy pamiętać, że kopia jest płytkią kopią, co oznacza, że jeśli typ elementu jest typem referencyjnym, tylko odwołanie jest kopiowane, a nie obiekt źródłowy. Pokazano to w poniższym przykładzie kodu.

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

Dane wyjściowe powyższego kodu są następujące:

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

Ciąg Test1 pojawia się tylko w pierwszej tablicy, ponieważ operacja tworzenia nowego elementu zastępuje odwołanie w firstArray pliku , ale nie ma wpływu na oryginalne odwołanie do pustego ciągu, który jest nadal obecny w secondArrayelemencie . Ciąg Test2 jest wyświetlany w obu tablicach, ponieważ Insert operacja na System.Text.StringBuilder typie wpływa na obiekt bazowy System.Text.StringBuilder , do którego odwołuje się oba tablice.

Array.sub generuje nową tablicę z podgrupy tablicy. Należy określić podwoje, podając indeks początkowy i długość. Poniższy kod demonstruje użycie metody Array.sub.

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

Dane wyjściowe pokazują, że podarray zaczyna się od elementu 5 i zawiera 10 elementów.

[|5; 6; 7; 8; 9; 10; 11; 12; 13; 14|]

Array.append tworzy nową tablicę, łącząc dwie istniejące tablice.

Poniższy kod demonstruje array.append.

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

Dane wyjściowe powyższego kodu są następujące.

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

Array.choose wybiera elementy tablicy do uwzględnienia w nowej tablicy. Poniższy kod demonstruje Array.chooseelement . Należy pamiętać, że typ elementu tablicy nie musi być zgodny z typem wartości zwracanej w typie opcji. W tym przykładzie typ elementu to int i opcja jest wynikiem funkcji wielomianowej , elem*elem - 1jako liczby zmiennoprzecinkowej.

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

Dane wyjściowe powyższego kodu są następujące.

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

Array.collect uruchamia określoną funkcję w każdym elemecie tablicy istniejącej tablicy, a następnie zbiera elementy wygenerowane przez funkcję i łączy je w nową tablicę. Poniższy kod demonstruje Array.collectelement .

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

Dane wyjściowe powyższego kodu są następujące.

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

Array.concat pobiera sekwencję tablic i łączy je w jedną tablicę. Poniższy kod demonstruje Array.concatelement .

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

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

Array.filter pobiera funkcję warunku warunkowego i generuje nową tablicę zawierającą tylko te elementy z tablicy wejściowej, dla której warunek jest spełniony. Poniższy kod demonstruje Array.filterelement .

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

Dane wyjściowe powyższego kodu są następujące.

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

Array.rev generuje nową tablicę, odwracając kolejność istniejącej tablicy. Poniższy kod demonstruje Array.revelement .

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

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

Dane wyjściowe powyższego kodu są następujące.

"Hello world!"

Funkcje można łatwo połączyć w module tablicy, który przekształca tablice przy użyciu operatora potoku (|>), jak pokazano w poniższym przykładzie.

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

Dane wyjściowe to

[|100; 36; 16; 4|]

Tablice wielowymiarowe

Można utworzyć tablicę wielowymiarową, ale nie ma składni do pisania literału tablicy wielowymiarowej. Użyj operatora array2D , aby utworzyć tablicę na podstawie sekwencji sekwencji elementów tablicy. Sekwencje mogą być literałami tablicy lub listy. Na przykład poniższy kod tworzy tablicę dwuwymiarową.

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

Za pomocą funkcji Array2D.init można również zainicjować tablice dwóch wymiarów, a podobne funkcje są dostępne dla tablic z trzema i czterema wymiarami. Te funkcje przyjmują funkcję używaną do tworzenia elementów. Aby utworzyć tablicę dwuwymiarową zawierającą elementy ustawione na wartość początkową zamiast określania funkcji, użyj Array2D.create funkcji, która jest również dostępna dla tablic do czterech wymiarów. Poniższy przykład kodu najpierw pokazuje, jak utworzyć tablicę tablic zawierających żądane elementy, a następnie użyć Array2D.init metody do wygenerowania żądanej tablicy dwuwymiarowej.

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

Składnia indeksowania tablic i fragmentowania jest obsługiwana w przypadku tablic do 4. Po określeniu indeksu w wielu wymiarach należy użyć przecinków, aby oddzielić indeksy, jak pokazano w poniższym przykładzie kodu.

twoDimensionalArray[0, 1] <- 1.0

Typ tablicy dwuwymiarowej jest zapisywany jako <type>[,] (na przykład int[,], double[,]), a typ tablicy trójwymiarowej jest zapisywany jako <type>[,,], itd. dla tablic wyższych wymiarów.

Tylko podzbiór funkcji dostępnych dla tablic jednowymiarowych jest również dostępny dla tablic wielowymiarowych.

Fragmentowanie tablic i tablice wielowymiarowe

W tablicy dwuwymiarowej (macierzy) można wyodrębnić macierz podrzędną, określając zakresy i używając symbolu wieloznakowego (*) w celu określenia całych wierszy lub kolumn.

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

Tablicę wielowymiarową można rozkładać na podarray tego samego lub niższego wymiaru. Można na przykład uzyskać wektor z macierzy, określając pojedynczy wiersz lub kolumnę.

// Get row 3 from a matrix as a vector:
matrix[3, *]

// Get column 3 from a matrix as a vector:
matrix[*, 3]

Można użyć tej składni fragmentowania dla typów, które implementują operatory dostępu elementów i przeciążone GetSlice metody. Na przykład poniższy kod tworzy typ macierzy, który opakowuje tablicę F# 2D, implementuje właściwość Item w celu zapewnienia obsługi indeksowania tablicy i implementuje trzy wersje GetSliceklasy . Jeśli możesz użyć tego kodu jako szablonu dla typów macierzy, możesz użyć wszystkich operacji fragmentowania opisanych w tej sekcji.

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

Funkcje logiczne w tablicach

Funkcje Array.exists i Array.exists2 elementy testowe odpowiednio w jednej lub dwóch tablicach. Te funkcje przyjmują funkcję testową i zwracają true , jeśli istnieje element (lub para elementów dla Array.exists2), który spełnia warunek.

Poniższy kod demonstruje użycie elementów Array.exists i Array.exists2. W tych przykładach nowe funkcje są tworzone przez zastosowanie tylko jednego z argumentów, w takich przypadkach argumentu funkcji.

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

Dane wyjściowe powyższego kodu są następujące.

true
false
false
true

Podobnie funkcja Array.forall testuje tablicę, aby określić, czy każdy element spełnia warunek logiczny. Odmiana Array.forall2 wykonuje to samo, używając funkcji logicznej, która obejmuje elementy dwóch tablic o równej długości. Poniższy kod ilustruje użycie tych funkcji.

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

Dane wyjściowe dla tych przykładów są następujące.

false
true
true
false

Tablice wyszukiwania

Array.find przyjmuje funkcję logiczną i zwraca pierwszy element, dla którego funkcja zwraca truewartość , lub zgłasza System.Collections.Generic.KeyNotFoundException element, jeśli nie zostanie znaleziony żaden element spełniający warunek. Array.findIndex jest jak Array.find, z tą różnicą, że zwraca indeks elementu zamiast samego elementu.

Poniższy kod używa Array.find metody i Array.findIndex do lokalizowania liczby, która jest zarówno idealnym kwadratem, jak i idealnym modułem.

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

Dane wyjściowe są następujące:

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

Array.tryFind jest jak Array.find, z wyjątkiem tego, że jego wynik jest typem opcji i zwraca None , jeśli nie znaleziono żadnego elementu. Array.tryFind należy użyć zamiast Array.find wtedy, gdy nie wiadomo, czy pasujący element znajduje się w tablicy. Podobnie jest jak Array.findIndex w przypadkuArray.tryFindIndex, gdy typ opcji jest zwracaną wartością. Jeśli element nie zostanie znaleziony, opcja to None.

Poniższy kod demonstruje użycie metody Array.tryFind. Ten kod zależy od poprzedniego kodu.

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

Dane wyjściowe są następujące:

Found an element: 1
Found an element: 729
Failed to find a matching element.

Użyj Array.tryPick polecenia , gdy musisz przekształcić element oprócz jego znajdowania. Wynik jest pierwszym elementem, dla którego funkcja zwraca przekształcony element jako wartość opcji lub None jeśli taki element nie zostanie znaleziony.

Poniższy kod przedstawia użycie polecenia Array.tryPick. W tym przypadku zamiast wyrażenia lambda zdefiniowano kilka lokalnych funkcji pomocnika w celu uproszczenia kodu.

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

Dane wyjściowe są następujące:

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.

Wykonywanie obliczeń na tablicach

Funkcja Array.average zwraca średnią każdego elementu w tablicy. Jest on ograniczony do typów elementów, które obsługują dokładne dzielenie według liczby całkowitej, która obejmuje typy zmiennoprzecinkowe, ale nie typy całkowite. Funkcja Array.averageBy zwraca średnią wyników wywoływania funkcji dla każdego elementu. W przypadku tablicy typu całkowitego można użyć funkcji Array.averageBy i przekonwertować każdy element na typ zmiennoprzecinkowy dla obliczeń.

Użyj Array.max polecenia lub Array.min , aby uzyskać maksymalny lub minimalny element, jeśli typ elementu go obsługuje. Podobnie i Array.minBy zezwól na Array.maxBy wykonanie funkcji jako pierwszej, być może w celu przekształcenia na typ obsługujący porównanie.

Array.sum dodaje elementy tablicy i Array.sumBy wywołuje funkcję dla każdego elementu i dodaje wyniki razem.

Aby wykonać funkcję dla każdego elementu w tablicy bez przechowywania zwracanych wartości, użyj polecenia Array.iter. W przypadku funkcji obejmującej dwie tablice o równej długości użyj polecenia Array.iter2. Jeśli musisz również zachować tablicę wyników funkcji, użyj funkcji Array.map lub Array.map2, która działa na dwóch tablicach jednocześnie.

Odmiany Array.iteri i Array.iteri2 umożliwiają udział indeksu elementu w obliczeniach. Dotyczy to również wartości Array.mapi i Array.mapi2.

Funkcje Array.fold, , Array.foldBack, Array.reduceArray.reduceBack, Array.scani Array.scanBack wykonują algorytmy, które obejmują wszystkie elementy tablicy. Podobnie odmiany Array.fold2 i Array.foldBack2 wykonują obliczenia na dwóch tablicach.

Te funkcje do wykonywania obliczeń odpowiadają funkcjom tej samej nazwy w module List. Aby zapoznać się z przykładami użycia, zobacz Listy.

Modyfikowanie tablic

Array.set ustawia element na określoną wartość. Array.fill ustawia zakres elementów w tablicy na określoną wartość. Poniższy kod zawiera przykład .Array.fill

let arrayFill1 = [| 1 .. 25 |]
Array.fill arrayFill1 2 20 0
printfn "%A" arrayFill1

Dane wyjściowe są następujące:

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

Możesz użyć Array.blit polecenia , aby skopiować podsekcję jednej tablicy do innej tablicy.

Konwertowanie na i z innych typów

Array.ofList tworzy tablicę na podstawie listy. Array.ofSeq tworzy tablicę na podstawie sekwencji. Array.toList i Array.toSeq przekonwertuj na te inne typy kolekcji z typu tablicy.

Sortowanie tablic

Służy Array.sort do sortowania tablicy przy użyciu funkcji porównania ogólnego. Użyj Array.sortBy polecenia , aby określić funkcję, która generuje wartość, nazywaną kluczem, do sortowania przy użyciu funkcji porównania ogólnego w kluczu. Użyj Array.sortWith polecenia , jeśli chcesz podać niestandardową funkcję porównania. Array.sort, Array.sortByi Array.sortWith wszystkie zwracają posortowaną tablicę jako nową tablicę. Odmiany Array.sortInPlace, Array.sortInPlaceByi Array.sortInPlaceWith modyfikują istniejącą tablicę zamiast zwracać nową.

Tablice i krotki

Funkcje Array.zip i Array.unzip konwertują tablice par krotki na krotki tablic i na odwrót. Array.zip3 i Array.unzip3 są podobne, z tą różnicą, że działają z krotkami trzech elementów lub krotkami trzech tablic.

Obliczenia równoległe w tablicach

Array.Parallel Moduł zawiera funkcje do wykonywania równoległych obliczeń na tablicach. Ten moduł nie jest dostępny w aplikacjach przeznaczonych dla wersji docelowej programu .NET Framework przed wersją 4.

Zobacz też

• Dokumentacja języka F#
• Typy F#