Array methods ในภาษา Ruby

ในบทก่อนหน้า คุณได้เรียนรู้เกี่ยวกับอาเรย์ในเบื้องต้นไปแล้ว และนั่นเป็นข้อมูลที่ค่อนข้างเพียงพอสำหรับการนำอาเรย์ไปใช้ในการเขียนโปรแกรม เช่นเดียวกับ String ในภาษา Ruby นั้นมีเมธอดจากคลาส Array เป็นจำนวนมากที่ช่วยอำนวยความสะดวกให้กับเราในการเขียนโปรแกรม

ในบทนี้ เราจะพาคุณมาสำรวจเมธอดของอาเรย์พร้อมตัวอย่างการใช้งานเมธอดเหล่านั้น อย่างไรก็ตาม เนื่องจากอาเรย์มีเมธอดเป็นจำนวนมาก ดังนั้นเราจะยกตัวอย่างเพียงเมธอดที่สำคัญและใช้บ่อย เมธอดส่วนมากของอาเรย์นั้นมาจากคลาส Array และมีบางเมธอดที่มาจากโมดูล Enumerable

เมธอดพื้นฐานของอาเรย์

เมธอดกลุ่มแรกเป็นเมธอดพื้นฐานที่คุณจะต้องได้ใช้เมื่อทำงานกับอาเรย์ มันคือเมธอดสำหรับนับออบเจ็คในอาเรย์ และเมธอดสำหรับเชื่อมต่ออาเรย์เข้าด้วยกัน มาดูตัวอย่างการใช้งาน

# Initialize array
numbers = [1, 2, 4, 5, 8, 10]
colors = ["Red", "Yellow", "Pink"]
puts numbers.length
puts colors.length

# Add more object to array
colors.push("Green")
colors.push("Orange")
puts colors.length

# Loop through array
for i in (0...colors.length)
    print "#{colors[i]}, "
end

ในตัวอย่าง เป็นการใช้งานเมธอด length สำหรับนับข้อมูลภายในอาเรย์ ในตอนแรก เราได้ประกาศตัวแปรอาเรย์ numbers และ colors สำหรับเก็บตัวเลขและชื่อของสีตามลำดับ และเราเรียกใช้เมธอด length เพื่อนับจำนวนออบเจ็คภายในอาเรย์

colors.push("Green")
colors.push("Orange")
puts colors.length

ในกลุ่มของคำสั่งต่อมา เราได้เพิ่มข้อมูลใหม่เข้าไปยังตัวแปร colors ตอนนี้จำนวนของออบเจ็คในอาเรย์ดังกล่าวเพิ่มขึ้นอีกสอง และเราใช้เมธอด length เพื่อนับจำนวนออบเจ็คในอาเรย์อีกครั้ง

for i in (0...colors.length)
    print "#{colors[i]}, "
end

ในคำสั่งกลุ่มสุดท้าย เป็นการใช้งานคำสั่งวนซ้ำ for loop เพื่อวนอ่านค่าสมาชิกในอาเรย์ colors ในกรณีนี้ เราได้สร้าง Index ของอาเรย์ด้วยออบเจ็ค Range โดยการระบุจุดสิ้นสุดเป็น colors.length เราใช้ออบเจ็ค Range เพื่อสร้าง Index ของอาเรย์จาก 0 ถึง colors.length - 1 เพื่อใช้ในการเข้าถึงข้อมูลภายในอาเรย์

6
3
5
Red, Yellow, Pink, Green, Orange,

นี่เป็นผลลัพธ์การทำงานของโปรแกรม สังเกตว่าเข้าไปในตัวแปรอาเรย์ colors ค่าที่นับจะอัพเดทใหม่ในทันที

อีกการดำเนินการหนึ่งที่เกิดขึ้นบ่อยๆ เมื่อเราทำงานกับอาเรย์คือการนำอาเรย์มาต่อเข้าด้วยกัน มาดูตัวอย่างการนำอาเรย์มาเชื่อมต่อกันในภาษา Ruby

planets = ["Mercury", "Mars", "Venus", "Earth"]
stars = ["Sun", "Sirius A", "Pollux"]
p planets + stars
p stars + planets
p planets
p stars 

n1 = ["One", "Two", "Three"]
n2 = ["Four", "Five", "Six"]
p n1.concat(n2)
p n1

ในตัวอย่างของ เรามีตัวแปรอาเรย์ของดาวเคราะห์ planets และอาเรย์ของดาวฤกษ์ stars เราสามารถใช้เมธอดเชื่อมต่ออาเรย์ + ในการต่ออาเรย์เข้าด้วยกัน หลังจากนั้นเราจะได้อาเรย์ใหม่ที่มีข้อมูลรวมกันจากทั้งสองอาเรย์

n1 = ["One", "Two", "Three"]
n2 = ["Four", "Five", "Six"]
p n1.concat(n2)
p n1

อีกวิธีหนึ่งในการเชื่อมต่ออาเรย์คือการใช้เมธอด concat การทำงานของเมธอด concat นั้นจะไม่ได้เป็นการส่งกลับเป็นอาเรย์ใหมา แต่จะเป็นการนำข้อมูลในอาเรย์ n2 เข้าไปต่อกับอาเรย์เดิมคือ n1 แทน ทำให้เราสูญเสียค่าของอาเรย์เดิมที่เคยมีในตัวแปร n1

