数组是固定大小的，基于零的，可变的所有相同类型的连续数据元素的集合。

创建数组

可以创建使用各种语法和方法阵列或通过使用从阵列模块的功能。在本节中，我们将讨论在不使用模块的功能创建数组。

有三种语法方法来创建没有函数的数组 

1、通过列出[| 和|]，并用分号分隔。
2、通过将每个元素放在单独的行上，在这种情况下，分号分隔符是可选的。
3、通过使用序列表达式。
您可以使用点运算符（。）和方括号（[and]）访问数组元素。
以下示例演示创建数组 

//using semicolon separator
let array1 = [| 1; 2; 3; 4; 5; 6 |]
for i in 0 .. array1.Length - 1 do
   printf "%d " array1.[i]
printfn" "

// without semicolon separator
let array2 =
   [|
      1
      2
      3
      4
      5
   |]
for i in 0 .. array2.Length - 1 do
   printf "%d " array2.[i]
printfn" "

//using sequence
let array3 = [| for i in 1 .. 10 -> i * i |]
for i in 0 .. array3.Length - 1 do
   printf "%d " array3.[i]
printfn" "

当你编译和执行程序，它产生以下输出 

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

对数组基本操作

库模块Microsoft.FSharp.Collections.Array支持对一维数组的操作。
下表显示了数组的基本操作 

