Use Option Explicit
Use Option Explicit
in your .asp files. This directive placed at the top of the .asp file forces the developer to declare all variables that will be used. Many programmers consider this helpful in debugging applications, as it avoids the chance of mistyping a variable name and inadvertently creating new variables (for example, MyXLMString=...
instead of MyXMLString=)
.
Perhaps more important, it turns out that declared variables are faster than undeclared variables. Under the covers, the scripting run time references undeclared variables by name, every time they are used. Declared variables, on the other hand, are assigned an ordinal, either at compile time or run time. Subsequently, declared variables are referenced by this ordinal. Since Option Explicit
forces variable declaration, it insures that all variables are declared and thus will be accessed quickly.
Use Local Variables in Subroutines and Functions
Local variables are those declared within subroutines and functions. Within a function or subroutine, local variable access is faster than global variable access. Use of local variables also tends to make code cleaner, so use them when you can.
Copy Frequently-Used Data to Script Variables
When accessing COM objects in ASP, you should copy frequently-used object data to script variables. This will cut down on COM method calls, which are relatively expensive compared to accessing script variables. When accessing Collection and Dictionary objects, this technique also cuts down on expensive lookups.
In general, if you are going to access object data more than once, put that data into a script variable. Prime targets for this optimization are Request variables (Form and QueryString variables). For example, your site may pass around a QueryString variable called UserID. Suppose this UserID is referenced a dozen times on a particular page. Instead of calling Request("UserID")
a dozen times, assign the UserID to a variable at the top of the ASP page. Then use that variable throughout the page. This will save 11 COM method calls.
In practice, accessing COM properties or methods can be deceptively expensive. Here is an example, showing some fairly common code (syntactically speaking):
Foo.bar.blah.baz = Foo.bar.blah.qaz(1)
If Foo.bar.blah.zaq = Foo.bar.blah.abc Then ' ...
When this code runs, here's what happens:
- The variable
Foo
is resolved as a global object. - The variable
bar
is resolved as a member ofFoo.
This turns out to be a COM method call. - The variable
blah
is resolved as a member ofFoo.bar
. This, too, turns out to be a COM method call. - The variable
qaz
is resolved as a member offoo.bar.blah
. Yes, this turns out to be a COM method call. - Invoke
Foo.bar.blah.quaz(1)
. One more COM method call. Get the picture? - Do steps 1 through 3 again to resolve
baz
. The system does not know if the call toqaz
changed the object model, so steps 1 through 3 must be done again to resolvebaz
. - Resolve
baz
as a member ofFoo.bar.blah
. Do the property put. - Do steps 1 through 3 again and resolve
zaq
. - Do steps 1 through 3 yet another time and resolve
abc
.
As you can see, this is terribly inefficient (and slow). The fast way to write this code in VBScript is:
Set myobj = Foo.bar.blah ' do the resolution of blah ONCE
Myobj.baz = myobj.qaz(1)
If Myobj.zaq = Myobj.abc Then '...
If you're using VBScript 5.0 or later, you can write this using the With
statement:
With Foo.bar.blah
.baz = .qaz(1)
If .zaq = .abc Then '...
...
End With
Note that this tip also works with VB programming.
No comments:
Post a Comment