["Mercury", "Mars", "Venus", "Earth", "Sun", "Sirius A", "Pollux"]
["Sun", "Sirius A", "Pollux", "Mercury", "Mars", "Venus", "Earth"]
["One", "Two", "Three", "Four", "Five", "Six"]
["One", "Two", "Three", "Four", "Five", "Six"]

นี่เป็นผลลัพธ์การทำงานของโปรแกรม สำหรับการเชื่อมต่ออาเรย์โดยการใช้งานเมธอด + และเมธอด concat

มาถึงตอนนี้ คุณควรจะทราบว่าคุณจะเลือกใช้เมธอดไหนในการเชื่อมต่ออาเรย์เข้าด้วยกัน ถ้าหากคุณต้องการเก็บอาเรย์เดิมหลังจากที่เชื่อมต่อแล้ว คุณควรใช้เมธอด + แต่ถ้าหากคุณไม้สนใจที่จะเก็บอาเรย์เดิมเอาไว้ คุณสามารถใช้เมธอด concat ในการเชื่อมต่ออาเรย์

การเพิ่มและลบข้อมูลในอาเรย์

หลังจากที่อาเรย์ถูกประกาศแล้ว คุณสามารถเพิ่มข้อมูลเข้าไปในอาเรย์หรือนำข้อมูลออกไปจากอาเรย์ได้ ซึ่งการกระทำเหล่านี้ถือว่าเป็นเรื่องปกติที่เกิดขึ้นเมื่อเราทำงานกับอาเรย์ Ruby มีเมธอดจำนวนมากสำหรับเพิ่มและลบข้อมูลในอาเรย์ และแต่ละเมธอดนั้นมีการทำงานที่แตกต่างกัน มาดูตัวอย่าง

names = ["Billy", "Simon"]
p names

names.push("Joshua")
names.push("Danny")
p names

names.unshift("Matteo")
p names

puts names.pop
p names

puts names.shift
p names

ในตัวอย่าง แสดงให้คุณเห็นวิธีการใช้งานของสี่เมธอดสำหรับการเพิ่มและนำข้อมูลออกจากอาเรย์ ในตอนแรก เราได้ประกาศตัวแปรอาเรย์ names พร้อมกับกำหนดสมาชิกสองตัวให้กับตัวแปร

names.push("Joshua")
names.push("Danny")

หลังจากที่อาเรย์ถูกประกาศแล้ว เราสามารถใช้เมธอด push เพื่อเพิ่มออบเจ็คใหม่เข้าไปในอาเรย์ได้ เมธอด push จะทำการเพิ่มใหม่เข้าไปต่อท้ายข้อมูลในอาเรย์ ในตัวอย่าง เราได้เพิ่มอีกสองชื่อเข้าไปยังอาเรย์

names.unshift("Matteo")

ในขณะที่เมธอด push เพิ่มข้อมูลเข้าไปต่อท้ายอาเรย์ เมธอด unshift นั้นทำงานตรงกันข้าม มันใช้สำหรับเพิ่มข้อมูลเข้าไปที่ด้านหน้าหรือตำแหน่งแรกของอาเรย์แทน ลองจินตนาการว่าคุณกำลังต่อแถวซื้ออาหาร แต่มีคนมาแซงคิวคุณ นั่นคงจะเป็นเรื่องที่ไม่น่ายินดีนัก

puts names.pop
...
puts names.shift

ต่อมาเป็นเมธอดสำหรับลบข้อมูลออกจากอาเรย์ เมธอด pop ใช้สำหรับนำข้อมูลที่อยู่ท้ายสุดของอาเรย์ออกและส่งค่าดังกล่าวกลับมา ส่วนเมธอด shift นำข้อมูลที่อยู่ตำแหน่งแรกของอาเรย์ออก

["Billy", "Simon"]
["Billy", "Simon", "Joshua", "Danny"]
["Matteo", "Billy", "Simon", "Joshua", "Danny"]
Danny
["Matteo", "Billy", "Simon", "Joshua"]
Matteo
["Billy", "Simon", "Joshua"]

นี่เป็นผลลัพธ์การทำงานของโปรแกรม เราได้แสดงค่าของอาเรย์ทุกครั้งหลังจากที่มีการเพิ่มหรือลบข้อมูลจากอาเรย์ เพื่อช่วยให้คุณได้เห็นลำดับของข้อมูลในอาเรย์หลังจากเรียกใช้งานเมธอดต่างๆ

ในตัวอย่างก่อนหน้า คุณได้เห็นแล้วว่าเราสามารถเพิ่มหรือลบข้อมูลจากท้ายหรือด้านหน้าของอาเรย์ได้ มาถึงตอนนี้ คุณอาจจะสงสัยว่าถ้าต้องการเพิ่มข้อมูลเข้าไปตรงกลางของอาเรย์หรือลบข้อมูลตำแหน่งที่สองออกจะต้องทำอย่างไร คำตอบก็คือ Ruby มีเมธอดสำหรับการทำงานดังกล่าว

# Insert object to array
lang = ["PHP", "Python", "C", "Java"]
lang.insert(1, "Ruby")
p lang

