Wie man in Ruby Ausnahmen auslöst und rettet

Ausnahmen sind ein grundlegender Bestandteil der Programmierung in Ruby. Sie ermöglichen es Entwicklern, Fehler elegant zu behandeln und robuste, fehlertolerante Anwendungen zu gewährleisten. Der Mechanismus zur Behandlung von Ausnahmen in Ruby ist intuitiv und dennoch leistungsstark. Er ermöglicht es Entwicklern, Fehler auszulösen, wenn etwas schief läuft, und sie zu retten, um einen Absturz der Anwendung zu verhindern. In diesem 2000 Wörter umfassenden Leitfaden wird erläutert, wie man in Ruby Ausnahmen auslöst und rettet. Dabei werden die Grundlagen, fortgeschrittene Techniken, Best Practices und Beispiele aus der Praxis behandelt.

Was sind Ausnahmen in Ruby?

Ausnahmen in Ruby sind Objekte, die Fehler oder unerwartete Bedingungen während der Programmausführung darstellen. Wenn ein Fehler auftritt, z. B. beim Versuch, durch Null zu dividieren, beim Zugriff auf eine nicht existierende Datei oder bei einem Netzwerkfehler, löst Ruby eine Ausnahme aus. Wenn die Ausnahme nicht behandelt wird, bricht das Programm mit einer Fehlermeldung ab.

Das Ausnahmesystem von Ruby ist um die Ausnahme Klasse, die als Wurzel der Ausnahmehierarchie dient. Unterklassen wie StandardFehler, LaufzeitFehler, ArgumentFehler, Und NoMethodError bestimmte Arten von Fehlern behandeln. Entwickler können auch eigene Ausnahmeklassen definieren, um anwendungsspezifische Fehler darzustellen.

Die Behandlung von Ausnahmen in Ruby dreht sich um zwei Schlüsselaktionen:

• Erhöhung der: Auslösen einer Ausnahme, wenn ein Fehler auftritt.
• Die Rettung: Abfangen und Behandeln von Ausnahmen, um Programmabstürze zu verhindern.

Wir wollen uns nun damit befassen, wie man Ausnahmen wirksam erheben und retten kann.

Auslösen von Ausnahmen in Ruby

Durch das Auslösen einer Ausnahme wird signalisiert, dass ein Fehler oder ein unerwarteter Zustand aufgetreten ist. Ruby bietet die erhöhen Methode (und ihr Alias scheitern), um Ausnahmen auszulösen.

Die erhöhen Methode

Der einfachste Weg, eine Ausnahme auszulösen, ist die Verwendung der erhöhen Methode ohne Argumente, die eine RuntimeError (eine Unterklasse von StandardFehler):

rubinrot
raise
# => RuntimeError: unbehandelte Ausnahme

Sie können auch eine Fehlermeldung angeben:

ruby
raise "Etwas ist schief gelaufen!"
# => RuntimeError: Es ist etwas schief gelaufen!

Um eine bestimmte Ausnahmeklasse auszulösen, übergeben Sie die Klasse als erstes Argument und die Nachricht als zweites:

ruby
raise ArgumentError, "Ungültige Eingabe angegeben"
# => ArgumentError: Ungültige Eingabe angegeben

Benutzerdefinierte Ausnahmeklassen

Für komplexere Anwendungen möchten Sie vielleicht benutzerdefinierte Ausnahmeklassen definieren, um bestimmte Fehler darzustellen. Benutzerdefinierte Ausnahmen erben von StandardFehler oder eine ihrer Unterklassen, um die Kompatibilität mit dem Standard-Rettungsverhalten von Ruby zu gewährleisten.

Beispiel:

ruby
class AuthenticationError  AuthenticationError: Ungültige Anmeldedaten

Durch die Definition AuthenticationErrorkönnen Sie authentifizierungsbezogene Fehler getrennt von allgemeinen Fehlern behandeln.

Auslösen von Ausnahmen mit Ursache

In Ruby können Sie einer Ausnahme eine "Ursache" zuordnen, was für die Fehlersuche nützlich ist. Die Ursache ist die ursprüngliche Ausnahme, die zu der aktuellen Ausnahme geführt hat. Verwenden Sie die Ausnahme Methode, um darauf zuzugreifen:

rubinrot
begin
  raise "Ursprünglicher Fehler"
retten => e
  raise "Neuer Fehler" # Der ursprüngliche Fehler bleibt als Ursache erhalten
end

Sie können die Ursache untersuchen mit e.Ursache:

rubinrot
beginnen
  begin
    raise "Ursprünglicher Fehler"
  retten => e
    raise "Neuer Fehler"
  end
Rettung => e
  puts e.message # => Neuer Fehler
  puts e.cause.message # => Ursprünglicher Fehler
end

Rettung von Ausnahmen

Die Rettung von Ausnahmen ermöglicht es Ihnen, Fehler abzufangen und elegant zu behandeln, so dass Ihr Programm nicht abstürzt. Ruby verwendet die beginnen/retten Block, um Ausnahmen zu verwalten.

Die beginnen/Rettung Block

Die Grundstruktur eines beginnen/retten Block ist:

rubinrot
beginnen
  # Code, der eine Ausnahme auslösen könnte
retten
  # Behandeln Sie die Ausnahme
end

Beispiel:

rubinrot
beginnen
  Ergebnis = 10 / 0
retten
  puts "Ein Fehler ist aufgetreten!"
end
# Ausgabe: Ein Fehler ist aufgetreten!

Standardmäßig, Rettung fängt StandardFehler und ihre Unterklassen. Wenn Sie keine Ausnahmeklasse angeben, ist es äquivalent zu rescue StandardFehler.

Behandlung spezifischer Ausnahmen

Um bestimmte Ausnahmen zu behandeln, geben Sie die Ausnahmeklasse in der Rettung Klausel:

rubinrot
beginnen
  Ergebnis = 10 / 0
rette ZeroDivisionError
  puts "Kann nicht durch Null geteilt werden!"
rescue ArgumentError
  puts "Ungültiges Argument angegeben!"
end
# Ausgabe: Kann nicht durch Null geteilt werden!

Sie können auch das Ausnahmeobjekt zur weiteren Prüfung erfassen:

rubinrot
begin
  raise ArgumentError, "Ungültige Eingabe"
rescue ArgumentError => e
  puts "Fehler: #{e.message}"
end
# Ausgabe: Fehler: Ungültige Eingabe

Verwendung von anders Und sicherstellen

Ruby bietet zwei zusätzliche Klauseln für die Behandlung von Ausnahmen:

• anders: Wird ausgeführt, wenn keine Ausnahme ausgelöst wird.
• sicherstellen: Wird unabhängig davon ausgeführt, ob eine Ausnahme auftritt, nützlich für Aufräumarbeiten.

Beispiel:

rubinrot
begin
  puts "Operation wird ausgeführt..."
  ergebnis = 10 / 2
rescue ZeroDivisionError
  puts "Kann nicht durch Null geteilt werden!"
else
  puts "Operation erfolgreich: #{Ergebnis}"
sicherstellen
  puts "Aufräumen..."
end
# Ausgabe:
# Ausführung der Operation...
# Operation erfolgreich: 5
# Aufräumen...

Wenn eine Ausnahme auftritt:

rubinrot
begin
  puts "Operation wird ausgeführt..."
  ergebnis = 10 / 0
rescue ZeroDivisionError
  puts "Kann nicht durch Null geteilt werden!"
else
  puts "Operation erfolgreich: #{Ergebnis}"
sicherstellen
  puts "Aufräumen..."
end
# Ausgabe:
# Ausführen der Operation...
# Kann nicht durch Null geteilt werden!
# Aufräumen...

Die erneut versuchen Schlüsselwort

Die erneut versuchen Schlüsselwort ermöglicht es Ihnen, die beginnen blockieren, nachdem eine Ausnahme abgefangen wurde. Dies ist nützlich für Szenarien wie die Wiederholung von fehlgeschlagenen Netzwerkanfragen.

Beispiel:

ruby
Versuche = 0
beginnen
  Versuche += 1
  puts "Versuch #{Versuche}"
  raise "Verbindung fehlgeschlagen"
retten
  erneut versuchen, wenn attempts < 3
  puts "Aufgeben nach #{Versuche} Versuchen"
end
# Ausgabe:
# Versuch 1
# Versuch 2
# Versuch 3
# Aufgeben nach 3 Versuchen

