Auswählen, um zum Inhalt zu springen.
Fehler elegant abfangen: Ein tiefgehender Blick auf ein IFERROR-Wrapper Makro für Excel

Fehler elegant abfangen: Ein tiefgehender Blick auf ein IFERROR-Wrapper Makro für Excel

fx
WENNFEHLER

CORSAIR K70 RGB PRO

Mechanische Tastatur mit MX-Red-Switches und RGB-Beleuchtung

Jetzt bei Amazon ansehen

* Als Amazon-Partner verdiene ich an qualifizierten Verkäufen

Einführung

Die WENNFEHLER-Funktion in Excel spielt eine entscheidende Rolle bei der Fehlerbehandlung in der Datenanalyse. Mit ihrer Hilfe können Formeln so angepasst werden, dass sie bei Auftreten eines Fehlers einen definierten Wert zurückgeben. Dies ist besonders nützlich, um die Stabilität von Berechnungen sicherzustellen und störende Fehlermeldungen wie #DIV/0! oder #N/A zu vermeiden.

Mit einem IFERROR-Wrapper Makro könnte man diesen Prozess automatisieren. Es soll einen Bereich von Zellen durchsuchen und die WENNFEHLER-Funktion hinzufügen, wenn sie noch nicht vorhanden ist. Dies kann Zeit sparen und die Effizienz erhöhen, insbesondere bei umfangreichen Tabellen.

In diesem Artikel lernen Sie:

  • Wie Sie ein IFERROR-Wrapper Makro mit VBA erstellen und optimieren.

Die WENNFEHLER-Funktion verstehen

Die WENNFEHLER-Funktion in Excel dient dazu, Fehler in Formeln abzufangen und eine spezifizierte Alternative zurückzugeben. Die Syntax dieser Funktion lautet:

=WENNFEHLER(wert, wert_falls_fehler)

Dabei steht wert für den Ausdruck oder die Formel, die einen Fehler verursachen könnte, und wert_falls_fehler für den Wert, der zurückgegeben werden soll, wenn ein Fehler auftritt.

Im englischen Excel heißt diese Funktion IFERROR.

Beispiele zur Veranschaulichung:

=WENNFEHLER(100/B12;0)

Diese Formel vermeidet eine Division durch Null und gibt stattdessen 0 aus.

=WENNFEHLER(SVERWEIS(A2; B:C; 2; FALSCH); "Wert nicht gefunden")

Kann der Wert aus A2 nicht in der Spalte B gefunden werden, ist der Output "Wert nicht gefunden".

Einführung in VBA und Makros in Excel

VBA (Visual Basic for Applications) ist eine Programmiersprache, die in Microsoft Office-Anwendungen wie Excel integriert ist. Sie ermöglicht die Automatisierung von Aufgaben und die Erstellung benutzerdefinierter Funktionen.

Grundlegende Konzepte der Makroprogrammierung in Excel

  • Makros: Aufgezeichnete oder programmierte Befehlsfolgen, die wiederholt ausgeführt werden können.
  • Editor: Der VBA-Editor in Excel dient zur Erstellung und Bearbeitung von Makros.
  • Objekte und Eigenschaften: In VBA werden Excel-Elemente wie Zellen oder Arbeitsblätter als Objekte behandelt, die Eigenschaften und Methoden besitzen.

Vorteile der Automatisierung von Aufgaben mit VBA

  • Zeiteffizienz: Wiederkehrende Aufgaben können automatisiert werden, was erheblich Zeit spart.
  • Fehlerreduktion: Durch Automatisierung wird das Risiko menschlicher Fehler minimiert.
  • Flexibilität: Benutzerdefinierte Lösungen können entwickelt werden, die spezifischen Anforderungen gerecht werden.

Erstellung eines IFERROR-Wrapper Makros: Ein Schritt-für-Schritt-Leitfaden

Dieser Abschnitt führt Sie durch die Erstellung eines VBA-Makros, das automatisch bestehende Formeln in einem ausgewählten Zellbereich mit der WENNFEHLER-Funktion umhüllt.

Darüber hinaus kann dieses Makro auch ins Excel Menüband hinzugefügt werden, um den Zugriff auf diese Funktionen zu optimieren.

