If you open up Excel you will see countless boxes. These boxes are called Cells. You can store many different kinds of variables within these cells including numbers, strings, and even dates. If you highlight a bunch of cells (click on a cell and while holding the left click down, drag your mouse to another cell), you just selected a Range of cells. The row numbers are on the left and the column numbers are denoted as letters across the top row. Now that definitions are out of the way, we can move on to cell manipulation.

Cell Manipulation

Let’s say we want to change the value in Cell A1 which is the top left most cell in the workbook to the value 42. Let’s look at the code:

Sub CellManipulation()
    Cells(1, 1) = 42
End Sub

Yup it’s that easy. The syntax is Cells(row number, column number) Now let’s try to make Cell A2 equal to 20 and then add the two cells together.

Sub CellManipulation()
    Cells(1, 1) = 42
    Cells(2, 1) = 20
    Cells(3, 1) = Cells(1, 1) + Cells(2, 1)
End Sub

Wowee, I think we almost did something noteworthy right there. Let’s not limit cell manipulation to just changing values, we can also change the font for a particular cell. Let’s make Cell A1 highlighted yellow, Cell A2 Times New Roman font, and Cell A3 size 20:

Sub CellManipulation()
    Cells(1, 1) = 42
    Cells(1, 1).Interior.ColorIndex = 6 'Yellow
    Cells(2, 1) = 20
    Cells(2, 1).Font.Name = "Times New Roman"
    Cells(3, 1) = Cells(1, 1) + Cells(2, 1)
    Cells(3, 1).Font.Size = 20
End Sub

But now everything is all messy and gross, let’s bring it back to normal by clearing everything:

Sub ClearEverything()
    Cells.Clear
End Sub

Now as you can see, we can do a lot with cell manipulation. Let’s see what we can do with ranges.

Range Manipulation

Now let’s assume that we have cells A1 through A10 filled with pseudo-random numbers between 1 and 100 and we want to see who passed, who failed, what the class average was, and what the highest score was. So we will change the font color to red for those who failed and green for those who passed. Try it on your own then have a look at the code:

Sub RangeExample()
    'For loop puts a random number (1-100) in the first 10 cells
    For i = 1 To 10
        Cells(i, 1) = Int((100 - 1 + 1) * Rnd + 1)
    Next i
    Cells(1, 2) = "Average"
    Cells(1, 3) = Application.Average(Range(Cells(1, 1), Cells(10, 1)))
    Cells(2, 2) = "Maximum"
    Cells(2, 3) = Application.Max(Range(Cells(1, 1), Cells(10, 1)))
    For j = 1 To 10
        If (Cells(j, 1) >= 60) Then
            Cells(j, 1).Font.ColorIndex = 4 'Green
        Else
            Cells(j, 1).Font.ColorIndex = 3 'Red
        End If
    Next j
End Sub

