How to Implement Conditional Includes in ASP using VBScriptBy Nathan Gibson
In almost every non-trivial computer program the amount of program code is quite large. To help manage this code, programmers like to chop up the code into smaller, more manageable pieces. This is where includes files enter the picture. Most programming languages allow the programmer to substitute entire blocks of code for a small statement that says "You can now find the code that was here, in a file over there". When the program runs it works just the same as the original, but is much easier to manage, because the code can be divided into logical units.
For example all the user interface code can be kept in one file, the data structures in another and the program business logic in another. These files, then, can be included into a single page. Includes reduce the amount of code repetition needed because repeated code can be placed in one location - a single include file - and then included where needed. One of the major benefits of this is that if changes need to be made to the oft-repeated code, the changes only need to be made in one place - the include file.
ASP offers include-like behavior through server-side includes using the
to import, at runtime, the contents of one file into another. (For an in-depth look at server-side includes
in ASP, be sure to read Scott Mitchell's article: The
#include.) While server-side includes are a useful tool for ASP
developers, one common complaint is that they do not allow conditional includes. In this
article we'll examine how to extend ASP to allow for conditional server-side includes.
Defining "Conditional" Includes
A conditional include allows a file to be included or excluded from program execution depending on a given condition. The condition could be the time of day, the name or version of the operating system the program is running on, or anything else you may care to think up.
It is easy to see that includes help in the management of program code, but what would you use conditional includes for? Wouldn't it be good to be able to include a file without having to worry if the file has already been included by another file that has also been included in the current ASP page. A common situation that occurs in ASP is where one file includes two files, and one of those files another also includes the other file that was included by the first.
For example, imagine that
includefile1.asp and also
includefile1.asp also includes
If this situation occurs there will likely be an error or some unexpected behavior since
includefile2.asp is being included twice. To avoid this undesired circumstance, the code
typically has to be edited so that these include files are included more than once. In the example above,
includefile2.asp must only be
included by one of the files: either
includefile1.asp, but not
As the number of files in a project increases and the dependencies between the files become more complicated it becomes a chore for the programmer to manage the order of the include statements. A conditional include can be placed in both files that wish to include a file. If the file has not already been included by another file it will be included. If the file has already been included by another it can be skipped. This is only one of many uses for conditional includes. You may want to write a program that can be installed on several different computers with varying capabilities and configurations, and be able to deploy without having to change any code. Conditional includes can help allow this to happen.
Many other programming languages allow you to do a conditional include, even plain vanilla ANSI C allows conditional includes. Until now it was though impossible to do in plain ASP and VBScript, but below I will show you how it can be done.
Allowing for Conditional Includes
In ASP you can use the following syntax to include code from files into your current ASP page.
The problem is caused by the order that the IIS web server processes ASP page requests. The file is included before any ASP code is able to run. This means that code like the following doesn't work as most would expect.
The code will run, except both files will be included no matter what. The
code in both files is substituted into the current page before the
If statement can choose which one to use. When the include files are
large this becomes a performance issue and can also cause problems when both
files define a function or variable with the same name.
Conditional Includes - a Solution
Most programs include both variable declarations and function definitions. Imagine we have the following include file, named
the following content:
Now, imagine we have a second page,
include2.asp with the following content:
The page that will include these files -
page.asp - will look like:
Because this method does not use the built-in IIS include, the code will be
run when the page is run, but only one file will be included. The code for the
getMappedFileAsString(filepath) function is shown below.
Essentially it grabs the complete contents of the specified filepath, returning the file's
contents as a string.
After the file's contents have been retrieved as a string, it is executed using the
statement. Execute can be used to dynamically execute statements passed in as a string. For more information
be sure to read the technical
A comment from 4Guys reader Christian Holm...Here is a function that fixes the includes, so that they can contain a mixture of HTML and ASP script...
Caveats with This Approach
Like all things there are some side effects from the inner workings of the include mechanism. Here are some of the more important ones:
- All the included variables will only be visible (in scope) from where the conditional include happens. If the include happens inside a function it will only be visible inside that function. If done globally, outside any function it will be global for that page and for any page that is included by that page in the regular ASP way.
- Included functions are visible even outside the functions from where the include takes place, when they are called in the same ASP page.
- Include files may be included over and over without any error occurring. Although without a little extra help they may still be parsed multiple times.
- Because the
Executestatement executes the VBScript code you need to remove the ASP tags -
%>- from the include files as they are not valid VBScript. This means you may need to be careful if you want to switch between VBScript and HTML in an include file. Although if you are just declaring functions and variables this will not make much difference. In fact with a little effort it would be possible to leave the ASP tags in the include files and strip them out before you send the string to the execute statement.
This method of conditional includes can be extended to work as a HTTP include mechanism where files from another computer connected by an Intranet or the Internet, so that ASP code can be distributed and managed at different locations.
In VBScript you can actually use a variable before it is declared. To help restrict the scope of variables and this sort of frowned upon behavior it should now be possible to clean up some of the traditional ASP code into a more modular form. I may even be possible to create a full object oriented VBScript program! With Inheritance!
I hope to bring you some more examples of these possibilities in the future. Until then, see what helpful things you can do with a few conditional includes.