Visual Basic for Applications

From Seo Wiki - Search Engine Optimization and Programming Languages

Jump to: navigation, search
Visual Basic for Applications (VBA)
Paradigm Multi-paradigm
Appeared in 1993
Developer Microsoft
Stable release 6.5
Typing discipline Static/Dynamic Hybrid, Strong/Weak Hybrid
Influenced by QuickBASIC, Visual Basic
OS Microsoft Windows, Mac OS X
License Proprietary EULA
Website Visual Basic for Applications

Visual Basic for Applications (VBA) is an implementation of Microsoft's event-driven programming language Visual Basic 6, and associated integrated development environment (IDE), which is built into most Microsoft Office applications. By embedding the VBA IDE into their applications, developers can build custom solutions using Microsoft Visual Basic. It was also built into Office applications up to version 2004 for Apple's Mac OS X, other Microsoft applications such as Microsoft MapPoint and Microsoft Visio; as well as being at least partially implemented in some other applications such as AutoCAD, WordPerfect and ArcGIS. It supersedes and expands on the capabilities of earlier application-specific macro programming languages such as Word's WordBasic, and can be used to control almost all aspects of the host application, including manipulating user interface features, such as menus and toolbars, and working with custom user forms or dialog boxes. VBA can also be used to create import and export filters for various file formats, such as ODF.

As its name suggests, VBA is closely related to Visual Basic and uses the Visual Basic Runtime, but can normally only run code within a host application rather than as a standalone application. It can, however, be used to control one application from another using OLE Automation. For example, it is used to automatically create a Word report from Excel data, in turn automatically collected by Excel from polled observation sensors.

VBA is functionally rich and extremely flexible but it does have some important limitations, including limited support for function pointers which are used as callback functions in the Windows API. It has the ability to use (but not create) (ActiveX/COM) DLLs, and later versions add support for class modules.



Code written in VBA is compiled[1] to a proprietary intermediate language called P-code (packed code)[2], which is stored by the hosting applications (Access, Excel, Word) as a separate stream in Structured storage files (e.g., .doc or .xls) independent of the document streams. The intermediate code is then executed[1] by a virtual machine (hosted by the hosting application). Despite its resemblance to many old BASIC dialects (particularly Microsoft BASIC, from which it is indirectly derived), VBA is not compatible with any of them except Microsoft Visual Basic, where source-code of VBA Modules and Classes can be directly imported, and which shares the same library and virtual machine. Compatibility ends with Visual Basic version 6; VBA is not compatible with VB.NET. VBA is proprietary to Microsoft and, apart from the COM interface, is not an open standard.

Object models

To use VBA with an application such as Access, Word, or Excel, terminology and language constructions are needed to interact with the application.[3][4] This portion of VBA is called the Object Model for the application. A map of the object model is online for Excel and for Word. Much of the difficulty in using VBA is related to learning the object model, which uses names invented by the originators of the model that may be less than transparent to a new user. One way to learn the terms and syntax of the object model is to use the macro recorder to record the steps taken to achieve a desired result using the mouse and menus of the application.[5] Once this is done, the VBA code constructed by the recorder can be viewed in the VBA editor, and often greatly streamlined or generalized with only a modicum of understanding of VBA itself. Unfortunately, the macro recorder does not always record everything (particularly for graphs), and some applications employing VBA do not provide a recorder at all. A complementary method to learn about the object model is to open the Macro/VBA editor in the target application and then "View" the Object Model (F2). Use of debugging tools to discover VBA constructs for some cases where the macro recorder does not work are described by Jelen and Syrstad,[6] but some steps may remain obscure.


Interaction with the host application uses OLE Automation. Typically, the host application provides a type library and API documentation which document how VBA programs can interact with the application. This documentation can be examined from inside the VBA development environment using its Object Browser.

VBA programs which are written to use the OLE Automation interface of one application cannot be used to automate a different application, even if that application hosts the Visual Basic runtime, because the OLE Automation interfaces will be different. For example, a VBA program written to automate Microsoft Word cannot be used with a different word processor, even if that word processor hosts VBA.

Conversely, multiple applications can be automated from the one host by creating Application objects within the VBA code. References to the different libraries must be created within the VBA client before any of the methods, objects, etc. become available to use in the application. These application objects create the OLE link to the application when they are first created. Commands to the different applications must be done explicitly through these application objects in order to work correctly.

For example: In Microsoft Access, users automatically have access to the Access library. References to the Excel, Word, and Microsoft Outlook libraries can also be created. This will allow creating an application that runs a query in Access, exports the results to Excel, formats the text, then writes a Mail merge document in Word that it automatically e-mails to each member of the original query through Outlook. (In this example, it is important to note that Microsoft Outlook contains a security feature that forces a user to allow, disallow, or cancel an e-mail being sent through an automated process with a forced 5 second wait. Information on this can be found at the Microsoft website.)

