Hur fungerar undantagshantering?

Question

Accepted Answer

Ruby hanterar fel med **`begin`/`rescue`/`ensure`** (Rubys motsvarighet till try/catch/finally). Du `raise` undantag och `rescue` dem, med `ensure` för rensning. Ruby tillåter också undantagshantering på metodnivå (utan explicit `begin`) för renare kod. ## Den grundläggande strukturen ```ruby begin result = risky_operation rescue ArgumentError => e # rescue a SPECIFIC exception type puts "Bad argument: #{e.message}" rescue StandardError => e # broader catch (StandardError, not Exception) puts "Error: #{e.message}" retry if attempts < 3 # retry can re-run the begin block else puts "succeeded" # runs if NO exception ensure cleanup # ALWAYS runs (success or failure) end ``` `begin/rescue/ensure` är Rubys try/catch/finally. **Rescue specifika typer** (`rescue ArgumentError`), använd `ensure` för garanterad rensning, och `else` för fallet när ingen fel inträffar. `retry` kan försöka igen med blocket. ## En viktig Rubycaveat: rescue StandardError, inte Exception ```ruby rescue => e # ✅ bare rescue catches StandardError (the right default) rescue StandardError # ✅ explicit, same thing rescue Exception # ❌ AVOID — catches EVERYTHING including system signals # (Interrupt/Ctrl-C, SystemExit) — can break the program ``` **Viktigt:** ett enkelt `rescue` fångar `StandardError` (rätt standardvärde för programfel). Att rescua `Exception` (roten) fångar *allt*, inklusive systemnivåsignaler som `Interrupt` (Ctrl-C) och `SystemExit` — vilket du vanligtvis inte vill fånga, eftersom det kan förhindra att programmet avbryts eller avslutas korrekt. Ett vanligt Ruby-misstag. ## Raising och anpassade undantag ```ruby raise ArgumentError, "Amount must be positive" # raise a built-in raise "Something failed" # raises RuntimeError # custom exception class class InsufficientFundsError < StandardError # inherit from StandardError def initialize(msg = "Not enough funds") super end end raise InsufficientFundsError ``` ## Undantagshantering på metodnivå (renare) ```ruby def process do_work rescue => e # rescue WITHOUT begin — applies to the whole method body handle(e) ensure cleanup end ``` ## Varför det spelar roll Korrekt undantagshantering är väsentlig för robusta Ruby-applikationer, och att förstå Rubys tillvagagångssätt — inklusive dess specifika idiom och varningar — är viktigt. Structuren `begin/rescue/ensure` (Rubys try/catch/finally), rescuing **specifika undantagstyper**, användning av `ensure` för garanterad rensning, och det rena **metodnivårescue** (utan explicit `begin`) är grundläggande vardagskunskap. En särskilt viktig och distinkt Ruby-poäng är **`StandardError` kontra `Exception` distinktionen**: ett enkelt `rescue` (och rätt standardvärde) fångar `StandardError`, men att rescua `Exception` (roten i hierarkin) fångar *allt* — inklusive systensignaler som `Interrupt` (Ctrl-C) och `SystemExit` — vilket du nästan aldrig vill, eftersom det kan förhindra programmet från att avbrytas eller avslutas korrekt, och är ett vanligt, skadligt misstag. Att förstå att du bör rescua `StandardError` (inte `Exception`) för programfel är viktig Ruby-specifik kunskap som förhindrar riktiga buggar. Att känna till strukturen, anpassade undantagsklasser (som ärver från `StandardError`), `retry`, idiomen för metodnivårescue, och särskilt StandardError-not-Exception varningen är viktigt för att skriva robust, korrekt Ruby som hanterar fel på ett elegant sätt utan att bryta programmets möjlighet att avbrytas. Eftersom ohanterade fel och Exception-rescuing-misstaget båda orsakar riktiga problem, att behärska Rubys undantagshantering — dess struktur, idiom, och den kritiska StandardError kontra Exception distinktionen — är viktigt, ofta relevant kunskap för tillförlitlig Ruby-utveckling och ett vanligt intervjuämne.