lang.insert(4, "Type Script")
p lang

# Delete object from array
days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday"]
days.delete_at(1)
p days

days.clear
p days
p days.length

ในตัวอย่างต่อมา เป็นการใช้เมธอด insert เพื่อเพิ่มข้อมูลไปยังตำแหน่งที่ต้องการโดยการระบุ Index และข้อมูลที่ต้องการจะเพิ่มผ่านทางอาร์กิวเมนต์ของเมธอด

lang.insert(1, "Ruby")

เรามีอาเรย์ของภาษาเขียนโปรแกรม lang ซึ่งมีสมาชิกอยู่สี่ตัว และเราได้เพิ่ม "Ruby" เข้าไปยัง Index ที่ 1 ของอาเรย์ หลังจากที่ข้อมูลถูกแทรกเข้าไปแล้ว Index ของข้อมูลในอาเรย์หลังจาก Index ที่ถูกแทรกจะเปลี่ยนไปคือเพิ่มขึ้นไป 1 นั่นทำให้ในตอนนี้ Index ของ "Python" จะกลายเป็น 2 แทน และ Index ของ "C" จะกลายเป็น 3 ตามลำดับ

lang.insert(4, "Type Script")

ต่อมาเราต้องการเพิ่มภาษา "Type Script" ให้อยู่ต่อท้ายภาษา "C" ในกรณีนี้ เราต้องยึดกับ Index ใหม่ที่เปลี่ยนแปลงไปแล้ว เนื่องจากในตอนนี้ภาษา "C" อยู่ในตำแหน่งที่สาม ดังนั้นในการเพิ่ม "Type Script" ไปต่อท้าย เราต้องใช้ Index เป็น 4

days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday"]
days.delete_at(1)

ตัวอย่างในส่วนต่อมาเป็นการลบข้อมูลจากตำแหน่งที่ระบุออกจากอาเรย์ ในตอนแรก เราได้ประกาศตัวแปร days ซึ่งเก็บชื่อของวันในสัปดาห์เอาไว้ และเนื่องจากเราไม่ชอบวันจันทร์ เราจึงได้นำวันจันทร์ที่อยู่ในตำแหน่งที่ 1 ของอาเรย์ออกไปด้วยเมธอด delete_at

หลังจากที่เรานำข้อมูลออกจากอาเรย์ด้วยเมธอด delete_at แล้วตำแหน่ง Index ของข้อมูลภายในอาเรย์หลังจากตำแหน่งดังกล่าวจะถูกลดค่าลง 1

days.clear

นอกจากการลบข้อมูลออกจากอาเรย์ด้วยเมธอด pop shift หรือ delete_at แล้ว คุณยังสามารถใช้เมธอด clear เพื่อลบข้อมูลทั้งหมดในอาเรย์ได้ นั่นจะทำให้มันกลายเป็นอาเรย์ว่างเปล่าและมีขนาดเป็นศูนย์

["PHP", "Ruby", "Python", "C", "Java"]
["PHP", "Ruby", "Python", "C", "Type Script", "Java"]
["Sunday", "Tuesday", "Wednesday"]
[]
0

นี่เป็นผลลัพธ์การทำงานของโปรแกรม จากการใช้เมธอด insert เพื่อเพิ่มข้อมูลเข้าไปยังตำแหน่งที่ต้องการ และเมธอด delete_at เพื่อลบข้อมูลจากตำแหน่งที่ต้องการออกไปจากอาเรย์

การ Slice อาเรย์

การ slice อาเรย์เป็นการสร้างอาเรย์ใหม่โดยการตัดเอาข้อมูลจากอาเรย์เดิมด้วยทาง Index ของอาเรย์โดยการใช้เมธอด [] หรือเมธอด slice

ch = ["a", "b", "c", "d", "e", "f", "g", "h"]
p ch[0]
p ch[3] + ch[5] + ch[7]
p ch[-1]

p ch[0, 3]
p ch[4, 2]
p ch[-3, 2]
p ch[-1, 1]

p ch[0..4]
p ch[0...4]

ในตัวอย่าง เรามีอาเรย์ของตัวอักษรภาษาอังกฤษ หลังจากนั้นเราจะทำการ slice อาเรย์เพื่อสร้างอาเรย์ใหม่โดยการเรียกใช้งานเมธอด [] ในรูปแบบต่างๆ

p ch[0]
p ch[3] + ch[5] + ch[7]
p ch[-1]

ในสามคำสั่งแรก เป็นการเรียกใช้งานเมธอด [] สำหรับการ slice อาเรย์ เนื่องจากเราได้ส่งอาร์กิวเมนต์เพียงหนึ่งตัวเข้าไปยังเมธอดในรูปแบบ ch[index] ดังนั้นการดำเนินการนี้คือการเข้าถึงข้อมูลภายในอาเรย์โดยตรง ค่าที่ได้รับจะเป็นค่าของสมาชิกที่ตำแหน่ง Index นั้นๆ

p ch[0, 3]
p ch[4, 2]
p ch[-3, 2]
p ch[-1, 1]

