เริ่มต้นช่วยเหลือและมั่นใจใน Ruby?

ฉันเพิ่งเริ่มเขียนโปรแกรมใน Ruby และฉันกำลังดูการจัดการข้อยกเว้น

ฉันสงสัยว่าensureทับทิมนั้นเทียบเท่ากับfinallyใน C # หรือไม่ ฉันควรจะมี:

file = File.open("myFile.txt", "w")

begin
  file << "#{content} \n"
rescue
  #handle the error here
ensure
  file.close unless file.nil?
end

หรือฉันควรทำเช่นนี้?

#store the file
file = File.open("myFile.txt", "w")

begin
  file << "#{content} \n"
  file.close
rescue
  #handle the error here
ensure
  file.close unless file.nil?
end

ถูกensureเรียกมาไม่ว่าจะเกิดอะไรขึ้นแม้ว่าข้อยกเว้นจะไม่ได้รับการยก

ใช่ensureรับรองว่าจะมีการประเมินรหัสอยู่เสมอ ensureนั่นเป็นเหตุผลที่มันเรียกว่า ดังนั้นจึงจะเทียบเท่ากับ C # ของ Java และ finally's

โฟลว์ทั่วไปของbegin/ rescue/ else/ ensure/ endมีลักษณะดังนี้:

begin
  # something which might raise an exception
rescue SomeExceptionClass => some_variable
  # code that deals with some exception
rescue SomeOtherException => some_other_variable
  # code that deals with some other exception
else
  # code that runs only if *no* exception was raised
ensure
  # ensure that this code always runs, no matter what
  # does not change the final value of the block
end

คุณสามารถปล่อยออกrescue, หรือensure elseคุณยังสามารถละทิ้งตัวแปรซึ่งในกรณีนี้คุณจะไม่สามารถตรวจสอบข้อยกเว้นในโค้ดการจัดการข้อยกเว้นของคุณ (ดีคุณสามารถใช้ตัวแปรยกเว้นทั่วโลกในการเข้าถึงข้อยกเว้นสุดท้ายที่ถูกยกขึ้น แต่ที่ hacky นิด ๆ หน่อย ๆ .) และคุณสามารถออกจากชั้นยกเว้นในกรณีที่มีข้อยกเว้นทุกสิ่งที่สืบทอดจากStandardErrorจะถูกจับ (โปรดทราบว่านี้ไม่ได้หมายความว่าทุกข้อยกเว้นจะถูกจับเพราะมีข้อยกเว้นซึ่งเป็นกรณีของExceptionแต่ไม่StandardError. ยกเว้นส่วนใหญ่ที่รุนแรงมากว่าการประนีประนอมความสมบูรณ์ของโปรแกรมเช่นSystemStackError, NoMemoryError, SecurityError, NotImplementedError, LoadError, SyntaxError, ScriptError, Interrupt,SignalExceptionหรือSystemExit.)

บล็อกบางรูปแบบบล็อกข้อยกเว้นโดยนัย ตัวอย่างเช่นคำจำกัดความของวิธีการนั้นยังมีข้อยกเว้นบล็อกโดยปริยายดังนั้นแทนที่จะเขียน

def foo
  begin
    # ...
  rescue
    # ...
  end
end

คุณเขียนแค่

def foo
  # ...
rescue
  # ...
end

หรือ

def foo
  # ...
ensure
  # ...
end

เช่นเดียวกับclassคำจำกัดความและmoduleคำจำกัดความ

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

# This is what you want to do:
File.open('myFile.txt', 'w') do |file|
  file.puts content
end

# And this is how you might implement it:
def File.open(filename, mode='r', perm=nil, opt=nil)
  yield filehandle = new(filename, mode, perm, opt)
ensure
  filehandle&.close
end

และสิ่งที่คุณรู้: นี้มีอยู่ในห้องสมุดแกนเป็นFile.openแล้ว แต่มันเป็นรูปแบบทั่วไปที่คุณสามารถใช้ในรหัสของคุณเองเช่นกันสำหรับการใช้งานการล้างทรัพยากร (เช่น la usingC #) หรือธุรกรรมหรือสิ่งอื่นใดที่คุณอาจนึกถึง

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

BTW: ในปัจจุบัน C # usingเป็นจริงที่ไม่จำเป็นเพราะคุณสามารถใช้บล็อกทรัพยากรสไตล์ทับทิมเอง:

class File
{
    static T open<T>(string filename, string mode, Func<File, T> block)
    {
        var handle = new File(filename, mode);
        try
        {
            return block(handle);
        }
        finally
        {
            handle.Dispose();
        }
    }
}

// Usage:

File.open("myFile.txt", "w", (file) =>
{
    file.WriteLine(contents);
});

FYI แม้ว่าจะมีข้อยกเว้นเกิดขึ้นอีกในrescueส่วนensureบล็อกจะถูกดำเนินการก่อนที่การเรียกใช้รหัสจะดำเนินต่อไปยังตัวจัดการข้อยกเว้นถัดไป ตัวอย่างเช่น

begin
  raise "Error!!"
rescue
  puts "test1"
  raise # Reraise exception
ensure
  puts "Ensure block"
end

หากคุณต้องการให้แน่ใจว่าไฟล์ถูกปิดคุณควรใช้รูปแบบบล็อกของFile.open:

File.open("myFile.txt", "w") do |file|
  begin
    file << "#{content} \n"
  rescue
  #handle the error here
  end
end

ใช่ensureถูกเรียกในกรณีใด ๆ สำหรับข้อมูลเพิ่มเติมโปรดดู " ข้อยกเว้นจับและโยน " ของหนังสือ Ruby Programming มิงและค้นหา "มั่นใจ"

ใช่ensureแน่ใจว่ามันทำงานทุกครั้งดังนั้นคุณไม่จำเป็นต้องfile.closeอยู่ในbeginบล็อก

โดยวิธีการทดสอบที่ดีคือการทำ:

begin
  # Raise an error here
  raise "Error!!"
rescue
  #handle the error here
ensure
  p "=========inside ensure block"
end

คุณสามารถทดสอบเพื่อดูว่า "========= ข้างในแน่ใจว่าบล็อก" จะถูกพิมพ์ออกมาเมื่อมีข้อยกเว้น จากนั้นคุณสามารถคอมเม้นท์ข้อความที่ทำให้เกิดข้อผิดพลาดและดูว่าensureคำสั่งนั้นดำเนินการโดยดูว่ามีอะไรที่พิมพ์ออกมาหรือไม่

นี่คือเหตุผลที่เราต้องการensure:

def hoge
  begin
    raise
  rescue  
    raise # raise again
  ensure  
    puts 'ensure' # will be executed
  end  
  puts 'end of func' # never be executed
end  

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