ตัวแปรในภาษา Ruby

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

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

ตัวแปรคืออะไร

ตัวแปร (Variables) คือสิ่งที่ใช้สำหรับเก็บข้อมูลในหน่วยความจำ โดยจะมีชื่อของตัวแปร (Identifier) เพื่อใช้ในการอ้างถึงข้อมูลดังกล่าว ซึ่งในภาษา Ruby คุณสามารถใช้ตัวแปรเพื่อเก็บข้อมูลประเภทต่างๆ ได้ไม่ว่าจะเป็น ตัวเลข ตัวอักษร ฟังก์ชัน และออบเจ็ค ซึ่งการเก็บข้อมูลไว้ในตัวแปรนั้น จะทำให้คุณสามารถนำข้อมูลมาใช้ในภายหลังในโปรแกรมได้ นอกจากนี้ ตัวแปรในภาษาคอมพิวเตอร์ยังสามารถเปลี่ยนแปลงค่าได้ตลอดเวลา

ในการประกาศตัวแปรในภาษา Ruby นั้นชื่อของตัวแปรจะต้องประกอบไปด้วย ตัวอักษร ตัวเลข และเครื่องหมาย _ (Underscore) และไม่สามารถขึ้นต้นด้วยตัวเลขได้ นั่นจะทำให้ Ruby สามารถแยกแยะระหว่างตัวแปรและรหัสอื่นๆ ในโค้ดของเราได้ นี่เป็นรูปแบบการประกาศตัวแปรในภาษา Ruby

name = value

จากรูปแบบการประกาศตัวแปรด้านบน name เป็นชื่อของตัวแปร ซึ่งมันใช้ในการอ้างถึงข้อมูลของตัวแปร และ value เป็นค่าของตัวแปรที่จะกำหนดให้กับตัวแปรดังกล่าว ซึ่งจะเป็น Literal ประเภทต่างๆ เช่น ตัวเลข String วันที่ ฟังก์ชัน หรือออบเจ็ค เป็นต้น

การประกาศและใช้งานตัวแปร

หลังจากที่คุณได้เห็นรูปแบบการประกาศตัวแปรแล้ว ต่อไปมาดูตัวอย่างการประกาศและใช้งานตัวแปรในภาษา Ruby

variable.rb
a = 3
b = 2
sum = a + b
puts sum

นี่เป็นผลลัพธ์ของการรันโปรแกรม หลังจากที่เรารันไฟล์ variable.rb

5

จากตัวอย่างนั้น เราได้ประกาศตัวแปรทั้งหมดสามตัว โดยตัวแปร a และ b นั้นจะเก็บค่าของตัวเลขจำนวนหนึ่ง แล้วนำตัวแปรทั้งสองมาบวกกันและเก็บผลลัพธ์ไว้ในตัวแปร sum และหลังจากนั้นเราแสดงผลค่าของตัวแปร sum ด้วยเมธอด puts ซึ่งจะเห็นว่าเราสามารถเก็บค่าไว้ในตัวแปรและนำมันมาใช้งาน

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

variable2.rb
name = "Mateo"
puts "His name is " + name
puts name + " is 18 years old"
puts name + " is programmer"

ในตัวอย่าง เราได้ประกาศตัวแปร name และกำหนดค่าให้กับตัวแปรเป็น "Mateo" ซึ่งเป็นข้อมูลประเภท String และหลังจากนั้น เราได้แสดงรายละเอียดเกี่ยวกับ Mateo ออกจากหน้าจอ สังเกตว่าเราได้เรียกใช้ตัวแปร name หลายครั้งหลังจากที่มันได้ถูกประกาศ และนี่แสดงให้เห็นว่าเราสามารถนำค่าในตัวแปรกลับมาใช้ซ้ำในโปรแกรมของเราได้

His name is Mateo
Mateo is 18 years old
Mateo is programmer

และนี่เป็นผลลัพธ์ของการรันโปรแกรม หลังจากที่เรารันไฟล์ variable2.rb ตอนนี้ให้คุณลองเปลี่ยนค่าในตัวแปร name ให้เป็นชื่อของคุณ และลองรันเพื่อดูผลลัพธ์การทำงานอีกครั้ง

