Excel VBA Mid Left and Right:

A Complete Guide
BY PAUL KELLY·0 COMMENTS

Welcome to this article on the VBA Left, Right and Mid string functions. In this post, I will
show you when to use these functions and equally importantly when to avoid using them. If you
use them for the wrong type of tasks(i.e. extracting from variable strings), you can waste a
considerable amount of time.
I will also cover a little-known feature of the Mid function where you can update the original
string using Mid.

Contents [hide] [hide]

o 0.1 Syntax of Left, Right and Mid functions
o 0.2 Introduction
o 0.3 Left Function
o 0.4 Right Function
 1 Mid Function
o 1.1 Updating the Original String with Mid
 1.1.1 Reading through each character in a string
o 1.2 Reading through each character in reverse
o 1.3 When to Use/Not Use These Functions
o 1.4 Fixed Strings
 1.4.1 Variable sized (delimited) Strings
o 1.5 Conclusion
o 1.6 Related Reading
Syntax of Left, Right and Mid functions
These three functions all have a very similar purpose and that is to extract text from a text string.
You can see the syntax of these functions in this table:

Function Parameters Description Example

Left string, length Return chars from left side Left("John Smith",4)

Right string, length Return chars from right side Right("John Smith",5)

Mid string, start, length Return chars from middle Mid("John Smith",3,2)

Introduction
First of all, what is a string? A string is a piece of text. You can see examples below:

text = "Mary had a little lamb"

text = "John Smith"

text = "Customer 234-AA=56"

We call the variable type String in VBA and it is equivalent to text in a cell on a spreadsheet.

So let’s get started by setting up a simple piece of code so that we can use to show the results of
these string functions. First of all, we create the text variable, and then we assign some text to it:

Dim text As string

text = "Mary had a little lamb"

Then we create a variable and this variable will store the result of the Left, Right or Mid
function. We start by assigning the text string to the variable without making any changes:

Sub UseLeft()

Dim text As String, result As String

 text = "Mary had a little lamb"

' set result to have the same text

result = text

' View result in the Intermediate Window(Ctrl + G)

Debug.Print "Original: " & text

Debug.Print "Result: " & result

End Sub

Let’s run this code by clicking in the sub and pressing F5(this is the same as selecting Run->Run
Sub/UserForm from the menu.)

You can see that both strings were shown in the Immediate window:
(Note: If the Immediate window is not visible then select View->Immediate Window from the
menu or Ctrl + G)
So now that we have our basic code in place. Let’s go ahead and use it to show how these
functions work.

Left Function
The Left function is possibly the simplest function in VBA. It returns a given number of
characters from the left of a string. All you have to do it to tell it the number of characters that
you want to get.
Syntax
Left(String, Length)
Example
Left(“abcdef”, 3)
Result
“abc”
The key thing to remember is that the original string is not changed. We get the result of the Left
function and we store it in a different string. The original string remains the same.
In the following example, we’re going to return the first four characters of the string, which
are Mary:

Sub UseLeft()

Dim text As String, result As String

text = "Mary had a little lamb"

' store the result of the Left function in the result variable

result = Left(text, 4)

' Print the result to the Intermediate Window(Ctrl + G)

Debug.Print "Original: " & text

Debug.Print "Result: " & result

End Sub
If we change 4 to 8, you will see that the function now returns the first eight characters of the
string:

Sub UseLeft()

Dim text As String, result As String

text = "Mary had a little lamb"

' store the result of the Left function in the result variable

result = Left(text, 8)

' View result in the Intermediate Window(Ctrl + G)

Debug.Print "Original: " & text

Debug.Print "Result: " & result

End Sub
If we use a value greater than the length of the string, then the entire string is returned. For
example, in the next example, we use 100 with the Left function and you can see that the entire
string has been returned:

Sub UseLeft()

Dim text As String, result As String

text = "Mary had a little lamb"

' store the result of the Left function in the result variable

result = Left(text, 100)

' View result in the Intermediate Window(Ctrl + G)

Debug.Print "Original: " & text

Debug.Print "Result: " & result

End Sub
That is the Left function and you can see that it is pretty straightforward to use.

Right Function
The Right function is also very straightforward and it is very similar to the Left function. The
difference is that it extracts characters from the right side of the string rather than from the left
side. Right takes the same parameters as Left. It takes the string to extract from and the number
of characters that you wish to extract:
Syntax
Right(String, Length)
Example
Right(“abcdef”, 3)
Result
“def”
Let’s change the code that we were using with Left. We replace the Left function with the Right
function and set the length to 4:

Sub UseRight()

Dim text As String, result As String