Neues Modul erstellen

Ich erstelle ein neues Modul in meiner persönllichen Arbeitsmappe und füge dort ein leeres Sub ein.

Option Explicit

Sub IRERRORWrapper()

End Sub

Mit WENNFEHLER Umhüllen

Die Hauptfunktionalität soll ja die Umhüllung mit WENNFEHLER sein, deshalb füge ich das als erstes ein.

Option Explicit

Sub IFERRORWrapper()
    Dim formulaText As String
    
    formulaText = ActiveCell.Formula
    
    ActiveCell.Formula = "=IFERROR(" & formulaText & ", """")"
End Sub

Was passiert hier? Ich definiere zunächst die Variable formulaText, der Wert der Variable soll der momentan ausgewählten Zelle entsprechen. Diese Formel soll in eine WENNFEHLER Formel eingefügt werden. Hierbei muss die englische Variante der Formel genommen werden.

Beim ersten Test scheitert dieser Weg natürlich, wählt man Zelle mit dem Inhalt 123 aus, wird daraus beim Ausführen des Makros =WENNFEHLER(123; ""). Aus abc wird =WENNFEHLER(@abc; "") und bei =SUMME(A1:A10) stürzt das Modul ab. Das ist jedoch die Funktionalität, die ich nicht haben möchte. Die Zellen mit 123 oder abc sollen überhaupt nicht verändert werden, sondern nur eine Zelle mit einer Formel drin. Eine Abfrage, ob eine Zelle eine Formel enthält, kann man mit dem Ausdruck hasFormula prüfen. Des Weiteren versucht das Makro den gesamten Zellinhalt zu nehmen und mit WENNFEHLER zu umhüllen. Also wird aus =SUMME(A1:A10) theoretisch =WENNFEHLER(=SUMME(A1:A10);""), das ist ein Gleichheitszeichen zu viel. Das kann ich entfernen, indem ich die Formel erst ab dem zweiten Zeichen in die Variable kopiere.

Option Explicit

Sub IFERRORWrapper()
    Dim formulaText As String
    
    If ActiveCell.HasFormula Then
        formulaText = Mid(ActiveCell.Formula, 2)
    
        ActiveCell.Formula = "=IFERROR(" & formulaText & ", """")"
    End If
End Sub

Und damit ist die Grundfunktionalität gegeben. 123 bleibt 123, abc bleibt abc, =SUMME(A1) wird zu =WENNFEHLER(SUMME(A1);"").

Gesamten Zellbereich verwenden

Momentan wird nur die aktive Zelle verändert. Auch wenn man einen Bereich mit mehreren Zellen auswählt, verändert wird nur eine. Dieses Verhalten kann man mit einer For Each Schleife ändern:

Option Explicit

Sub IFERRORWrapper()
    Dim cell As Range
    Dim formulaText As String
    
    For Each cell In Selection.Cells
        If cell.HasFormula Then
            formulaText = Mid(cell.Formula, 2)
    
            cell.Formula = "=IFERROR(" & formulaText & ", """")"
        End If
    Next cell
End Sub

Doppelter WENNFEHLER WENNFEHLER

Ist der Inhalt einer Zelle =WENNFEHLER(SUMME(A1);"") wird daraus =WENNFEHLER(WENNFEHLER(SUMME(A1);"");""). Das geht dann auch immer weiter. Das bringt irgendwie nicht wirklich viel, außer man versucht nach und nach verschiedene Ergebnisse durchzugehen, bis man auf eins ohne Fehler stößt. Für mein Makro nehme ich den Fall dennoch raus:

Option Explicit

Sub IFERRORWrapper()
    Dim cell As Range
    Dim formulaText As String
    
    For Each cell In Selection.Cells
        If cell.HasFormula Then
            formulaText = Mid(cell.Formula, 2)
            If Not formulaText Like "IFERROR(*)" Then
                cell.Formula = "=IFERROR(" & formulaText & ", """")"
            End If
        End If
    Next cell
End Sub

