F# - 列表

---

---

在 F# 中，列表是一個有序的、不可變的相同型別元素序列。在某種程度上，它等價於連結串列資料結構。

F# 模組 Microsoft.FSharp.Collections.List 包含了列表的常用操作。但是，F# 自動匯入此模組並使其可用於每個 F# 應用程式。

建立和初始化列表

以下是建立列表的各種方法：

• 使用列表**字面量**。

• 使用**cons** (::) 運算子。

• 使用 List 模組的**List.init** 方法。

• 使用一些稱為**列表推導式**的**語法結構**。

列表字面量

在這種方法中，您只需在方括號中指定一個用分號分隔的值序列。例如：

let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]

cons (::) 運算子

使用此方法，您可以透過使用 :: 運算子將某些值新增到現有列表的開頭或**cons** 到現有列表中。例如：

let list2 = 1::2::3::4::5::6::7::8::9::10::[];;

[] 表示空列表。

List init 方法

List 模組的 List.init 方法通常用於建立列表。此方法具有以下型別：

val init : int -> (int -> 'T) -> 'T list

第一個引數是新列表所需的長度，第二個引數是初始化函式，用於生成列表中的項。

例如，

let list5 = List.init 5 (fun index -> (index, index * index, index * index * index))

在這裡，索引函式生成列表。

列表推導式

列表推導式是用於生成列表的特殊語法結構。

F# 列表推導式語法有兩種形式：範圍和生成器。

範圍具有以下結構：[start .. end] 和 [start .. step .. end]

例如，

let list3 = [1 .. 10]

生成器具有以下結構：[for x in collection do ... yield expr]

例如，

let list6 = [ for a in 1 .. 10 do yield (a * a) ]

由於**yield** 關鍵字將單個值推送到列表中，因此**yield!** 關鍵字將值的集合推送到列表中。

以下函式演示了上述方法：

示例

(* using list literals *)
let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "The list: %A" list1

(*using cons operator *)
let list2 = 1 :: 2 :: 3 :: []
printfn "The list: %A" list2

(* using range constructs*)
let list3 = [1 .. 10]
printfn "The list: %A" list3

(* using range constructs *)
let list4 = ['a' .. 'm']
printfn "The list: %A" list4

(* using init method *)
let list5 = List.init 5 (fun index -> (index, index * index, index * index * index))
printfn "The list: %A" list5

(* using yield operator *)
let list6 = [ for a in 1 .. 10 do yield (a * a) ]
printfn "The list: %A" list6

(* using yield operator *)
let list7 = [ for a in 1 .. 100 do if a % 3 = 0 && a % 5 = 0 then yield a]
printfn "The list: %A" list7

(* using yield! operator *)
let list8 = [for a in 1 .. 3 do yield! [ a .. a + 3 ] ]
printfn "The list: %A" list8

編譯並執行程式時，它將生成以下輸出：

The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The list: [1; 2; 3]
The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The list: ['a'; 'b'; 'c'; 'd'; 'e'; 'f'; 'g'; 'h'; 'i'; 'j'; 'k'; 'l'; 'm']
The list: [(0, 0, 0); (1, 1, 1); (2, 4, 8); (3, 9, 27); (4, 16, 64)]
The list: [1; 4; 9; 16; 25; 36; 49; 64; 81; 100]
The list: [15; 30; 45; 60; 75; 90]
The list: [1; 2; 3; 4; 2; 3; 4; 5; 3; 4; 5; 6]

列表資料型別的屬性

下表顯示了列表資料型別的各種屬性：

以下示例顯示了這些屬性的使用：

示例

let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]

// Use of Properties
printfn "list1.IsEmpty is %b" (list1.IsEmpty)
printfn "list1.Length is %d" (list1.Length)
printfn "list1.Head is %d" (list1.Head)
printfn "list1.Tail.Head is %d" (list1.Tail.Head)
printfn "list1.Tail.Tail.Head is %d" (list1.Tail.Tail.Head)
printfn "list1.Item(1) is %d" (list1.Item(1))

編譯並執行程式時，它將生成以下輸出：

list1.IsEmpty is false
list1.Length is 8
list1.Head is 2
list1.Tail.Head is 4
list1.Tail.Tail.Head is 6
list1.Item(1) is 4

