CFDocs: CFML Reference Tool

If you do not want to use the default init method as your constructor, you can specify a different method using the initmethod attribute in the component tag. The method specified will be called upon instantiation.

component initmethod="birth" {
    public Dog function birth( required string name, string breed="mixed" ) {
        variables.name = name;
        return this;
    }
}

<!--- Usage --->
<cfset pet = new Dog( "fido" )>

Development Profile

Use this profile for local development. It provides enhanced debugging, remote inspection, remote start/stop, and support for bundled servers like Node.js or Weinre. It has low security settings and does not enforce complex passwords.

Production Profile

Use this for internal production servers. It disables RDS (Remote Development Services) and enables strict enforcement of complex passwords. It disables most debugging and remote inspection features to improve stability and security.

Production Profile (Secure)

Use this for high-security production environments. It includes all the security hardening of the standard Production Profile, plus it enables the 'Secure Profile' settings by default.

In CFDocs, built-in ColdFusion functions are treated as 'first-class' functions. This means you can treat functions like lCase(), uCase(), or any other built-in CFML function as objects. You can assign them to variables or pass them directly as arguments to other functions (callbacks).

Note: The ability to return built-in functions from other functions (e.g., return lCase;) is specific to ColdFusion versions CF11 through CF2021.

function convertCaseForArray(array array, function convertor)
{
    for (var i=1; i <= arrayLen(array); i++) {
        array[i] = convertor(array[i]);
    } 
    return array;
}

// Passing the built-in lCase function as a callback argument
resultantArray = convertCaseForArray(['One', 'Two','Three'], lCase);

The CFML community generally discourages the use of tags that generate client-side UI code directly. Instead of using these tags, consider using modern web standards or manual HTML/JavaScript generation to maintain better control over your frontend.

Discouraged UI tags include:
- `cfcol`
- `cfdiv`
- `cfgrid`, `cfgridcolumn`, `cfgridrow`, `cfgridupdate`
- `cflayout`, `cflayoutarea`, `cfpod`
- `cfmap`, `cfmapitem`
- `cfmenu`, `cfmenuitem`
- `cfprogressbar`
- `cfselect`
- `cftable`
- `cftooltip`
- `cftree`, `cftreeitem`
- `cfwindow`

The APPLICATION scope is used to store information that is shared across all requests within a specific application.

• Availability: Variables set in the APPLICATION scope are accessible from anywhere within the application.
• Lifecycle: Variables are typically initialized during onApplicationStart and remain constant throughout the application lifecycle.
• Timeout: The default timeout is 2 days, but you can customize it by setting this.applicationTimeout in your Application.cfc.

Example of initializing a variable in onApplicationStart:

component {
    this.name = "myApplication";

    function onApplicationStart() {
        application.something = "otherthing";
    }
}

Because the APPLICATION scope is shared across multiple simultaneous requests (threads), you must manage concurrency to prevent data corruption.

When locking is NOT required:

• If you only set variables in onApplicationStart and do not modify them later (except for reading in onRequestStart).
• In most modern ColdFusion/Lucee environments, simple reads/writes are handled automatically.

When locking IS required:

• When performing operations that use the application scope on both sides of an assignment (e.g., incrementing a counter).
• To ensure a consistent value if a variable might be changed mid-request by another thread.

Use the lock block to ensure atomicity:

lock scope="application" timeout="1" type="exclusive" {
    application.counter += 1;
}

The Ternary operator (? :) is a decision-making operator that allows you to execute one of two statements based on a condition. It requires three operands: a condition, a true statement, and a false statement.

Syntax: ((condition) ? trueStatement : falseStatement)

If the condition evaluates to true, the trueStatement is executed; otherwise, the falseStatement is executed.

// Example of ternary usage
result = isNumeric("nineteen") ? "it's numeric" : "no it isn't"; // returns "no it isn't"