Lines 2-5 is just a fancy way to generate random numbers and you can ignore it for now. Line 7 finds the average of a range. The syntax for a range selection is Range(Cells(row number, column number), Cells(row number, column number) where the first cell is the top left most cell in your range and the second cell is the bottom right most cell in your range. This does not need to be just a row or column range, you can select multiple rows and columns. This is great for making charts.

With just this basic knowledge of cell manipulation and range manipulation, we can do almost anything involving calculations or custom formula solvers. It doesn’t look like people are that interested in Excel VBA, so if the people want more examples/tutorials I will make them, but for now I might be moving to something more interesting like Actionscript 3.0. ~Signing Off iAtoria.

The Select-Case is often ignored when programming as it can be easily substituted with If-Then-Else statements. It functions much like a If-Then-Else statement and computes a conditional where if true, completes a segment of code. Let’s look at the example:

Sub SelectCaseStatment()
    Dim i As Integer
    i = 79
    Select Case i
        Case 0 To 59
            Debug.Print "Grade: F"
        Case 60 To 69
            Debug.Print "Grade: D"
        Case 70 To 79
            Debug.Print "Grade: C"
        Case 80 To 89
            Debug.Print "Grade: B"
        Case 90 To 100
            Debug.Print "Grade: A"
        Case Else
            Debug.Print "You need to enter a value between 0 and 100"
    End Select
End Sub

The output you will see in your Immediate Window will be Grade: C. In lines 2-3 we declare i to be an integer with a value of 79. Line 4 enters the Select-Case statement. It then proceeds to ask in line 5 “in the case that i is in between 0 and 59 inclusive (0 <= i <= 59), complete the statement below." We can clearly see that the case that our integer will follow is the case in line 9. The Select-Case is pretty simple to understand and I won’t delve too deeply into it, but it may be useful to you in the future. We are now finished with all the basics of Excel VBA, next time we will finally begin manipulating Cells & Ranges, signing off ~iAtoria.

A Do-While-Loop is similar to a For-Loop in the sense that they are both iteration statements. The only difference is that the Do-While-Loop has a conditional statement that it uses to determine whether or not the loop shall continue. Take a look:

Sub TheDoWhileLoop()
    Dim x As Integer
    x = 1
    Do While (x <= 10)
        Debug.Print x
        x = x + 1
    Loop
End Sub

After executing the code above you should get the integers 1-10 displayed in your immediate window. Line 4 reads exactly as it shows, keep looping while x is less than or equal to 10. We print x in line 5 and increase it’s value by 1 in line 6. Then the loop statement in line 7 sends it back to line 4. This is exactly what the For-Loop did, but instead you have to manually change the variable that is in the conditional statement, which can lead to . . .

The Loop . . . It’s Never Ending!!!

READ THIS WHOLE SECTION BEFORE TRYING THIS!! Try deleting line 6 and re-running the code. Finished yet? How about now? Notice that because we never increase the x value manually the conditional statement will always be true because x will remain 1. This is called a never ending loop. I have run into many a never ending loops in my day and unless you are a programming prodigy, you will too. There are a couple ways to get out of this never ending loop, here are a few:

Steps to take to kill your code execution:

1. Hit the Escape Key a couple times
2. Hit the Pause/Break Key a couple times
3. Press Ctrl+C a couple times
4. If none of the above key combos worked then Ctrl+Alt+Delete and kill Excel

Join me next time as I talk about the under appreciated Select-Case, signing off ~iAtoria.

The For-Loop is an iteration statement. An iteration statement is one that repeats a segment of code until a desired result is achieved. Each repetition is called an iteration. Again, it’s easier to learn by example:

Sub TheForLoop()
    For i = 1 To 10
        Debug.Print i
    Next i
End Sub

After running the procedure above you will see 1 through 10 printed in your immediate window. In line 2 we declare the For-Loop and create a variable i which is equal to 1. In the same line we ask for i to increase by 1 until it equals 10 which will end the loop. Line 4 tells us to increase i by 1 and the code goes back to line 2. Here we can see the looping effect first hand.

Wait a For-Loop within a For-Loop?

This lesson is fairly short so let’s delve into a more advanced looping technique which you will likely use in the future . . . The Double For-Loop. It’s exactly what it sounds like, its a For-Loop with a For-Loop inside of it. Let’s say we wanted to write values in a 8×4 grid in your excel sheet a Double For-Loop could be used to access these cells and write the values. Take a look at this code, execute it and see if you can tell what is happening:

Sub TheForLoop()
    For i = 1 To 8
        For j = 1 To 4
            Cells(i, j) = 100
        Next j
    Next i
End Sub

Line 4 is new. This is how you write values into cells. This will be discussed later, but essentially, Cells(1,1) is row 1 column A, Cells(1, 2) is row 1 column B and so on. The best way to understand code is to follow it line by line. See if you can tell the order in which the lines are executed (ANSWER: 1, 2, 3-4-5, 3-4-5, 3-4-5, 3-4-5, 6, 2, 3-4-5, 3-4-5, 3-4-5, 3-4-5, 6, see the pattern?). Note that a For-Loop doesn’t always need to start at 1, it can start at any number. Next time we’ll talk about the Do-While-Loop, signing off ~iAtoria.

The If-Then-Else is a perfect example of a conditional statement. A conditional statement is a true/false statement that is computed to determine if a code segment should be executed. Let’s have a look at a practical example:

Sub TheIfStatement()
    Dim i As Integer
    i = 100
    If (i = 100) Then
        Debug.Print "i equals 100"
    End If
End Sub

If you copy and paste the above sub routine into a module you will see i equals 100 displayed in your immediate window. We can see in lines 2 and 3 that i is an integer that equals 100. Line 4 asks if variable i equals 100 then execute the following code. Now that we understand how conditionals work, let’s expand the If-Then-Else statement to it’s full potential:

Sub TheIfStatement()
    Dim i As Integer
    i = 100
    If (i = 100) Then
        Debug.Print "i equals 100"
    ElseIf (i = 0) Then
        Debug.Print "i equals 0"
    Else
        Debug.Print "i equals something else"
    End If
End Sub

It is basically the same module with a little addition. Line 4 remains the same, but now line 6 asks, alright if i does not equal 100 and i equals 0 then execute the following code. Also, newly added is line 8 where it asks, alright if i does not equal 100 or 0 then execute the following code. This is the easiest and most used statement in most Visual Basic scripts. Note here that I only have 1 ElseIf in my If-Then-Else, but you can as many as you want. Next time let’s chat about a For-Loop and what it does, signing off ~iAtoria.

Variables are like boxes. You can change the contents of the box whenever you want and you can change the label of the box depending on what you want to put inside. Variables must not start with a number, must not have spaces, and must not contain symbols. For example, “Happy” is acceptable, “1Happy”, “Ha ppy”, and “Happy!” are all unacceptable variable names. Let’s make it easy and start with variable foo. Variable foo is undeclared at the moment, meaning he doesn’t know whether he is a string, integer, or other data type. First let’s see what foo can choose to be:

Common Data Types

• Byte = any number between 0 and 255
• Integer = any number between -32,768 and 32,767
• Long = any number between -2,147,483,648 and 2,147,483,648
• Single = any decimal between -3.402823E+38 and 3.402823E+38
• Double = any decimal between -1.79769313486232e+308 and 1.79769313486232e+308
• String = 0 to 2,000,000,000 characters
• Boolean = True or False
• Object = any embedded object
• Variant = any number as large as a Double or any String, but not both

Note that these are not all of the data types, just the ones commonly used. Now that we know what foo can be let’s assume foo wants to be an Integer. Let’s declare him as one:

Sub MyFirstModule()
    Dim foo As Integer
End Sub

Now foo is a happy Integer, but he has nothing inside of him. Let’s make foo equal to 42.

Sub MyFirstModule()
    Dim foo As Integer
    foo = 42
End Sub

Now foo is a happy Integer whose value is 42.

Subs and Functions

So there are only 2 different types of ways you can define a procedure. They are Sub and Function. Sub is generally used when you do not need to return a result and Function is used when you want a result returned. For example, if you want your procedure to add two numbers together then return the result you would use a Function. Remember foo the happy Integer whose value is 42? Well let’s write a Function that doubles the size of an integer and returns it. Then let’s have a Sub call that Function and print out the value.

Sub MyFirstModule()
    Dim foo As Integer
    foo = 42
    foo = DoubleIntegers(foo)
    Debug.Print foo
End Sub

Function DoubleIntegers(d As Integer) As Integer
    DoubleIntegers = d * 2
End Function

Whoah, whoah, whoah, let’s slow down a bit. A lot of things just happened in the last minute. First we see that you can have multiple Sub and Function procedures in the same module without a problem.

Second, we see that Function procedures can take an argument and set a return data type. In line 8 of the code we are essentially saying that “hey function, you are going to be returned as an Integer, and you will receive an Integer temporarily named “d” to work with.” Note that Sub procedures can also take arguments, but they cannot return a result.

Third, we can see that Sub and Function procedures can call one another to complete tasks.

Whew, you now can make basic level procedures. If you run the MyFirstModule procedure you will get a value of 82 returned in the immediate window. Next time we will discuss conditionals and loops. Signing Off ~iAtoria.

If you are reading this then you already found a reason why you want to learn Excel VBA. I will be using Microsoft Excel 2007 to demonstrate all the amazing things you can do. All versions of Microsoft Office have a Visual Basic Editor built right in, so you don’t need to buy anything extra. Note that, although you are learning Visual Basic through Excel, you could apply it to other applications that use Visual Basic as well.

Setting Up Your Workspace

Open up Excel 2007 and you will have an empty worksheet labeled Book1 or something along those lines. The first thing we want to do is get a developer tab.

Getting the Developer Tab

1. Click on the big circle Microsoft button in the upper left hand corner
2. Click on “Excel Options” it should be right next to “Exit Excel”
3. Click on “Popular” tab on left if not already on it
4. Check the box labeled “Show Developer tab in the Ribbon”

Now that we have a Developer Tab, click on it and then click on the first icon labeled Visual Basic. You should see another window open, get used to this window, it is your Visual Basic Editor and it is where you will be doing a majority of your coding. Notice on the left you have a project explorer with a breakdown of all the sheets in your workbook, as well as your modules. Wait, you don’t know what a module is? Of course you don’t you just started how silly of me.

Making Your First Module

If you followed above you should have your empty Visual Basic Editor open. Now click on Insert->Module. You should have a white empty screen open up. Now enter this code into the module:

Sub MyFirstModule()
    Debug.Print "My First Module!"
End Sub

There are many ways to run this Sub procedure, here are a couple different ones:

• Click the green play arrow in the Visual Basic Editor at the top of the screen
• Press “F5″
• Click on Run->Run Sub/UserForm
• In Excel, click on Macros under the Developer tab, then select the Sub and click “Run”

You should see My First Module! in your Immediate Window below. If you do not have an Immediate Window simply go to View->Immediate Window and it will pop up at the bottom of the Visual Basic Editor. If you see the text you did everything right, now we just need to understand what the heck we just did . . . next time. Signing Off ~ iAtoria.