Dadurch bleibt eine Zelle mit =WENNFEHLER(SUMME(A1);"") unverändert. Eine Zelle mit dem Wert =WENNFEHLER(SUMME(A1);"") + 1 würde jedoch verändert werden. Eine Randerscheinung wäre jedoch, dass auch =WENNFEHLER(1;"")+(1+1) und =WENNFEHLER(1;"")+WENNFEHLER(1;"") nicht angepasst werden, weil sie mit =WENNFEHLER beginnen und mit einer Klammer aufhören. Es gäbe jetzt die Möglichkeit das aus Gründen der Einfachheit so zu lassen oder man zählt die Klammern in der Formel, um herauszufinden, ob es hinter der WENNFEHLER-Funktion in der Formel noch weitergeht.

Option Explicit

Sub IFERRORWrapper()
    Dim cell As Range
    Dim char As String
    Dim formulaText As String
    Dim i As Long
    Dim openParenCount As Long
    
    For Each cell In Selection.Cells
        If cell.HasFormula Then
            formulaText = Mid(cell.Formula, 2)
            If Not formulaText Like "IFERROR(*)" Then
                cell.Formula = "=IFERROR(" & formulaText & ", """")"
            Else
                openParenCount = 0
                For i = 1 To Len(formulaText)
                    char = Mid(formulaText, i, 1)
                    If char = "(" Then
                        openParenCount = openParenCount + 1
                    ElseIf char = ")" Then
                        openParenCount = openParenCount - 1
                        If openParenCount = 0 Then
                            If i < Len(formulaText) Then
                                cell.Formula = "=IFERROR(" & formulaText & ", """")"
                            End If
                            Exit For
                        End If
                    End If
                Next i
            End If
        End If
    Next cell
End Sub

Im ersten Moment scheint das zu funktionieren, jedoch könnten sich auf Klammern in dem Fehler Parameter der Funktion befinden: =WENNFEHLER(SUMME(A1:A10); "Es gibt einen Fehler :)")

Um das auch zu beachten, muss der Code durch eine Prüfung erweitert werden, ob wir uns momentan innerhalb eines Strings befinden.

Option Explicit

Sub IFERRORWrapper()
    Dim cell As Range
    Dim char As String
    Dim formulaText As String
    Dim i As Long
    Dim inString As Boolean
    Dim openParenCount As Long
    
    For Each cell In Selection.Cells
        If cell.HasFormula Then
            formulaText = Mid(cell.Formula, 2)
            If Not formulaText Like "IFERROR(*" Then
                cell.Formula = "=IFERROR(" & formulaText & ", """")"
            Else
                openParenCount = 0
                For i = 1 To Len(formulaText)
                    char = Mid(formulaText, i, 1)
                    If char = """" Then
                        inString = Not inString
                    ElseIf Not inString Then
                        If char = "(" Then
                            openParenCount = openParenCount + 1
                        ElseIf char = ")" Then
                            openParenCount = openParenCount - 1
                            If openParenCount = 0 Then
                                If i < Len(formulaText) Then
                                    cell.Formula = "=IFERROR(" & formulaText & ", """")"
                                End If
                                Exit For
                            End If
                        End If
                    End If
                Next i
            End If
        End If
    Next cell
End Sub

Damit ist die Grundfunktionalität gegeben.

Refactoring in kleinere Bestandteile

Würde man versuchen all die Funktionalität in ein großes Sub zu packen, wird es mit der Zeit sehr unübersichtlich, weshalb ich gerne die Prüfung, ob die Formel bereits von einer WENNFEHLER-Funktion umschlossen ist, in eine einzelne Funktion auslagern möchte. Ebenso soll die Verarbeitung der einzelnen Zellen in eine eigene Funktion.

Option Explicit

Public Sub IFERRORWrapper()
    ProcessRange Selection
    Exit Sub
End Sub


Private Function ProcessRange(ByVal rng As Range)
    Dim cell As Range
    Dim formulaText As String
    
    For Each cell In rng.Cells
        If cell.HasFormula Then
            formulaText = Mid(cell.Formula, 2)
            If Not IsAlreadyWrapped(formulaText) Then
                cell.Formula = "=IFERROR(" & formulaText & ", """")"
            End If
        End If
    Next cell
End Function


Private Function IsAlreadyWrapped(formulaText As String) As Boolean
    Dim i As Long
    Dim inString As Boolean
    Dim openParenCount As Long
    Dim char As String
    
    If Not formulaText Like "IFERROR(*)" Then
        IsAlreadyWrapped = False
        Exit Function
    End If
    
    For i = 1 To Len(formulaText)
        char = Mid(formulaText, i, 1)
        Select Case char
            Case """"
                inString = Not inString
            Case "("
                If Not inString Then openParenCount = openParenCount + 1
            Case ")"
                If Not inString Then
                    openParenCount = openParenCount - 1
                    If openParenCount = 0 Then
                        IsAlreadyWrapped = (i = Len(formulaText))
                        Exit Function
                    End If
                End If
        End Select
    Next i
    
    IsAlreadyWrapped = False
End Function

Dadurch wird es leichter einzelne Bestandteile zu ändern.

Errorhandler hinzufügen

Damit man bei einem Fehler im Ablauf der Funktion nicht die Standard-Benachrichtigung mit dem Link zum Debugger bekommt, sondern man den Text selbst festlegen kann, bietet es sich an einen Errorhandler in den Funktionsablauf einzubauen.

Option Explicit

Public Sub IFERRORWrapper()
    On Error GoTo ErrorHandler
    
    ProcessRange Selection
    Exit Sub
    
ErrorHandler:
    MsgBox "An error occurred: " & Err.Description, vbCritical, "IFERROR Wrapper"
    
End Sub


Private Function ProcessRange(ByVal rng As Range)
    Dim cell As Range
    Dim formulaText As String
    
    For Each cell In rng.Cells
        If cell.HasFormula Then
            formulaText = Mid(cell.Formula, 2)
            If Not IsAlreadyWrapped(formulaText) Then
                cell.Formula = "=IFERROR(" & formulaText & ", """")"
            End If
        End If
    Next cell
End Function


Private Function IsAlreadyWrapped(formulaText As String) As Boolean
    Dim i As Long
    Dim inString As Boolean
    Dim openParenCount As Long
    Dim char As String
    
    If Not formulaText Like "IFERROR(*)" Then
        IsAlreadyWrapped = False
        Exit Function
    End If
    
    For i = 1 To Len(formulaText)
        char = Mid(formulaText, i, 1)
        Select Case char
            Case """"
                inString = Not inString
            Case "("
                If Not inString Then openParenCount = openParenCount + 1
            Case ")"
                If Not inString Then
                    openParenCount = openParenCount - 1
                    If openParenCount = 0 Then
                        IsAlreadyWrapped = (i = Len(formulaText))
                        Exit Function
                    End If
                End If
        End Select
    Next i
    
    IsAlreadyWrapped = False
End Function

Bildschirmaktualisierung ausschalten

Da wir nun einen Errorhandler haben, können wir während des Makroablaufs die Bildschirmaktualisierung ausschalten sowie die automatischen Berechnungen deaktivieren.

Durch das Deaktivieren der Bildschirmaktualisierung (ScreenUpdating) und der automatischen Berechnung (Calculation) während der Ausführung des Makros, lässt sich die Performance deutlich steigern. Nach Abschluss des Makros oder bei einem Fehler werden diese Funktionen wieder aktiviert.

In diesem Makro ist das nicht zwingend notwendig, dennoch füge ich es dazu. Vielleicht führt es zu einer schnelleren Bearbeitung, wenn man eine große Menge an Zellen auswählt.

Option Explicit

Public Sub IFERRORWrapper()
    On Error GoTo ErrorHandler
    SetApplicationSettings False
    ProcessRange Selection
    SetApplicationSettings True
    Exit Sub
    
ErrorHandler:
    MsgBox "An error occurred: " & Err.Description, vbCritical, "IFERROR Wrapper"
    SetApplicationSettings True
    
End Sub


Private Function ProcessRange(ByVal rng As Range)
    Dim cell As Range
    Dim formulaText As String
    
    For Each cell In rng.Cells
        If cell.HasFormula Then
            formulaText = Mid(cell.Formula, 2)
            If Not IsAlreadyWrapped(formulaText) Then
                cell.Formula = "=IFERROR(" & formulaText & ", """")"
            End If
        End If
    Next cell
End Function


Private Function IsAlreadyWrapped(formulaText As String) As Boolean
    Dim i As Long
    Dim inString As Boolean
    Dim openParenCount As Long
    Dim char As String
    
    If Not formulaText Like "IFERROR(*)" Then
        IsAlreadyWrapped = False
        Exit Function
    End If
    
    For i = 1 To Len(formulaText)
        char = Mid(formulaText, i, 1)
        Select Case char
            Case """"
                inString = Not inString
            Case "("
                If Not inString Then openParenCount = openParenCount + 1
            Case ")"
                If Not inString Then
                    openParenCount = openParenCount - 1
                    If openParenCount = 0 Then
                        IsAlreadyWrapped = (i = Len(formulaText))
                        Exit Function
                    End If
                End If
        End Select
    Next i
    
    IsAlreadyWrapped = False
End Function


Private Sub SetApplicationSettings(enable As Boolean)
    With Application
        .ScreenUpdating = enable
        .Calculation = IIf(enable, xlCalculationAutomatic, xlCalculationManual)
    End With
End Sub

Selbst wenn das Makro wegen eines Fehlers abgebrochen wird, haben wir im Errorhandler die Anweisung die normalen Einstellungen wieder herzustellen.

Auswahl prüfen

Wir können eine Prüfung einbauen, um zu schauen, ob überhaupt irgendwas ausgewählt ist. Falls nicht, sollte eine gesonderte Meldung erscheinen.

Option Explicit

Public Sub IFERRORWrapper()
    Dim selectedRange As Range
    
    On Error GoTo ErrorHandler
    
    Set selectedRange = GetSelectedRange()
    If selectedRange Is Nothing Then Exit Sub
    
    SetApplicationSettings False
    ProcessRange selectedRange
    SetApplicationSettings True
    Exit Sub
    
ErrorHandler:
    MsgBox "An error occurred: " & Err.Description, vbCritical, "IFERROR Wrapper"
    SetApplicationSettings True
    
End Sub


Private Function GetSelectedRange() As Range
    If TypeName(Selection) <> "Range" Then
        MsgBox "Bitte wählen Sie zunächst einen Bereich aus.", vbExclamation, "IFERROR Wrapper"
        Set GetSelectedRange = Nothing
    Else
        Set GetSelectedRange = Selection
    End If
End Function


Private Function ProcessRange(ByVal rng As Range)
    Dim cell As Range
    Dim formulaText As String
    
    For Each cell In rng.Cells
        If cell.HasFormula Then
            formulaText = Mid(cell.Formula, 2)
            If Not IsAlreadyWrapped(formulaText) Then
                cell.Formula = "=IFERROR(" & formulaText & ", """")"
            End If
        End If
    Next cell
End Function


Private Function IsAlreadyWrapped(formulaText As String) As Boolean
    Dim i As Long
    Dim inString As Boolean
    Dim openParenCount As Long
    Dim char As String
    
    If Not formulaText Like "IFERROR(*)" Then
        IsAlreadyWrapped = False
        Exit Function
    End If
    
    For i = 1 To Len(formulaText)
        char = Mid(formulaText, i, 1)
        Select Case char
            Case """"
                inString = Not inString
            Case "("
                If Not inString Then openParenCount = openParenCount + 1
            Case ")"
                If Not inString Then
                    openParenCount = openParenCount - 1
                    If openParenCount = 0 Then
                        IsAlreadyWrapped = (i = Len(formulaText))
                        Exit Function
                    End If
                End If
        End Select
    Next i
    
    IsAlreadyWrapped = False
End Function


Private Sub SetApplicationSettings(enable As Boolean)
    With Application
        .ScreenUpdating = enable
        .Calculation = IIf(enable, xlCalculationAutomatic, xlCalculationManual)
    End With
End Sub

Variabler Wert falls Fehler

Momentan ist der Wert falls Fehler der mit dem Makro erstellen immer ein leerer String (""). Dies kann man anpassen, indem man die Zeile cell.Formula = "=IFERROR(" & formulaText & ", """")" im Code ändert. Ich hätte jedoch gerne die Möglichkeit, dass ich gefragt werde, was als Fehlerwert genutzt wird.

Dafür brauche ich zunächst eine InputBox:

Private Function GetErrorValue() As String
    Dim userInput As String
    
    userInput = InputBox("Geben Sie den Wert ein, der im Falle eines Fehlers zurückgegeben werden soll:", "IFERROR_Wrapper", """""")
    GetErrorValue = UserInput
End Function

Diesen Wert gebe ich an die Hauptfunktion weiter:

Public Sub IFERRORWrapper()
    Dim selectedRange As Range
    Dim errorValue As String
    
    On Error GoTo ErrorHandler
    
    Set selectedRange = GetSelectedRange()
    If selectedRange Is Nothing Then Exit Sub
    
    errorValue = GetErrorValue()
    If errorValue = "" Then Exit Sub
    
    SetApplicationSettings False
    ProcessRange selectedRange, errorValue
    SetApplicationSettings True
    Exit Sub
    
ErrorHandler:
    MsgBox "An error occurred: " & Err.Description, vbCritical, "IFERROR Wrapper"
    SetApplicationSettings True
    
End Sub

Und ich nutze diesen in der Prozedur.

Private Sub ProcessRange(ByVal rng As Range, ByVal errorValue As String)
    Dim cell As Range
    Dim formulaText As String
    
    For Each cell In rng.Cells
        If cell.HasFormula Then
            formulaText = Mid(cell.Formula, 2)
            If Not IsAlreadyWrapped(formulaText) Then
                cell.Formula = "=IFERROR(" & formulaText & ", " & errorValue & ")"
            End If
        End If
    Next cell
End Sub

Führt man das aus, merkt man, dass es nur mit dem Standardwert oder numerischen Werten richtig funktioniert, andere Eingaben jedoch in einem Fehler enden (z.B. =SUMME(A1)) oder ein @ zusätzlich erscheint. Wir brauchen eine zusätzliche Funktion, die die Eingabe verarbeitet.

Private Function GetErrorValue() As String
    Dim userInput As String
    userInput = InputBox("Geben Sie den Wert ein, der im Falle eines Fehlers zurückgegeben werden soll:", "IFERROR_Wrapper", "")
    GetErrorValue = FormatErrorValue(userInput)
End Function


Private Function FormatErrorValue(value As String) As String
    value = Trim(value)
    
    Select Case True
        Case IsNumeric(value)
            FormatErrorValue = value
        Case Left(value, 1) = "="
            FormatErrorValue = Mid(value, 2)
        Case Else
            FormatErrorValue = """" & Replace(value, """", """""") & """"
    End Select
End Function

Gibt man eine Formel ein, muss sie auf Englisch eingegeben werden, damit sie als solche erkannt wird, =SUM(A1) statt =SUMME(A1). Meiner Meinung nach hat sich Microsoft keinen Gefallen damit getan, die Formeln zu übersetzen, irgendwie bringt das mehr Probleme als Vorteile.

Gibt man Apfel ein, wird die Eingabe automatisch zu "Apfel" umgewandelt. Es könnte jedoch auch sein, dass ich einen benannten Bereich habe, der so heißt. Dafür baue ich dann auch einen Check ein.

Private Function FormatErrorValue(value As String) As String
    value = Trim(value)
    
    Select Case True
        Case IsNumeric(value)
            FormatErrorValue = value
        Case Left(value, 1) = "="
            FormatErrorValue = Mid(value, 2)
        Case IsValidNameOrReference(value)
            FormatErrorValue = value
        Case Else
            FormatErrorValue = """" & Replace(value, """", """""") & """"
    End Select
End Function


Private Function IsValidNameOrReference(value As String) As Boolean
    On Error Resume Next
    IsValidNameOrReference = Not IsError(Evaluate(value))
    On Error GoTo 0
End Function

Das Modul entspricht nun größtenteils meiner Vorstellung.

Option Explicit

Public Sub IFERRORWrapper()
    Dim selectedRange As Range
    Dim errorValue As String
    
    On Error GoTo ErrorHandler
    
    Set selectedRange = GetSelectedRange()
    If selectedRange Is Nothing Then Exit Sub
    
    errorValue = GetErrorValue()
    If errorValue = "" Then Exit Sub
    
    SetApplicationSettings False
    ProcessRange selectedRange, errorValue
    SetApplicationSettings True
    Exit Sub
    
ErrorHandler:
    MsgBox "An error occurred: " & Err.Description, vbCritical, "IFERROR Wrapper"
    SetApplicationSettings True
    
End Sub


Private Function GetSelectedRange() As Range
    If TypeName(Selection) <> "Range" Then
        MsgBox "Bitte wählen Sie zunächst einen Bereich aus.", vbExclamation, "IFERROR Wrapper"
        Set GetSelectedRange = Nothing
    Else
        Set GetSelectedRange = Selection
    End If
End Function


Private Function GetErrorValue() As String
    Dim userInput As String
    userInput = InputBox("Geben Sie den Wert ein, der im Falle eines Fehlers zurückgegeben werden soll:", "IFERROR_Wrapper", "")
    GetErrorValue = FormatErrorValue(userInput)
End Function


Private Function FormatErrorValue(value As String) As String
    value = Trim(value)
    
    Select Case True
        Case IsNumeric(value)
            FormatErrorValue = value
        Case Left(value, 1) = "="
            FormatErrorValue = Mid(value, 2)
        Case IsValidNameOrReference(value)
            FormatErrorValue = value
        Case Else
            FormatErrorValue = """" & Replace(value, """", """""") & """"
    End Select
End Function


Private Function IsValidNameOrReference(value As String) As Boolean
    On Error Resume Next
    IsValidNameOrReference = Not IsError(Evaluate(value))
    On Error GoTo 0
End Function


Private Sub ProcessRange(ByVal rng As Range, ByVal errorValue As String)
    Dim cell As Range
    Dim formulaText As String
    
    For Each cell In rng.Cells
        If cell.HasFormula Then
            formulaText = Mid(cell.Formula, 2)
            If Not IsAlreadyWrapped(formulaText) Then
                cell.Formula = "=IFERROR(" & formulaText & ", " & errorValue & ")"
            End If
        End If
    Next cell
End Sub


Private Function IsAlreadyWrapped(formulaText As String) As Boolean
    Dim i As Long
    Dim inString As Boolean
    Dim openParenCount As Long
    Dim char As String
    
    If Not formulaText Like "IFERROR(*)" Then
        IsAlreadyWrapped = False
        Exit Function
    End If
    
    For i = 1 To Len(formulaText)
        char = Mid(formulaText, i, 1)
        Select Case char
            Case """"
                inString = Not inString
            Case "("
                If Not inString Then openParenCount = openParenCount + 1
            Case ")"
                If Not inString Then
                    openParenCount = openParenCount - 1
                    If openParenCount = 0 Then
                        IsAlreadyWrapped = (i = Len(formulaText))
                        Exit Function
                    End If
                End If
        End Select
    Next i
    
    IsAlreadyWrapped = False
End Function


Private Sub SetApplicationSettings(enable As Boolean)
    With Application
        .ScreenUpdating = enable
        .Calculation = IIf(enable, xlCalculationAutomatic, xlCalculationManual)
    End With
End Sub

Fazit

Die Implementierung eines IFERROR-Wrapper Makros bietet bedeutende Vorteile für die Datenintegrität und Effizienz in Excel. Durch die Automatisierung des Prozesses, Formeln mit IFERROR zu umhüllen, sparen Sie Zeit und reduzieren das Risiko von Fehlern, die Ihre Analysen verfälschen könnten.

Vorteile des IFERROR-Makros

  • Verbesserte Datenintegrität: Fehlerhafte Berechnungen werden vermieden, was zu verlässlicheren Ergebnissen führt.
  • Erhöhte Effizienz: Zeitaufwendiges manuelles Editieren wird durch automatisierte Prozesse ersetzt.
  • Flexibilität: Anpassbar an verschiedene Szenarien und Anforderungen.

Wir benutzen Cookies

Diese Webseite nutzt Cookies. Näheres dazu erfahren Sie in unserer Datenschutzerklärung.