TM-SmartString: Replace

Eine wichtige Funktionen bei der Verarbeitung von Texten ist die Funktion "Replace". Es ist also nur folgerichtig, dass die Klasse TM-SmartString auch mit dieser Funktionalität ausgestattet wird.
Leider kann die gleichnamige VBA-Funktion nur einen festen, bekannten Text ersetzen. Wenn es darum geht, einen Text über ein Muster zu identifizieren, müssen so genannte
Regular Expressions über eine externe Bibliothek zur Hilfe genommen werden. Was liegt also näher, als die Funktionalität in dieser Klasse gleich mit Regular Expressions zu implementieren.

Eigenschaft: Replace
Diese Eigenschaft dient dazu, einen bestimmten Teil des enthaltenen Textes zu ersetzen. Dabei können reguläre Ausdrücke verwendet werden.

Implementierung
Die Implementierung erfolgt mit folgendem Code:

1:  Private m_RegExp As Object  
2:    
3:  Private Property Get myRegExp() As Object  
4:    If (m_RegExp Is Nothing) Then  
5:      Set m_RegExp = CreateObject("VBScript.RegExp")  
6:    End If  
7:    Set myRegExp = m_RegExp  
8:  End Property  
9:    
10:  Public Property Get Replace(ByVal Pattern As String, _
11:                ByVal ReplaceValue As String, _  
12:                Optional ByVal fGlobal As Boolean = True, _  
13:                Optional ByVal fIgnoreCase As Boolean = True, _  
14:                Optional ByVal fMultiline As Boolean = True) As String  
15:    myRegExp.Global = fGlobal  
16:    myRegExp.IgnoreCase = fIgnoreCase  
17:    myRegExp.Multiline = fMultiline  
18:    myRegExp.Pattern = Pattern  
19:    Replace = myRegExp.Replace(m_String, ReplaceValue)  
20:  End Property  
21:    
22:  Private Sub Class_Terminate()  
23:    Set m_RegExp = Nothing  
24:  End Sub  

In der ersten Zeile wird eine modul-private Variable vom Typ Object deklariert. In dieser Variable wird eine Instanz des Regular-Expression Objekts gespeichert.
In den Zeile 3 bis 8 wird eine private Property für das Regular Expression Objekt bereitgestellt. Hier wird das Singleton-Pattern umgesetzt. Auf diesem Weg wird sichergestellt, dass immer nur eine Instanz des Regular Expression Objekts instanziert und (wieder)verwendet wird. Zu beachten ist auch, dass das Regular Expressions Objekt per Late Binding erzeugt wird. Es ist also kein Verweis erforderlich.
In den Zeilen 10 bis 20 wird die Eigenschaft Replace bereitgestellt. Der Property werden neben dem gesuchten Text und dem Ersatzwert auch noch drei optionale Parameter übergeben. Diese Parameter steuern die Feinheiten der Regular Expression. Die Standardwerte für diese Parameter sind so eingestellt, dass sich die Property so verhält, wie sich auch die Replace-Funktion aus VBA verhalten würde. Informationen zu Regular Expressions finden sich in diesem Artikel.
Im Ereignis Terminate des Klassenmoduls wird am Ende noch die Instanz des Regular Expression Objekts vernichtet.

Bisheriger Code
Bisher wurde ein Replace mittels Regular Expression wie folgt durchgeführt:

1:  Dim myString As String  
2:  Dim myRegExp As Object  
3:      
4:  myString = "Hello World"  
5:      
6:  Set myRegExp = CreateObject("VBScript.RegExp")  
7:  myRegExp.Global = True  
8:  myRegExp.IgnoreCase = True  
9:  myRegExp.Multiline = True  
10:  myRegExp.Pattern = " "  
11:  myString = myRegExp.Replace(myString, " new ")  
12:      
13:  MsgBox myString  

In der zweiten Zeile wird die Variable vom Typ Objekt deklariert. In der Zeile 6 wird mittels Late Binding ein Regular Expressions Objekt erzeugt und dieser Variable zugewiesen. In den folgenden Zeilen werden die Eigenschaften des Regular Expression Objekts gesetzt. In der Zeile 11 wird schließlich die Ersetzung mittels Replace vorgenommen.

Künftiger Code
Bei Verwendung der Klasse TM_SmartString sieht der Code wie folgt aus:

1:  Dim myString As TM_SmartString  
2:  Set myString = New TM_SmartString  
3:  myString = "Hello World"  
4:  MsgBox myString.Replace(" ", " new ")  

In der vierten Zeile wird die Eigenschaft Replace abgerufen. Als Parameter werden der gesuchte Text und der Ersatztext übergeben.

Auch diese Implementierung zeigt wieder, dass die Verwendung einer Klasse einige Vorteile mit sich bringt. So braucht das Regular Expressions Objekt nur einmal deklariert zu werden. Die Feinheiten der Implementierung werden in der Klasse verborgen. Für den Benutzer sichtbar ist lediglich ein kleines, sauberes Interface.

Die neue Version 1.14.02 steht (wie immer) auf meiner Webseite zum Download bereit.