VBA programs can be attached to a menu button, a macro, a keyboard shortcut, or an OLE/COM event, such as the opening of a document in the application. The language also provides a user interface in the form of UserForms, which can host ActiveX controls for added functionality.

Security concerns

Like any common programming language, VBA macros can be created with a malicious intent. Using VBA, most of the security features lie in the hands of the user, not the author. The VBA 'host-application' options are accessible to the user. The user who runs any document containing VBA macros can preset the software with user preferences, much like those for internet browsers. End-users can protect themselves from attack by disabling macros from running in an application if they do not intend to use documents containing them, or only grant permission for a document to run VBA code if they are sure the source of the document can be trusted.


A common use of VBA is to add functionality that may be missing from the standard user interface. This macro provides a shortcut for entering the current date in Word:

Sub EnterCurrentDate()
    Selection.InsertDateTime DateTimeFormat:="dd-MM-yy", InsertAsField:=False, _
         DateLanguage:=wdEnglishAUS, CalendarType:=wdCalendarWestern, _
End Sub

VBA is useful for automating database tasks such as traversing a table:

Sub LoopTableExample
    Dim db As DAO.Database
    Dim rs As DAO.Recordset
    Set db = CurrentDb
    Set rs = db.OpenRecordset("select columnA, columnB from tableA")
    Do Until rs.EOF
         MsgBox rs!FieldName
    Set db = Nothing
End Sub

VBA is useful for automating repeated actions in rows of a spreadsheet. For example, using the following code example, the built-in iterative solver Goal Seek is applied automatically to each row in a column array, avoiding repeated use of manual menu entry. Below a column variable "C_M" determines the values of another column variable "Target" in some nonlinear fashion. The built-in nonlinear solver Goal Seek is called to find the value of "C_M" that brings "Target" to value one. The subroutine is inserted into the workbook using the VBA editor and command Insert Module. It is called directly from the VBA editor, or by using a "hot key" or keyboard shortcut. Values on the spreadsheet automatically update as the rows are scanned.

It is useful to note that subroutines have the power to update variables on the spreadsheet; functions do not - they simply report their evaluation.

