Benutzerdefinierte Ausnahme mit Argumenten erhöhen

Ich bin die Definition einer benutzerdefinierten Ausnahme auf ein Modell in Schienen als eine Art wrapper-Ausnahme: (begin[code]rescue[raise custom exception]end)

Wenn ich Hebe die Ausnahme, würde ich mag, um es zu übergeben, ein paar Infos über a) die Instanz des Modell, dessen interne Funktionen auslösen des Fehlers, und b) der Fehler, der abgefangen wurde.

Dies geht auf eine automatisierte import-Methode von einem Modell, wird bevölkert von POST-Anforderung von ausländischen datasource.

tldr; Wie kann man Argumente an eine Ausnahme, da Sie definieren die Ausnahme Sie sich? Ich habe eine initialize-Methode auf, die Ausnahme, sondern die raise syntax scheint zu akzeptieren nur eine Ausnahme, Klasse und Nachricht, keine optionale Parameter übergeben bekommen, in der die Instanziierung von Prozess.

InformationsquelleAutor der Frage Chris Keele | 2012-07-24

  1. 56

    erstellen Sie eine Instanz der Ausnahme, die mit neuen:

    class CustomException < StandardError
  def initialize(data)
    @data = data
  end
end
# => nil 
raise CustomException.new(bla: "blupp")
# CustomException: CustomException

    InformationsquelleAutor der Antwort phoet

  2. 9

    Lösung:

    class FooError < StandardError
  attr_reader :foo

  def initialize(foo)
   super
   @foo = foo
  end
end

    Dies ist der beste Weg, wenn Sie Folgen Sie den Rubocop Style Guide und immer passen Sie Ihre Nachricht, wie das zweite argument raise:

    raise FooError.new('the foo'), 'bar baz'

    Erhalten Sie foo wie diese:

    rescue FooError => error
  error.foo     # => 'the foo'
  error.message # => 'bar baz'

    Wenn Sie wollen, definieren Sie die Fehlermeldung in FooError dann schreiben:

    class FooError < StandardError
  attr_reader :foo

  def initialize(foo)
   super
   @foo = foo
  end

  def message
    "The foo is: #{foo}"
  end
end

    Erklärung:

    Geben Sie Ihre Nachricht als zweites argument raise

    Als Rubocop Style Guide sagt, die Nachricht und die exception-Klasse sollte zur Verfügung gestellt werden als separate Argumente, weil, wenn Sie schreiben:

    raise FooError.new('bar baz')

    Und wollen, einen backtrace zu raisees gibt keinen Weg, es zu tun, ohne die Nachricht zweimal: 

    raise FooError.new('bar baz'), 'bar baz', other_error.backtrace

    Als diese Antwort sagt, Sie wird sich übergeben zu müssen, ein backtrace, wenn Sie wollen, um re-raise eine Ausnahme, wie eine neue Instanz mit dem gleichen backtrace und eine andere Nachricht oder Daten.

    In initialize rufen supernicht super(message)

    Hier drei verschiedene Möglichkeiten der Umsetzung FooError mit test-code, den Sie ausführen können, in Pry:

    class SuperError < StandardError
  attr_reader :foo

  def initialize(foo)
   super
   @foo = foo
  end
end

class SuperWithMessageError < StandardError
  attr_reader :foo

  def initialize(foo)
   super(message)
   @foo = foo
  end
end

class SuperWithMessageArgumentError < StandardError
  attr_reader :foo

  def initialize(message = nil, foo)
   super(message)
   @foo = foo
  end
end

# All three classes behave the same except in this case:

raise SuperError, 'bar'
_ex_.foo     # => 'bar'
_ex_.message # => 'bar'

raise SuperWithMessageError, 'bar'
_ex_.foo     # => 'bar'
_ex_.message # => 'SuperWithMessageError'

raise SuperWithMessageArgumentError, 'bar'
_ex_.foo     # => 'bar'
_ex_.message # => 'SuperWithMessageArgumentError'

    In SuperWithMessageError und SuperWithMessageArgumentError die Nachricht nicht richtig eingestellt, so SuperError ist die richtige Umsetzung.

    InformationsquelleAutor der Antwort Max Wallace

  3. 8

    Hier ist ein Beispiel-code hinzufügen code zu einem Fehler:

    class MyCustomError < StandardError
    attr_reader :code

    def initialize(code)
        @code = code
    end

    def to_s
        "[#{code}] #{super}"
    end
end

    Und es zu erhöhen:
    raise MyCustomError.new(code), message

    InformationsquelleAutor der Antwort cyrilchampier

  4. -2

    Können Sie erstellen eine neue Instanz der Exception Unterklasse, dann erhöhen. Zum Beispiel:

    begin
  # do something
rescue => e
  error = MyException.new(e, 'some info')
  raise error
end

    InformationsquelleAutor der Antwort Emily

Schreibe einen Kommentar