วิธีส่วนตัวใน Ruby คืออะไร
เป็นเมธอดประเภทหนึ่งที่คุณเรียกใช้ได้จากภายในคลาสที่กำหนดไว้เท่านั้น
วิธีนี้ช่วยให้คุณควบคุมการเข้าถึงวิธีการของคุณ
วิธี Ruby สามารถ :
- ส่วนตัว
- สาธารณะ (ค่าเริ่มต้น)
- ได้รับการปกป้อง
โดยค่าเริ่มต้น วิธีการทั้งหมดของคุณจะเป็น public .
ใครๆ ก็ใช้ได้!
แต่คุณสามารถเปลี่ยนได้โดยสร้างวิธีการ private หรือ protected .
เหตุใดจึงมีประโยชน์
เพราะคุณสามารถเปลี่ยนแปลงวิธีการเหล่านี้ได้ง่ายขึ้น
ลองนึกภาพว่าคุณกำลังเขียนไลบรารีโค้ดที่จะใช้ในโครงการต่างๆ ในที่ทำงาน
เมื่อโปรเจ็กต์เหล่านี้ใช้ไลบรารีของคุณ พวกเขาจะเรียกใช้เมธอดในคลาสที่คุณสร้างขึ้น
ตอนนี้ :
คุณเปิดตัวเวอร์ชันใหม่…
แต่คุณตัดสินใจเปลี่ยนชื่อเป็น public วิธีการ
นั่นจะทำให้เกิดข้อผิดพลาด ในทุกโครงการที่ใช้วิธีนี้!
จำสิ่งนี้ไว้ :
การมีวิธีการสาธารณะน้อยลงจะทำให้คุณมีอิสระในการเปลี่ยนแปลงในชั้นเรียนของคุณมากขึ้น
มาดูตัวอย่างโค้ดกัน!
ทำความเข้าใจกับวิธีการส่วนตัวใน Ruby
คุณเคยเห็นข้อความแสดงข้อผิดพลาด "วิธีส่วนตัวที่เรียกว่า" หรือไม่
อันนี้ :
self.puts 123 # NoMethodError: private method `puts' called
จากนั้นคุณได้ลองใช้ private ผิดวิธี
คุณสามารถใช้วิธีการส่วนตัวได้ด้วยตัวเองเท่านั้น
ตัวอย่าง :
puts 123
วิธีเดียวกันแต่ต้องเรียกแบบนี้
เมธอดส่วนตัวมักถูกเรียกในบริบทของ self .
กล่าวอีกนัยหนึ่ง…
คุณสามารถใช้วิธีการส่วนตัวได้เฉพาะกับ :
- วิธีอื่นๆ จากคลาสเดียวกัน
- วิธีการที่สืบทอดมาจากคลาสหลัก
- วิธีการที่รวมอยู่ในโมดูล
ซึ่งหมายความว่าคุณไม่สามารถเรียกเมธอดส่วนตัวจากภายนอกคลาสที่กำหนดเมธอดส่วนตัวได้
เพราะนั่นจะต้องมี “ผู้รับที่ชัดเจน”
เว้นแต่…
คุณใช้วิธีการเช่น send เพื่อข้ามกฎนี้
send(:puts, "apple")
คุณกำหนด private . อย่างไร วิธีการ?
ถูกใจสิ่งนี้ :
def bacon "private bacon" end private :bacon
คำว่า private ตัวเองไม่ใช่คีย์เวิร์ด แต่เป็นเมธอดที่กำหนดไว้ใน Kernel โมดูล
จะวางวิธีการส่วนตัวของคุณไว้ที่ใด
เป็นเรื่องปกติที่ชั้นเรียนจะมีวิธีการส่วนตัวมากกว่าหนึ่งวิธี
คุณจะวางวิธีการเหล่านี้ไว้ที่ไหน
ทำเช่นนี้ :
class Food def public_method end private def bacon end def orange end def coconut end end
ทุก วิธีอินสแตนซ์ หลัง private กลายเป็นวิธีการส่วนตัว
คุณสามารถใช้
private_class_method :method_nameหากคุณต้องการกำหนดวิธีการเรียนเป็นแบบส่วนตัว
เป็นรูปแบบทั่วไปในการกำหนดวิธีการสาธารณะทั้งหมดของคุณก่อน จากนั้นจึงกำหนด private ร่วมกันในตอนท้ายของชั้นเรียน
วิธีการสาธารณะ
สาธารณะคือการมองเห็นวิธีการเริ่มต้นใน Ruby
นี่คือตัวอย่าง :
def orange "Vitamin C" end
หากคุณมีวัตถุ food ที่กำหนด orange , คุณสามารถเรียกแบบนี้:
food.orange
หากวิธีการใดถูกทำให้เป็นส่วนตัวหรือมีการป้องกัน คุณสามารถทำให้เป็นสาธารณะได้อีกครั้ง
ถูกใจสิ่งนี้ :
public :orange
วิธีการป้องกันคืออะไร
วิธีการที่ได้รับการป้องกันนั้นพบได้น้อย
พวกเขาเป็นเหมือน private เมธอด แต่คุณสามารถเรียกพวกมันบนอ็อบเจ็กต์ได้ &ไม่ใช่แค่โดยตรง
หากคุณ ลองใช้ตัวอย่างนี้กับส่วนตัว คุณจะได้รับข้อผิดพลาด:
class Food
def initialize(name)
@name = name
end
def ==(other)
name == other.name
end
protected
attr_reader :name
end
food = Food.new("chocolate")
puts food == food
คุณได้รับข้อผิดพลาดเนื่องจาก name จะเป็นส่วนตัว ดังนั้นคุณจึงทำ other.name . ไม่ได้ .
แต่ด้วย protected รหัสนี้ใช้งานได้!
วิธีส่วนตัวกับวิธีป้องกัน
นั่นคือความแตกต่าง ความจริงที่ว่า protected เก็บเมธอด private แต่ยังให้คุณเรียกเมธอดนั้นบนอ็อบเจ็กต์ได้ด้วย
แบบส่วนตัวทำได้แค่ name ด้วยการป้องกัน คุณสามารถทำ object.name .
คุณควรใช้การป้องกันเมื่อใด
เฉพาะในกรณีที่คุณมีกรณีที่เฉพาะเจาะจงมาก เช่น เท่ากับ (== ) วิธีการ
เอกสาร Ruby แนะนำให้ใช้ private แทนที่จะ protected เมื่อใดก็ตามที่เป็นไปได้
และก็มีโน้ตนี้ :
“วิธีการที่ได้รับการป้องกันนั้นช้าเพราะไม่สามารถใช้แคชแบบอินไลน์ได้”
ฉันอยากรู้เรื่องนี้มาก ฉันจึงทำการวัดประสิทธิภาพ :
public: 2813891.9 i/s private: 2699273.8 i/s protected: 2572122.0 i/s
นั่นคือความแตกต่างของประสิทธิภาพ 8.5%
วิดีโอสอน
สรุป
คุณได้เรียนรู้เกี่ยวกับการมองเห็นวิธี Ruby วิธีสาธารณะ วิธีส่วนตัว และการป้องกัน นี่ไม่ใช่คำหลัก เป็นวิธีการที่กำหนดไว้ใน Module ชั้นเรียน
โปรดแชร์โพสต์นี้เพื่อให้คนอื่นเข้าใจหัวข้อนี้มากขึ้น!
ขอบคุณที่อ่านนะคะ 🙂