Verwenden Sie "retry" mit Bedacht, um Endlosschleifen zu vermeiden.

Best Practices für die Behandlung von Ausnahmen

1. Rettungsspezifische Ausnahmen: Vermeiden Sie nackte Rettung Klauseln, da sie alle StandardFehler Unterklassen und kann unerwartete Fehler verbergen. Geben Sie genau die Ausnahmen an, die Sie erwarten.

   rubinrot
   # Schlecht
   beginnen
     # Code
   retten
     # Fängt alles auf
   end
   
   # Gut
   beginnen
     # Code
   retten ArgumentError, TypeError
     # Spezifische Fehler behandeln
   end

2. Rettungsblöcke klein halten: Umschließen Sie nur den Code, der eine Ausnahme auslösen könnte. Dies verbessert die Lesbarkeit und verhindert, dass unzusammenhängende Fehler abgefangen werden.
3. Geben Sie aussagekräftige Fehlermeldungen aus: Wenn Sie Ausnahmen auslösen, fügen Sie klare, umsetzbare Meldungen ein, um die Fehlersuche zu erleichtern.
4. Benutzerdefinierte Ausnahmen für die Domänenlogik verwenden: Erstellen Sie benutzerdefinierte Ausnahmeklassen für anwendungsspezifische Fehler, um Ihren Code aussagekräftiger und wartbarer zu machen.
5. Vermeiden Sie die übermäßige Verwendung von Ausnahmen für die Ablaufsteuerung: Ausnahmen sind für Ausnahmefälle gedacht, nicht zur Steuerung des Programmablaufs. Verwenden Sie Konditionale für erwartete Szenarien.

   rubinrot
   # Schlecht
   begin
   wert = hash[:schlüssel]
   retten
   wert = nil
   end
   
   # Gut
   Wert = hash[:key] || nil

6. Ressourcen aufräumen mit sicherstellen: Verwenden Sie sicherstellen um Dateien, Datenbankverbindungen oder andere Ressourcen zu schließen, auch wenn eine Ausnahme auftritt.

Beispiele aus der Praxis

Handhabung von Dateien

Das Lesen einer Datei kann Ausnahmen auslösen wie Errno::ENOENT (Datei nicht gefunden) oder Errno::EACCES (Erlaubnis verweigert). So gehen Sie damit um:

rubinrot
begin
  File.open("nicht-existent.txt", "r") do |file|
    puts datei.lesen
  end
rescue Errno::ENOENT
  puts "Datei nicht gefunden!"
rescue Errno::EACCES
  puts "Erlaubnis verweigert!"
sicherstellen
  puts "Dateioperation abgeschlossen."
end
# Ausgabe: Datei nicht gefunden!
# Dateivorgang abgeschlossen.

API-Aufrufe

Bei HTTP-Anfragen können Netzwerkfehler oder ungültige Antworten auftreten. Die Verwendung der httparty gem:

ruby
require 'httparty'

beginnen
  Antwort = HTTParty.get('https://api.example.com/data')
rescue HTTParty::Error => e
  puts "API-Anfrage fehlgeschlagen: #{e.message}"
rescue SocketError
  puts "Netzwerkfehler: Konnte keine Verbindung zum Server herstellen"
sonst
  puts "Empfangene Antwort: #{response.body}"
end

Benutzerdefinierte Ausnahmebehandlung in einer Klasse

Hier ist ein Beispiel für eine Klasse, die Zahlungen verarbeitet und benutzerdefinierte Ausnahmen verwendet:

ruby
class PaymentError < StandardError; end
class InsufficientFundsError < PaymentError; end
class UngültigeKarteFehler  card.balance
    karte.saldo -= betrag
    puts "Zahlung von #{Betrag} erfolgreich verarbeitet"
  end

  privat
  def valid_card?(karte)
    karte.nummer.länge == 16
  end
end

class Karte
  attr_accessor :zahl, :saldo
  def initialize(Zahl, Saldo)
    @Zahl = Zahl
    @Saldo = Saldo
  end
end

Karte = Karte.new("1234567890123456", 50)
Prozessor = PaymentProcessor.new

begin
  processor.process_payment(100, Karte)
rescue InsufficientFundsError => e
  puts "Fehler: #{e.message}"
rescue InvalidCardError => e
  puts "Fehler: #{e.message}"
