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