F # - อาร์เรย์

อาร์เรย์เป็นคอลเลกชันที่มีขนาดคงที่ฐานเป็นศูนย์และไม่สามารถเปลี่ยนแปลงได้ขององค์ประกอบข้อมูลที่ต่อเนื่องกันซึ่งเป็นชนิดเดียวกันทั้งหมด

การสร้างอาร์เรย์

คุณสามารถสร้างอาร์เรย์โดยใช้ไวยากรณ์และวิธีการต่างๆหรือโดยใช้ฟังก์ชันจากโมดูลอาร์เรย์ ในส่วนนี้เราจะพูดถึงการสร้างอาร์เรย์โดยไม่ใช้ฟังก์ชันโมดูล

มีสามวิธีในการสร้างอาร์เรย์โดยไม่ใช้ฟังก์ชันเชิงไวยากรณ์ -

• โดยแสดงรายการค่าที่ต่อเนื่องกันระหว่าง [| และ |] และคั่นด้วยอัฒภาค
• โดยการวางแต่ละองค์ประกอบในบรรทัดแยกกันซึ่งในกรณีนี้ตัวคั่นอัฒภาคเป็นทางเลือก
• โดยใช้นิพจน์ลำดับ.

คุณสามารถเข้าถึงองค์ประกอบอาร์เรย์โดยใช้ตัวดำเนินการจุด (.) และวงเล็บ ([และ])

ตัวอย่างต่อไปนี้สาธิตการสร้างอาร์เรย์ -

//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 สนับสนุนการดำเนินการกับอาร์เรย์หนึ่งมิติ

ตารางต่อไปนี้แสดงการทำงานพื้นฐานบน Arrays -

