do..end vs braces แบบหยิกสำหรับบล็อกใน Ruby

ฉันมีเพื่อนร่วมงานที่พยายามโน้มน้าวใจฉันว่าฉันไม่ควรใช้ do..end และใช้วงเล็บปีกกาเพื่อกำหนดบล็อกหลายเส้นในรูบี

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

แล้วมันคืออะไรและทำไม? (ตัวอย่างของรหัส shoulda บางอย่าง)

context do
  setup { do_some_setup() }
  should "do somthing" do
    # some more code...
  end
end

หรือ

context {
  setup { do_some_setup() }
  should("do somthing") {
    # some more code...
  }
}

โดยส่วนตัวแล้วการดูที่ด้านบนตอบคำถามของฉัน แต่ฉันต้องการเปิดสิ่งนี้ให้กับชุมชนส่วนใหญ่

หลักการทั่วไปคือการใช้ do..end สำหรับบล็อกหลายบรรทัดและเครื่องหมายปีกกาสำหรับบล็อกบรรทัดเดียว แต่ก็มีความแตกต่างระหว่างทั้งสองที่สามารถแสดงด้วยตัวอย่างนี้:

puts [1,2,3].map{ |k| k+1 }
2
3
4
=> nil
puts [1,2,3].map do |k| k+1; end
#<Enumerator:0x0000010a06d140>
=> nil

ซึ่งหมายความว่า {} มีลำดับความสำคัญสูงกว่า do..end ดังนั้นโปรดระลึกไว้เสมอเมื่อตัดสินใจว่าคุณต้องการใช้อะไร

PS: อีกตัวอย่างหนึ่งที่ต้องจำไว้ในขณะที่คุณพัฒนาความชอบของคุณ

รหัสต่อไปนี้:

task :rake => pre_rake_task do
  something
end

จริงๆหมายถึง:

task(:rake => pre_rake_task){ something }

และรหัสนี้:

task :rake => pre_rake_task {
  something
}

จริงๆหมายถึง:

task :rake => (pre_rake_task { something })

ดังนั้นเพื่อให้ได้คำจำกัดความที่แท้จริงที่คุณต้องการด้วยเครื่องหมายปีกกาคุณต้องทำ:

task(:rake => pre_rake_task) {
  something
}

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

จากการเขียนโปรแกรม Ruby :

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

ดังนั้นรหัส

f param {do_something()}

ผูกบล็อกกับparamตัวแปรในขณะที่รหัส

f param do do_something() end

fผูกปิดกั้นการทำงานของ

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

มีความเห็นเกี่ยวกับเรื่องนี้เล็กน้อยมันเป็นเรื่องของความชอบส่วนตัว rubyists หลายคนใช้วิธีการที่คุณทำ อย่างไรก็ตามสไตล์อื่นสองแบบที่ใช้กันทั่วไปคือให้ใช้อย่างใดอย่างหนึ่งหรืออย่างอื่นหรือใช้{}สำหรับบล็อกที่คืนค่าและdo ... endสำหรับบล็อกที่ดำเนินการสำหรับผลข้างเคียง

มีประโยชน์สำคัญอย่างหนึ่งต่อการจัดฟันแบบขดคือผู้แก้ไขหลายคนมีเวลามากขึ้นในการจับคู่ทำให้การแก้ไขข้อผิดพลาดบางประเภทง่ายขึ้นมาก ในขณะเดียวกันคำหลัก "do ... end" นั้นค่อนข้างยากที่จะจับคู่โดยเฉพาะเมื่อ "end" จับคู่กับ "ถ้า"

กฎที่พบบ่อยที่สุดที่ฉันเคยเห็น (ล่าสุดในEloquent Ruby ) คือ:

• ถ้าเป็นบล็อกหลายบรรทัดให้ใช้ do / end
• หากเป็นบล็อกเส้นเดียวให้ใช้ {}

ฉันลงคะแนนให้ทำ / จบ

การประชุมมีdo .. endไว้สำหรับ multiline และ{ ... }สำหรับหนึ่ง liners