值	描述
append : 'T [] → 'T [] → 'T []	创建包含后跟另一个阵列的元件中的一个数组的元素的数组。
average : ^T [] → ^T	返回的数组的元素的平均值。
averageBy : ('T → ^U) → 'T [] → ^U	返回通过施加一个函数的阵列的每个元件产生的元素的平均。
blit : 'T [] → int → 'T [] → int → int → unit	读取范围从一个数组中的元素，并将其写入到另一个。
choose : ('T → U option) → 'T [] → 'U []	一个应用提供的函数对数组中的每个元素。返回包含每个元素的结果x上的数组，该函数返回一些（X）。
collect : ('T → 'U []) → T [] → 'U []	应用提供的函数，一个阵列的每个元素，并置的结果，并返回合并数组。
concat : seq<'T []> → 'T []	创建一个包含每个阵列提供的序列中的元素的数组。
copy : 'T → 'T []	创建一个包含所提供数组的元素的数组。
create : int → 'T → 'T []	创建一个数组，其元素都是最初所提供的值。
empty : 'T []	返回给定类型的空数组。
exists : ('T → bool) → 'T [] → bool	测试数组中的任何元素是否满足所提供的谓语。
exists2 : ('T1 → 'T2 → bool) → 'T1 [] → 'T2 [] → bool	测试是否有对两个数组的相应元素的满足提供的条件。
fill : 'T [] → int → int → 'T → unit	填补了一系列与所提供的数值数组的元素。
filter : ('T → bool) → 'T [] → 'T []	返回只包含所提供的数组，所提供的条件返回true的元素的集合。
find : ('T → bool) → 'T [] → 'T	返回为其提供的函数返回true的第一个元素。引发KeyNotFoundException如果没有这样的元素存在。
findIndex : ('T → bool) → 'T [] → int	返回满足提供的条件数组的第一个元素的索引。引发KeyNotFoundException如果没有一个元素的满足该条件。
fold : ('State → 'T → 'State) → 'State → 'T [] → 'State	将函数应用于数组中的每个元素，穿线通过计算累加器的说法。如果输入函数为f，所述阵列元件是I0 ...中，此函数计算F（...（FS I0）...）中。
fold2 : ('State → 'T1 → 'T2 → 'State) → 'State → 'T1 [] → 'T2 [] → 'State	适用于对从两个提供的数组中的元素，左到右，穿线通过计算累加器参数的函数。两个输入数组必须具有相同的长度;否则，ArgumentException的上升。
foldBack : ('T → 'State → 'State) → 'T [] → 'State → 'State	将函数应用于数组中的每个元素，穿线通过计算累加器的说法。如果输入函数为f，所述阵列元件是I0 ...中，此函数计算˚FI0（...（F s中））。
foldBack2 : ('T1 → 'T2 → 'State → 'State) → 'T1 [] → 'T2 [] → 'State → 'State	将函数应用于对从两个提供的数组中的元素，从右到左，穿线通过计算累加器的说法。两个输入数组必须具有相同的长度;否则，ArgumentException的上升。
forall : ('T → bool) → 'T [] → bool	测试数组中的所有元素是否满足提供的条件。
forall2 : ('T1 → 'T2 → bool) → 'T1 [] → 'T2 [] → bool	测试是否提供的两个阵列的所有相应的元素满足提供的条件。
get : 'T [] → int → 'T	会从数组中的元素。
init : int → (int → 'T) → 'T []	使用提供的函数来创建提供维数组。
isEmpty : 'T [] → bool	测试一个数组是否有任何元素。
iter : ('T → unit) → 'T [] → unit	应用提供的函数，一个数组中的每个元素。
iter2 : ('T1 → 'T2 → unit) → 'T1 [] → 'T2 [] → unit)	应用提供的函数，一对从两个数组索引匹配的元素。两个阵列必须具有相同的长度;否则，ArgumentException的上升。
iteri : (int → 'T → unit) → 'T [] → unit	应用提供的函数，一个数组中的每个元素。传递给函数的整数表示该元素的索引。
iteri2 : (int → 'T1 → 'T2 → unit) → 'T1 [] → 'T2 [] → unit	应用提供的函数，一对从两个阵列的匹配的索引，也传递元件的索引元素。两个阵列必须具有相同的长度;否则，一个ArgumentException升高。
length : 'T [] → int	返回的数组的长度。 Length属性做同样的事情。
map : ('T → 'U) → 'T [] → 'U []	创建一个数组，其元素施加提供的函数，每一个提供的数组的元素的结果。
map2 : ('T1 → 'T2 → 'U) → 'T1 [] → 'T2 [] → 'U []	创建一个数组，其元素是应用提供的函数，提供的两个数组的相应元素的结果。两个输入数组必须具有相同的长度;否则，ArgumentException的上升。
mapi : (int → 'T → 'U) → 'T [] → 'U []	创建一个数组，其元素施加提供的函数，每一个提供的数组的元素的结果。传递给函数的整数索引指示正在转变的元素的索引。
mapi2 : (int → 'T1 → 'T2 → 'U) → 'T1 [] → 'T2 [] → 'U []	创建一个数组，其元素施加提供的函数，所述两个集合成对的相应的元件，也传递元件的索引的结果。两个输入数组必须具有相同的长度;否则，ArgumentException的上升。
max : 'T [] → 'T	返回最大的数组中的所有元素。 Operators.max用于元素进行比较。
maxBy : ('T → 'U) → 'T [] → 'T	返回最大的数组的所有元素，通过Operators.max上的功能结果相比较。
min : ('T [] → 'T	返回最小的一个数组的所有元素。 Operators.min用于元素进行比较。
minBy：（'T→'U）→“T []→'T	返回最小的一个数组的所有元素。 Operators.min用于元素进行比较。
ofList : 'T list → 'T []	创建一个从所提供的列表中的数组。
ofSeq : seq<'T> → 'T []	创建一个从所提供的枚举对象的数组。
partition : ('T → bool) → 'T [] → 'T [] * 'T []	分割的阵列分成两个阵列，一个包含的量，提供的条件返回true的元素，和其他含有这些对于其返回false。
permute : (int → int) → 'T [] → 'T []	根据指定的置换Permutes数组的元素。
pick : ('T → 'U option) → 'T [] → 'U	应用提供的函数，所提供的数组的连续元素，返回的第一个结果所在的函数返回一些（十）有些X的。如果函数永远不会返回部分（X），KeyNotFoundException升高。
reduce : ('T → 'T → 'T) → 'T [] → 'T	将函数应用于数组中的每个元素，穿线通过计算累加器的说法。如果输入函数为f，所述阵列元件是I0 ...中，此函数计算F（...（六I0的i1）...）中。如果数组的大小为零，ArgumentException的升高。
reduceBack：（'T→'T→'T）→“T []→'T	将函数应用于数组中的每个元素，穿线通过计算累加器的说法。如果输入函数是f和元素I0 ...中，此函数计算˚FI0（...（F IN-1））。如果数组的大小为零，ArgumentException的升高。
rev : 'T [] → 'T []	反转在供给数组中的元素的顺序。
scan : ('State → 'T → 'State) → 'State → 'T [] → 'State [])	行为就像折，但是中间结果与最终结果一起返回。
scanBack : ('T → 'State → 'State) → 'T [] → 'State → 'State []	行为就像折返，但中介结果与最终结果一起返回。
set : 'T [] → int → 'T → unit	设置一个数组中的一个元素。
sort : 'T[] → 'T []	排序的数组中的元素，并返回一个新的数组。 Operators.compare用于元素进行比较。
sortBy : ('T → 'Key) → 'T [] → 'T []	使用附带的功能改造元素上排序操作所基于的类型排序的数组的元素，并返回一个新的数组。 Operators.compare用于元素进行比较。
sortInPlace : 'T [] → unit	通过改变到位阵列，使用提供的比较函数排序数组的元素。 Operators.compare用于元素进行比较。
sortInPlaceBy : ('T → 'Key) → 'T [] → unit	通过改变到位阵列，使用为键所提供的投影排序数组的元素。 Operators.compare用于元素进行比较。
sortInPlaceWith : ('T → 'T → int) → 'T [] → unit	使用附带的比较功能改变的地方数组排序数组的元素。
sortWith : ('T → 'T → int) → 'T [] → 'T []	使用附带的比较函数排序数组的元素，并返回一个新的数组。
sub : 'T [] → int → int → 'T []	创建包含所提供的子范围，它是由开始索引和长度指定的数组。
sum : 'T [] → ^T	返回数组中的元素的总和。
sumBy : ('T → ^U) → 'T [] → ^U	返回通过施加一个函数的阵列的每个元件产生的结果的总和。
toList : 'T [] → 'T list	所提供的数组列表转换。
toSeq : 'T [] → seq<'T>	享有提供的数组作为序列。
tryFind : ('T → bool) → 'T [] → 'T option	返回提供的数组为其提供的函数返回true的第一个元素。如果没有这样的元素存在，则返回无 。
tryFindIndex : ('T → bool) → 'T [] → int option	返回满足提供的条件数组的第一个元素的索引。
tryPick : ('T → 'U option) → 'T [] → 'U option	应用提供的函数，所提供的阵列的相继的元素，并返回第一个结果，其中函数返回部分（x）的一些X]。如果函数永远不会返回部分（X），返回None。
unzip : ('T1 * 'T2) [] → 'T1 [] * 'T2 []	拆分元组对的数组分成两个数组的元组。
unzip3：（'T1 *'T2 *'T3）[]→“T1 [] *'T2 [] *'T3 []	分裂三种元素的元组的阵列成三个阵列中的元组。
zeroCreate：INT→'T []	创建一个数组，其元素最初设置为Unchecked.defaultof <'T>的默认值。
zip : 'T1 [] → 'T2 [] → ('T1 * 'T2) []	结合两个阵列成具有两个元素的元组的阵列。两个数组必须有相等的长度;否则，ArgumentException的上升。
zip3：“T1 []→'T2 []→”T3 []→（'T1 *'T2 * 113'T3）[]	结合三个数组成有三个元素的元组的数组。三个数组必须有相等的长度;否则，ArgumentException的上升。

在以下部分中，我们将看到的一些这些功能的用途。

创建阵列使用函数

阵列模块提供了从头开始创建一个数组多种功能。

• 该Array.empty函数创建一个新的空数组。

• 该Array.create函数创建一个指定大小的数组，并将所有元素给定的值。

• 所述Array.init函数给出的尺寸和产生的元素的函数创建一个数组。

• 所述Array.zeroCreate函数创建在其中所有元素初始化为零值的数组。

• 该Array.copy函数创建一个包含从现有阵列复制元素的数组。

• 该Array.sub函数生成从阵列中的一个子范围的新数组。

• 该Array.append函数创建通过合并两个现有阵列的新数组。

• 该Array.choose功能选择一个数组元素在新数组中包含。

• 该Array.collect功能运行的现有阵列的每个数组元素的指定函数，然后收集该函数生成的元素，并将它们组合成一个新的数组。

• 该Array.concat函数接受阵列的序列，并将它们组合成一个阵列。

• 该Array.filter函数接受一个布尔条件的功能，并只包含从输入数组，它的条件是真的这些元素的数组。

• 该Array.rev函数通过颠倒现有数组的顺序的新数组。

下面的例子演示这些功能 

例1

(* using create and set *)
let array1 = Array.create 10 ""
for i in 0 .. array1.Length - 1 do
   Array.set array1 i (i.ToString())
for i in 0 .. array1.Length - 1 do
   printf "%s " (Array.get array1 i)
printfn " "

(* empty array *)
let array2 = Array.empty
printfn "Length of empty array: %d" array2.Length

let array3 = Array.create 10 7.0
printfn "Float Array: %A" array3

(* using the init and zeroCreate *)
let array4 = Array.init 10 (fun index -> index * index)
printfn "Array of squares: %A" array4

let array5 : float array = Array.zeroCreate 10
let (myZeroArray : float array) = Array.zeroCreate 10
printfn "Float Array: %A" array5

当你编译和执行程序，它产生以下输出 

0 1 2 3 4 5 6 7 8 9
Length of empty array: 0
Float Array: [|7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0|]
Array of squares: [|0; 1; 4; 9; 16; 25; 36; 49; 64; 81|]
Float Array: [|0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0|]

例2

(* creating subarray from element 5 *)
(* containing 15 elements thereon *)

let array1 = [| 0 .. 50 |]
let array2 = Array.sub array1 5 15
printfn "Sub Array:"
printfn "%A" array2

(* appending two arrays *)
let array3 = [| 1; 2; 3; 4|]
let array4 = [| 5 .. 9 |]
printfn "Appended Array:"
let array5 = Array.append array3 array4
printfn "%A" array5

(* using the Choose function *)
let array6 = [| 1 .. 20 |]
let array7 = Array.choose (fun elem -> if elem % 3 = 0 then
                                             Some(float (elem))
                                          else
                                             None) array6
printfn "Array with Chosen elements:"
printfn "%A" array7

(*using the Collect function *)
let array8 = [| 2 .. 5 |]
let array9 = Array.collect (fun elem -> [| 0 .. elem - 1 |]) array8
printfn "Array with collected elements:"
printfn "%A" array9

当你编译和执行程序，它产生以下输出 

Sub Array:
[|5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15; 16; 17; 18; 19|]
Appended Array:
[|1; 2; 3; 4; 5; 6; 7; 8; 9|]
Array with Chosen elements:
[|3.0; 6.0; 9.0; 12.0; 15.0; 18.0|]
Array with collected elements:
[|0; 1; 0; 1; 2; 0; 1; 2; 3; 0; 1; 2; 3; 4|]

搜索数组

该Array.find函数接受一个布尔函数，并返回该函数返回true的第一个元素，否则会引发KeyNotFoundException。

所述Array.findIndex功能工作，除了它返回元素的索引，而不是元素本身类似。

下面的例子说明了这一点。

Microsoft提供这个有趣的程序例子，它找到的第一个元件在给定的数，它是两个完全平方以及完美立方体的范围 

let array1 = [| 2 .. 100 |]
let delta = 1.0e-10
let isPerfectSquare (x:int) =
   let y = sqrt (float x)
   abs(y - round y) < delta

let isPerfectCube (x:int) =
   let y = System.Math.Pow(float x, 1.0/3.0)
   abs(y - round y) < delta

let element = Array.find (fun elem -> isPerfectSquare elem && isPerfectCube elem) array1

let index = Array.findIndex (fun elem -> isPerfectSquare elem && isPerfectCube elem) array1

printfn "The first element that is both a square and a cube is %d and its index is %d." element index

当你编译和执行程序，它产生以下输出 

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