ตอนนี้คุณคงเริ่มสนุกแล้ว และอย่างที่เราได้บอกไปว่าตัวแปรในภาษาคอมพิวเตอร์นั้นสามารถเปลี่ยนแปลงค่าได้ตลอดเวลา มาดูตัวอย่างกันต่อ

variable3.rb
width = 2
height = 3
puts("Area of rectangle is #{width * height}")

height = 4
puts("Now, area of rectangle is #{width * height}")

width = 0
height = 0
puts("Value of width = #{width}")
puts("Value of height = #{height}")

และนี่เป็นผลลัพธ์ของการรันโปรแกรม หลังจากที่เรารันไฟล์ variable3.rb

Area of rectangle is 6
Now, area of rectangle is 8
Value of width = 0
Value of height = 0

ในตัวอย่าง เราได้ประกาศตัวแปร width และ height เพื่อเก็บความยาวและความสูงของรูปสี่เหลี่ยม หลังจากนั้นเราแสดงผลพื้นที่ของรูปสี่เหลี่ยมนั้นออกมา โดยนำความยาวและความสูงมาคูณกัน

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

มาดูอีกตัวอย่างสำหรับกรณีที่เราต้องเปลี่ยนค่าตัวแปรเดิม ซึ่งเป็นสิ่งที่พบได้บ่อยในการเขียนโปรแกรม

variable4.rb
numbers = [3, 5, 10, 7, 22, 15]

sum = 0
max = numbers[0]
min = numbers[0]

numbers.each { |x|
    sum = sum + x
    max = x if x > max
    min = x if x < max
}

p numbers
puts "Sum = #{sum}"
puts "Max = #{max}"
puts "Min = #{min}"

นี่เป็นผลลัพธ์การทำงานของโปรแกรม หลังจากที่เรารันไฟล์ variable4.rb

[3, 5, 10, 7, 22, 15]
Sum = 62
Max = 22
Min = 3

ในตัวอย่าง เราได้ประกาศตัวแปร numbers ซึ่งเก็บข้อมูลที่เป็นอาเรย์ โดยอาเรย์นั้นเป็นข้อมูลชุดลำดับที่สามารถเก็บข้อมูลได้หลายค่า (คุณจะได้เรียนเกี่ยวกับอาเรย์ในบทของอาเรย์)

sum = 0
max = numbers[0]
min = numbers[0]

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

numbers.each { |x|
    sum = sum + x
    max = x if x > max
    min = x if x < max
}

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

p numbers
puts "Sum = #{sum}"
puts "Max = #{max}"
puts "Min = #{min}"

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

คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับเมธอด puts และ p ได้ที่บทการรับค่าและการแสดงผล

ค่าคงที่ในภาษา Ruby

ค่าคงที่ (Constants) นั้นเป็นตัวแปรที่ไม่สามารถเปลี่ยนค่าได้หลังจากที่มันถูกประกาศไปแล้ว ซึ่งตรงกันข้ามกับตัวแปรที่เรารู้จักก่อนหน้าซึ่งค่าของมันสามารถเปลี่ยนแปลงได้ตลอดเวลา โดยทั่วไปแล้วค่าคงที่จะใช้สำหรับกำหนดค่าที่แน่นอนที่จะไม่เปลี่ยนแปลง และใช้งานบ่อยๆ ซึ่งการใช้ค่าคงที่นั้นจะทำให้โปรแกรมของเราเป็นระเบียบและเข้าใจง่ายกว่า นี่เป็นรูปแบบการประกาศค่าคงที่ในภาษา Ruby

Name = Value

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

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

constant.rb
PI = 22 / 7

r = 5

puts "Area: #{2 * PI * r}"
puts "Circumference: #{PI * (r ** 2)}"
puts "Volume: #{(4 / 3) * PI * (r ** 3)}"
puts "Surface area: #{4 * PI * (r ** 2)}"

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