Line Option Explicit is not part of the subroutine: it sets a compiler option that forces identification of all variables that have not been specified in Dim statements, which avoids difficult to detect debugging problems caused by typos. Notation ( ' ) in the following code denotes a comment, and ( _) line continuation. The code uses NAMED variables: a form of cell reference in which cells are assigned names of user choice, rather than the standard cell designation referring to specific row and column numbers. Naming is accomplished on the worksheet using the Excel "Name Manager", or menu Insert Name: Create.

Option Explicit
Sub SetTarget()
' SetTarget Macro
   Dim J As Integer
   Dim Size As Integer
' On the spreadsheet, array "C_M" is a NAMED column variable
'     Its members use a row index taken as J
' Built-in function COUNT determines size of array "C_M"
   Size = Range("C_M").Cells.Count
' Set initial value of all members of array 
'    C_M to 1E-06; J = row index
       For J = 1 To Size
           Range("C_M").Cells(J) = 0.000001
       Next J
' "Target" is another NAMED array on the spreadsheet of 
'      dimension "Size"; the same size as array "C_M"
' Each "Target" entry in each row depends in a
'      specified way upon the value of "C_M" in that row, 
'      for example, by a function such as: Target = C_M*C_M 
' GOAL SEEK is a built-in iterative solver in Excel
' Call GOAL SEEK to set each "Target" member to unity: for example,
'   taking J = row index, in row J the cell named "C_M" is changed 
'   by GOAL SEEK until "Target" in row J is one
' Syntax (aside from "for-next" details) found with macro recorder;
'      underscore "_" is line continuation
       For J = 1 To Size
           Range("Target").Cells(J).GoalSeek Goal := 1, _
             ChangingCell := Range("C_M").Cells(J)
       Next J
End Sub

In the example below VBA is used to get an array from a cell range, manipulate the array, and then set the values back in a different range. This works many times faster than directly setting the cell values one-by-one.

Sub CalculateSquares(rinput As Range, routput As Range)
   'Variable specifications
    Dim values() As Variant
    Dim i As Integer, N As Integer
    'Count the rows to compute
    N = rinput.Rows.Count
    'Set values array from input range.
    'Expected shape of array is (1 to N, 1 to 1)
    values = rinput.Value
    'Iterate through rows and set values
    For i = 1 To N
        values(i, 1) = values(i, 1) ^ 2
    Next i
    'Export values back into the spreadsheet by setting the
    'value property of the output range.
    routput.Value = values
End Sub

VBA can be used to create a user defined function (UDF) for use in a Microsoft Excel workbook:

Public Function BusinessDayPrior(dt As Date) As Date
    Select Case Weekday(dt, vbMonday)
        Case 1
            BusinessDayPrior = dt - 3      'Monday becomes Friday
        Case 7
            BusinessDayPrior = dt - 2      'Sunday becomes Friday
        Case Else
            BusinessDayPrior = dt - 1      'All other days become previous day
    End Select
End Function

Example of how to add an external application object (The user must have the application library referenced in the application before this):

Public Sub Example()
    Dim XLApp As Excel.Application
    Dim WDApp As Word.Application
    Set XLApp = CreateObject("Excel.Application")
    Set WDApp = CreateObject("Word.Application")
    ' ...your code here...

    Set XLApp = Nothing
    Set WDApp = Nothing
End Sub


As of July 1, 2007, Microsoft no longer offers VBA distribution licenses to new customers.[7] Microsoft intended to add .NET-based languages to the current version of VBA ever since the release of the .NET Framework.[8] The .NET Framework versions 1.0 and 1.1 included a scripting runtime technology known as Script for the .NET Framework.[9] Also, Visual Studio .NET 2002 and 2003 SDK contained a separate scripting IDE called Visual Studio for Applications (VSA) that supported VB.NET.[10][11][12] One of its significant features was that the interfaces to the technology were also available via Active Scripting (VBScript and JScript), allowing even .NET-unaware applications to be scripted using .NET languages. However, VSA was deprecated in version 2.0 of the .NET Framework,[12] leaving no clear upgrade path for applications desiring Active Scripting support (although "scripts" can be created in C#, VBScript, and other .NET languages, which can be compiled and executed at run-time via libraries installed as part of the standard .NET runtime).

Support for VBA in the Mac OS X version of Microsoft Office was dropped with the release of Microsoft Office 2008 for Mac.[13]. The official reason given was that VBA relied heavily on machine code written for the PowerPC architecture, and that rewriting this code for dual PowerPC/Intel architectures would have added another 2 years to the development of the suite. However, the office suite can be automated using AppleScript to an extent. In a press statement released on May 13, 2008, Microsoft's Macintosh Business Unit (Mac BU) announced that VBA will be returning in the next version of Office for Mac.[14] Microsoft has also clearly stated that they have no plans to remove VBA from the Windows version of Office.[15][16]

Visual Studio Tools for Applications (VSTA)

With the release of Visual Studio 2005, Microsoft announced Visual Studio Tools for Applications (VSTA). Independent Software Vendors may license VSTA in order to provide their end-users with customisation facilities within their application, in a similar way to VBA, however VSTA uses the Visual Studio 2005 or Visual Studio 2008 development environment for programming against the .NET Framework.

VSTA was included in Office 2007 particularly for adding custom program code to InfoPath forms.

See also


  1. 1.0 1.1 ACC: Visual/Access Basic Is Both a Compiler and an Interpreter
  2. Microsoft P-Code technology
  3. Steven Roman (2002). Writing Excel Macros with VBA. Sebastopol CA: O'Reilly. Chapter 15. ISBN 0596003595.,M1. 
  4. Steven Roman (1999). Writing Word Macros. Sebastopol CA: O'Reilly. Chapter 10. ISBN 1565927257. 
  5. Matthew MacDonald (2005). Excel: The Missing Manual. Sebastopol CA: O'Reilly. pp. 655. ISBN 0596006640. 
  6. Jelen, B., & Syrstad, T. (2008). VBA and macros for Microsoft Office Excel 2007 (business solutions) (Second edition ed.). Indianapolis, Ind: Que. Chapter 2; pp. 42–52. ISBN 0789736829. 
  7. Discontinuation of the VBA Licensing Program
  8. Visual Studio for Applications
  9. Introducing Visual Studio for Applications
  10. Script happens .NET: MSDN
  11. Microsoft Takes Wraps Off VSA Development Technology
  12. 12.0 12.1 VSA scripting in .NET
  13. "WWDC: Microsoft updates Universal status of Mac apps". Macworld. 2006-08-07. Retrieved 2007-05-25. 
  14. Microsoft Mac BU Delivers Strongest Launch in History of Office for Mac: Group releases Service Pack 1, announces the return of Visual Basic for Applications in next version
  15. The Reports of VBA's Demise Have Been Greatly Exaggerated
  16. Clarification on VBA Support

External links

Template:Microsoft Office Template:MS DevTools


ar:فيجوال بيسك للتطبيقات bs:Microsoft VBA bg:Visual Basic for Applications da:Visual Basic for Applications de:Visual Basic for Applications es:Visual Basic for Applications fr:Visual Basic for Applications ko:VBA hr:Visual Basic for Applications id:Visual Basic for Applications it:Visual Basic for Applications nl:Visual Basic for Applications ja:Visual Basic for Applications pl:Visual Basic for Applications pt:Visual Basic for Applications ru:VBA sk:Visual Basic for Applications sv:Visual Basic for Applications th:Visual Basic for Applications tr:Visual Basic for Applications uk:Visual Basic for Applications vi:VBA zh:Visual Basic for Applications

Personal tools

Served in 1.181 secs.