แต่ฉันชอบที่do .. endดีกว่าดังนั้นเมื่อฉันมีหนึ่งซับฉันใช้do .. endต่อไป แต่จัดรูปแบบตามปกติสำหรับทำ / สิ้นสุดในสามบรรทัด ทำให้ทุกคนมีความสุข

  10.times do 
    puts ...
  end

ปัญหาหนึ่ง{ }คือว่ามันเป็นบทกวี - โหมด - ศัตรู (เพราะพวกเขาผูกแน่นกับพารามิเตอร์สุดท้ายและไม่ใช่วิธีการโทรทั้งหมดดังนั้นคุณต้องรวมวิธีการ parens) และพวกเขาเพียงใจของฉันดูไม่ดี พวกเขาไม่ได้กลุ่มคำสั่งและพวกเขาปะทะกับค่าคงที่แฮสำหรับอ่านง่าย

นอกจากนี้ฉันเคยเห็น{ }โปรแกรม C มากพอ วิธีของรูบี้ตามปกติดีกว่า มีifบล็อกประเภทหนึ่งอยู่อย่างแน่นอนและคุณไม่ต้องย้อนกลับไปและเปลี่ยนคำสั่งเป็นคำสั่งผสม

rubyists คู่ที่มีอิทธิพลแนะนำให้ใช้การจัดฟันเมื่อคุณใช้ค่าส่งคืนและทำ / สิ้นสุดเมื่อคุณไม่

http://talklikeaduck.denhaven2.com/2007/10/02/ruby-blocks-do-or-brace (บน archive.org)

http://onestepback.org/index.cgi/Tech/Ruby/BraceVsDoEnd.rdoc (บน archive.org)

ดูเหมือนว่าเป็นการปฏิบัติที่ดีโดยทั่วไป

ฉันจะปรับเปลี่ยนหลักการนี้เล็กน้อยเพื่อบอกว่าคุณควรหลีกเลี่ยงการใช้ do / end ในบรรทัดเดียวเพราะอ่านยากขึ้น

คุณต้องระวังให้มากขึ้นด้วยการใช้เครื่องมือจัดฟันเพราะมันจะผูกเข้ากับ param สุดท้ายของเมธอดแทนการเรียกเมธอดทั้งหมด เพียงเพิ่มวงเล็บเพื่อหลีกเลี่ยงปัญหานั้น

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

ตัวอย่างหนึ่งก็คือถ้าคุณอ้างอิงจากพื้นหลัง JAVA สำหรับวิธีบูลีนที่คุณอาจใช้

def isExpired
  #some code
end 

สังเกตเห็นกรณีอูฐและส่วนใหญ่ 'เป็น' คำนำหน้าเพื่อระบุว่าเป็นวิธีบูลีน

แต่ในโลกทับทิมวิธีเดียวกันก็คือ

def expired?
  #code
end

ดังนั้นฉันคิดว่าเป็นการส่วนตัวดีกว่าไปกับ 'วิธี ruby' (แต่ฉันรู้ว่าต้องใช้เวลาพอสมควรที่จะเข้าใจ (ใช้เวลาประมาณ 1 ปี: D))

ในที่สุดฉันจะไปกับ

do 
  #code
end

บล็อก

ฉันใส่คำตอบอีกครั้งแม้ว่าความแตกต่างที่ยิ่งใหญ่ได้ชี้ให้เห็นแล้ว (การอ้างอิง / การผูกมัด) และนั่นอาจทำให้เกิดปัญหาในการค้นหาปัญหาได้ยาก (Tin Man และคนอื่น ๆ ชี้ให้เห็น) ฉันคิดว่าตัวอย่างของฉันแสดงปัญหากับโค้ดขนาดสั้นที่ไม่ปกตินักแม้แต่โปรแกรมเมอร์ที่มีประสบการณ์ก็ไม่ได้อ่านเหมือนวันอาทิตย์:

module I18n
    extend Module.new {
        old_translate=I18n.method(:translate)
        define_method(:translate) do |*args|
            InplaceTrans.translate(old_translate, *args)
        end
        alias :t :translate
    }
end

module InplaceTrans
    extend Module.new {
        def translate(old_translate, *args)
            Translator.new.translate(old_translate, *args)
        end
    }
end

จากนั้นฉันก็ทำโค้ดให้สวยงาม ...

#this code is wrong!
#just made it 'better looking'
module I18n
    extend Module.new do
        old_translate=I18n.method(:translate)
        define_method(:translate) do |*args|
            InplaceTrans.translate(old_translate, *args)
        end
        alias :t :translate
    end
end

ถ้าคุณเปลี่ยน {}นี่do/endคุณจะได้รับข้อผิดพลาดวิธีการนั้นtranslateนั้นไม่มีอยู่ ...

ทำไมสิ่งนี้เกิดขึ้นที่นี่มากกว่าหนึ่ง - ความสำคัญ แต่จะใส่เหล็กดัดไว้ตรงไหนล่ะ? (@The Tin Man: ฉันมักจะใช้เครื่องมือจัดฟันเหมือนคุณ แต่ที่นี่ ... ดูแล)

ดังนั้นทุกคำตอบที่ชอบ

If it's a multi-line block, use do/end
If it's a single line block, use {}

เป็นเพียง ผิดถ้าใช้โดยไม่ต้อง "แต่จับตาดู / นำหน้า!"

อีกครั้ง:

extend Module.new {} evolves to extend(Module.new {})

และ

extend Module.new do/end evolves to extend(Module.new) do/end

(สิ่งที่เคยเป็นผลมาจากการขยายทำกับบล็อก ... )

ดังนั้นหากคุณต้องการใช้ do / end ใช้สิ่งนี้:

#this code is ok!
#just made it 'better looking'?
module I18n
    extend(Module.new do 
        old_translate=I18n.method(:translate)
        define_method(:translate) do |*args|
            InplaceTrans.translate(old_translate, *args)
        end
        alias :t :translate
    end)
end

มาถึงอคติส่วนตัวฉันชอบวงเล็บปีกกามากกว่าบล็อก do / end เนื่องจากเป็นที่เข้าใจได้ง่ายกว่านักพัฒนาจำนวนมากเนื่องจากภาษาพื้นหลังส่วนใหญ่ใช้พวกมันมากกว่าการประชุม do / end เมื่อพูดถึงคีย์ที่แท้จริงคือการทำข้อตกลงภายในร้านของคุณหากนักพัฒนา 6/10 ใช้งานมากกว่าที่ทุกคนควรใช้พวกเขาถ้า 6/10 ใช้วงเล็บปีกกาแล้วยึดติดกับกระบวนทัศน์นั้น

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

มีความแตกต่างเล็กน้อยระหว่างพวกเขา แต่ {} ผูกแน่นกว่าทำ / สิ้นสุด

สไตล์ส่วนตัวของฉันคือการเน้นการอ่านมากกว่ากฎเข้มงวดของ{... }VS do... endทางเลือกเมื่อเลือกที่เป็นไปได้ดังกล่าว ความคิดในการอ่านของฉันมีดังนี้:

[ 1, 2, 3 ].map { |e| e + 1 }      # preferred
[ 1, 2, 3 ].map do |e| e + 1 end   # acceptable

[ 1, 2, 3 ].each_with_object [] do |e, o| o << e + 1 end # preferred, reads like a sentence
[ 1, 2, 3 ].each_with_object( [] ) { |e, o| o << e + 1 } # parens make it less readable

Foo = Module.new do     # preferred for a multiline block, other things being equal
  include Comparable
end

Foo = Module.new {      # less preferred
  include Comparable
}

Foo = Module.new { include Comparable }      # preferred for a oneliner
Foo = module.new do include Comparable end   # imo less readable for a oneliner

[ [ 1 ], [ 1, 2 ] ].map { |e| e.map do |e| e + 1 end }  # slightly better
[ [ 1 ], [ 1, 2 ] ].map { |e| e.map { |e| e + 1 } }     # slightly worse