ต่อมาเมื่อเราทำการ slice อาเรย์โดยการใช้สองอาร์กิวเมนต์ในรูปแบบ ch[start, count] นั่นหมายความว่าเป็นการตัดเอาสมาชิกของอาเรย์โดยเริ่มจาก Index ตำแหน่งที่ start และนับไปเป็นจำนวน count ตัว ในคำสั่ง ch[0, 3] หมายความว่าเราตัดเอาสมาชิกของอาเรย์จาก Index ตำแหน่งที่ 0ไปเป็นจำนวน 3 ตัว

p ch[0..4]
p ch[0...4]

ต่อมาเป็นการ slice โดยการใช้ Range เป็นอาร์กิวเมนต์ ซึ่งค่าเริ่มต้นและสิ้นสุดของ Range หมายถึง Index เริ่มต้นและสิ้นสุดของอาเรย์ที่เราต้องการตัด และจุดสามจุดบน Range จะรวมสมาชิกใน Index สิ้นสุดด้วย ในขณะที่จุดสองจุดจะไม่รวม

"a"
"dfh"
"h"
["a", "b", "c"]
["e", "f"]
["f", "g"]
["h"]
["a", "b", "c", "d", "e"]
["a", "b", "c", "d"]

นี่เป็นผลลัพธ์การทำงานของโปรแกรม ในการ slice อาเรย์ในภาษา Ruby

สำหรับการ slice อาเรย์ในภาษา Ruby นั้น คุณสามารถใช้เมธอด slice ได้เช่นกัน ซึ่งทั้งสองเมธอดนี้ให้ผลลัพธ์การทำงานที่เหมือนกัน แต่เราแนะนำให้ใช้วิธีแรกด้วยเมธอด [] มากกว่าเพราะมันสั้นและเข้าใจได้ง่ายกว่า

ch = ["a", "b", "c", "d", "e", "f", "g", "h"]
p ch.slice(0)
p ch.slice(0, 3)
p ch.slice(0..4)

การตรวจสอบค่าภายในอาเรย์

ต่อไปเป็นเมธอดสำหรับการตรวจสอบค่าในอาเรย์ เมธอดเหล่านี้สามารถใช้เพื่อตรวสอบว่ามีออบเจ็คที่ต้องการอยู่ในอาเรย์หรือไม่ นี่เป็นตัวอย่างการใช้งานเมธอดชนิดต่างๆ ในการค้นหาค่าและตรวจสอบค่าในอาเรย์

puts [].empty?
puts ["A", "B", "C"].empty?

puts ["Apple", "Banana", "Peach"].include?("Peach")
puts ["Apple", "Banana", "Peach"].include?("Grape")

numbers = [1, 2, 3, 4, 2]
puts numbers.count(2)
puts numbers.count {|x| x % 2 == 0}

puts ["Billy", "Mateo", "Samuel", "Mateo"].index("Mateo")
puts ["Billy", "Mateo", "Samuel", "Mateo"].rindex("Mateo")
p ["Billy", "Mateo", "Samuel", "Mateo"].rindex("Danny")

สองเมธอดแรกเป็นเมธอดที่ส่งค่ากลับเป็น Boolean เราสามารถใช้เมธอด empty? เพื่อตรวจสอบว่าอาเรย์นั้นว่างเปล่าหรือไม่ เมธอดนี้ส่งค่ากลับเป็นจริงถ้าหากอาเรย์ว่างเปล่าหรือไม่มีสมาชิกอยู่เลย ส่วนเมธอด include? นั้นใช้สำหรับตรวจสอบว่าออบเจ็คที่ระบุเป็นสมาชิกของอาเรย์หรือไม่

เมธอด count ใช้เพื่อนับว่าออบเจ็คที่ระบุมีจำนวนเท่าไหร่ในอาเรย์ ในตัวอย่างเราได้นับตัวเลข 2 ที่มีอยู่ในอาเรย์ นอกจากนี้ เรายังสามารถส่งบล็อคเข้าไปยังเมธอดได้ โดยที่สมาชิกแต่ละตัวในอาเรย์จะถูกส่งเข้าไปในบล็อคผ่านทางตัวแปร x ในตัวอย่าง เป็นการนับเลขคู่ทั้งหมดในอาเรย์ จากเงื่อนไข x % 2 == 0 ถ้าหากเงื่อนไขเป็นจริง โปรแกรมจะทำการนับออบเจ็คดังกล่าว

สุดท้ายเป็นเมธอดสำหรับค้นหาค่าภายในอาเรย์เช่นเดียวกันกับเมธอด include? แต่สิ่งที่แตกต่างกันคือ เมธอดเหล่านี้จะส่งค่ากลับเป็น Index ของออบเจ็คในอาเรย์แทน เมธอด index ใช้ค้นหาว่ามีออบเจ็คในอาเรย์หรือไม่ โดยเริ่มค้นหาจากสมาชิกตัวแรกของอาเรย์ ส่วนเมธอด rindex นั้นจะเริ่มค้นหาจากสมาชิกตัวสุดท้ายของอาเรย์ ถ้าหากพบ เมธอดส่งค่ากลับเป็น Index ของอาเรย์ และส่งค่ากลับเป็น nil ถ้าหากไม่พบ

true
false
true
false
2
3
1
3
nil

นี่เป็นผลลัพธ์การทำงานของโปรแกรมสำหรับการใช้เมธอดต่างๆ ในการค้นหาและตรวจสอบค่าภายในอาเรย์ในภาษา Ruby

