Brettb.Com
  HOME | ABOUT ME | BIOTECHNOLOGY | ARTICLES | GALLERY | CONTACT
Search: Go
TECHNICAL ARTICLES
 ASP
 ASP.NET
 JavaScript
 Transact SQL
 Other Articles
 Software Reviews

PHOTO GALLERIES
 Canon EOS 300D Samples
 Akihabara Maids!
 More Galleries...

TRAVEL LOG
 2009: China
 2008: Tokyo
 2007: Tokyo
 2006: Hong Kong
 2005: New York City

MORE STUFF
 Search Engine Optimisation
 Build an ASP Search Engine
 My Tropical Fishtank
 Autoglass
 SQL Month Name
 SQL Get Date Today
 SQL Year Month
 Other New Stuff...

POPULAR STUFF
 Regular Expressions
 Index Server & ASP
 JavaScript Ad Rotator

Home > Articles > ASP Programming Articles

Regular Expressions with VBScript and Visual Basic 6.0

From a programming perspective, one of the biggest annoyances I have faced with VBScript is the lack of decent string handling functions. Sure, with a bit of imagination, functions such as InStr, Left and Mid can be combined to help with the job at hand. But for anyone used to the Perl programming language, VBScript can appear to be extremely inflexible.

VBScript Regular Expressions

While still being someway off the effectiveness of Perl, version 5 of VBScript now has much improved text handling functions, through it's support for Regular Expressions. For anyone who hasn’t encountered the term, Regular Expressions have been an essential part of that nasty operating system known as Unix for many years (and where considered so useful that they were incorporated into Perl). They can be cryptic and difficult to learn, but they allow sophisticated pattern matching in strings.

Regular Expressions are quite involved (it is possible to buy whole books devoted to their use!), and the purpose of this article is simply to draw your attention to the potential of using them within VBScript.

If you want to know more, then try some of the references at the bottom of the article.

Using the VBScript RegEx object

Support for Regular Expressions has been included in VBScript by the inclusion of the RegExp object in VBScript version 5. This is the version of the VBScript scripting engine released with Internet Explorer 5. If you don’t have IE5 on your server, but want to upgrade the scripting engine, then download the new scripting engine from Microsoft.

If you don’t know which version of the scripting engine you are using, then try using the following small script:

<%
Response.Write "
You are using "
Response.Write ScriptEngine
Response.Write "
version " & ScriptEngineMajorVersion & "." & ScriptEngineMinorVersion
%>

This should display a message such as the one below:

Identification of the VBScript scripting engine version

Using the RegExp object

Once you have determined that your web server is running the correct version of VBScript, the following lines of code will demonstrate the use of the RegExp object.

The first line of code will create a new string that will be searched for the existence of a sub-string:

StringToSearch = "http://www.brettb.com"

The RegExp object can then be created:

Set RegularExpressionObject = New RegExp

This object has three properties: Pattern, IgnoreCase and Global. Pattern specifies the Regular Expression that should be searched for. IgnoreCase should be True or False depending on whether the search should be case sensitive (the default is true). Finally, the Global property should be set to True if the search should match all occurrences of the pattern, or False if just the first occurrence should be matched:

With RegularExpressionObject
.Pattern = "
.com"
.IgnoreCase = True
.Global = True
End With

Once the RegExp object’s properties have been set, it is time to test the Regular Expression. This is done using something like the line below. This uses the Test method of the RegExp object to see if the Regular Expression is found in the StringToSearch string.

expressionmatch = RegularExpressionObject.Test(StringToSearch)

The Test method will return True if the Regular Expression was found, and False if it was not found.

If expressionmatch Then
Response.Write RegularExpressionObject.Pattern & " was found in " & StringToSearch
Else
Response.Write RegularExpressionObject.Pattern & " was not found in " & StringToSearch
End If

Finally, the RegExp object is destroyed since it is no longer required.

Set RegularExpressionObject = nothing

More RegExp object methods

As well as the Test method, the VBScript RegExp object has two further methods: Execute and Replace.

The RegExp Execute method

The RegExp Execute method is a more sophisticated version of the Test method. As well as seeing if the Regular Expression is found within a string, it will also return the number of matches made within that string, and at which position in the string the match(es) were made. An example of its use is below:

<%
StringToSearch = "
The website ASPWatch.com contains lots of information about ASP, asp, as well as Asp."

Set RegularExpressionObject = New RegExp

With RegularExpressionObject
.Pattern = "
ASP"
.IgnoreCase = False
.Global = True
End With

Set expressionmatch = RegularExpressionObject.Execute(StringToSearch)

If expressionmatch.Count > 0 Then
For Each expressionmatched in expressionmatch
Response.Write "
<B>" & expressionmatched.Value & "</B> was matched at position <B>" & expressionmatched.FirstIndex & "</B><BR>"
Next

Else
Response.Write "
<B>" & RegularExpressionObject.Pattern & "</B> was not found in the string: <B>" & StringToSearch & "</B>."
End If

Set RegularExpressionObject = nothing
%>

As with the Test method, the RegExp’s Global and IgnoreCase properties are useful.

The RegExp Replace method

This can be used to replace a part of a string using Regular Expression matching. For example, in the script below, .co.uk is changed into .com:

<%
InitialString = "
www.foo.co.uk"

Set RegularExpressionObject = New RegExp

With RegularExpressionObject
.Pattern = ".co.uk"
.IgnoreCase = True
.Global = True
End With

ReplacedString = RegularExpressionObject.Replace(InitialString, "
.com")

Response.Write "
Replaced " & InitialString & " with " & ReplacedString

Set RegularExpressionObject = nothing
%>

Real life Regular Expressions

So far, this article has shown how to use the VBScript RegExp object to manipulate and test strings, but there is nothing here that couldn’t already be done with other VBScript functions. The power of Regular Expressions only become apparent when more complex situations are encountered. For example, the VBScript function below will strip out all the HTML tags from strings:

<%
Function stripHTMLtags(HTMLstring)

Set RegularExpressionObject = New RegExp

With RegularExpressionObject
.Pattern = "
<[^>]+>"
.IgnoreCase = True
.Global = True
End With

stripHTMLtags = RegularExpressionObject.Replace(HTMLstring, "")
Set RegularExpressionObject = nothing

End Function
%>

The function can then be called using something like:

<%
Response.Write stripHTMLtags("
<B>This <I>is</I> <TT style=""background-color: rgb(0,255,255)"">some</TT> <FONT COLOR=#FF00FF> HTML</FONT></B>")
%>

The function works because it replaces HTML tags with a null character. HTML tags are identified using the Regular Expression held in the Pattern property. This is a sequence of special characters. This means that a HTML tag should start with a "<". It should then contain one or more characters except for a greater than sign ">". This is indicated by enclosing the greater than sign in square brackets, and using the plus sign (which means match the preceding character one or more times. The ^ symbol denotes that the character should NOT appear. Finally, it should contain a greater than sign to close the HTML tag.

Looks complicated? Unfortunately most things that originate on Unix systems are! The best way to figure out Regular Expressions is to play around with them – check the bottom of this article for guides to the various characters that can be used. As a further help, a couple more regular expressions are shown below:

The dollar sign is used to look for matches at the end of a string, so the following will look for .co.uk at the end of a string:

.Pattern = ".co.uk$"

Use a bar to specify that several expressions should be matched. The following will match .co.uk or .com at the end of a string:

.Pattern = ".co.uk$|.com$"

Using Regular Expressions in Visual Basic

Few people seem to know that Regular Expressions can also be used with Visual Basic 5 or 6. All you need to do is to include a reference to "Microsoft VBScript Regular Expressions" in your project.

The following sample code will replace the HTML in the Text1 textbox with plain text:

<%
Dim RegularExpressionObject As Object

Set RegularExpressionObject = New VBScript_RegExp.RegExp

With RegularExpressionObject
.Pattern = "
<[^>]+>"
.IgnoreCase = True
.Global = True
End With

Text1.Text = RegularExpressionObject.Replace(Text1.Text, "")

Set RegularExpressionObject = Nothing
%>

Further Reading

  Site Map | Privacy Policy

All content is 1995 - 2012