Hash ในภาษา Ruby
ในบทนี้ คุณจะได้เรียนรู้เกี่ยวกับ Hash ในภาษา Ruby เราจะพูดเกี่ยวกับการประกาศและใช้งาน Hash ในการเขียนโปรแกรมพร้อมกับตัวอย่างการใช้งาน Hash สำหรับการแก้ปัญหาด้วยวิธีการต่างๆ และในตอนท้ายของบทเราจะแนะนำเมธอดที่สำคัญของ Hash และที่ใช้งานกันบ่อยๆ ที่คุณควรรู้จัก
การประกาศ Hash ในภาษา Ruby
Hash (แฮท) คือประเภทข้อมูลที่เก็บข้อมูลในรูปแบบของ Key และ Value โดยที่ทั้ง Key และ Value นั้นสามารถเป็นออบเจ็คชนิดใดก็ได้ การจัดเก็บข้อมูลของ Hash นั้นจะถูกจัดทำดัชนีอยู่ในหน่วยความจำโดย Key ของมัน นั่นจึงทำให้การเข้าถึงข้อมูลภายใน Hash รวดเร็วและมีประสิทธิภาพกว่าการเข้าถึงข้อมูลในรูปแบบปกติ นี่เป็นรูปแบบการประกาศ Hash ในภาษา Ruby
hash_name = { key1 => value1, key2 => value2, ... }
จากรูปแบบการประกาศ hash_name
เป็นชื่อตัวแปรของ Hash และค่าของ Hash นั้นจะอยู่ภายในวงเล็บปีกกา {}
และตามด้วยข้อมูลที่ประกอบไปด้วยคู่ของ Key และ Value ในรูปแบบ key => value
และคั่นสมาชิกแต่ละตัวด้วยเครื่องหมายคอมมา (,
) ในกรณีที่มีสมาชิกมากกว่าหนึ่ง ต่อไปเป็นตัวอย่างในการประกาศ Hash ในภาษา Ruby
countries = {
"th" => "Thailand",
"sg" => "Singapore",
"de" => "Germany"
}
numbers = {
1 => "One",
2 => "Two",
3 => "Three"
}
puts countries
puts numbers
ในตัวอย่าง เราได้ประกาศ Hash สองตัว ในตัวแปร countries
นั้นใช้สำหรับเก็บชื่อของประเทศ โดยมีชื่อย่อเป็น Key ของ Hash และในตัวแปร numbers
เก็บข้อความของตัวเลข โดยใช้เลขจำนวนเต็มเป็น Key ลองจินตนาการถึงอาเรย์ ในอาเรย์เราสามารถใช้เพียงเลขจำนวนเต็มเท่านั้นเพื่อเป็น Index ของอาเรย์ แต่สำหรับ Hash นั้นเราสามารถใช้ข้อมูลทุกประเภทเพื่อเป็น Key ของมัน
{"th"=>"Thailand", "sg"=>"Singapore", "de"=>"Germany"}
{1=>"One", 2=>"Two", 3=>"Three"}
นี่เป็นผลลัพธ์การทำงานของโปรแกรม เราได้แสดงเนื้อหาของตัวแปร Hash ทั้งสองด้วยเมธอด puts
อย่างหนึ่งที่น่าสนเกี่ยวกับ Hash ในภาษา Ruby คือคุณสามารถกำหนดค่าให้กับ Hash หลังจากที่มันถูกประกาศไปแล้วได้ ซึ่งจะทำให้เราสามารถสร้าง Hash แบบไดนามิกส์ได้
countries = {
"th" => "Thailand",
"sg" => "Singapore"
}
countries["de"] = "Germany"
countries["jp"] = "Japanese"
puts countries
ในตัวอย่าง เราได้ประกาศตัวแปร countries
และกำหนดสมาชิกสองตัวในตอนที่ประกาศ หลังจากนั้นเราได้กำหนดค่าให้กับ Hash ในภายหลังด้วยเมธอด []
{"th"=>"Thailand", "sg"=>"Singapore", "de"=>"Germany", "jp"=>"Japanese"}
นี่เป็นผลลัพธ์การทำงานของโปรแกรม จะเห็นว่าเราสามารถกำหนดค่าให้กับ Hash ในขณะที่โปรแกรมทำงานได้ ซึ่งนี่จะทำให้เราสามารถสร้าง Hash แบบไดนามิกส์ได้
การเข้าถึงข้อมูลภายใน Hash
หลังจากที่คุณได้ทราบวิธีการประกาศ Hash ในภาษา Ruby ไปแล้ว ขั้นตอนต่อไปในการทำงานกับ Hash ก็คือการเข้าถึงข้อมูลภายใน Hash การเข้าถึงข้อมูลนั้นหมายถึงการอ่านค่าหรือกำหนดค่าให้กับ Hash ต่อไปมาดูตัวอย่างการเข้าถึงข้อมูลภายใน Hash
countries = {
"th" => "Thailand",
"sg" => "Singapore",
"de" => "Germany"
}
puts countries["th"]
puts countries["sg"]
countries["th"] = "ประเทศไทย"
puts countries["th"]
ในตัวอย่าง เราได้ยกตัวแปรเดิมจากตัวอย่างก่อนหน้ามาใช้งาน ตัวแปร countries
นั้นเก็บชื่อของประเทศไว้สามชื่อ และมี Key เป็น String ซึ่งเป็นตัวอักษรย่อประเทศต่างๆ
puts countries["th"]
puts countries["sg"]
ต่อมาเป็นการเข้าถึงข้อมูลภายใน Hash และอย่างที่คุณเห็นว่าเราสามารถเข้าถึงข้อมูลภายใน Hash ด้วยเมธอด [key]
โดยการระบุ Key ของข้อมูลที่เราต้องการเข้าถึง เนื่องจากเราได้กำหนด Key เป็น String ในตอนที่ประกาศ ดังนั้นตอนเข้าถึงข้อมูลเราจะต้องใช้ Key เดียวกันเหมือนกับในคำสั่ง countries["th"]
countries["th"] = "ประเทศไทย"
ในบรรทัดต่อมาเป็นการเปลี่ยนแปลงค่าภายใน Hash ที่มี Key เป็น "th"
โดยการอัพเดทค่าใหม่เป็น "ประเทศไทย"
สังเกตว่าเราสามารถใช้เมธอด []
สำหรับการอ่านค่าและอัพเดทค่าภายใน Hash
Thailand
Singapore
ประเทศไทย
นี่เป็นผลลัพธ์การทำงานของโปรแกรม เราได้ประกาศตัวแปร Hash หลังจากนั้นเราได้เปลี่ยนแปลงค่าภายใน Hash และแสดงข้อมูลของ Hash มาดู
Hash กับ Symbol
ในการใช้งาน Hash นั้นมีเทคนิคอยู่อย่างหนึ่งคือ ถ้าหากเราต้องการอ่านค่าเพื่ออัพเดทข้อมูลภายใน Hash เป็นจำนวนมาก การใช้ Symbol เป็น Key ของ Hash แทน String นั้นจะทำให้เราสามารถเข้าถึงค่าของข้อมูลภายใน Hash ได้รวดเร็วขึ้น เนื่องจากว่า Symbol นั้นจะแชร์ออบเจ็คเดียวกันทั้งโปรแกรม
config = {
:name => "MarcusCode",
:font_size => 17,
:font_family => "Open Sans",
:color => "Blue"
}
puts "Welcome to #{config[:name]}"
puts "Its color is #{config[:color]}"
puts config
ในตัวอย่าง เรามีตัวแปร config
สำหรับเก็บค่าการตั้งค่าต่างๆ ของเว็บไซต์ เช่น ชื่อเว็บไซต์ ขนาดฟอนต์ ชื่อของฟอนต์ที่ใช้ และสีของเว็บไซต์ เนื่องจากค่าเหล่านี้จำเป็นที่จะต้องนำมาใช้งานทุกครั้งที่มีการเปิดหน้าเว็บไซต์ ดังนั้นเราจึงเก็บมันไว้ใน Hash และใช้ Symbol เพื่อให้การเข้าถึงข้อมูลภายใน Hash รวดเร็วมากขึ้น
puts "Welcome to #{config[:name]}"
puts "Its color is #{config[:color]}"
เมื่อเรากำหนด Key ของ Hash เป็น Symbol แล้วในการเข้าถึงข้อมูลก็จะต้องใช้ Symbol เช่นเดียวกัน
Welcome to MarcusCode
Its color is Blue
{:name=>"MarcusCode", :font_size=>17, :font_family=>"Open Sans", :color=>"Blue"}
นี่เป็นผลลัพธ์การทำงานของโปรแกรม อย่างไรก็ตาม มันขึ้นอยู่กับประเภทข้อมูลที่คุณใช้เป็น Key ของ Hash ถ้าหาก Key ของคุณเป็น String และไม่มีค่าว่าง คุณสามารถใช้ Symbol เป็น Key แทนได้ แต่ถ้าหากมันเป็น String ที่มีตัวอักษรเป็นจำนวนมาก การใช้ Symbol อาจจะเป็นเรื่องที่ไม่แนะนำ
คุณอาจจะสร้าง Symbol จาก String ในขณะที่โปรแกรมทำงานโดยการเรียกใช้เมธอด to_sym
บน String เพื่อแปลงให้เป็น Symbol นี่เป็นตัวอย่าง
colors = {
:red => "#f00",
:green => "#008000",
:blue => "#00f"
}
# Get data from hash via string
puts colors["red".to_sym]
user_color = "blue"
puts colors[user_color.to_sym]
ในตัวอย่าง เราได้ประกาศตัวแปร colors
ซึ่งเป็น Hash ที่เก็บรหัสของสี และเราใช้ชื่อสีซึ่งเป็น Symbol เป็น Key ในกรณีนี้ ในตอนที่เราต้องการอ่านข้อมูลภายใน Hash โดยผ่าน String ที่อาจจะรับค่ามาจากผู้ใช้งานโปรแกรมของเรา เราสามารถใช้เมธอด to_sym
เพื่อแปลง String ให้เป็น Symbol เพื่อที่เราจะสามารถอ่านค่าภายใน Hash ได้
การวนอ่านค่าภายใน Hash
เนื่องจาก Hash นั้นเป็นคอลเล็กชั่นของข้อมูล ดังนั้นในบางครั้งคุณอาจจะต้องการวนอ่านค่าทั้งหมดภายใน Hash และเช่นเดียวกับอาเรย์ Hash นั้นมีเมธอดจำนวนหนึ่งที่ให้เราสามารถวนอ่านข้อมูลทั้งหมดภายใน Hash ได้ มาดูตัวอย่าง
scores = {
"mateo" => 840,
"billy" => 723,
"daniel" => 1202,
"gary" => 650
}
scores.each {|key, value|
puts "#{key} has score #{value}"
}
ในตัวอย่าง เรามีตัวแปร scores
ซึ่งเก็บค่าคะแนนของผู้เล่นเกมโดยใช้ชื่อเป็น Key และเนื่องจากเราต้องการทราบว่าผู้เล่นแต่ละคนนั้นมีคะแนนเท่าไหร่ เราสามารถใช้เมธอด each
เพื่อวนอ่านค่าภาย Hash ได้
scores.each {|key, value|
puts "#{key} has score #{value}"
}
เมธอด each
นั้นรับบล็อคเป็นอาร์กิวเมนต์ และมันจะส่งค่า Key และ Value สำหรับการวนในแต่ละรอบเข้าไปในบล็อคผ่านทางตัวแปร key
และ value
ตามลำดับ ภายในบล็อคเราได้แสดงชื่อและตามด้วยคะแนนของพวกเขา
mateo has score 840
billy has score 723
daniel has score 1202
gary has score 650
นี่เป็นผลลัพธ์การทำงานของโปรแกรม เราได้แสดงเนื้อหาภายใน Hash ที่ประกอบไปด้วย Key และ Value ด้วยการวนรอบ Hash ด้วยเมธอด each
ในกรณีที่คุณอาจจะต้องการแค่ Key หรือ Value ของ Hash คุณสามารถใช้เมธอด each_key
และเมธอด each_value
สำหรับการทำงานดังกล่าวได้ ดังในตัวอย่างด้านล่างนี้
scores = {
"mateo" => 840,
"billy" => 723,
"daniel" => 1202,
"gary" => 650
}
scores.each_key {|key| puts key }
scores.each_value {|value| puts value }
ตัวอย่างการใช้งาน Hash
หลังจากที่คุณได้ทำความรู้จักกับ Hash ในเบื้องต้นไปแล้ว ต่อไปเป็นตัวอย่างการนำ Hash มาใช้งานในการเขียนโปรแกรม
Mateo เป็นบรรณารักษ์ของห้องสมุดแห่งหนึ่ง ในวันนี้มีผู้มาใช้งานห้องสมุดของเขาเป็นจำนวน 40 คน โดยผู้ที่เข้ามาใช้งานนั้นมีอายุอยู่ระหว่าง 18 - 28 ปี เขาต้องการทราบว่าผู้ที่มาใช้งานห้องสมุดนั้นแบ่งเป็นอายุต่างๆ อย่างละกี่คน เพื่อแก้ปัญหานี้ เขาจึงเขียนโปรแกรมด้วยการใช้ Hash เข้ามาช่วย และนี่เป็นโค้ดของโปรแกรม
people_age = [
18, 28, 23, 21, 18, 18, 27, 23, 24, 19,
26, 21, 22, 19, 23, 25, 21, 24, 21, 20,
23, 25, 26, 21, 26, 24, 27, 23, 20, 24,
23, 23, 18, 22, 26, 20, 27, 23, 27, 24
]
count = {}
people_age.each { |age|
if count.has_key?(age)
count[age] = count[age] + 1
else
count[age] = 1
end
}
puts count
ในตัวอย่าง นั้นเป็นโปรแกรมสำหรับนับแต่ละอายุที่คนมาใช้ห้องสมุดว่ามีจำนวนเท่าไหร่ ในตอนแรกของโปรแกรม ในตัวแปรอาเรย์ people_age
นั้นเป็นอายุทั้งหมดของผู้คนที่มาใช้ห้องสมุดที่เรามี
count = {}
หลังจากนั้นเราได้ประกาศตัวแปร count
ซึ่งเป็นตัวแปร Hash สำหรับนับอายุ โดยใช้อายุเป็น Key ของ Hash ในตอนแรก เราได้กำหนดค่าให้กับตัวแปรเป็น Hash ที่ว่างเปล่าเนื่องจากว่าเรายังไม่ได้เริ่มนับ และเราจะสร้าง Key ขึ้นมาในภายหลัง
if count.has_key?(age)
count[age] = count[age] + 1
else
count[age] = 1
end
หลังจากนั้นเราใช้เมธอด each
ของอาเรย์เพื่อวนอ่านค่าอายุทั้งหมดในอาเรย์ และภายในบล็อคเพื่อที่จะนับ เราได้ตรวจสอบว่าอายุ age
นั้นได้ถูกกำหนดเป็น Key ของ Hash แล้งหรือยัง ถ้าหากมีแล้วก็หมายความว่าเราเคยนับอายุนี้ไปแล้ว ดังนั้นเราจึงเพิ่มค่าของ Key ขึ้นไป 1 และถ้าหากยังไม่มี หมายความว่าเลขอายุนี้เพิ่'เจอครั้งแรก ดังนั้นเราจึงกำหนดค่าเริ่มต้นให้เป็น 1
puts count
และหลังจากนับเสร็จครบทุกคนแล้ว เราจะได้จำนวนของแต่ละอายุที่มาใช้ห้องสมุดในตัวแปร count
โดยมีเลขอายุเป็น Key ของ Hash
{18=>4, 28=>1, 23=>8, 21=>5, 27=>4, 24=>5, 19=>2, 26=>4, 22=>2, 25=>2, 20=>3}
นี่เป็นผลลัพธ์การทำงานของโปรแกรม ในตอนนี้คุณจะเห็นว่าคนที่อายุ 23 ปีนั้นชอบมาอ่านหนังสือในห้องสมุดมากที่สุดถึง 8 คน ในขณะที่คนที่อายุ 28 ปีนั้นมาห้องสมุดน้อยที่สุดเพียงแค่ 1 คน
จากในตัวอย่างของการนับอายุนั้น จะเห็นว่าเราสามารถใช้ Hash ในการแก้ปัญหานี้ได้ เนื่องจากว่าเราต้องการนับคนที่มาใช้โดยแบ่งจากอายุของพวกเขา ดังนั้นสิ่งที่เราจะใช้เป็น Key ของ Hash ก็คืออายุนั้นเอง
อีกตัวอย่างหนึ่งของการใช้งาน Hash คือการใช้เก็บข้อมูลที่สามารถอ้างถึงได้โดย Key ซึ่ง Key ของ Hash นั้นควรจะเป็นสิ่งที่สั้นและกระชับ ต่อมาดูตัวอย่างของโปรแกรมที่อธิบายเกรดที่คุณได้ว่าเป็นอย่างไร นี่เป็นโค้ดของโปรแกรม
grade_des = {
"A" => "Excellent",
"B" => "Very good",
"C" => "Good",
"D" => "Acceptable",
"F" => "Failure"
}
print "What is your grade (A-F): "
grade = gets.chomp
if grade_des.has_key?(grade)
puts "Your grade is #{grade_des[grade]}"
else
puts "Please enter a valid grade"
end
ในตัวอย่าง เราได้พัฒนาโปรแกรมเพื่อให้นักเรียนกรอกเกรดของพวกเขาผ่านทางคีย์บอร์ดเป็น A-F
และโปรแกรมจะบอกว่าเกรดเหล่านั้นมีหมายความว่าอย่างไร ในกรณีนี้ เราใช้ตัวอักษรย่อของเกรดเป็น Key ของ Hash และคำอธิบายเป็น Value
print "What is your grade (A-F): "
grade = gets.chomp
ในตอนแรก โปรแกรมถามเพื่อให้นักเรียนกรอกเกรดของพวกเขาผ่านทางคีย์บอร์ด โดยแสดงข้อความบอกว่าเกรดที่กรอกต้องเป็น A-F เท่านั้น
if grade_des.has_key?(grade)
puts "Your grade is #{grade_des[grade]}"
else
puts "Please enter a valid grade"
end
ก่อนทำการแสดงคำอธิบายของเกรดที่นักเรียนกรอกเข้ามา เราได้ใช้เมธอด has_key?
เพื่อตรวจสอบว่าเกรดที่เป็น Key นั้นมีอยู่ภายใน Hash หรือไม่ ถ้าหากไม่มีเราแสดงข้อความบอกว่าเกรดที่กรอกไม่ถูกต้อง และถ้าหากมี เราแสดงคำอธิบายของเกรดผ่าน Key ของมันด้วยคำสั่ง grade_des[grade]
What is your grade (A-F): A
Your grade is Excellent
What is your grade (A-F): C
Your grade is Good
นี่เป็นผลลัพธ์การทำงานของโปรแกรม เราได้รันโปรแกรมสองครั้งและกรอกเกรดเป็น A
และ C
ตามลำดับ และจากตัวอย่างนี้แสดงให้เห็นว่า เราสามารถใช้ Hash เพื่อสร้างเงื่อนไขแทนการใช้งานคำสั่ง if else ได้
Hash methods
สำหรับเนื้อหาในส่วนสุดท้ายของบทเรียนนี้นั้นจะเป็นตัวอย่างการใช้งาน Hash เมธอด ซึ่งภาษา Ruby นั้นได้ให้เมธอดที่มากับคลาส Hash
เพื่อให้เราสามารถทำงานกับ Hash ได้ง่ายขึ้น เนื่องจากเมธอดของ Hash นั้นมีเป็นจำนวนมาก ดังนั้นในตัวอย่างของเราจะเป็นเมธอดที่ใช้งานบ่อยเท่านั้น มาดูตัวอย่างแรกกัน
month = {
"JAN" => "January",
"FEB" => "February",
"MAR" => "March",
"APR" => "April",
"MAY" => "May",
"JUN" => "June"
}
puts month.length
month.delete("FEB")
month.delete("JUN")
puts month.length
month.clear
puts month.empty?
ในตัวอย่าง เราได้แนะนำการใช้งานของ 4 เมธอดของ Hash เราได้ประกาศตัวแปร month
ซึ่งเก็บค่าเป็นชื่อของเดือน โดยใช้ตัวย่อของเดือนเป็น Key ของ Hash
puts month.length
month.delete("FEB")
month.delete("JUN")
puts month.length
เราใช้เมธอด length
เพื่อนับจำนวนสมาชิกภายใน Hash หลังจากนั้นเราได้ทำการลบข้อมูลออกจาก Hash ด้วยเมธอด delete
โดยการระบุผ่าน Key ของมัน และนับดูจำนวนสมาชิกของ Hash อีกครั้ง
month.clear
puts month.empty?
เราสามารถใช้เมธอด clear
เพื่อลบข้อมูลทั้งหมดออกจาก Hash ได้ และสุดท้ายเมธอด empty?
ใช้เพื่อตรวจสอบว่า Hash ว่างหรือไม่
6
4
true
และนี่เป็นผลลัพธ์การทำงานของโปรแกรมจากการใช้งานเมธอดของ Hash
ต่อไปจะเป็นการใช้งานเมธอดสำหรับตรวจสอบค่าภายใน Hash ซึ่งสำหรับบางเมธอดนั้นคุณอาจจะได้เห็นไปก่อนหน้านี้แล้ว
month = {
"JAN" => "January",
"FEB" => "February",
"MAR" => "March",
"APR" => "April",
"MAY" => "May",
"JUN" => "June"
}
puts month.has_key?("JAN")
puts month.has_key?("OCT")
puts month.has_value?("March")
puts month.has_value?("MARCH")
puts month.fetch("MAY")
puts month.fetch("SEP", "September")
ในตัวอย่างของเรานั้นเราได้ใช้ข้อมูลของ Hash จากตัวอย่างก่อนหน้า แต่ในตัวอย่างนี้เป็นการใช้งานเมธอดสำหรับตรวจสอบและอ่านข้อมูลจาก Hash
puts month.has_key?("JAN")
puts month.has_key?("OCT")
เมธอดแรกนั้นเป็นเมธอด has_key?
มันใช้สำหรับตรวจสอบว่ามี Key ดังกล่าวอยู่ใน Hash หรือไม่ เรามักจะใช้เมธอดนี้เพื่อตรวจสอบก่อนที่จะอ่านข้อมูลจาก Hash
puts month.has_value?("March")
puts month.has_value?("MARCH")
ต่อมาเมธอด has_value?
นั้นใช้สำหรับตรวจสอบว่าภายใน Hash นั้นมีค่าดังกล่าวอยู่หรือไม่ ในภาษา Ruby นั้นค่าของ Hash สามารถซ้ำกันได้ ในขณะที่ Key จะซ้ำกันไม่ได้
puts month.fetch("MAY")
puts month.fetch("SEP", "September")
และสุดท้าย เมธอด fetch
มันใช้สำหรับอ่านค่าจาก Hash ด้วย Key เช่นเดียวกับการใช้งานผ่านเมธอด [key]
แต่สิ่งที่แตกต่างกันคือถ้าหากไม่มี Key ดังกล่าวอยู่ เมธอด fetch
จะเกิดข้อผิดพลาด KeyError
ขึ้น สำหรับการใช้งานเมธอดนี้ เราสามารถกำหนดค่าเริ่มต้นที่จะให้ส่งกลับได้ในกรณีที่ไม่พบ Key
true
false
true
false
May
September
นี่เป็นผลลัพธ์การทำงานของโปรแกรม
units = {
"km" => "Kilometer",
"m" => "Meter",
"cm" => "Centimeter",
"mm" => "Millimeter",
"µm" => "Micrometer"
}
p units.keys
p units.values
p units.invert
ในตัวอย่างต่อมาเรามีตัวแปร units
ที่ใช้สำหรับเก็บชื่อของหน่วยวัดความยาว โดยใช้ตัวอักษรย่อเป็น Key ของ Hash และเราได้แนะนำการใช้งานของ 3 เมธอดสำหรับตัวอย่างนี้
p units.keys
p units.values
เมธอด keys
นั้นส่งค่ากลับเป็นอาเรย์ของ Key ทั้งหมดที่อยู่ใน Hash ส่วนเมธอด values
นั้นส่งค่ากลับเป็นอาเรย์ของ Value ทั้งหมด
p units.invert
สำหรับเมธอด invert
ใช้เพื่อแปลงกลับจาก Key ให้เป็น Value และในทางกลับกัน
["km", "m", "cm", "mm", "µm"]
["Kilometer", "Meter", "Centimeter", "Millimeter", "Micrometer"]
{"Kilometer"=>"km", "Meter"=>"m", "Centimeter"=>"cm", "Millimeter"=>"mm", "Micrometer"=>"µm"}
นี่เป็นผลลัพธ์การทำงานของโปรแกรม เราได้ใช้เมธอดเพื่อรับเอาอาเรย์ของ Key และ Value และกลับด้านของ Hash
ในบทนี้ คุณได้เรียนรู้เกี่ยวกับ Hash ในภาษา Ruby เราได้พูดถึงการสร้างและนำ Hash ไปใช้งานพร้อมกับยกตัวอย่างการใช้งาน Hash ในรูปแบบต่างๆ ในตอนท้าย เราได้แนะเมธอดพื้นฐานของ Hash ที่สามารถช้วยให้อำนวยความสะดวกให้กับเราในการเขียนโปรแกรมได้ ในตอนนี้ เราหวังว่าคุณสามารถนำ Hash ไปใช้งานในการแก้ปัญหาการเขียนโปรแกรมได้อย่างมีประสิทธิภาพได้