การดำเนินการทางเซต

อาเรย์นั้นเหมือนกับเซต มันสามารถประกอบไปด้วยสมาชิกซึ่งเป็นออบเจ็คชนิดต่างๆ ในภาษา Ruby นั้นมีเมธอดเกี่ยวกับการดำเนินการทางเซต สำหรับจัดการข้อมูลในอาเรย์ นี่เป็นตัวอย่างการใช้งาน

a = [1, 2, 3, 4, 5]
b = [4, 5, 6, 7]

p a & b
p a.union(b)
p a.difference(b)

p ["a", "b", "a", "e", "d"].uniq

การดำเนินการพื้นฐานที่เราคุ้นเคยกันดีเกี่ยวกับเซตก็คือ การอินเตอร์เซกชัน (Intersection) การยูเนียน (Union) และการหาผลต่างระหว่างเซต (Difference) ซึ่งในภาษา Ruby นั้นมีเมธอดทั้งหมดสำหรับการดำเนินการเหล่านี้

a = [1, 2, 3, 4, 5]
b = [4, 5, 6, 7]

ในตัวอย่าง เรามีตัวแปรอาเรย์สองตัวแปรคือ a และ b ซึ่งแต่ละตัวแปรนั้นมีสมาชิกที่เป็นตัวเลขจำนวนเต็มอยู่ข้างใน ่คุณสามารถจินตนาการได้ว่าตัวแปรทั้งสองนั้นเป็นเหมือนกับเซต ดังนั้นเรามาใช้เมธอดเพื่อดำเนินการทางเซตกับเซตเหล่านี้

p a & b

ในคำสั่งแรก เราได้ใช้เมธอด Intersection & กับอาเรย์ a และอาเรย์ b ซึ่งการ Intersection นั้นจะส่งค่ากลับเป็นอาเรย์ใหม่เป็นค่าที่อยู่ทั้งในอาเรย์ a และอาเรย์ b

Note: ตั้งแต่ Ruby เวอร์ชัน 2.7.0 เป็นต้นไป คุณสามารถใช้เมธอด intersection สำหรับการอินเตอร์เซกชันแทนเมธอด & ได้ ทั้งสองเมธอดนั้นให้ผลลัพธ์ที่เหมือนกัน

p a.union(b)

ต่อมาเป็นการใช้เมธอด union เมธอดใช้สำหรับนำอาเรย์มารวมกัน มันจะส่งค่ากลับเป็นอาเรย์ที่เกิดจากการรวมกันจากสมาชิกในอาเรย์ทั้งสอง โดยจะนำค่าที่ซ้ำกันออกไป

p a.difference(b)

เมธอด difference ใช้สำหรับหาผลต่างของสมาชิกภายในอาเรย์ มันค่าส่งค่ากลับเป็นสมาชิกของอาเรย์ a ที่ไม่มีอยู่ในอาเรย์ b

p ["a", "b", "a", "e", "d"].uniq

เมธอด uniq ใช้สำหรับรับเอาอาเรย์ที่เหลือเพียงสมาชิกที่ไม่ซ้ำกัน โดยมันจะทำการลบข้อมูลที่ซ้ำกันออกไปให้เหลือเพียงตัวเดียว

[4, 5]
[1, 2, 3, 4, 5, 6, 7]
[1, 2, 3]
["a", "b", "e", "d"]

นี่เป็นผลลัพธ์การทำงานของโปรแกรมสำหรับการใช้งานเมธอดต่างๆ ในการดำเนินการทางเซตในภาษา Ruby

การหาค่าสถิติทางตัวเลข

เมื่อเรามีตัวเลขเป็นจำนวนมากเก็บไว้ในอาเรย์ บางครั้งเราอาจจะต้องการทราบข้อมูลทางสถิติบางอย่างเกี่ยวกับมัน ยกตัวอย่างเช่น ค่าที่น้อยที่สุด หรือมากที่สุดภายในอาเรย์ มาดูตัวอย่างการใช้งานเมธอดเหล่านี้กัน

numbers = [5, 1, 7, 12, 9, 8, 13, 6]
puts "Min: #{numbers.min}"
puts "Max: #{numbers.max}"
puts "Sum: #{numbers.sum}"

puts "First: #{numbers.first}"
puts "Last: #{numbers.last}"

สำหรับเมธอดกลุ่มแรก เมธอด min นั้นใช้สำหรับหาค่าที่น้อยที่สุดในอาเรย์ เมธอด max นั้นใช้สำหรับหาค่าที่มากที่สุดในอาเรย์ ส่วนเมธอด sum นั้นสำหรับใช้หาผลรวมของตัวเลขทั้งหมดภายในอาเรย์ ในการใช้งานเมธอด sum คุณจะต้องใช้กับอาเรย์ที่เป็นตัวเลขเท่านั้น ไม่เช่นนั้นจะเกิดข้อผิดพลาดขึ้นในโปรแกรม

