อาร์กิวเมนต์วิธีอันทรงพลังของ Ruby &วิธีใช้งานอย่างถูกต้อง

ฉันได้รับอีเมลถามความคิดเห็นเกี่ยวกับเวลาที่จะใช้อาร์กิวเมนต์คำหลัก

ฉันคิดว่าฉันจะขยายคำตอบของฉันเป็นบทความเต็มเกี่ยวกับอาร์กิวเมนต์วิธี Ruby เพื่อให้ทุกคนได้รับประโยชน์ !

Ruby มีความยืดหยุ่นสูงเมื่อกล่าวถึงเมธอดอาร์กิวเมนต์

เรามีทุกอย่าง :

ตั้งแต่อาร์กิวเมนต์มาตรฐานที่ต้องการไปจนถึงอาร์กิวเมนต์ที่เป็นตัวเลือก &แม้แต่อาร์กิวเมนต์คีย์เวิร์ด (ระบุชื่อ)

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

การใช้อาร์กิวเมนต์ที่ถูกต้องจะทำให้โค้ดของคุณอ่านง่ายขึ้นและทำงานได้ง่ายขึ้น

เมื่อมีข้อสงสัยให้ใช้อาร์กิวเมนต์มาตรฐาน

อาร์กิวเมนต์ที่จำเป็นคือสิ่งที่คุณได้รับโดยค่าเริ่มต้น

นี่คือตัวอย่าง :

def write(file, data, mode)
end

write("cats.txt", "cats are cool!", "w")

หากคุณไม่ผ่านจำนวนอาร์กิวเมนต์ที่ต้องการ คุณจะได้รับข้อความแสดงข้อผิดพลาดที่คุ้นเคย:

write("shopping_list.txt", "bacon")

ArgumentError: wrong number of arguments (2 for 3)

ซึ่งหมายความว่าคุณให้วิธีการ 2 ข้อโต้แย้ง แต่ต้องการ 3 !

วิธีการที่ยืดหยุ่นพร้อมอาร์กิวเมนต์เสริม

คุณอาจต้องการทำให้อาร์กิวเมนต์ของคุณเป็นทางเลือกโดยการระบุค่าเริ่มต้น

ตัวอย่างเช่น :

def write(file, data, mode = "w")
end

ตอนนี้คุณสามารถโทร write มี 2 ​​อาร์กิวเมนต์ ซึ่งในกรณีนี้ mode จะเท่ากับค่าเริ่มต้น ("w" ) หรือคุณสามารถส่งผ่านอาร์กิวเมนต์ 3 รายการเพื่อแทนที่ค่าเริ่มต้นและรับผลลัพธ์ที่แตกต่างกัน

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

ใช้อาร์กิวเมนต์คำหลักเพื่อเพิ่มความชัดเจน

ข้อเสียอย่างหนึ่งของอาร์กิวเมนต์ที่จำเป็นและดีฟอลต์คืออาร์กิวเมนต์ขึ้นอยู่กับลำดับ

หมายความว่าคุณต้องผ่านข้อโต้แย้งในลำดับเดียวกัน

หากคุณส่งผิดลำดับ :

คุณจะได้ผลลัพธ์ที่คาดไม่ถึง!

ตัวอย่างเช่น ใน write วิธีคุณต้องเรียกใช้ด้วย file อันดับแรก ตามด้วย data และสุดท้าย mode .

def write(file, data, mode)
end

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

นี่คือตัวอย่าง :

def write(file:, data:, mode: "ascii")
end

วิธีนี้ทำให้คุณสามารถเรียกใช้เมธอดในลำดับที่ต่างออกไป:

write(data: 123, file: "test.txt")

แต่ที่สำคัญกว่านั้น เมื่อคุณเรียกเมธอด คุณจะเห็นความหมายของข้อโต้แย้ง .

ฉันไม่พบว่าตัวเองใช้อาร์กิวเมนต์คีย์เวิร์ดบ่อยนัก แต่อาจมีประโยชน์เมื่อคุณต้องการเพิ่มความชัดเจนในการเรียกใช้เมธอด

สมมติว่าเรามี Point ชั้นเรียน

เขียนแบบนี้ก็ได้ :

class Point
  def initialize(x: , y:)
    @x, @y = x, y
  end
end

point = Point.new(x: 10, y: 20)

วิธีนี้จะไม่เกิดความสับสนว่าตัวเลขใดในสองตัว (10 &20) ที่ตรงกับ x ค่าหรือ y ค่า