text = "Mary had a little lamb"

 ' store the result of the Right function in the result variable

result = Right(text, 4)

' View result in the Intermediate Window(Ctrl + G)

Debug.Print "Original: " & text

Debug.Print "Result: " & result

End Sub

When we run this code and you can see that it has returned the last four characters of the string:

Let’s try another example, this time we’re changing the length to 11:

Sub UseRight()

Dim text As String, result As String

text = "Mary had a little lamb"

 ' store the result of the Right function in the result variable

result = Right(text, 11)

' View result in the Intermediate Window(Ctrl + G)

Debug.Print "Original: " & text

Debug.Print "Result: " & result

End Sub

Let’s run this code, now you can see that it returns the characters little lamb which are the last
11 characters:

Let’s try one more thing. This time we’re changing the length to 100 which is a number greater
than the length of the entire string:

Sub UseRight()

Dim text As String, result As String

text = "Mary had a little lamb"

 ' store the result of the Right function in the result variable

result = Right(text, 100)

' View result in the Intermediate Window(Ctrl + G)

Debug.Print "Original: " & text

Debug.Print "Result: " & result

End Sub

Let’s run this code, now you can see that it returns the entire string:

That means that anytime we supply a length that is greater than the length of the string, it will
return the entire string.
That is how we use the Right function. As you can see it is very similar to the Left function and
quite simple to use.

Mid Function
Now we are going to take a look at the Mid function. The Mid function extracts text from the
middle of the string, just as the name implies:
Syntax
Mid(String, Start, Length)
Example
Mid(“abcdef”, 2, 3)
Result
“bcd”
The Mid function is very similar to the Left function. The main difference between Mid and Left
is that Mid has one extra parameter – Start. The Start parameter is used to specify where the
starting position is in the string:
Syntax
Mid(String, Start, Length)
If we set the Start position to 1, then Mid works exactly the same as Left. If we want to extract
text from the string, then we set the Start parameter to the position from where we want to start
extracting characters.
Let’s look at some examples so that we can understand it better. In the first example, we use 1 as
the start position and 4 as the length. This will produce the same result as using the Left function
with 4 as the length:

Let’s try some code with Start as 1 and Length as 4:

Sub UseMid()

Dim text As string

text = "Mary had a little lamb"

Dim result As string

result = Mid(text, 1, 4)
 Debug.Print "Original: " & text

Debug.Print "Result: " & result

End Sub

You can see the result is the same as using Left with 3 as the length:

To extract the word “had”, we set the start position to 6 and the length to 3.

Sub UseMid()

Dim text As string

text = "Mary had a little lamb"

Dim result As string

result = Mid(text, 6, 3)

Debug.Print "Original: " & text

 Debug.Print "Result: " & result

End Sub

When we run the code, you can see what the result is.

Now we’re going to extract “little” from this string. We set the start position to 12 and the length
to 6:

Sub UseMid()

Dim text As string

text = "Mary had a little lamb"

Dim result As string

result = Mid(text, 12, 6)

Debug.Print "Original: " & text

Debug.Print "Result: " & result

End Sub

When we run the code, you can see the result:

Just like in the other two functions, if we use a length value greater than the length of the text
remaining, then the entire string is returned after the start position.
In the next example, we use 5 of the start position and we’re going to use 100 as the length
which is obviously longer than the length of the string:

Sub UseMid()

Dim text As String

text = "Mary had a little lamb"

Dim result As String

result = Mid(text, 12, 100)

Debug.Print "Original: " & text

Debug.Print "Result: " & result

End Sub

When you run the code you will see that you got back all the text from the start position:

One difference with Mid and the other two functions is that we don’t actually need to specify the
length. This parameter is actually optional. If we don’t include the length parameter, it will return
the rest of the string from the starting position that we provided. If we remove length from the
previous example, so instead of having 100, we just don’t have the parameter, you will see that it
also returns the rest of the string from the starting position:

Sub UseMid()

Dim text As String

text = "Mary had a little lamb"

Dim result As String

result = Mid(text, 12)

Debug.Print "Original: " & text

 Debug.Print "Result: " & result

End Sub

Updating the Original String with Mid

At the beginning of this article, I mentioned that Mid has a little-known feature and here I’m
going to show you what this feature is. We can update the string using Mid. With the Left\Right
functions, we just get back what we’ve extracted from the string. We cannot update the original
string with these functions.
The following shows an example of what I mean:
The original string is NOT changed
New string = Left(Original String, Length)
New string = Right(Original String, Length)
New string = Mid(Original String, Start, Length)
The original string is changed
Mid(String, Start, Length) = text

Let’s have a look at some examples to explain how this works. Let’s look at a simple example of
Mid first. The following code will return “Mary”:

Sub UseMid()

Dim text As String

text = "Mary had a little lamb"

Dim result As String

result = Mid(text, 1, 4)

Debug.Print "Original: " & text

 Debug.Print "Result: " & result

End Sub

Now we will take Mid and put it on the left-hand side of the equals sign. Then we assign it to the
string “Jack”. When we run the code, “Jack” will replace “Mary” in the original string:

Sub UpdateUsingMid()

Dim text As String

text = "Mary had a little lamb"

Mid(text, 1, 4) = "Jack"

Debug.Print "Original: " & text

End Sub
One thing to keep in mind is how the length works. If we use a length the only the number of
characters are replaced. So if we use 4 in the following example then only only 4 characters are
replaced:

Mid(text, 1, 4) = "Andrew"

The result is: Andr had a little lamb

But if we don’t use any length then all the letters in the string on the right are used as we can see
in this example:

Mid(text, 1) = "Andrew"

The result is: Andrewad a little lamb

If you just want to replace “Mary” with “Andrew” then the easiest thing to do is to use the
Replace function:

text = Replace(text, "Mary", "Andrew")

The result is: Andrew had a little lamb

Reading through each character in a string

One useful feature of the Mid function is that it allows us to read through each individual
character in a string. We can do it like this:
Sub MidLoop()

Dim text As String

text = "abcdef"

Dim i As Long, character As String

For i = 1 To Len(text)

character = Mid(text, i, 1)

Debug.Print i & ": " & character

Next i

End Sub

When we run this code we get the following result:

1: a
2: b
3: c
4: d
5: e
6: f

Reading through each character in reverse

If we want to read the text in the reverse direction we can do it like this:

Sub MidLoopReverse()

Dim text As String

text = "abcdef"
 Dim i As Long, character As String

For i = Len(text) To 1 Step -1

character = Mid(text, i, 1)

Debug.Print i & ": " & character

Next i

End Sub

You will get the following when you run the code:
6: f
5: e
4: d
3: c
2: b
1: a

When to Use/Not Use These Functions

We have seen how to use these functions. The next question is when should we use these
functions and when should we avoid using them. These functions work best with fixed strings,
but they don’t work so well with variable strings.

Fixed Strings
Fixed strings are where each field in a string is always the same size and in the same position.
For example, you might have records where the first characters are the customer id, the next 4
characters are the year, the next two the transaction type and so on e.g.
1234AB2019XX
4567AB2019YY
1245AB2018ZY
When dealing with strings like this Left, Right and Mid are very useful. But for Variable size
strings(i.e. typically a CSV style file), they are not suitable.
Variable sized (delimited) Strings
Variable size strings are ones where the fields may be of different sizes. The end of a field is
marked by a delimiter like a comma. These types of strings are very common and you will see
them in CSV files.
For example, imagine we have a file with a person’s name and their company name:
Jack Smith, United Block Company,36 High Street
Jenny Cathy Walton, Good Plumbers, Paradise Plaza
Helen McDonald, High-quality Software Providers, 16 Main Avenue
You can see that each field can be a different size. We use the delimiter (the comma in this case)
to show us where the field ends.
Many people make the mistake of using our 3 functions with the Instr function to extract the
data. For example:

Sub ReadVariableStrings()

' Create the test string

Dim text As String

text = "Jack Smith,United Block Company,36 High Street"

' Declare the variables

Dim person As String, company As String

Dim startPostion As Long, endPosition As Long

' Get the persons name

endPosition = InStr(text, ",")

person = Left(text, endPosition - 1)

' Get the company name

startPostion = endPosition + 1

endPosition = InStr(startPostion, text, ",") - 1

company = Mid(text, startPostion, endPosition - startPostion + 1)

 ' Print the results

Debug.Print person

Debug.Print company

End Sub

You can see that the above code is very longwinded. We actually do this much easier using the
Split function which I cover in this article. It has plenty of examples of using split with variable
strings.
Here is the code above, rewritten to use the Split function:

Sub ReadVariableStringsSplit()

' Create the test string

Dim text As String

text = "Jack Smith,United Block Company,36 High Street"

' Declare the array

Dim arr As Variant

' Split the string to an array

arr = Split(text, ",")

' Print the results

Debug.Print arr(0) ' Person

Debug.Print arr(1) ' Company

End Sub

You can see that this code is much simpler.

Conclusion
In this post, we covered using the Left; Right and Mid functions. These are very useful for
extracting text from a fixed-size string. We saw that the Mid function has the added feature
which allows us to replace text in a string. We also saw that the Mid function can be used to read
through the individual characters in a string.