ในเมธอดกลุ่มต่อมา เมธอด first ใช้เพื่อรับเอาสมาชิกตัวแรกในอาเรย์ และเมธอด last ใช้เพื่อรับเอาสมาชิกตัวสุดท้ายในอาเรย์ คุณสามารถใช้เมธอดเหล่านี้เพื่อตรวจสอบดูว่าสมาชิกตัวแรกและสมาชิกตัวสุดท้ายในอาเรย์คืออะไร

Min: 1
Max: 13
Sum: 61
First: 5
Last: 6

นี่เป็นผลลัพธ์การทำงานของโปรแกรมสำหรับการใช้เมธอดเพื่อหาค่าสถิติทางตัวเลขของอาเรย์ในภาษา Ruby

การเรียงลำดับ การเปลี่ยนลำดับของอาเรย์

การดำเนินการที่สำคัญอย่างหนึ่งเกี่ยวกับอาเรย์ก็คือการจัดเรียงข้อมูลภายในอาเรย์ ลองจินตนาการว่าคุณมีรายชื่อเป็นจำนวนมากในอาเรย์ และคุณต้องการเรียงชื่อเหล่านั้นตามตัวอักษร และแน่นอนว่า Ruby มีเมธอดสำหรับให้คุณทำเช่นนี้

numbers = [7, 5, 1, 12, 13, 9, 14, 2, 3, 10]
names = ["Billy", "Mateo", "Andy", "Lewis", "Steve"]

p numbers.reverse
p names.reverse

p numbers.sort
p names.sort

p numbers.sort.reverse
p names.sort.reverse

p numbers.shuffle
p names.join("-")

ในตัวอย่าง เพื่อให้คุณได้เห็นการทำงานของเมธอด sort ในประเภทข้อมูลที่ต่างกัน เราจึงได้ประกาศตัวแปร numbers ซึ่งเป็นอาเรย์ของตัวเลข และตัวแปร names ซึ่งเป็นอาเรย์ของ String ที่เก็บรายชื่อเอาไว้

p numbers.reverse
p names.reverse

ในตอนแรก เราใช้เมธอด reverse เพื่อกลับข้อมูลภายในอาเรย์ ผลลัพธ์ที่ได้ก็คือสมาชิกตัวแรกจะไปอยู่ท้ายสุดของอาเรย์ และสมาชิกตัวสุดท้ายจะมาอยู่ที่ตำแหน่แรกของอาเรย์

p numbers.sort
p names.sort

เมธอด sort นั้นใช้สำหรับจัดเรียงข้อมูลภายในอาเรย์จากน้อยไปมากสำหรับอาเรย์ที่เป็นตัวเลข และเรียงตามตัวอักษรสำหรับอาเรย์ที่เป็น String ดังนั้นถ้าหากเราต้องการเรียงข้อมูลจากมากไปน้อยหรือในทางกลับกัน เราสามารถเรียกใช้เมธอด reverse จากอาเรย์ที่จัดเรียงแล้วได้ เหมือนกับในคำสั่ง numbers.sort.reverse

p numbers.shuffle
p names.join("-")

สุดท้ายเมธอด shuffle ใช้สำหรับสุ่มตำแหน่งของสมาชิกภายในอาเรย์ใหม่ และเมธอด join นั้นจะส่งค่ากลับเป็น String มันใช้สำหรับนำค่าในอาเรย์มาต่อกันด้วย String ที่กำหนด ในกรณีนี้คือตัวอักษร -

[10, 3, 2, 14, 9, 13, 12, 1, 5, 7]
["Steve", "Lewis", "Andy", "Mateo", "Billy"]
[1, 2, 3, 5, 7, 9, 10, 12, 13, 14]
["Andy", "Billy", "Lewis", "Mateo", "Steve"]
[14, 13, 12, 10, 9, 7, 5, 3, 2, 1]
["Steve", "Mateo", "Lewis", "Billy", "Andy"]
[5, 10, 14, 3, 9, 2, 7, 13, 12, 1]
"Billy-Mateo-Andy-Lewis-Steve"

นี่เป็นผลลัพธ์การทำงานของโปรแกรมจากการใช้งานเมธอดเพื่อจัดเรียงข้อมูลในอาเรย์ กลับด้านข้อมูลในอาเรย์ และสุ่มตำแหน่งของสมาชิกภายในอาเรย์ใหม่

เมธอด select และ collect

ต่อไปเราจะพูดถึงเมธอดที่ใช้งานบ่อยมาก มันใช้สำหรับเลือกข้อมูลและแปลงข้อมูลในอาเรย์ นั่นคือเมธอด select และเมธอด collect มาดูตัวอย่างการใช้งาน

numbers = [1, 1, 2, 2, 3, 6, 8, 10]
p numbers.select {|x| x % 2 == 0}
p numbers.select {|x| x > 5}

lang = ["PHP", "Python", "Ruby", "Java", "C++"]
p lang.select {|x| x.length == 4}
p lang.select {|x| x.start_with?("P")}

ในตัวอย่าง เป็นการใช้งานเมธอด select ในการเลือกข้อมูลในอาเรย์จากเงื่อนไขที่กำหนด เมธอดนี้รับอาร์กิวเมนต์เป็นบล็อคที่จะส่งสมาชิกแต่ละตัวเข้าไปในบล็อคผ่านตัวแปร x เราจะต้องสร้างเงื่อนไขที่ส่งค่ากลับเป็นจริง เพื่อเลือกเอาสมาชิกในอาเรย์ที่ต้องการ