จากในนิพจน์ r ** 2 จะเห็นว่าเราใช้ตัวดำเนินการ ** (Power) ซึ่งมันหมายถึงการยกกำลัง และมีค่าเท่ากับ r2 Ruby เพิ่มตัวดำเนินการนี้มาเพื่ออำนวยความสะดวกในการเขียนโปรแกรม ซึ่งในภาษาอื่นๆ จะไม่มี คุณจะได้เรียนเกี่ยวกับตัวดำเนินการทั้งหมดในภาษา Ruby ในบทตัวดำเนินการ

Area: 30
Circumference: 75
Volume: 375
Surface area: 300

นี่เป็นผลลัพธ์หลังจากที่เรารันไฟล์โปรแกรม constant.rb

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

SITE_NAME = 'marcuscode'

puts "Welcome to #{SITE_NAME}"

SITE_NAME = 'mateocode'

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

Welcome to marcuscode
constant.rb:5: warning: already initialized constant SITE_NAME
constant.rb:1: warning: previous definition of SITE_NAME was here

นี่เป็นผลลัพธ์หลังจากที่เรารัน

ตัวแปรกับการรับค่าจากคีย์บอร์ด

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

จากรูปภาพด้านบนนั้น อธิบายได้ว่าเราสามารถหาด้านที่ยาวที่สุดที่ตรงข้ามกับมุมฉาก c เมื่อเราทราบ a และ b ได้ เพราะว่าความยาวของทั้งสามด้านนั้นมีความสัมพันธ์กันดังสมการ c2 = a2 + b2 ต่อไปเรามาเขียนโปรแกรมเพื่อหาค่า c กัน

pythagoras.rb
puts "Pythagoras calculator"
print "Enter a: "
a = gets.chomp.to_i

print "Enter b: "
b = gets.chomp.to_i

c = Math.sqrt((a ** 2) + (b ** 2))
puts "c = #{c}"

ในตัวอย่างด้านบน แสดงให้เห็นว่าเราสามารถรับค่าจากคีย์บอร์ดมาเก็บไว้ในตัวแปรได้ โดยในการรับค่านั้นจะใช้เมธอด gets และใช้เมธอด chomp เพื่อตัดอักษรขึ้นบรรทัดใหม่ออกไป (ตอนเรากด Enter) และเนื่องจากค่าที่ได้มาจากคีย์บอร์ดนั้นจะเป็น String เสมอเราใช้เมธอด to_i แปลงให้เป็นตัวเลข

c = Math.sqrt((a ** 2) + (b ** 2))

และหลังจากที่เราได้รับค่าตัวเลข 2 จำนวนมาเก็บไว้ในตัวแปร a และ b แล้ว เราได้ทำการคำนวณหาค่า c และเก็บไว้ในตัวแปร c หลังจากนั้นเราแสดงผลของ c ออกมาทางหน้าจอ

Pythagoras calculator
Enter a: 3
Enter b: 4
c = 5.0

และนี่เป็นผลลัพธ์การทำงานของโปรแกรม pythagoras.rb โดยหลังจากโปรแกรมรัน เรากรอกค่าของ a และ b เป็น 3 และ 4 ตามลำดับ โปรแกรมจะคำนวณหาค่า c และแสดงผลออกทางหน้าจอให้เราได้ทราบ

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

การแปลงประเภทข้อมูลในภาษา Ruby

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

type_conversion.rb
puts "Number conversions"
p 1.2.to_i
p 5.to_f
p 5.to_s
p 3.to_c
p 3.to_r

puts "String conversions"
p "13.25".to_i
p "-13.25".to_f
p "13.25".to_c
p "-13.25".to_r
p "marcuscode".to_i