列表的基本運算子

下表顯示了列表資料型別上的基本操作：

以下示例演示了上述功能的使用。

示例 1

此程式顯示了遞迴反轉列表。

let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]
printfn "The original list: %A" list1

let reverse lt =
   let rec loop acc = function
      | [] -> acc
      | hd :: tl -> loop (hd :: acc) tl
   loop [] lt

printfn "The reversed list: %A" (reverse list1)

編譯並執行程式時，它將生成以下輸出：

The original list: [2; 4; 6; 8; 10; 12; 14; 16]
The reversed list: [16; 14; 12; 10; 8; 6; 4; 2]

但是，您可以使用模組的 **rev** 函式來實現相同目的。

let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]
printfn "The original list: %A" list1
printfn "The reversed list: %A" (List.rev list1)

編譯並執行程式時，它將生成以下輸出：

The original list: [2; 4; 6; 8; 10; 12; 14; 16]
The reversed list: [16; 14; 12; 10; 8; 6; 4; 2]

示例 2

此程式顯示了使用 **List.filter** 方法過濾列表。

let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "The list: %A" list1
let list2 = list1 |> List.filter (fun x -> x % 2 = 0);;
printfn "The Filtered list: %A" list2

編譯並執行程式時，它將生成以下輸出：

The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The Filtered list: [2; 4; 6; 8; 10]

示例 3

**List.map** 方法將一個列表從一種型別對映到另一種型別。

let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "The list: %A" list1
let list2 = list1 |> List.map (fun x -> (x * x).ToString());;
printfn "The Mapped list: %A" list2

編譯並執行程式時，它將生成以下輸出：

The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The Mapped list: ["1"; "4"; "9"; "16"; "25"; "36"; "49"; "64"; "81"; "100"]

示例 4

**List.append** 方法和 @ 運算子將一個列表附加到另一個列表。

let list1 = [1; 2; 3; 4; 5 ]
let list2 = [6; 7; 8; 9; 10]
let list3 = List.append list1 list2

printfn "The first list: %A" list1
printfn "The second list: %A" list2
printfn "The appened list: %A" list3

let lt1 = ['a'; 'b';'c' ]
let lt2 = ['e'; 'f';'g' ]
let lt3 = lt1 @ lt2

printfn "The first list: %A" lt1
printfn "The second list: %A" lt2
printfn "The appened list: %A" lt3

編譯並執行程式時，它將生成以下輸出：

The first list: [1; 2; 3; 4; 5]
The second list: [6; 7; 8; 9; 10]
The appened list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The first list: ['a'; 'b'; 'c']
The second list: ['e'; 'f'; 'g']
The appened list: ['a'; 'b'; 'c'; 'e'; 'f'; 'g']

示例 5

**List.sort** 方法對列表進行排序。**List.sum** 方法給出列表中元素的總和，而 **List.average** 方法給出列表中元素的平均值。

let list1 = [9.0; 0.0; 2.0; -4.5; 11.2; 8.0; -10.0]
printfn "The list: %A" list1

let list2 = List.sort list1
printfn "The sorted list: %A" list2

let s = List.sum list1
let avg = List.average list1
printfn "The sum: %f" s
printfn "The average: %f" avg

編譯並執行程式時，它將生成以下輸出：

The list: [9.0; 0.0; 2.0; -4.5; 11.2; 8.0; -10.0]
The sorted list: [-10.0; -4.5; 0.0; 2.0; 8.0; 9.0; 11.2]
The sum: 15.700000
The average: 2.242857

“摺疊”操作將一個函式應用於列表中的每個元素，將函式的結果聚合到一個累加器變數中，並將累加器作為摺疊操作的結果返回。

示例 6

**List.fold** 方法從左到右將函式應用於每個元素，而 **List.foldBack** 方法從右到左將函式應用於每個元素。

let sumList list = List.fold (fun acc elem -> acc + elem) 0 list
printfn "Sum of the elements of list %A is %d." [ 1 .. 10 ] (sumList [ 1 .. 10 ])

編譯並執行程式時，它將生成以下輸出：

Sum of the elements of list [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] is 55.