p numbers.select {|x| x % 2 == 0}
p numbers.select {|x| x > 5}

เราได้ใช้เมธอด select เพื่อเลือกเอาเลขคู่ที่อยู่ภายในอาเรย์จากเงื่อนไข x % 2 == 0 และเลือกเอาตัวเลขที่มีค่ามากกว่า 5 จากเงื่อนไข x > 5 โดยเมธอดนี้จะส่งกลับเป็นอาเรย์ของตัวเลขทั้งหมดที่ทำให้เงื่อนไขเป็นจริง

p lang.select {|x| x.length == 4}
p lang.select {|x| x.start_with?("P")}

ต่อมาเรามีตัวแปร lang ซึ่งเป็นอาเรย์ของภาษาเขียนโปรแกรม เราได้ใช้เมธอด select เพื่อเลือกเอาสมาชิกในอาเรย์ที่มีความยาวเท่ากับ 4 จากเงื่อนไข x.length == 4 และเลือกเอาสมาชิกในอาเรย์ที่ขึ้นต้นด้วยตัวอักษร P

[2, 2, 6, 8, 10]
[6, 8, 10]
["Ruby", "Java"]
["PHP", "Python"]

นี่เป็นผลลัพธ์การทำงานของโปรแกรม สำหรับการใช้งานเมธอด select เพื่อสร้างอาเรย์ใหม่จากการเลือกเอาข้อมูลในอาเรย์เดิมตามเงื่อนไขที่กำหนดภายในบล็อค

ต่อไปเป็นตัวอย่างการใช้งานเมธอด collect เพื่อเปลี่ยนแปลงข้อมูลภายในอาเรย์

numbers = [1, 2, 3, 4, 5, 6, 7, 8]
p numbers.collect {|x| x ** 2}
p numbers.collect {|x| "%b" % x}

names = ["Mateo", "Luke", "Danny", "Robert"]
p names.collect {|x| x.upcase}
p names.collect {|x| x.length}

ในตัวอย่าง เรามีอาเรย์ของตัวเลขและรายชื่อ เมธอด collect ใช้แปลงค่าของอาเรย์ปัจจุบันให้เป็นค่าที่เรากำหนด โดยเมธอดนี้จะรับอาร์กิวเมนต์เป็นบล็อค และสิ่งที่เราส่งกลับจากบล็อคจะกลายมาเป็นค่าใหม่ของอาเรย์ และเช่นเดิม สมาชิกแต่ละตัวจะถูกส่งเข้าไปในบล็อคผ่านตัวแปร x

p numbers.collect {|x| x ** 2}
p numbers.collect {|x| "%b" % x}

ในตัวอย่างแรก เราได้แปลงอาเรย์ของตัวเลขที่เรามีให้เป็นค่ากำลังสองของมัน และในคำสั่งต่อมาแปลงตัวเลขเหล่านั้นให้เป็น String ในรูปแบบของตัวเลขฐานสอง

p names.collect {|x| x.upcase}
p names.collect {|x| x.length}

ในตัวอย่างต่อมา เป็นการแปลงรายชื่อในอาเรย์ให้เป็นตัวพิมพ์ใหญ่ และหลังจากนั้นแปลงให้เป็นจำนวนของตัวอักษรทั้งหมดแทน

[1, 4, 9, 16, 25, 36, 49, 64]
["1", "10", "11", "100", "101", "110", "111", "1000"]
["MATEO", "LUKE", "DANNY", "ROBERT"]
[5, 4, 5, 6]

นี่เป็นผลลัพธ์การทำงานของโปรแกรม สำหรับการใช้งานเมธอด collect ในการแปลงข้อมูลในอาเรย์ให้เป็นข้อมูลใหม่จากข้อมูลเดิมที่มี

และอย่างที่คุณได้เห็นจากตัวอย่างของการใช้เมธอดทั้งสอง คุณสามารถทำอะไรกับมันได้อย่างมากมาย เนื่องจากว่าสองเมธอดนี้รับค่าเป็นบล็อค และให้เรากำหนดเงื่อนไขที่ต้องการเลือก หรือค่าที่ต้องการแปลงได้เอง

การวนรอบอาเรย์

อย่างที่คุณรู้ว่าเราสามารถใช้คำสั่งวนซ้ำ เช่น คำสั่ง for loop หรือ while loop เพื่อวนค่าในอาเรย์ อย่างไรก็ตาม Ruby มีสองเมธอดสำหรับวนค่าในอาเรย์ โดยที่คุณไม่จำเป็นต้องเขียนคำสั่งวนอ่านค่าเองให้ยุ่งยาก มาดูตัวอย่าง

numbers = [1, 2, 4, 6, 7, 10, 4, 8 ,13]

sum = 0
numbers.each {|x|
    sum = sum + x
    print "#{x}, "
}

puts
puts "Sum: #{sum}"
puts "Average: #{sum.to_f / numbers.length}"

ในตัวอย่าง เป็นการใช้งานเมธอด each เพื่อวนอ่านค่าภายในอาเรย์ เมธอดนี้รับอาร์กิวเมนต์เป็นบล็อค และเมธอดจะส่งสมาชิกในแต่ละรอบของการวนเข้าไปในบล็อคผ่านทางตัวแปร x เราสามารถใช้ตัวแปรดังกล่าวเหมือนกับการเข้าถึงข้อมูลภายในอาเรย์ผ่านทาง numbers[index]