end
# Ausgabe: Fehler: Nicht genügend Mittel

Erweiterte Ausnahmebehandlung

Verschachtelte Rettungen

Sie können verschachteln beginnen/retten Blöcke, um Ausnahmen auf verschiedenen Ebenen zu behandeln:

rubinrot
beginnen
  begin
    raise "Innerer Fehler"
  rescue
    puts "Innerer Fehler aufgetreten"
    raise "Äußerer Fehler"
  end
retten
  puts "Gefangener äußerer Fehler"
end
# Ausgabe:
# Abgefangener innerer Fehler
# Abgefangener äußerer Fehler

Hierarchie der Ausnahmen

Es ist wichtig, die Ausnahmehierarchie von Ruby zu verstehen. Die wichtigsten Klassen sind:

• ExceptionM: Wurzelklasse für alle Ausnahmen.
• StandardFehler: Standard für Rettung ohne eine Klasse; die meisten eingebauten Ausnahmen erben von ihr.
• RuntimeError: Standard für erhöhen ohne eine Klasse.
• NoMethodError, ArgumentError, TypeErrorusw.: Spezifische Fehlerarten.

Um alle Ausnahmen abzufangen (einschließlich NichtStandardFehler solche wie SystemExit), verwenden Rettung Ausnahme:

rubinrot
beginnen
  exit
rescue Exception
  puts "Gefangener Exit"
end
# Ausgabe: Gefangener Exit

Verwendung von retten_von in Schiene

In Ruby on Rails können Sie Folgendes verwenden retten_von in Controllern, um Ausnahmen global zu behandeln:

ruby
Klasse ApplicationController < ActionController::Base
  rescue_from ActiveRecord::RecordNotFound, mit: :not_found

  private

  def not_found
    Datei rendern: 'public/404.html', status: :not_found
  end
end

Dieser Ansatz zentralisiert die Behandlung von Ausnahmen für bestimmte Steuerungen.

Häufig zu vermeidende Fallstricke

1. Blindes Abfangen aller Ausnahmen: Verwendung von Rettung ohne Angabe einer Ausnahmeklasse kann Fehler verbergen.
2. Übermäßige Nutzung von erneut versuchen: Unendliche Wiederholungen können zu Endlosschleifen führen oder zugrundeliegende Probleme verschleiern.
3. Details zu Ausnahmen ignorieren: Inspizieren Sie immer das Ausnahmeobjekt (e.message, e.backtrace) zur Fehlersuche.
4. Erhebung von Nicht-Standard-Fehlern: Vermeiden Sie das Auslösen von Exceptions, die nicht von StandardFehlerda sie standardmäßig nicht erfasst werden Rettung Klauseln.
5. Nicht aufgeräumte Ressourcen: Vergessen zu benutzen sicherstellen können Dateien oder Verbindungen offen lassen.

Abschluss

Das Auslösen und Retten von Ausnahmen in Ruby ist eine leistungsfähige Methode, um Fehler zu behandeln und robuste Anwendungen zu erstellen. Unter SchienenCarmaeinem führenden Ruby on Rails-EntwicklungsunternehmenWir setzen diese Techniken ein, um zuverlässige, wartbare Lösungen zu schaffen. Durch die Verwendung erhöhen um Fehler zu signalisieren, Rettung um sie zu fangen, und Werkzeuge wie erneut versuchen, sonst, Und sicherstellenkönnen Entwickler Fehler effektiv verwalten. Benutzerdefinierte Ausnahmeklassen und spezifische Rettungsklauseln sorgen für mehr Klarheit und Präzision in Ihrem Code. Die Befolgung von Best Practices - wie z. B. die Rettung spezifischer Ausnahmen, die Beibehaltung kleiner Rettungsblöcke und die Verwendung aussagekräftiger Fehlermeldungen - sorgt für wartbaren und zuverlässigen Code.

Egal, ob Sie Datei-Operationen, API-Aufrufe oder domänenspezifische Logik behandeln, Rubys System zur Ausnahmebehandlung bietet die Flexibilität, Fehler elegant zu behandeln. Durch die Beherrschung dieser Techniken und die Vermeidung von häufigen Fallstricken hilft RailsCarma Unternehmen dabei, robuste Ruby-Anwendungen zu erstellen, die mit Fehlern sicher umgehen.