Tömbök (F#)
A tömbök rögzített méretű, nulla alapú, azonos típusú, egymást követő adatelemekből álló mutable gyűjtemények.
Tömbök létrehozása
Tömböket többféleképpen is létrehozhat. Kis tömböt úgy hozhat létre, hogy pontosvesszővel tagolt és |] egymástól [| elválasztott egymást követő értékeket sorol fel, ahogyan az alábbi példákban is látható.
let array1 = [| 1; 2; 3 |]
Az egyes elemeket külön sorba is helyezheti, ebben az esetben a pontosvessző-elválasztó nem kötelező.
let array1 =
[|
1
2
3
|]
A tömbelemek típusa a használt literálokból származik, és konzisztensnek kell lennie.
// 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 |]
A következő kód hibát okoz, mert a 3.0 egy lebegőpontos, az 1 és a 2 pedig egész szám.
// Causes an error. The 3.0 (float) cannot be converted to integer implicitly.
// let array3 = [| 1; 2; 3.0 |]
Az alábbi kód hibát is okoz, mert 1,2 egy rekord, és 3 egész szám.
// Causes an error too. The 3 (integer) cannot be converted to tuple implicitly.
// let array4 = [| 1, 2; 3 |]
Tömbök létrehozásához szekvenciakifejezéseket is használhat. Az alábbi példa egy egész számból álló négyzettömböt hoz létre 1 és 10 között.
let array3 = [| for i in 1 .. 10 -> i * i |]
Ha olyan tömböt szeretne létrehozni, amelyben az összes elem nullára van inicializálva, használja a következőt Array.zeroCreate: .
let arrayOfTenZeroes : int array = Array.zeroCreate 10
Hozzáférési elemek
A tömbelemeket szögletes zárójelek ([ és ]) használatával érheti el. Az eredeti pontszintaxis (.[index]) továbbra is támogatott, de már nem ajánlott az F# 6.0-s verziójától.
array1[0]
A tömbindexek 0-nál kezdődnek.
A tömbelemeket a szelet jelölésével is elérheti, amely lehetővé teszi a tömb altartományának megadását. Példák a szeletek jelölésére.
// 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..]
Ha szelet jelölést használ, létrejön a tömb új példánya.
Tömbtípusok és modulok
Az összes F#-tömb típusa a .NET-keretrendszer típusSystem.Array. Ezért az F#-tömbök támogatják a rendelkezésre álló System.Arrayösszes funkciót.
A Array modul támogatja az egydimenziós tömbök műveleteit. A modulok Array2D, Array3Dés Array4D olyan függvényeket tartalmaznak, amelyek két, három, illetve négy dimenziós tömbök műveleteit támogatják. A négynél nagyobb rangot tartalmazó tömböket a használatával System.Arrayhozhatja létre.
Egyszerű függvények
Array.get elemet kap. Array.length a tömb hosszát adja meg. Array.set egy elemet egy megadott értékre állít be. Az alábbi kód példája a függvények használatát mutatja be.
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)
A kimenet a következő.
0 1 2 3 4 5 6 7 8 9
Tömböket létrehozó függvények
Számos függvény tömböket hoz létre meglévő tömb nélkül. Array.empty olyan új tömböt hoz létre, amely nem tartalmaz elemeket. Array.create egy megadott méretű tömböt hoz létre, és az összes elemet megadott értékekre állítja. Array.init egy tömböt hoz létre, amely egy dimenziót és egy függvényt ad az elemek létrehozásához. Array.zeroCreate létrehoz egy tömböt, amelyben az összes elem inicializálva lesz a tömb típusának nulla értékére. Az alábbi kód ezeket a függvényeket mutatja be.
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
A kimenet a következő.
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 létrehoz egy új tömböt, amely egy meglévő tömbből másolt elemeket tartalmaz. Vegye figyelembe, hogy a másolat egy sekély másolat, ami azt jelenti, hogy ha az elemtípus hivatkozástípus, akkor csak a hivatkozás lesz másolva, nem az alapul szolgáló objektum. Az alábbi példakód ezt szemlélteti.
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
Az előző kód kimenete a következő:
[|Test1; Test2; |]
[|; Test2; |]
A sztring Test1 csak az első tömbben jelenik meg, mert egy új elem létrehozásának művelete felülírja a hivatkozást firstArray , de nem befolyásolja az eredeti hivatkozást egy üres sztringre, amely továbbra is jelen van a fájlban secondArray. A sztring Test2 mindkét tömbben megjelenik, mert a System.Text.StringBuilderInsert típuson végzett művelet hatással van a mögöttes System.Text.StringBuilder objektumra, amelyre mindkét tömb hivatkozik.
Array.sub Új tömböt hoz létre egy tömb altartományából. Az alrangot a kezdő index és a hossz megadásával adhatja meg. Az alábbi kód bemutatja a .Array.sub
let a1 = [| 0 .. 99 |]
let a2 = Array.sub a1 5 10
printfn "%A" a2
A kimenet azt mutatja, hogy az alarraság az 5. elemnél kezdődik, és 10 elemet tartalmaz.
[|5; 6; 7; 8; 9; 10; 11; 12; 13; 14|]
Array.append létrehoz egy új tömböt két meglévő tömb kombinálásával.
Az alábbi kód a Array.append parancsot mutatja be.
printfn "%A" (Array.append [| 1; 2; 3|] [| 4; 5; 6|])
Az előző kód kimenete a következő.
[|1; 2; 3; 4; 5; 6|]
Array.choose egy tömb elemeit választja ki, hogy belefoglaljanak egy új tömbbe. Az alábbi kód bemutatja.Array.choose Vegye figyelembe, hogy a tömb elemtípusának nem kell megegyeznie a beállítástípusban visszaadott érték típusával. Ebben a példában az elem típusa, int a beállítás pedig egy polinomfüggvény eredménye, elem*elem - 1lebegőpontos számként.
printfn "%A" (Array.choose (fun elem -> if elem % 2 = 0 then
Some(float (elem*elem - 1))
else
None) [| 1 .. 10 |])
Az előző kód kimenete a következő.
[|3.0; 15.0; 35.0; 63.0; 99.0|]
Array.collect Egy meglévő tömb minden tömbelemén futtat egy adott függvényt, majd összegyűjti a függvény által létrehozott elemeket, és egyesíti őket egy új tömbbe. Az alábbi kód bemutatja.Array.collect
printfn "%A" (Array.collect (fun elem -> [| 0 .. elem |]) [| 1; 5; 10|])
Az előző kód kimenete a következő.
[|0; 1; 0; 1; 2; 3; 4; 5; 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10|]
Array.concat tömbsorozatot vesz fel, és egyetlen tömbbe egyesíti őket. Az alábbi kód bemutatja.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 logikai feltételfüggvényt vesz fel, és létrehoz egy új tömböt, amely csak azokat az elemeket tartalmazza a bemeneti tömbből, amelyeknél a feltétel igaz. Az alábbi kód bemutatja.Array.filter
printfn "%A" (Array.filter (fun elem -> elem % 2 = 0) [| 1 .. 10|])
Az előző kód kimenete a következő.
[|2; 4; 6; 8; 10|]
Array.rev új tömböt hoz létre egy meglévő tömb sorrendjének megfordításával. Az alábbi kód bemutatja.Array.rev
let stringReverse (s: string) =
System.String(Array.rev (s.ToCharArray()))
printfn "%A" (stringReverse("!dlrow olleH"))
Az előző kód kimenete a következő.
"Hello world!"
A tömbmodulban egyszerűen kombinálhatja a tömböket átalakító függvényeket a folyamatkezelő (|>) használatával, ahogyan az az alábbi példában is látható.
[| 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"
A kimenet a következő:
[|100; 36; 16; 4|]
Többdimenziós tömbök
Többdimenziós tömb is létrehozható, de a többdimenziós tömbkonstans írásához nincs szintaxis. Az operátor array2D használatával tömböt hozhat létre tömbelemek sorozatából. A szekvenciák lehetnek tömbök vagy listakonstansok. A következő kód például létrehoz egy kétdimenziós tömböt.
let my2DArray = array2D [ [ 1; 0]; [0; 1] ]
A függvény Array2D.init két dimenzióból álló tömbök inicializálására is használható, és hasonló függvények érhetők el három és négy dimenziós tömbökhöz. Ezek a függvények az elemek létrehozásához használt függvényt használják. Ha egy függvény megadása helyett egy kezdeti értékre beállított elemeket tartalmazó kétdimenziós tömböt szeretne létrehozni, használja a Array2D.create függvényt, amely akár négy dimenziós tömbökhöz is elérhető. Az alábbi példakód először bemutatja, hogyan hozhat létre tömböket a kívánt elemeket tartalmazó tömbökből, majd hogyan Array2D.init hozhatja létre a kívánt kétdimenziós tömböt.
let arrayOfArrays = [| [| 1.0; 0.0 |]; [|0.0; 1.0 |] |]
let twoDimensionalArray = Array2D.init 2 2 (fun i j -> arrayOfArrays[i][j])
A tömbindexelés és szeletelés szintaxisa a 4. rangig tartó tömbök esetében támogatott. Ha több dimenzióban ad meg indexet, vesszővel választja el az indexeket, ahogy az az alábbi kód példájában is látható.
twoDimensionalArray[0, 1] <- 1.0
A kétdimenziós tömb típusa ki van írva <type>[,] (például int[,]), double[,]és a háromdimenziós tömb típusa a következőképpen van megírva <type>[,,], és így tovább a magasabb dimenziójú tömbök esetében.
A többdimenziós tömbökhöz csak az egydimenziós tömbökhöz elérhető függvények egy részhalmaza érhető el.
Tömb szeletelése és többdimenziós tömbök
A kétdimenziós tömbökben (mátrixokban) kinyerhet egy almátrixot tartományok megadásával, valamint helyettesítő karakterrel* egész sorokat vagy oszlopokat adhat meg.
// 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]
A többdimenziós tömböket azonos vagy alacsonyabb dimenziós alarrá alakíthatja. Egy vektort például egyetlen sor vagy oszlop megadásával szerezhet be egy mátrixból.
// Get row 3 from a matrix as a vector:
matrix[3, *]
// Get column 3 from a matrix as a vector:
matrix[*, 3]
Ezt a szeletelő szintaxist az elemhozzáférési operátorokat és a túlterhelt GetSlice metódusokat implementáló típusok esetében használhatja. A következő kód például létrehoz egy mátrixtípust, amely az F# 2D tömböt burkolja, egy Item tulajdonságot implementál a tömbindexelés támogatásához, és a tömb három verzióját GetSliceimplementálja. Ha ezt a kódot sablonként használhatja a mátrixtípusokhoz, az ebben a szakaszban leírt összes szeletelési műveletet használhatja.
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}"
Logikai függvények tömbökön
Egy vagy két tömb függvényei Array.exists és Array.exists2 tesztelemei. Ezek a függvények egy tesztfüggvényt vesznek igénybe, és visszaadják true , ha van olyan elem (vagy elempár), amely megfelel a feltételnek Array.exists2.
Az alábbi kód bemutatja az és Array.exists2a Array.exists . Ezekben a példákban az új függvények úgy jönnek létre, hogy csak az egyik argumentumot alkalmazzák, ezekben az esetekben a függvényargumentumot.
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|])
Az előző kód kimenete a következő.
true
false
false
true
A függvény Array.forall hasonlóképpen tesztel egy tömböt annak megállapításához, hogy minden elem megfelel-e logikai feltételnek. A variáció Array.forall2 ugyanezt teszi egy logikai függvény használatával, amely két egyenlő hosszúságú tömb elemeit foglalja magában. Az alábbi kód ezeknek a függvényeknek a használatát mutatja be.
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 |])
A példák kimenete a következő.
false
true
true
false
Tömbök keresése
Array.find logikai függvényt vesz fel, és visszaadja az első elemet, amelyhez a függvény visszatér true, vagy ha System.Collections.Generic.KeyNotFoundException nem található olyan elem, amely megfelel a feltételnek. Array.findIndex hasonló Array.find, azzal a kivételrel, hogy az elem indexét adja vissza, nem magát az elemet.
Az alábbi kód egy olyan számot használ Array.find és Array.findIndex keres, amely tökéletes négyzet és tökéletes kocka.
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
A kimenet a következő.
The first element that is both a square and a cube is 64 and its index is 62.
Array.tryFind olyan, mint Array.find, azzal a kivétellel, hogy az eredménye egy beállítástípus, és akkor ad vissza None , ha nem található elem. Array.tryFind helyett akkor érdemes használni Array.find , ha nem tudja, hogy egyező elem szerepel-e a tömbben. Hasonlóképpen, ez is olyan, Array.tryFindIndex mint Array.findIndex azzal a kivételel, hogy a beállítás típusa a visszatérési érték. Ha nem található elem, a beállítás a következő None: .
Az alábbi kód bemutatja a .Array.tryFind Ez a kód az előző kódtól függ.
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 |]
A kimenet a következő.
Found an element: 1
Found an element: 729
Failed to find a matching element.
Akkor használható Array.tryPick , ha egy elemet a megtalálás mellett át kell alakítania. Az eredmény az első elem, amelynél a függvény az átalakított elemet adja vissza beállításértékként, vagy None ha nem található ilyen elem.
Az alábbi kód a következő kód használatát Array.tryPickmutatja be. Ebben az esetben a lambda kifejezés helyett több helyi segédfüggvény is definiálva van a kód egyszerűsítése érdekében.
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 |]
A kimenet a következő.
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.
Számítások végrehajtása tömbökön
A Array.average függvény egy tömb egyes elemeinek átlagát adja vissza. Csak olyan elemtípusokra korlátozódik, amelyek támogatják a pontos osztást egész számokkal, beleértve a lebegőpontos típusokat, de az integrál típusokat nem. A Array.averageBy függvény az egyes elemeken egy függvény meghívásának eredményeinek átlagát adja vissza. Az integrál típusú tömbökhöz használhatja Array.averageBy és használhatja, hogy a függvény minden elemet lebegőpontos típussá alakítsa a számításhoz.
Használja Array.max vagy Array.min kérje le a maximális vagy minimális elemet, ha az elem típusa támogatja. Hasonlóképpen, Array.maxBy és Array.minBy lehetővé teszi egy függvény végrehajtásának első végrehajtását, talán az összehasonlítást támogató típussá alakítható át.
Array.sum Hozzáadja egy tömb elemeit, és Array.sumBy meghív egy függvényt az egyes elemeken, és összeadja az eredményeket.
Ha függvényt szeretne végrehajtani egy tömb minden elemén a visszatérési értékek tárolása nélkül, használja a következőt Array.iter: . Két egyenlő hosszúságú tömböt tartalmazó függvényhez használja a következőt Array.iter2: . Ha a függvény eredményeinek tömböt is meg kell őriznie, használja Array.map vagy Array.map2, amely egyszerre két tömbön működik.
A variációk Array.iteri , és Array.iteri2 lehetővé teszik az elem indexének bevonását a számításba; ugyanez igaz Array.mapi az és Array.mapi2a .
A függvények Array.fold, Array.foldBack, Array.reduce, Array.reduceBack, Array.scan, , és Array.scanBack végrehajtják az algoritmusokat, amelyek egy tömb összes elemét magukban foglalják. Hasonlóképpen, a variációk Array.fold2 és Array.foldBack2 számítások végrehajtása két tömbön.
Ezek a számításokhoz használt függvények a Lista modul azonos nevű függvényeinek felelnek meg. Használati példákért lásd a Listák című témakört.
Tömbök módosítása
Array.set egy elemet egy megadott értékre állít be. Array.fill egy tömb elemeinek tartományát egy megadott értékre állítja. Az alábbi kód egy példát mutat be a következőkre Array.fill:
let arrayFill1 = [| 1 .. 25 |]
Array.fill arrayFill1 2 20 0
printfn "%A" arrayFill1
A kimenet a következő.
[|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|]
Az egyik tömb alszakaszát átmásolhatja Array.blit egy másik tömbbe.
Konvertálás más típusokra és más típusból
Array.ofList egy tömböt hoz létre egy listából. Array.ofSeq tömböt hoz létre egy sorozatból. Array.toList és Array.toSeq a tömbtípusból konvertálja ezeket a gyűjteménytípusokat ezekre a gyűjteménytípusokra.
Tömbök rendezése
Tömb Array.sort rendezése az általános összehasonlító függvény használatával. Egy olyan függvény megadására szolgálArray.sortBy, amely egy kulcsot generáló értéket hoz létre a kulcs általános összehasonlító függvényének használatával történő rendezéshez. Ha egyéni összehasonlító függvényt szeretne megadni, használja Array.sortWith . Array.sort, Array.sortByés Array.sortWith mindegyik új tömbként adja vissza a rendezett tömböt. A változatok Array.sortInPlace, Array.sortInPlaceByés Array.sortInPlaceWith módosítsa a meglévő tömb helyett egy újat.
Tömbök és csuplok
A függvények Array.zip és Array.unzip a tömbök tömbjei tömbökké alakítása tömbökké és fordítva. Array.zip3 és Array.unzip3 hasonlóak, azzal a kivétellel, hogy három elemből vagy három tömbből álló kukkával működnek.
Párhuzamos számítások tömbökön
A modul Array.Parallel függvényeket tartalmaz a párhuzamos számítások tömbökön való végrehajtásához. Ez a modul nem érhető el azokban az alkalmazásokban, amelyek a .NET-keretrendszer 4. verzió előtti verzióit célják.
Lásd még
Visszajelzés
Hamarosan elérhető: 2024-ben fokozatosan kivezetjük a GitHub-problémákat a tartalom visszajelzési mechanizmusaként, és lecseréljük egy új visszajelzési rendszerre. További információ: https://aka.ms/ContentUserFeedback.
Visszajelzés küldése és megtekintése a következőhöz: