String Handling Functions

VB.NET provides a rich set of functionality for working with strings, both in terms of "native .NET" methods as well as the
functions found in the Microsoft.VisualBasic namespace, which will look familiar to classic VB (pre-.NET) programmers. This
article presents both the native .NET methods and the MS.VB namespace functions for string-handling. Where equivalent
functionality exists between the two methodologies, the description, syntax, and examples are presented side-by-side for easy
comparison.
Getting a String's Length
Microsoft.VisualBasic
Namespace Function
Function / Property
Name:
Description:

Syntax:

Example:

Len

Length

Returns an integer containing the length of the

specified string.

Returns an integer containing the length of the

specified string.

Len(string)

String.Length

Where string is the string whose length

(number of characters) is to be returned.

Where string is the string whose length (number of

characters) is to be returned.

intLen = Len("Visual Basic")

' intLen now has the value 12

intLen = "Visual Basic".Length

' intLen now has the value 12

Getting Parts of a String (Substrings)

Microsoft.VisualBasic
Namespace Function
Function / Method
Name:
Description:

Syntax:

VB.NET
Property

Mid

VB.NET
Method
Substring

Returns a substring containing a specified

number of characters from a string.

Returns a substring containing a specified number

of characters from a string.

Mid(string, start[, length])

String.Substring(start, length)

The Mid function syntax has these parts:

start

Part
string

Description
Required. String expression from which
characters are returned.

start

Required; Integer. Character position in

string at which the part to be taken
begins. If start is greater than the
number of characters in string, Mid
returns a zero-length string ("").

Required; Integer. Character position in

string at which the part to be taken
begins. If start is greater than or equal to
the number of characters in string,
Substring throws an exception.

length Optional; Integer. Number of characters to

return. If omitted all characters from the
start position to the end of the string are
returned.

length Optional; Integer. Number of characters

to return. If omitted or if there are fewer
than length characters in the text
(including the character at start), all
characters from the start position to the
end of the string are returned.

Example:

strSubstr = Mid("Visual Basic", 3, 4)

' strSubstr now contains "sual"