ในตัวอย่างข้างบน นั้นเป็นการใช้งานเมธอดสำหรับแปลงข้อมูลในภาษา Ruby เมธอด to_i ใช้แปลงข้อมูลไปเป็นตัวเลขจำนวนเต็ม (Integer) เมธอด to_f ใช้แปลงข้อมูลไปเป็นตัวเลขจำนวนเต็ม (Floating) เมธอด `to_s ใช้แปลงข้อมูลไปเป็น String และเมธอด to_c ใช้แปลงข้อมูลไปเป็นจำนวนเชิงซ้อน (Complex number) และสุดท้ายเมธอด to_r ใช้แปลงข้อมูลไปเป็นศษส่วนหรือ (Rational number)

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

Number conversions
1
5.0
"5"
(3+0i)
(3/1)
String conversions
13
-13.25
(13.25+0i)
(-53/4)
0

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

fruit_store.rb
print "How many apple do you want?: "
apple = gets.chomp.to_i
print "How many orange do you want?: "
orange = gets.chomp.to_i

puts "Total money to pay is #{(apple * 10) + (orange * 8)} THB"

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

apple = gets.chomp.to_i

การรับค่าผ่านคีย์บอร์ดในภาษา Ruby ด้วยเมธอด gets.chomp นั้นค่าที่ได้จะเป็น String และเพื่อเอาไปคำนวณหาราคาผลไม้ทั้งหมด เราต้องแปลงจำนวนผลไม้ให้เป็นตัวเลขก่อนด้วยเมธอด to_i

How many apple do you want?: 3
How many orange do you want?: 5
Total money to pay is 70 THB

นี่เป็นผลลัพธ์การทำงานของโปรแกรม จะเห็นว่าเราต้องการซื้อแอปเปิ้ล 3 ลูกและส้ม 5 ลูก ดังนั้นยอดเงินที่เราต้องจ่ายก็คือ 70 บาทนั่นเอง

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

puts 5 * 3
puts "5" * 3
puts "Jaja" * 5
# puts 3 * "5" # Error

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

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

และในบรรทัดสุดท้าย ถ้าหากคุณนำคอมเมนต์ออกโปรแกรมจะเกิดข้อผิดพลาด เพราะว่าคุณไม่สามารถคูณตัวเลขกับ String ได้ในภาษา Ruby

15
555
JajaJajaJajaJajaJaja

นี่เป็นผลลัพธ์การทำงานของโปรแกรม

เมธอดสำหรับใช้งานกับตัวแปร

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

variable_method.rb
name = 'Mateo'
height = 178

def method1
    a = 10
    b = 20
    p local_variables
end

# Show all local variables
p local_variables

# Determine if variable is defined 
p local_variables.include?(:name)
p local_variables.include?(:weight)

# Determine variable type
p name.class
p height.class

# Determine if variable is a specified type
p name.instance_of? String
p name.instance_of? Integer
p [1,2].instance_of? Array

# Call method
method1

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

p local_variables

เมธอด local_variables ใช้สำหรับดูตัวแปรทั้งหมดที่เราได้สร้างขึ้น โดยเมธอดจะส่งค่ากลับเป็นอาเรย์ของ symbol ของตัวแปรทั้งหมด อย่างไรก็ตาม ถ้าหากคุณเรียกใช้งานเมธอด local_variables ภายในเมธอด method1 ดังตัวอย่าง ตัวแปร local ที่จะได้รับจะเป็นตัวแปรที่ประกาศในเมธอดเท่านั้น

p local_variables.include?(:name)
p local_variables.include?(:weight)

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

p name.class
p height.class

เมธอด class ใช้สำหรับตรวจสอบประเภทของตัวแปร โดยเมธอดจะส่งชื่อคลาสของตัวแปรกลับมา

p name.instance_of? String
p name.instance_of? Integer
p [1,2].instance_of? Array

และสุดท้ายเมธอด instance_of? ใช้สำหรับตรวจสอบว่าตัวแปรนั้นเป็นประเภทข้อมูลดังกล่าวหรือไม่ และในตัวอย่างตัวแปร name นั้นมีประเภทข้อมูลเป็น String และไม่ใช่ Integer และหลังจากนั้นเราตรวจสอบว่าอาเรย์มีประเภทข้อมูลเป็น Array หรือไม่

[:name, :height]
true
false
String
Integer
true
false
true
[:a, :b]

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

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

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