One of the great things about ColdFusion is its easy-to-use, tagbased syntax. Having the capability to intersperse CFML and HTML tags without needing to open and close script blocks or needing to remember what syntax you’re currently working in is a wonderful thing. At times, however, using a scriptable syntax would be nice—for example, if you’re doing heavy data processing on a page. As nice as CFML’s tag-based syntax is, number crunching is best expressed in script. CFSCRIPT is a server-side scripting language that works with CFML to give you the best of both worlds: an elegant, tag-based syntax whenever you need it and a flexible scripting syntax if you don’t. User-defined functions are discussed later. We do not include them in this article because of ColdFusion MX’s capability to define UDFs by using either CFSCRIPT or CFML syntax. This article describes the basics of CFSCRIPT. Essentially, CFSCRIPT is an instruction to the ColdFusion processing engine to treat a block of code as scripting-based syntax rather than as tag-based syntax. Why mess with a perfectly good thing (CFML) by adding another complication (scripting)? Because the latter is easier to code and faster to process. Consider the following snippet, for example, which loops from 1 to 10, adding each index to a running total:

<cfset TheSum = 0>
   <cfloop from=”1” to=”10” index=”i”>
   <cfset TheSum = TheSum + i>
   </cfloop>

Following is the same code expressed in CFSCRIPT’s scripting syntax:

<cfscript>
   TheSum = 0;
   for(i = 1; i LTE 10; i = i + 1) {

TheSum = TheSum + 1;
   }
 </cfscript>

CFSCRIPT doesn’t support the ++ syntax for incrementing a variable that may be familiar to you if you have experience with Java, JavaScript, or C++. Look familiar? If you’re having JavaScript déjà vu, that’s normal, because CFSCRIPT is almost identical to JavaScript. CFSCRIPT blocks mostly instantiate variables and perform calculations, but they can produce output, too. Consider, for example, the following extension of the preceding code snippet:

<cfset TheSum = 0>
   <cfloop from=”1” to=”10” index=”i”>
   <cfset TheSum = TheSum + i>
   </cfloop>
   <cfoutput>#TheSum#</cfoutput>

Normally, anything that isn’t part of a CFML tag is output to the page. CFSCRIPT, however, uses a function named WriteOutput() for page output, as the following example shows:

<cfscript>
   TheSum = 0;
   for(i = 1; i LTE 10; i = i + 1) {
   TheSum = TheSum + 1;
   }
   WriteOutput(TheSum);
 </cfscript>

Think of WriteOutput() as the server-side equivalent of JavaScript’s client-side document.write() method. The difference between WriteOutput() and document.write() shows the different mindset of CFSCRIPT as compared to CFML. Rather than the text just “being there,” as it is in CFML, CFSCRIPT must be directed to output the text. Notice the use of semicolons, which terminate CFSCRIPT statements. CFSCRIPT is less forgiving than JavaScript with respect to semicolon termination; forget one, and ColdFusion throws an error. Another thing that you need to get used to in CFSCRIPT is the use of curly braces. Curly braces surround blocks of CFSCRIPT code similar to the way that opening and closing tags surround blocks of CFML code, but their use is actually more critical. A simple if construct in CFSCRIPT looks as follows:

<cfscript>
   if(this EQ that)
   doThis();
   else
   doThat();
 </cfscript>

The preceding snippet runs error free, but suppose that you need to add another statement after doThis(), as in the following example:

<cfscript>

if(this EQ that)
   doThis();
   doSomeOtherThingToo();
   else
   doThat();
 </cfscript>

ColdFusion throws an error, because it sees an else clause without a corresponding if clause. This happens because the doSomeOtherThingToo() statement is considered the continuation of statements after the if statement finishes executing the doThis() statement. For CFSCRIPT to execute both statements when the if tests TRUE, you must enclose them within curly braces as follows:

<cfscript>
   if(this EQ that) {
   doThis();
   doSomeOtherThingToo();
   } else
   doThat();
 </cfscript>

In fact, a best practice is to always include the curly braces, regardless of whether you need them or not, as in the following example:

<cfscript>
   if(this EQ that) {
   doThis();
   doSomeOtherThingToo();
   } else {
   doThat();
   }
 </cfscript>

Why? Because you never know when you’re going to add another statement to an existing if test. We can’t tell you how many times that we threw errors in the early days by adding a second statement to an existing, unenclosed if construct, simply because we didn’t pay attention to the enclosure mechanism. If you always enclose, you never throw errors. The same holds true for any language that requires such enclosure. All CFSCRIPT code is contained between CFSCRIPT tags, as shown in the following example:

... Regular CFML code goes here ...
   <cfscript>
   ... CFSCRIPT code goes here
   </cfscript>
   ... Regular CFML code goes here ...

Notice that the content of a CFSCRIPT block must be a complete statement. You cannot, for example, do the following:

<cfscript>
   if(myVar GT yourVar) {

</cfscript>
   My text goes here.
   <cfscript>
   }
 </cfscript>

That type of construction is valid in some other scripting languages, but not in CFSCRIPT. CFSCRIPT operations must be self-contained in a single code block, as follows:

<cfscript>
   if(myVar GT yourVar) {
   WriteOutput(“My text goes here.”);
   }
 </cfscript>

You can have several CFSCRIPT blocks in a single ColdFusion template, but each CFSCRIPT block must be a self-standing block of executable code. The simplest operation in CFSCRIPT is setting a variable, as follows:

<cfscript>
   myVar = 1;
 </cfscript>

Setting a variable in CFSCRIPT requires no CFSET tag, and the statement ends with a semicolon. You can now use myVar just as you would any other ColdFusion variable. Notice that you can share any variable between CFSCRIPT and regular CFML, as follows:

<cfset myVar = 1>
   <cfscript>
   myVar = myVar + 1;
   yourVar = 3;
   </cfscript>
   <cfoutput>#yourVar + myVar#</cfoutput>

You are not limited to setting and reading variables in the Variables scope, either. Any variable that you can set by using tag-based CFML can also be set by using CFSCRIPT’s scripting syntax. The if construct in CFSCRIPT works exactly the same as its CFML counterpart, CFIF. ColdFusion evaluates a condition and executes a dependant statement based on whether the condition is true or false. Compare the following CFML and CFSCRIPT if constructs:

CFML:

<cfif myVar GT yourVar>

... execute if true ...
 </cfif>

 CFSCRIPT:

if(myVar GT yourVar) {
   ... execute if true ...
   }

CFSCRIPT also has an equivalent to CFELSE, as the following example shows:

if(myVar GT yourVar) {
   ... execute if true ...
   }
   else {
   ... execute if false ...
   }

You also find an equivalent to CFELSEIF in CFSCRIPT, as follows:

if(myVar GT yourVar) {
   ... execute if true ...
   }
   else if (myVar EQ yourVar) {
   ... execute if true ...
   }
   else {
   ... execute if all conditions false ...
   }