นั่นเป็นหนึ่งในเป้าหมายหลักของคุณในการเขียนโค้ด เพื่อหลีกเลี่ยงความสับสนและความเข้าใจผิดให้มากที่สุด .

หากการใช้อาร์กิวเมนต์ของคีย์เวิร์ดช่วยคุณได้ ให้ใช้อาร์กิวเมนต์

คิดถึงสิ่งนี้ :

“การเพิ่มอาร์กิวเมนต์คีย์เวิร์ดจะทำให้เข้าใจได้ง่ายขึ้นหรือจะเพิ่มงานและความยุ่งเหยิงให้กับโค้ดของฉันไหม”

อีกสิ่งหนึ่งเกี่ยวกับอาร์กิวเมนต์ของคีย์เวิร์ดคือมีความชัดเจนมากเกี่ยวกับอาร์กิวเมนต์ที่คุณขาดหายไป

ตัวอย่าง :

point = Point.new

# missing keywords: x, y

คุณยังสามารถรวมอาร์กิวเมนต์ของคีย์เวิร์ดกับอาร์กิวเมนต์ปกติได้

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

ตัวอย่างนี้คืออาร์กิวเมนต์ของคีย์เวิร์ดสำหรับ Float#round , Kernel#clone &String#lines เปิดตัวใน Ruby 2.4

ใช้อาร์กิวเมนต์ตัวแปรเพื่อเก็บค่าได้มากเท่าที่จำเป็น

จะทำอย่างไรถ้าคุณต้องการรับค่าไม่จำกัดจำนวน?

จากนั้นคุณสามารถใช้อาร์กิวเมนต์ตัวแปร :

def print_all(*args)
end

print_all(1, 2, 3, 4, 5)

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

คุณสามารถรวมสิ่งนี้กับอาร์กิวเมนต์ประเภทอื่นได้

ตัวอย่าง :

def print_all(title, *chapters)
end

นี่จะใช้อาร์กิวเมนต์ที่ 1 เป็น title และที่เหลือเป็น chapters อาร์เรย์ สังเกตว่าอาร์กิวเมนต์ตัวแปรต้อง หลัง อาร์กิวเมนต์ที่จำเป็นและเป็นทางเลือกทั้งหมดของคุณ และก่อนอาร์กิวเมนต์ของคีย์เวิร์ดใดๆ

ใช้ลำดับที่ถูกต้อง

นี่คือลำดับอาร์กิวเมนต์ที่ถูกต้อง หากคุณต้องการรวมและหลีกเลี่ยงข้อผิดพลาดทางไวยากรณ์:

required -> optional -> variable -> keyword

นี่คือวิธีการที่แสดงทุกประเภทอาร์กิวเมนต์ที่เป็นไปได้ :

def testing(a, b = 1, *c, d: 1, **x)
  p a,b,c,d,x
end

testing('a', 'b', 'c', 'd', 'e', d: 2, x: 1)

**x เหมือนกับอาร์กิวเมนต์ตัวแปร แต่สำหรับอาร์กิวเมนต์ของคีย์เวิร์ด มันจะเป็นแฮชแทนที่จะเป็นอาร์เรย์

ข้อโต้แย้งที่จับได้ทั้งหมด

คุณอาจเห็นสิ่งนี้ในบางโอกาส:

def print_all(*)
end

ซึ่งหมายความว่าวิธีการนี้ยอมรับข้อโต้แย้งใด ๆ แต่ไม่ได้ทำอะไรกับพวกเขา คล้ายกับการใช้อักขระขีดล่าง (_ ) ภายในบล็อกเพื่อแสดงว่าคุณไม่ได้ใช้อาร์กิวเมนต์ใด

การใช้งานจริงสำหรับสิ่งนี้อาจใช้ร่วมกับ super keyword:

class Food
  def nutrition(vitamins, minerals)
    puts vitamins
    puts minerals
  end
end

class Bacon < Food
  def nutrition(*)
    super
  end
end

bacon = Bacon.new

bacon.nutrition("B6", "Iron")

เมื่อnutritionของอาหาร เปลี่ยนรายการอาร์กิวเมนต์ คุณไม่จำเป็นต้องเปลี่ยนอาร์กิวเมนต์ใน Bacon ด้วย

สรุป

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

หวังว่าคุณจะพบว่าสิ่งนี้มีประโยชน์และน่าสนใจ!

แชร์โพสต์นี้บน Twitter เพื่อให้คนอื่นเห็น 🙂