| Developing ColdFusion MX Applications with CFML |
|
|
Using ColdFusion Variables |
|
| Developing ColdFusion MX Applications with CFML |
|
|
Using ColdFusion Variables |
|
ColdFusion automatically converts between data types to satisfy the requirements of an expression's operations, including a function's argument requirements. As a result, you generally don't need to be concerned about compatibility between data types and the conversions from one data type to another. However, understanding how ColdFusion evaluates data values and converts data between types can help you prevent errors and code more effectively.
Conventional programming languages enforce strict rules about mixing objects of different types in expressions. For example, in a language such as C++ or Basic, the expression ("8" * 10) produces an error because the multiplication operator requires two numerical operands and "8" is a string. When you program in such languages, you must convert between data types to ensure error-free program execution. For example, the previous expression might have to be written as (ToNumber("8") * 10).
In ColdFusion, however, the expression ("8" * 10) evaluates to the number 80 without generating an error. When ColdFusion processes the multiplication operator, it automatically attempts to convert its operands to numbers. Since "8" can be successfully converted to the number 8, the expression evaluates to 80.
ColdFusion processes expressions and functions in the following sequence:
For functions, it determines the type required for each function argument. (For example, the Min function requires two numbers as arguments and the Len function requires a string.)
Although the expression evaluation mechanism in ColdFusion is very powerful, it cannot automatically convert all data. For example, the expression "eight" * 10 produces an error because ColdFusion cannot convert the string "eight" to the number 8. Therefore, you must understand the rules for conversion between data types.
The following table explains how conversions are performed. The first column shows values to convert. The remaining columns show the result of conversion to the listed data type.
ColdFusion cannot convert complex types, such as arrays, queries, and COM objects to other types. However, it can convert simple data elements of complex types to other simple data types.
The following sections detail specific rules and considerations for converting between types.
The cfoutput tag always displays data as a string. As a result, when you display a variable using the cfoutput tag, ColdFusion applies the type conversion rules to any non-string data before displaying it. For example, the cfoutput tag displays a date-time value as an ODBC timestamp.
Because ColdFusion expression evaluation is not case-sensitive, Yes, YES, and yes are equivalent; False, FALSE, and false are equivalent; No, NO, and no are equivalent; and True, TRUE, and true are equivalent.
ColdFusion cannot automatically convert binary data to other data types. To convert binary data use the ToBase64 and ToString functions. For more information, see "Binary data type and Base64 encoding".
To ensure that a date and time value is expressed as a real number, add zero to the variable. The following example shows this:
<cfset mynow = now()>
Use cfoutput to display the result of the now function:<br> <cfoutput>#mynow#</cfoutput><br> Now add 0 to the result and display it again:<br> <cfset mynow = mynow + 0> <cfoutput>#mynow#</cfoutput>
At 5:34 PM on November 7, 2001, its output looked like this:
Using cfoutput to display the result of the now function:
{ts '2001-11-07 17:34:01'}
Now Add 0 to the result and display it:
37202.731956
When ColdFusion evaluates an expression that includes both integers and real numbers, the result is a real number. To convert a real number to an integer, use a ColdFusion function. The Int, Round, Fix, and Ceiling functions convert real numbers to integers, and differ in their treatment of the fractional part of the number.
If you use a hidden form field with a name that has the suffix _integer or _range to validate a form input field, ColdFusion truncates real numbers entered into the field and passes the resulting integer to the action page.
If you use a hidden form field with a name that has the suffix _integer, _float, or _range to validate a form input field, and the entered data contains a dollar amount (including a dollar sign) or a numeric value with commas, ColdFusion considers the input to be valid, removes the dollar sign or commas from the value, and passes the resulting integer or real number to the action page.
The following sections explain several issues that you might encounter with type evaluation and conversion.
You might expect the following two cfif tags to produce the same results:
<cfif myVariable> <cfoutput>myVariable equals #myVariable# and is True </cfoutput>
</cfif>
<cfif myVariable IS True> <cfoutput>myVariable equals #myVariable# and is True </cfoutput>
</cfif>
However, if myVariable has a numeric value such as 12, only the first example produces a result. In the second case, the value of myVariable is not converted to a Boolean data type, because the IS operator does not require a specific data type and just tests the two values for identity. Therefore, ColdFusion compares the value 12 with the constant True. The two are not equal, so nothing is printed. If myVariable is 1, "Yes", or True, however, both examples print the same result, because ColdFusion considers these to be identical to Boolean True.
If you use the following code, the output statement does display, because the contents of the variable, 12, is not equal to the Boolean value False.
<cfif myVariable IS NOT False> <cfoutput>myVariable equals #myVariable# and IS NOT False </cfoutput>
</cfif>
As a result, you should use the test <cfif testvariable>, and not use the IS comparison operator when testing whether a variable is True or False. This issue is a case of the more general problem of ambiguous type expression evaluation, described in the following section.
When ColdFusion evaluates an expression that does not require strings, including all comparison operations, such as IS or GT, it checks whether it can convert each string value to a number or date-time object. If so, ColdFusion converts it to the corresponding number or date-time value (which is stored as a number). It then uses the number in the expression.
Short strings, such as 1a and 2P, can produce unexpected results. ColdFusion can interpret a single "a" as AM and a single "P" as PM. This can cause ColdFusion to interpret strings as date-time values in cases where this was not intended.
Similarly, if the strings can be interpreted as numbers, you might get unexpected results.
For example, ColdFusion interprets the following expressions as shown:
To prevent such ambiguities when you compare strings, use the ColdFusion string comparison functions Compare and CompareNoCase, instead of the comparison operators.
You can also use the IsDate function to determine whether a string can be interpreted as a date-time value, or to add characters to a string before comparison to avoid incorrect interpretation.
Many CFML functions, including the Now, CreateDate, CreateTime, and CreateDateTime functions, return date-time objects. ColdFusion creates Open Database Connectivity (ODBC) timestamp values when it converts date-time objects to strings. As a result, you might get unexpected results when using dates with a database driver that does not support ODBC escape sequences., or when you use SQL in a query of queries.
If you use SQL to insert data into a database or in a WHERE clause to select data from a database, and the database driver does not support ODBC-formatted dates, use the DateFormat function to convert the date-time value to a valid format for the driver. This rule also applies to queries of queries.
For example, the following SQL statement uses the DateFormat function in a query of queries to select rows that have MyDate values in the future:
<cfquery name="MyQofQQ" dbtype="query">
SELECT * FROM DateQuery WHERE MyDate >= '#DateFormat(Now())#' </cfquery>
The following query of queries fails with the error message "Error: {ts is not a valid date," because the ColdFusion Now function returns an ODBC timestamp:
<cfquery name="MyQofQQ" dbtype="query">
SELECT * FROM DateQuery WHERE MyDate >= '#now()#' </cfquery>
You can overload Java methods so a class can have several identically named methods that differ only in parameter data types. At runtime, the Java virtual machine (VM) attempts to resolve the specific method to use, based on the types of the parameters passed in the call. Because ColdFusion does not use explicit types, you cannot predict which version of the method the VM will use.
The ColdFusion JavaCast function helps you ensure that the right method executes by specifying the Java type of a variable, as in the following example:
<cfset emp.SetJobGrade(JavaCast("int", JobGrade))>
The JavaCast function takes two parameters: a string representing the Java data type and the variable whose type you are setting. You can specify the following Java data types: bool, int, long, float, double, and String.
For more information on the JavaCast function, see CFML Reference.
To ensure that ColdFusion properly interprets string data, surround strings in single or double quotes. For example, ColdFusion evaluates "10/2/2001" as a string that can be converted into a date-time object. However, it evaluates 10/2/2001 as a mathematical expression, 5/2001, which evaluates to 0.00249875062469.
The following examples demonstrate ColdFusion expression evaluation.
2 * True + "YES" - ('y' & "es")
Explanation: (2*True) is equal to 2; ("YES"- "yes") is equal to 0; 2 + 0 equals 2.
True AND 2 * 3
Explanation: 6 is converted to Boolean True because it is nonzero; True AND True is True.
"Five is " & 5
Result value as string: "Five is 5"
Explanation: 5 is converted to the string "5".
DateFormat("October 30, 2001" + 1)
Result value as string: "31-Oct-01"
Explanation: The addition operator forces the string "October 30, 2001" to be converted to a date-time object and then to a number. The number is incremented by one. The DateFormat function requires its argument to be a date-time object; thus, the result of the addition is converted to a date-time object. One is added to the date-time object, moving it ahead by one day to October 31, 2001.