ภายในบล็อค เราได้หาผลรวมของตัวเลขทั้งหมดในอาเรย์โดยเก็บเข้าในตัวแปร sum และแสดงข้อมูลสมาชิกในการวนแต่ละรอบ สุดท้ายเราแสดงผลรวมและค่าเฉลี่ยของตัวเลขทั้งหมดออกมาทางหน้าจอ

1, 2, 4, 6, 7, 10, 4, 8, 13,
Sum: 55
Average: 6.111111111111111

นี่เป็นผลลัพธ์การทำงานของโปรแกรมสำหรับการใช้งานเมธอด each เพื่อวนอ่านค่าภายในอาเรย์

numbers = [1, 2, 4, 6, 7, 10, 4, 8 ,13]
numbers.reverse.each {|x|
    print "#{x}, "
}

puts
numbers.sort.each {|x|
    print "#{x}, "
}

คุณสามารถใช้งานเมธอด each ร่วมกับเมธอดอื่น ได้ เช่น ใช้ร่วมกับเมธอด reverse เพื่อวนอ่านค่าในอาเรย์จากทิศทางตรงกันข้าม หรือเมธอด sort เพื่อวนค่าในอาเรย์ตามลำดับข้อมูลที่จัดเรียงแล้ว เหมือนในตัวอย่างด้านบน

อีกเมธอดหนึ่งในการวนรอบอาเรย์คือเมธอด each_index เมธอดนี้จะวนแต่ละ Index ในอาเรย์และส่ง Index เข้าไปในบล็อคเพื่อให้เราใช้งาน เราใช้เมธอดนี้ในกรณีที่เราต้องการนำค่า Index ของอาเรย์มาใช้งานด้วย เช่น นำมาแสดงผล

countries = ["Russia", "Germany", "Thailand", "Singapore", "Australia"]

countries.each_index { |index|
    puts "countries[#{index}]: #{countries[index]}"
}

ในตัวอย่าง เรามีตัวแปรอาเรย์ countries ซึ่งเก็บชื่อของประเทศในโลก หลังจากนั้นเราเรียกใช้เมธอด each_index เพื่อวนรอบอาเรย์ด้วย Index ของมัน

เมื่อคุณวนรอบอาเรย์ด้วยเมธอด each_index สิ่งที่ส่งเข้าไปในบล็อคนั้นจะมีเพียง Index ของข้อมูลในแต่ละรอบเท่านั้น ดังนั้นเพื่อเข้าถึงค่าสมาชิกของอาเรย์ เราจำเป็นต้องเข้าผ่าน Index ของมันเหมือนกับในคำสั่ง countries[index]

countries[0]: Russia
countries[1]: Germany
countries[2]: Thailand
countries[3]: Singapore
countries[4]: Australia

นี่เป็นผลลัพธ์การทำงานของโปรแกรม เราได้วนรอบอาเรย์โดยการแสดงทั้ง index และข้อมูลภายในอาเรย์ และเช่นเดียวกัน คุณสามารถใช้เมธอด each_index ร่วมกับเมธอดอื่นๆ ได้เช่นเดียวกันกับเมธอด each

การแปลงออบเจ็คเป็นอาเรย์

เมธอดสุดท้ายสำหรับบทนี้คือ เมธอดที่ใช้สำหรับแปลงออบเจ็คอื่นๆ ให้เป็นอาเรย์ นี่เป็นตัวอย่างการใช้งาน

p (1..10).to_a

hash = {
    "USD": "United States Dollar",
    "EUR": "Euro",
    "THB": "Thai Baht"
}
p hash.to_a

ในตัวอย่าง เป็นการใช้งานเมธอด to_a สำหรับแปลงออบเจ็คประเภท Range และ Hash ให้เป็นอาเรย์ เมธอด to_a นั้นพบได้ในคลาสของออบเจ็คที่สามารถวนรอบได้ เช่น Enumerator เป็นต้น

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[[:USD, "United States Dollar"], [:EUR, "Euro"], [:THB, "Thai Baht"]]

นี่เป็นผลลัพธ์การทำงานของโปรแกรม จากการแปลง Range และ Hash ให้เป็นอาเรย์ สำหรับการเรียกใช้เมธอด to_a บน Hash นั้นค่าที่ได้จะเป็นอาเรย์คู่ลำดับของ Key และ Value ของ Hash โดยที่ Key นั้นจะแสดงในรูปแบบของ Symbol เสมอ

ในบทนี้ เราได้พูดถึงเมธอดสำคัญในการจัดการอาเรย์ ซึ่งในภาษา Ruby นั้นมีเมธอดสำหรับจัดการอาเรย์เป็นจำนวนมาก อย่างไรก็ตาม ทั้งหมดที่เราได้กล่าวไปนั้นเป็นเมธอดเพียงส่วนหนึ่งเท่านั้น สำหรับเมธอดของอาเรย์ทั้งหมด คุณสามารถดูได้ที่ https://ruby-doc.org/core-2.7.0/Array.html