ในไวยากรณ์ที่ซับซ้อนมากขึ้นเช่นบล็อกหลายระดับซ้อนกันฉันพยายามที่จะกระจาย{... }และdo... endตัวคั่นเพื่อผลลัพธ์ที่เป็นธรรมชาติที่สุดเช่น

Foo = Module.new { 
  if true then
    Bar = Module.new {                          # I intersperse {} and keyword delimiters
      def quux
        "quux".tap do |string|                  # I choose not to intersperse here, because
          puts "(#{string.size} characters)"    # for multiline tap, do ... end in this
        end                                     # case still loks more readable to me.
      end
    }
  end
}

แม้ว่าการขาดกฎที่เข้มงวดอาจสร้างทางเลือกที่แตกต่างกันเล็กน้อยสำหรับโปรแกรมเมอร์ที่แตกต่างกัน แต่ฉันเชื่อว่าการปรับให้เหมาะสมเป็นกรณี ๆ ไปสำหรับการอ่านแม้ว่าส่วนตัวจะมีกำไรสุทธิมากกว่าการยึดมั่นกับกฎที่เข้มงวด

ฉันเอาตัวอย่างของคำตอบที่โหวตมากที่สุดที่นี่ พูด,

[1,2,3].map do 
  something 
end

หากคุณตรวจสอบการใช้งานภายในใน array.rb ส่วนหัวของวิธีการแผนที่พูดว่า :

Invokes the given block once for each element of self.

def map(*several_variants)
    (yield to_enum.next).to_enum.to_a
end

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

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

มีตัวเลือกที่สามคือเขียนตัวประมวลผลล่วงหน้าเพื่ออนุมาน "สิ้นสุด" บนบรรทัดของตัวเองจากการเยื้อง นักคิดลึกที่ชอบรหัสรัดกุมเกิดขึ้นถูกต้อง

ยังดีกว่าแฮ็คทับทิมดังนั้นนี่คือธง

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

20% ถึง 25% ของรหัสบรรทัด ruby ​​ของฉันคือ "สิ้นสุด" ในบรรทัดของตัวเองทั้งหมดอนุมานเล็กน้อยโดยอนุสัญญาเยื้องของฉัน Ruby เป็นภาษาที่กระเพื่อมคล้ายกับการประสบความสำเร็จที่ยิ่งใหญ่ที่สุด เมื่อมีคนโต้แย้งเรื่องนี้การถามว่าอะไรคือวงเล็บที่น่ากลัวฉันจะแสดงฟังก์ชันทับทิมที่ลงท้ายด้วย "สิ้นสุด" เจ็ดบรรทัด

ฉันใช้รหัสเป็นเวลาหลายปีโดยใช้ตัวประมวลผลเสียงกระเพื่อมเพื่อสรุปวงเล็บส่วนใหญ่: A bar '|' เปิดกลุ่มที่ autoclosed ตอนท้ายบรรทัดและเครื่องหมายดอลลาร์ '$' ทำหน้าที่เป็นตัวยึดตำแหน่งที่ว่างเปล่ามิฉะนั้นจะไม่มีสัญลักษณ์เพื่อช่วยในการจัดกลุ่ม แน่นอนว่าเป็นเขตสงครามทางศาสนา เสียงกระเพื่อม / โครงการโดยไม่ต้องวงเล็บเป็นบทกวีที่มากที่สุดของทุกภาษา ถึงกระนั้นก็เป็นการง่ายกว่าที่จะเงียบวงเล็บลงโดยใช้การระบายสีไวยากรณ์

ฉันยังคงโค้ดด้วยตัวประมวลผลล่วงหน้าสำหรับ Haskell เพื่อเพิ่ม heredocs และเริ่มต้นการลบบรรทัดทั้งหมดเป็นความคิดเห็นทุกอย่างเยื้องเป็นรหัส ฉันไม่ชอบตัวละครความคิดเห็นไม่ว่าจะเป็นภาษาอะไรก็ตาม