The REAL reason you need to var-scope your local CFC function variables

So, Nat makes a great point that vars not specifically placed in the var scope become CFC instance variables. To be honest, I didn't even realize this myself until he pointed it out. However, the REAL reason you should be explicitly var-scoping your local variables in a CFC method has to do with performance.

Attached to this post, you'll find a small test application (varScopeTestApp.zip). The ColdFusion logic within the test application is quite simple - loop a specified number of times and set a simple variable equal to the current value of the loop counter. The test application compares 6 different methods of executing the exact same ColdFusion logic, and then displays the results. All you need to do to run the application is extract all of the contained files into a single directory on your application server, and then call the index.cfm page in your web browser. You can use the intLoopCount URL parameter in order to increase the size of the loop and really emphasize the performance difference. I would recommend a number around 500000.

The test application attempts to execute this same code concept using 6 different ColdFusion approaches.

• As inline ColdFusion code written with CF tags
• As inline ColdFusion code written within a CFSCRIPT block
• As a call to a CFC function written with CF tags without explicitly var-scoped variables
• As a call to a CFC function written within a CFSCRIPT block without explicitly var-scoped variables
• As a call to a CFC function written with CF tags with explicitly var-scoped variables
• As a call to a CFC function written within a CFSCRIPT block with explicitly var-scoped variables

In order to ensure that the execution time of each method is measured without being affected by concurrent thread resource contention, you'll find that each of the 6 test cases executes within a named exclusive lock. This provides for the most accurate measure of the true performance of the code being executed.

You'll make some interesting discoveries upon firing up this test application and seeing the results for yourself. Most notable, in my opinion, is the performance bulk added when the code is executed from within a CFC function without proper local var scoping. Going one step further, it would also seem that more bulk is added to the CFSCRIPT function than to the CF tag function. In my own tests, I found the CFSCRIPT function without var-scoped variables to be about 30% slower than the CF tag counterpart. And both CFC functions without explicitly var-scoped variables end up being roughly 2-3 times slower than the inline code.

Sure, we all despise the var keyword and the way that it has been implemented. And yes, we all agree that Adobe should introduce a new argument for the CFFUNCTION tag that would allow us to control the behavior of unscoped variables set within a CFC function. But until that magical revision arrives, we'll just need to bite the bullet and give into the var keyword for the sake of general application performance.