NOTE: The Mid function is one-based (i.e., the

first position of a string is 1).
NOTE:
Mid can also be used on the left side of an
assignment statement, where you can replace a
substring within a string. (When Mid is used in
this manner, it is referred to as the "Mid
statement" rather than the "Mid function".)
Example:
strTest = "Visual Basic"

strSubstr = "Visual Basic".Substring(2,

4)
' strSubstr now contains "sual"

NOTE: The Substring method is zero-based (i.e.,

the first position of a string is 0).

Mid(strTest, 3, 4) = "xxxx"
' strTest now contains "Vixxxx Basic"

Microsoft.VisualBasic
Namespace Function
Function / Method
Name:

VB.NET
Method

Left
(NOTE: The Left function must be qualified with
the Microsoft.VisualBasic namespace
because Left is also a property in the
Windows.Forms.Form namespace.)

Description:

Returns a substring containing a specified

number of characters from the beginning (left
side) of a string.

Syntax:

Left(string, length)

(use Substring)

The Left function syntax has these parts:

Part
string

Description
Required. String expression from which
the leftmost characters are returned.

length Required; Integer. Numeric expression

indicating how many characters to
return. If 0, a zero-length string ("") is
returned. If greater than or equal to the
number of characters in string, the entire
string is returned.
Example:

strSubstr = _
Microsoft.VisualBasic.Left _
("Visual Basic", 3)
' strSubstr now contains "Vis"

NOTE: The Left function is one-based (i.e., the

first position of a string is 1).

strSubstr = "Visual Basic".Substring(0,

3)
' strSubstr now contains "Vis"

REMINDER: The Substring method is zero-based

(i.e., the first position of a string is 0).

' Note that the same thing could be

' accomplished with Mid:
strSubstr = Mid("Visual Basic", 1, 3)

Microsoft.VisualBasic
Namespace Function
Function / Method
Name:

VB.NET
Method

Right
(NOTE: The Right function must be qualified
with the Microsoft.VisualBasic namespace
because Right is also a property in the
Windows.Forms.Form namespace.)

Description:

Returns a substring containing a specified

number of characters from the end (right side) of
a string.

Syntax:

Right(string, length)

The Right function syntax has these parts:

Part
string

Description
Required. String expression from which
the rightmost characters are returned.

length Required; Integer. Numeric expression

indicating how many characters to
return. If 0, a zero-length string ("") is
returned. If greater than or equal to the
number of characters in string, the entire

(use Substring)

string is returned.
Example:

strSubstr = _
Microsoft.VisualBasic.Right _
("Visual Basic", 3)
' strSubstr now contains "sic"

NOTE: The Right function is one-based (i.e., the

first position of a string is 1).

strSubstr = "Visual Basic".Substring(9,

3)
' strSubstr now contains "sic"

REMINDER: The Substring method is zero-based

(i.e., the first position of a string is 0).

' Note that the same thing could be

' accomplished with Mid:
strSubstr = Mid("Visual Basic", 10, 3)

Getting a Specific Character of a String with the Chars Property

To get a specific character of a string, you can use the Chars property, which will return the character found at the position
specified by a number (called an index) in parentheses. The position is zero-based, so the first position of the string is 0.
Example:
Dim chrTheChar As Char
Dim strTest As String = "Visual Basic"
chrTheChar = strTest.Chars(7)
' chrTheChar now contains "B"

It is also legal syntax to omit the ".Chars" part. If omitted, the Chars method will be assumed, as in the example below:
Dim chrTheChar As Char
Dim strTest As String = "Visual Basic"
chrTheChar = strTest(2)
' chrTheChar now contains "s"

Testing the Beginning and Ending Parts of a String with StartsWith and EndsWith
If you want to test whether or not a string begins with a certain combination of characters, you can use the StartsWith method,
which returns a Boolean True or False value indicating whether or not the string being tested starts with the characters given as
the argument. Therefore:
If strTest.StartsWith("Vis") Then ...

is equivalent to:
If strTest.Substring(0, 3) = "Vis" Then ...

or:
If Microsoft.VisualBasic.Left(strTest, 3) = "Vis" Then ...

If you want to test whether or not a string ends with a certain combination of characters, you can use the EndsWith method,
which returns a Boolean True or False value indicating whether or not the string being tested ends with the characters given as
the argument. Therefore:
If strTest.EndsWith("ic") Then ...

is equivalent to:
If strTest.Substring(10, 2) = "ic" Then ...

or:
If Microsoft.VisualBasic.Right(strTest, 2) = "ic" Then ...

Finding One String Within Another

Microsoft.VisualBasic
Namespace Function
Function / Method
Name:
Description:

VB.NET
Method

Instr

IndexOf

Returns an integer specifying the position of

one string within another. The search starts
either at the first character position or at the
position specified by the start argument, and
proceeds forward toward the end of the string
(stopping when either string2 is found or when
the end of the string1 is reached). If the string is
not found, 0 is returned.

Returns an integer specifying the position of one

string within another. The search starts either at
the first character position or at the position
specified by the startindex argument, and
proceeds forward toward the end of the string
(stopping when either string is found or when the
end of the string being searched is reached). If the
string is not found, -1 is returned. IndexOf

performs a case-sensitive search.

Syntax:

InStr
([start,] string1, string2 [, compare])

String.IndexOf(string [, startindex])

string

String expression sought.

startindex

Optional. Numeric expression that

sets the starting position for each
search. If omitted, search begins at the
first character position.

The InStr function syntax has these parts:

Part

Description

start

Optional. Numeric expression that

sets the starting position for each
search. If omitted, search begins at
the first character position. The
start argument is required if
compare is specified.

string1

Required. String expression being

searched.

string2

Required. String expression sought.

compare

Optional; numeric. A value of 0 (the

default) specifies a binary (casesensitive) search. A value of 1
specifies a textual (caseinsensitive) search.

NOTE: The CompareMethod enumeration can

be specified for the compare argument: for 0
(case-sensitive), CompareMethod.Binary is
used; for 1 (case-insensitive),
CompareMethod.Text is used. Alternatively,
the older "vb" constants vbBinaryCompare
and vbTextCompare can be used for 0 and 1
respectively.
NOTE: If the optional compare argument is
specified, then the start argument must also be
specified.
Example:

intPos = Instr("Visual Basic", "a")

' intPos now has the value 5
' (search started at position 1
' by default and is case-sensitive
' by default)

intPos = "Visual Basic".IndexOf("a")

' intPos now has the value 4

intPos = Instr(6, "Visual Basic", "a")

' intPos now has the value 9
' (search started at position 6
' and is case-sensitive by default)

intPos = "Visual Basic".IndexOf("A")

' intPos now has the value -1

intPos = Instr("Visual Basic", "A")

' intPos now has the value 0
' (case-sensitive search was performed
' by default)

intPos = "Visual Basic".IndexOf("a", 6)

' intPos now has the value 8

NOTE: The IndexOf method is zero-based (i.e.,

the first position of a string is 0).

intPos = Instr(1, "Visual Basic", _

"A", 1)
- or
intPos = Instr(1, "Visual Basic", _
"A", CompareMethod.Text)
' intPos now has the value 5
' (search started at position 1 and is
' case-insensitive)

NOTE: The Instr function is one-based (i.e., the

first position of a string is 1).

Function / Method
Name:

Microsoft.VisualBasic
Namespace Function

VB.NET
Method

InstrRev

LastIndexOf

Description:

Returns an integer specifying the position of

one string within another. The search starts
either at the last character position or at the
position specified by the start argument, and
proceeds backward toward the beginning of the
string (stopping when either string2 is found or
when the beginning of the string1 is reached). If
the string is not found, 0 is returned.

Returns an integer specifying the position of one

string within another. The search starts either at
the last character position or at the position
specified by the startindex argument, and
proceeds backward toward the beginning of the
string (stopping when either string is found or
when the beginning of the string being searched is
reached). If the string is not found, -1 is returned.
LastIndexOf performs a case-sensitive search.

Syntax:

InStrRev
(string1, string2[, start, [,
compare]])

String.LastIndexOf(string [, startindex])

string

String expression sought.

The InStrRev function syntax has these parts:

startindex

Optional. Numeric expression that

sets the starting position for each
search. If omitted, search begins at the
last character position.

Part

Description

string1

Required. String expression being

searched.

string2

Required. String expression sought.

start

Optional. Numeric expression that

sets the starting position for each
search. If omitted, search begins at
the last character position.

compare

Optional; numeric. A value of 0 (the

default) specifies a binary (casesensitive) search. A value of 1
specifies a textual (caseinsensitive) search.

NOTE: The CompareMethod enumeration can

be specified for the compare argument: for 0
(case-sensitive), CompareMethod.Binary is
used; for 1 (case-insensitive),
CompareMethod.Text is used. Alternatively,
the older "vb" constants vbBinaryCompare
and vbTextCompare can be used for 0 and 1
respectively.
Example:

intPos = InstrRev("Visual Basic", "a")

' intPos now has the value 9
' (search started at last position
' by default and is case-sensitive
' by default)
intPos = InstrRev("Visual Basic", _
"a", 6)
' intPos now has the value 5
' (search started at position 6
' and is case-sensitive by default)
intPos = InstrRev("Visual Basic", "A")
' intPos now has the value 0
' (case-sensitive search was performed
' by default)
lngPos = InstrRev("Visual Basic", _
"A", , 1)
' intPos now has the value 9
' (search started at last position
' and is case-insensitive)
' Note that this example has a
' placeholder for the optional
' start argument.

NOTE: The InstrRev function is one-based (i.e.,

the first position of a string is 1).

intPos = "Visual Basic".LastIndexOf("a")

' intPos now has the value 8
intPos = _
"Visual Basic".LastIndexOf("a", 6)
' intPos now has the value 4
intPos = "Visual Basic".LastIndexOf("A")
' intPos now has the value -1

NOTE: The LastIndexOf method is zero-based

(i.e., the first position of a string is 0).

Testing to See If One String is Contained Within Another with Contains

If you want to test whether or not one string is contained within another, you can use the Contains method, which returns a
Boolean True or False value indicating whether or not the string being tested contains the characters given as the argument.
Therefore:
If strTest.Contains("asi") Then ...

is equivalent to:
If strTest.IndexOf("asi") <> -1 Then ...

or:
If Instr(strTest, "asi") > 0 Then ...

Replacing Text Within a String

Microsoft.VisualBasic
Namespace Function
Function / Method
Name:
Description:

Syntax:

Replace

VB.NET
Method
Replace

Returns a string in which a specified substring

has been replaced with another substring a
specified number of times.

Returns a string in which all occurrences of a

specified substring has been replaced with another
substring.

Replace (expression, find, replacewith

[, start[, count[, compare]]])

String.Replace(oldstring, newstring)

oldstring

Required. Substring being

searched for.

newstring

Required. Replacement substring.

The Replace function syntax has these parts:

Part
expression
find

Description
Required. String expression
containing substring to replace.
Required. Substring being
searched for.

replacewith

Required. Replacement
substring.

start

Optional. Position within

expression where substring
search is to begin. If omitted, 1
is assumed.

count

Optional. Number of substring

substitutions to perform. If
omitted, the default value is 1,
which means make all possible
substitutions.

compare

Optional. Numeric value

indicating the kind of
comparison to use when
evaluating substrings. (0 =
case sensitive, 1 = caseinsensitive)

NOTE: The CompareMethod enumeration can

be specified for the compare argument: for 0
(case-sensitive), CompareMethod.Binary is
used; for 1 (case-insensitive),
CompareMethod.Text is used. Alternatively,
the older "vb" constants vbBinaryCompare
and vbTextCompare can be used for 0 and 1
respectively.
Example:

strNewDate = _
Replace("08/31/2001", "/", "-")
' strNewDate now contains "08-31-2001"

strNewDate = _
"08/31/2001".Replace("/", "-")
' strNewDate now contains "08-31-2001"

Casing Strings
Microsoft.VisualBasic
Namespace Function
Function / Method
Name:
Description:

VB.NET
Method

UCase

ToUpper

Converts all lowercase letters in a string to

uppercase. Any existing uppercase letters and
non-alpha characters remain unchanged.

Converts all lowercase letters in a string to

uppercase. Any existing uppercase letters and
non-alpha characters remain unchanged.

Syntax:

UCase(string)

String.ToUpper

Example:

strNew = UCase("Visual Basic")

' strNew now contains "VISUAL BASIC"

strNew = "Visual Basic".ToUpper

' strNew now contains "VISUAL BASIC"

Function / Method
Name:
Description:

Microsoft.VisualBasic
Namespace Function

VB.NET
Method

LCase

ToLower

Converts all uppercase letters in a string to

lowercase. Any existing lowercase letters and
non-alpha characters remain unchanged.

Converts all uppercase letters in a string to

lowercase. Any existing lowercase letters and nonalpha characters remain unchanged.

Syntax:

LCase(string)

String.ToLower

Example:

strNew = LCase("Visual Basic")

' strNew now contains "visual basic"

strNew = "Visual Basic".ToLower

' strNew now contains "visual basic"

Trimming Strings
Microsoft.VisualBasic
Namespace Function

VB.NET
Method

Function / Method
Name:
Description:

Removes leading blank spaces from a string.

Removes leading blank spaces from a string.

Syntax:

LTrim(string)

String.TrimStart

Example:

strTest = LTrim(" Visual Basic ")

' strTest now contains "Visual Basic

LTrim

TrimStart

"

strTest = " Visual Basic ".TrimStart

' strTest now contains "Visual Basic "

Microsoft.VisualBasic
Namespace Function

VB.NET
Method

RTrim

TrimEnd

Function / Method
Name:
Description:

Removes trailing blank spaces from a string.

Removes trailing blank spaces from a string.

Syntax:

RTrim(string)

String.TrimEnd

Example:

strTest = RTrim(" Visual Basic ")

' strTest now contains " Visual Basic"

strTest = " Visual Basic ".TrimEnd

' strTest now contains " Visual Basic"

Function / Method
Name:
Description:

Microsoft.VisualBasic
Namespace Function

VB.NET
Method

Trim

Trim

Removes both leading and trailing blank

spaces from a string.

Removes both leading and trailing blank spaces

from a string.

Syntax:

Trim(string)

String.Trim

Example:

strTest = Trim(" Visual Basic ")

' strTest now contains "Visual Basic"

strTest = " Visual Basic ".Trim

' strTest now contains "Visual Basic"

More VB.NET String-Handling Methods

Method Name:

Concat

Description:

Concatenates two or more strings together. This can be used as an alternative to the + or & operators.

Syntax:

String.Concat(string1, string2, ... stringn)

Example:

The following three statements are all equivalent:

strTest = String.Concat("Hello ", "World")
strTest = "Hello " & "World"
strTest = "Hello " + "World"

Method Name:

Insert

Description:

Inserts characters into a string

Syntax:

String.Insert(startindex, value)

Example:

startindex

Required. The (zero-based) position at which to insert characters.

value

Required. The string of characters to insert.

strTest = "The time now."

strTest = strTest.Insert(9, "is ")
' strTest now contains "The time is now."

Method Name:

Remove

Description:

Removes characters from a string

Syntax:

String.Remove(startindex [, count])

Examples:

startindex

Required. The (zero-based) position at which to delete characters.

count

Optional. The number of characters to delete. If omitted, all characters from startindex
to the end of the string will be deleted.

strTest = "Two hundred dollars."

strTest = strTest.Remove(4, 8)
' strTest now contains "Two dollars."
strTest = strTest.Remove(3)
' strTest now contains "Two"

Method Name:
Description:

Padding Strings
PadLeft
Returns a string that is right-aligned and padded on the left with spaces (or other specified character)
so that the length of the string is the specified width.

Syntax:

String.PadLeft(totalWidth [, paddingChar])

totalWidth

Required. The total number of characters to be contained in the resulting string.

paddingChar

Optional. The character to pad the string with. If omitted, a blank space will be used.

Example:

strName = "John Doe"

strNewName = strName.PadLeft(15)
' strNewName now contains "
John Doe"
strNewName = strName.PadLeft(15, "*")
' strNewName now contains "*******John Doe"

Method Name:
Description:

PadRight
Returns a string that is left-aligned and padded on the right with spaces (or other specified character)
so that the length of the string is the specified width.

Syntax:

String.PadRight(totalWidth [, paddingChar])

totalWidth

Required. The total number of characters to be contained in the resulting string.

paddingChar
Example:

Optional. The character to pad the string with. If omitted, a blank space will be used.

strName = "John Doe"

strNewName = strName.PadRight(15)
' strNewName now contains "John Doe
"
strNewName = strName.PadRight(15, "*")
' strNewName now contains "John Doe*******"

String Object
(NOTE: This can be used as an equivalent to the String function found in pre-.NET versions of Visual Basic)
Description:

Can be used to return a string containing a repeating character string of the length specified.

Syntax:

New String(character, count)

character

The character to be repeated.

count
Examples:

The number of characters to pad the string with.

strTest = New String("*", 5)

' strTest now contains "*****"

More Microsoft.VisualBasic Namespace String-Handling Functions

Function Name:

StrReverse

Description:

Returns a string in which the character order of a specified string is reversed.

Syntax:

StrReverse (string)

Examples:

strTest = StrReverse ("Visual Basic")

' strTest now contains "cisaB lausiV"

Function Name:

Space

Description:

Returns a string containing the specified number of blank spaces.

Syntax:

Space(number)
Where number is the number of blank spaces desired.

Examples:

strTest = Space(5)
' strTest now contains "

"

Function Name:

Asc

Description:

Returns an Integer representing the ASCII character code corresponding to the first letter in a string.
(For an ASCII character reference, click here.)

Syntax:

Asc(string)

Examples:

intCode =
' intCode
intCode =
' intCode

Function Name:

Asc("*")
now has the value 42
Asc("ABC")
now has the value 65

Chr

Description:

Returns a string containing the character associated with the specified ASCII character code.
(For an ASCII character reference, click here.)

Syntax:

Chr(charcode)
Where charcode is a number from 0 to 255 that identifies the character.

Examples:

strChar = Chr(65)
' strChar now contains "A"

"Try It" Example

To demonstrate the built-in string functions, set up a "Try It" console project, and place the following code in the main method:
Sub Main()
Dim strTest As String
Console.Write("Please enter a string: ")
strTest = Console.ReadLine()
Console.WriteLine("Using Len and Length: <" _
& CStr(Len(strTest)) & "><" & CStr(strTest.Length) & ">")
Console.WriteLine("Using Mid, Left, Right, and Substring: <" _
& Mid(strTest, 3, 4) _
& "><" & Microsoft.VisualBasic.Left(strTest, 3) _
& "><" & Microsoft.VisualBasic.Right(strTest, 2) _
& "><" & strTest.Substring(2, 4) & ">")
Console.WriteLine("Using Chars: <" & strTest.Chars(0) & "><" & strTest(7) & ">")
Console.WriteLine("Using StartsWith and EndsWith: <" _
& CStr(strTest.StartsWith(" Vis")) _
& "><" & CStr(strTest.EndsWith("ic")) & ">")
Console.WriteLine("Using Instr, IndexOf, InstrRev, and LastIndexOf: <" _
& CStr(InStr(strTest, "a")) _
& "><" & CStr(strTest.IndexOf("a")) _
& "><" & CStr(InStrRev(strTest, "a")) _
& "><" & CStr(strTest.LastIndexOf("a")) & ">")
Console.WriteLine("Using Contains: <" & CStr(strTest.Contains("asi")) & ">")
Console.WriteLine("Using the Replace function and Replace method: <" _
& Replace(strTest, "a", "*") & "><" & strTest.Replace("a", "*") & ">")
Console.WriteLine("Using UCase and ToUpper: <" _
& UCase(strTest) & "><" & strTest.ToUpper & ">")
Console.WriteLine("Using LCase, and ToLower: <" _
& LCase(strTest) & "><" & strTest.ToLower & ">")
Console.WriteLine("Using LTrim and TrimStart: <" _
& LTrim(strTest) & "><" & strTest.TrimStart & ">")
Console.WriteLine("Using RTrim and TrimEnd: <" _
& RTrim(strTest) & "><" & strTest.TrimEnd & ">")
Console.WriteLine("Using the Trim function and Trim method: <" _
& Trim(strTest) & "><" & strTest.Trim & ">")
Console.WriteLine("Using Concat: <" & String.Concat(strTest, "-", strTest) & ">")
Console.WriteLine("Using Insert: <" & strTest.Insert(3, "*****") & ">")
Console.WriteLine("Using Remove: <" & strTest.Remove(3, 2) & ">")
Console.WriteLine("Using PadLeft and PadRight: <" _
& strTest.PadLeft(20, "*") & "><" & strTest.PadRight(20) & ">")
Console.WriteLine("Using String, Space, and Chr: <" _
& New String("*", 3) & Space(2) & Trim(strTest) & Space(2) _
& New String(Chr(42), 3) & ">")
Console.WriteLine("Using StrReverse: <" & StrReverse(strTest) & ">")
Console.WriteLine("Using Asc: <" & CStr(Asc(strTest)) & ">")
Console.WriteLine("")
Console.WriteLine("(Press Enter to close this window.)")
Console.ReadLine()
End Sub

Run the project and enter a string of your choice.

Some tips on what to enter:

To see the effects of UCase, LCase, ToUpper, and ToLower, enter a mixed case string.

To see the effects of Instr, InstrRev, IndexOf, and LastIndexOf, enter a string with at least two "a"s in it.

To see the effects of LTrim, RTrim, TrimStart, TrimEnd, and Trim, enter a string with leading and/or trailing spaces.

To see the effect of Replace, enter a string with at least one "a" in it.
You can also modify the code and run the project to see if you get the results you expect.
The screen shot below shows a run of the project using the code above where the string Visual Basic was input:

Download the VB project code for the example above here.