ค่า	คำอธิบาย
ต่อท้าย: 'T [] →' T [] → 'T []	สร้างอาร์เรย์ที่มีองค์ประกอบของอาร์เรย์หนึ่งตามด้วยองค์ประกอบของอาร์เรย์อื่น
ค่าเฉลี่ย: ^ T [] → ^ T	ส่งคืนค่าเฉลี่ยขององค์ประกอบในอาร์เรย์
เฉลี่ยโดย: ('T → ^ U) →' T [] → ^ U	ส่งกลับค่าเฉลี่ยขององค์ประกอบที่สร้างขึ้นโดยใช้ฟังก์ชันกับแต่ละองค์ประกอบของอาร์เรย์
blit: 'T [] → int →' T [] → int → int →หน่วย	อ่านช่วงขององค์ประกอบจากอาร์เรย์หนึ่งและเขียนลงในอีกรายการหนึ่ง
เลือก: (ตัวเลือก 'T → U) →' T [] → 'U []	ใช้ฟังก์ชันที่ให้มากับแต่ละองค์ประกอบของอาร์เรย์ ส่งคืนอาร์เรย์ที่มีผลลัพธ์ x สำหรับแต่ละองค์ประกอบที่ฟังก์ชันส่งคืนค่า Some (x)
รวบรวม: ('T →' U []) → T [] → 'U []	ใช้ฟังก์ชันที่ให้มากับแต่ละองค์ประกอบของอาร์เรย์เชื่อมต่อผลลัพธ์และส่งคืนอาร์เรย์รวม
concat: seq <'T []> →' T []	สร้างอาร์เรย์ที่มีองค์ประกอบของแต่ละลำดับของอาร์เรย์ที่ให้มา
สำเนา: 'T →' T []	สร้างอาร์เรย์ที่มีองค์ประกอบของอาร์เรย์ที่ให้มา
สร้าง: int → 'T →' T []	สร้างอาร์เรย์ที่องค์ประกอบทั้งหมดเป็นค่าที่ระบุในตอนแรก
ว่างเปล่า: 'T []	ส่งคืนอาร์เรย์ว่างของประเภทที่กำหนด
มีอยู่: ('T → bool) →' T [] → bool	ทดสอบว่าองค์ประกอบใด ๆ ของอาร์เรย์ตรงตามเพรดิเคตที่ให้มาหรือไม่
มีอยู่ 2: ('T1 →' T2 →บูล) → 'T1 [] →' T2 [] →บูล	ทดสอบว่าคู่ขององค์ประกอบที่สอดคล้องกันของสองอาร์เรย์เป็นไปตามเงื่อนไขที่ให้มาหรือไม่
เติม: 'T [] → int → int →' T →หน่วย	เติมช่วงขององค์ประกอบของอาร์เรย์ด้วยค่าที่ให้มา
ตัวกรอง: ('T → bool) →' T [] → 'T []	ส่งคืนคอลเล็กชันที่มีเฉพาะองค์ประกอบของอาร์เรย์ที่ให้มาซึ่งเงื่อนไขที่ให้มาจะส่งกลับ true.
ค้นหา: ('T → bool) →' T [] → 'T	ส่งคืนองค์ประกอบแรกที่ฟังก์ชันที่ให้มาส่งกลับ true. เพิ่ม KeyNotFoundException หากไม่มีองค์ประกอบดังกล่าว
findIndex: ('T → bool) →' T [] → int	ส่งคืนดัชนีขององค์ประกอบแรกในอาร์เรย์ที่ตรงตามเงื่อนไขที่ระบุ เพิ่ม KeyNotFoundException หากไม่มีองค์ประกอบใดที่ตรงตามเงื่อนไข
พับ: ('รัฐ→' ​​T → 'รัฐ) →' รัฐ→ 'T [] →' รัฐ	ใช้ฟังก์ชันกับแต่ละองค์ประกอบของอาร์เรย์โดยทำเธรดอาร์กิวเมนต์ตัวสะสมผ่านการคำนวณ ถ้าฟังก์ชันอินพุตคือ f และองค์ประกอบอาร์เรย์คือ i0 ... iN ฟังก์ชันนี้จะคำนวณ f (... (fs i0) ... ) iN
fold2: ('รัฐ→' ​​T1 → 'T2 →' รัฐ) → 'รัฐ→' ​​T1 [] → 'T2 [] →' รัฐ	ใช้ฟังก์ชันกับคู่ขององค์ประกอบจากอาร์เรย์ที่ให้มาสองอาร์เรย์ซ้ายไปขวาเธรดอาร์กิวเมนต์ตัวสะสมผ่านการคำนวณ อาร์เรย์อินพุตทั้งสองต้องมีความยาวเท่ากัน มิฉะนั้น ArgumentException จะถูกยกขึ้น
foldBack: ('T →' State → 'State) →' T [] → 'State →' State	ใช้ฟังก์ชันกับแต่ละองค์ประกอบของอาร์เรย์โดยทำเธรดอาร์กิวเมนต์ตัวสะสมผ่านการคำนวณ ถ้าฟังก์ชันอินพุตคือ f และองค์ประกอบอาร์เรย์คือ i0 ... iN ฟังก์ชันนี้จะคำนวณ f i0 (... (f iN s))
foldBack2: ('T1 →' T2 → 'รัฐ→' ​​รัฐ) → 'T1 [] →' T2 [] → 'รัฐ→' ​​รัฐ	ใช้ฟังก์ชันกับคู่ขององค์ประกอบจากอาร์เรย์ที่ให้มาสองอาร์เรย์จากขวาไปซ้ายโดยทำเกลียวอาร์กิวเมนต์ตัวสะสมผ่านการคำนวณ อาร์เรย์อินพุตทั้งสองต้องมีความยาวเท่ากัน มิฉะนั้น ArgumentException จะถูกยกขึ้น
สำหรับ: ('T → bool) →' T [] → bool	ทดสอบว่าองค์ประกอบทั้งหมดของอาร์เรย์เป็นไปตามเงื่อนไขที่ให้มาหรือไม่
forall2: ('T1 →' T2 →บูล) → 'T1 [] →' T2 [] →บูล	ทดสอบว่าองค์ประกอบที่เกี่ยวข้องทั้งหมดของสองอาร์เรย์ที่ให้มานั้นตรงตามเงื่อนไขที่ให้มาหรือไม่
รับ: 'T [] → int →' T	รับองค์ประกอบจากอาร์เรย์
เริ่มต้น: int → (int → 'T) →' T []	ใช้ฟังก์ชันที่ให้มาเพื่อสร้างอาร์เรย์ของมิติข้อมูลที่ให้มา
isEmpty: 'T [] →บูล	ทดสอบว่าอาร์เรย์มีองค์ประกอบหรือไม่
iter: ('T →หน่วย) →' T [] →หน่วย	ใช้ฟังก์ชันที่ให้มากับแต่ละองค์ประกอบของอาร์เรย์
iter2: ('T1 →' T2 →หน่วย) → 'T1 [] →' T2 [] →หน่วย)	ใช้ฟังก์ชันที่ให้มากับคู่ขององค์ประกอบจากดัชนีที่ตรงกันในสองอาร์เรย์ อาร์เรย์ทั้งสองต้องมีความยาวเท่ากัน มิฉะนั้น ArgumentException จะถูกยกขึ้น
iteri: (int → 'T →หน่วย) →' T [] →หน่วย	ใช้ฟังก์ชันที่ให้มากับแต่ละองค์ประกอบของอาร์เรย์ จำนวนเต็มที่ส่งผ่านไปยังฟังก์ชันบ่งชี้ดัชนีขององค์ประกอบ
iteri2: (int → 'T1 →' T2 → unit) → 'T1 [] →' T2 [] →หน่วย	ใช้ฟังก์ชันที่ให้มากับคู่ขององค์ประกอบจากดัชนีที่ตรงกันในสองอาร์เรย์และส่งผ่านดัชนีขององค์ประกอบด้วย อาร์เรย์ทั้งสองต้องมีความยาวเท่ากัน มิฉะนั้น ArgumentException จะถูกยกขึ้น
ความยาว: 'T [] → int	ส่งกลับความยาวของอาร์เรย์ คุณสมบัติ Length ทำสิ่งเดียวกัน
แผนที่: ('T →' U) → 'T [] →' U []	สร้างอาร์เรย์ที่มีองค์ประกอบเป็นผลลัพธ์ของการใช้ฟังก์ชันที่ให้มากับแต่ละองค์ประกอบของอาร์เรย์ที่ให้มา
แผนที่ 2: ('T1 →' T2 → 'U) →' T1 [] → 'T2 [] →' U []	สร้างอาร์เรย์ที่มีองค์ประกอบเป็นผลลัพธ์ของการใช้ฟังก์ชันที่ให้มากับองค์ประกอบที่สอดคล้องกันของอาร์เรย์ที่ให้มาสองชุด อาร์เรย์อินพุตทั้งสองต้องมีความยาวเท่ากัน มิฉะนั้น ArgumentException จะถูกยกขึ้น
แผนที่: (int → 'T →' U) → 'T [] →' U []	สร้างอาร์เรย์ที่มีองค์ประกอบเป็นผลลัพธ์ของการใช้ฟังก์ชันที่ให้มากับแต่ละองค์ประกอบของอาร์เรย์ที่ให้มา ดัชนีจำนวนเต็มที่ส่งผ่านไปยังฟังก์ชันบ่งชี้ดัชนีขององค์ประกอบที่กำลังเปลี่ยนรูป
mapi2: (int → 'T1 →' T2 → 'U) →' T1 [] → 'T2 [] →' U []	สร้างอาร์เรย์ที่มีองค์ประกอบเป็นผลลัพธ์ของการใช้ฟังก์ชันที่ให้มากับองค์ประกอบที่สอดคล้องกันของสองคอลเลกชันแบบคู่และส่งผ่านดัชนีขององค์ประกอบ อาร์เรย์อินพุตทั้งสองต้องมีความยาวเท่ากัน มิฉะนั้น ArgumentException จะถูกยกขึ้น
สูงสุด: 'T [] →' T	ส่งคืนองค์ประกอบที่ใหญ่ที่สุดของอาร์เรย์ทั้งหมด Operators.max ใช้เพื่อเปรียบเทียบองค์ประกอบ
maxBy: ('T →' U) → 'T [] →' T	ส่งคืนองค์ประกอบที่ใหญ่ที่สุดของอาร์เรย์ทั้งหมดโดยเปรียบเทียบผ่าน Operators.max ในผลลัพธ์ของฟังก์ชัน
นาที: ('T [] →' T	ส่งคืนองค์ประกอบที่เล็กที่สุดของอาร์เรย์ทั้งหมด Operators.min ใช้เพื่อเปรียบเทียบองค์ประกอบ
นาทีโดย: ('T →' U) → 'T [] →' T	ส่งคืนองค์ประกอบที่เล็กที่สุดของอาร์เรย์ทั้งหมด Operators.min ใช้เพื่อเปรียบเทียบองค์ประกอบ
ofList: 'T list →' T []	สร้างอาร์เรย์จากรายการที่ให้มา
ofSeq: seq <'T> →' T []	สร้างอาร์เรย์จากอ็อบเจ็กต์ที่ระบุได้ที่ให้มา
พาร์ติชัน: ('T → bool) →' T [] → 'T [] *' T []	แบ่งอาร์เรย์ออกเป็นสองอาร์เรย์โดยหนึ่งมีองค์ประกอบที่เงื่อนไขที่ให้มาส่งกลับ true, และอื่น ๆ ที่มีสิ่งที่ส่งคืน false.
อนุญาต: (int → int) → 'T [] →' T []	อนุญาตองค์ประกอบของอาร์เรย์ตามการเปลี่ยนแปลงที่ระบุ
เลือก: ('T →' ตัวเลือก U) → 'T [] →' U	ใช้ฟังก์ชันที่ให้มากับองค์ประกอบต่อเนื่องของอาร์เรย์ที่ให้มาโดยส่งคืนผลลัพธ์แรกโดยที่ฟังก์ชันส่งคืนค่า Some (x) สำหรับบาง x ถ้าฟังก์ชันไม่คืนค่า Some (x) KeyNotFoundException จะถูกยกขึ้น
ลด: ('T →' T → 'T) →' T [] → 'T	ใช้ฟังก์ชันกับแต่ละองค์ประกอบของอาร์เรย์โดยทำเธรดอาร์กิวเมนต์ตัวสะสมผ่านการคำนวณ ถ้าฟังก์ชันอินพุตคือ f และองค์ประกอบอาร์เรย์คือ i0 ... iN ฟังก์ชันนี้จะคำนวณ f (... (f i0 i1) ... ) iN ถ้าอาร์เรย์มีขนาดเป็นศูนย์ ArgumentException จะถูกยกขึ้น
ลดแบ็ค: ('T →' T → 'T) →' T [] → 'T	ใช้ฟังก์ชันกับแต่ละองค์ประกอบของอาร์เรย์โดยทำเธรดอาร์กิวเมนต์ตัวสะสมผ่านการคำนวณ หากฟังก์ชันอินพุตเป็น f และองค์ประกอบคือ i0 ... iN ฟังก์ชันนี้จะคำนวณ f i0 (... (f iN-1 iN)) ถ้าอาร์เรย์มีขนาดเป็นศูนย์ ArgumentException จะถูกยกขึ้น
rev: 'T [] →' T []	กลับลำดับขององค์ประกอบในอาร์เรย์ที่ให้มา
สแกน: ('State →' T → 'State) →' State → 'T [] →' State [])	ทำตัวเหมือนพับ แต่ส่งคืนผลลัพธ์ระดับกลางพร้อมกับผลลัพธ์สุดท้าย
scanBack: ('T →' รัฐ→ 'รัฐ) →' T [] → 'รัฐ→' ​​รัฐ []	ทำงานเหมือน foldBack แต่ส่งคืนผลลัพธ์ตัวกลางพร้อมกับผลลัพธ์สุดท้าย
ตั้งค่า: 'T [] → int →' T →หน่วย	ตั้งค่าองค์ประกอบของอาร์เรย์
จัดเรียง: 'T [] →' T []	จัดเรียงองค์ประกอบของอาร์เรย์และส่งคืนอาร์เรย์ใหม่ Operators.compare ใช้เพื่อเปรียบเทียบองค์ประกอบ
sortBy: ('T →' คีย์) → 'T [] →' T []	จัดเรียงองค์ประกอบของอาร์เรย์โดยใช้ฟังก์ชันที่ให้มาเพื่อแปลงองค์ประกอบเป็นประเภทที่ใช้การดำเนินการจัดเรียงและส่งกลับอาร์เรย์ใหม่ Operators.compare ใช้เพื่อเปรียบเทียบองค์ประกอบ
sortInPlace: 'T [] →หน่วย	จัดเรียงองค์ประกอบของอาร์เรย์โดยการเปลี่ยนอาร์เรย์ในตำแหน่งโดยใช้ฟังก์ชันเปรียบเทียบที่ให้มา Operators.compare ใช้เพื่อเปรียบเทียบองค์ประกอบ
sortInPlaceBy: ('T →' คีย์) → 'T [] →หน่วย	จัดเรียงองค์ประกอบของอาร์เรย์โดยการเปลี่ยนอาร์เรย์ในตำแหน่งโดยใช้การฉายภาพที่ให้มาสำหรับคีย์ Operators.compare ใช้เพื่อเปรียบเทียบองค์ประกอบ
sortInPlaceWith: ('T →' T → int) → 'T [] →หน่วย	จัดเรียงองค์ประกอบของอาร์เรย์โดยใช้ฟังก์ชันการเปรียบเทียบที่ให้มาเพื่อเปลี่ยนอาร์เรย์ในตำแหน่ง
เรียงลำดับด้วย: ('T →' T → int) → 'T [] →' T []	จัดเรียงองค์ประกอบของอาร์เรย์โดยใช้ฟังก์ชันการเปรียบเทียบที่ให้มาและส่งคืนอาร์เรย์ใหม่
ย่อย: 'T [] → int → int →' T []	สร้างอาร์เรย์ที่มีช่วงย่อยที่ให้มาซึ่งระบุโดยดัชนีเริ่มต้นและความยาว
ผลรวม: 'T [] → ^ T	ส่งคืนผลรวมขององค์ประกอบในอาร์เรย์
sumBy: ('T → ^ U) →' T [] → ^ U	ส่งกลับผลรวมของผลลัพธ์ที่สร้างขึ้นโดยใช้ฟังก์ชันกับแต่ละองค์ประกอบของอาร์เรย์
toList: รายการ 'T [] →' T	แปลงอาร์เรย์ที่ให้มาเป็นรายการ
toSeq: 'T [] → seq <' T>	ดูอาร์เรย์ที่ให้มาเป็นลำดับ
tryFind: ('T → bool) →' T [] → 'ตัวเลือก T	ส่งคืนองค์ประกอบแรกในอาร์เรย์ที่ให้มาซึ่งฟังก์ชันที่ให้มาจะส่งกลับ true. ผลตอบแทนNone หากไม่มีองค์ประกอบดังกล่าว
tryFindIndex: ('T → bool) →' T [] →ตัวเลือก int	ส่งคืนดัชนีขององค์ประกอบแรกในอาร์เรย์ที่ตรงตามเงื่อนไขที่ระบุ
tryPick: ('T →' ตัวเลือก U) → 'T [] →' ตัวเลือก U	ใช้ฟังก์ชันที่ให้มากับองค์ประกอบต่อเนื่องของอาร์เรย์ที่ให้มาและส่งกลับผลลัพธ์แรกโดยที่ฟังก์ชันส่งคืนค่า Some (x) สำหรับบาง x ถ้าฟังก์ชันไม่คืนค่า Some (x)None จะถูกส่งกลับ
เปิดเครื่องรูด: ('T1 *' T2) [] → 'T1 [] *' T2 []	แบ่งอาร์เรย์ของคู่ทูเพิลเป็นทูเพิลสองอาร์เรย์
unzip3: ('T1 *' T2 * 'T3) [] →' T1 [] * 'T2 [] *' T3 []	แยกอาร์เรย์ของทูเปิลของสามองค์ประกอบออกเป็นทูเพิลจากสามอาร์เรย์
zeroCreate: int → 'T []	สร้างอาร์เรย์ที่องค์ประกอบเริ่มต้นถูกตั้งค่าเป็นค่าเริ่มต้น Unchecked.defaultof <'T>
ซิป: 'T1 [] →' T2 [] → ('T1 *' T2) []	รวมอาร์เรย์สองอาร์เรย์เข้ากับอาร์เรย์ของทูเปิลที่มีสององค์ประกอบ อาร์เรย์ทั้งสองต้องมีความยาวเท่ากัน มิฉะนั้น ArgumentException จะถูกยกขึ้น
zip3: 'T1 [] →' T2 [] → 'T3 [] → (' T1 * 'T2 * 113' T3) []	รวมอาร์เรย์สามอาร์เรย์เข้ากับอาร์เรย์ของสิ่งที่มีสามองค์ประกอบ อาร์เรย์ทั้งสามต้องมีความยาวเท่ากัน มิฉะนั้น ArgumentException จะถูกยกขึ้น

ในส่วนต่อไปนี้เราจะเห็นการใช้ฟังก์ชันเหล่านี้บางส่วน

การสร้างอาร์เรย์โดยใช้ฟังก์ชัน

โมดูล Array มีฟังก์ชันมากมายที่สร้างอาร์เรย์ตั้งแต่เริ่มต้น

• 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 ฟังก์ชันรับฟังก์ชันบูลีนและส่งกลับองค์ประกอบแรกที่ฟังก์ชันส่งคืนจริงมิฉะนั้นจะเพิ่ม 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.