Strain in Cfml: Complete Solution & Deep Dive Guide

---

Mastering Collection Filtering in CFML: The Ultimate Guide to Strain

The Strain operation is a fundamental concept for filtering collections in CFML. It involves implementing keep and discard methods that take a collection and a predicate function, returning a new, filtered collection based on whether the predicate evaluates to true or false, without modifying the original data.

---

You've been there before. Staring at a chunk of data—an array of user structs, a list of product IDs, a series of numbers—and your task is to sift through it. You need to separate the active users from the inactive, the premium products from the standard, the even numbers from the odd. So you reach for the trusty for loop, initialize an empty array, and start writing conditional logic. It works, but it feels clunky, repetitive, and verbose.

This traditional, imperative approach clutters your components with boilerplate code. It mixes the "what" (I want only the even numbers) with the "how" (loop through each item, check if it's divisible by 2, add it to a new array). What if you could write code that speaks your intention directly? What if you could simply tell your collection: "keep the elements that match this rule," or "discard the ones that don't"?

This is the essence of the Strain pattern, a powerful concept borrowed from functional programming that revolutionizes how you handle data. In this comprehensive guide, we'll deconstruct the Strain operation from the ground up, build a robust implementation in modern CFML, and explore how it leads to cleaner, more expressive, and more maintainable code. Prepare to transform your data manipulation logic from a chore into an elegant expression of intent.

---

What Is the Strain Operation? A Functional Approach to Filtering

At its core, the Strain operation is a method of filtering a collection of items based on a specific condition. It is defined by two distinct but complementary actions: keep and discard. This concept is a cornerstone of functional programming, emphasizing what to do with data rather than how to do it step-by-step.

Let's break down the key components:

• The Collection: This is the original set of data you want to filter. In CFML, this is typically an Array, but the concept can apply to any iterable data structure.
• The Predicate: This is a function that takes a single element from the collection and returns a boolean value (true or false). The predicate is your "rule" or "test." For example, a predicate could be "is the number even?" or "is the user's status 'active'?".
• The keep Operation: This operation iterates through the collection, applies the predicate to each element, and returns a new collection containing only the elements for which the predicate returned true.
• The discard Operation: This is the inverse of keep. It iterates through the collection, applies the predicate to each element, and returns a new collection containing only the elements for which the predicate returned false.

A crucial principle here is immutability. The Strain operation never modifies the original collection. It always produces a new, filtered collection. This prevents unintended side effects and makes your code more predictable and easier to debug.

Think of it like using a coffee filter. Your collection is the mixture of coffee grounds and water. The predicate is the filter paper that only lets liquid pass through. The keep operation gives you the brewed coffee (what passed the test), while the discard operation would be like keeping the used grounds (what failed the test).

---

Why Is This Pattern So Important in Modern CFML?

While CFML has its roots in tag-based, procedural code, the language has evolved significantly. Modern CFML (both Lucee and Adobe ColdFusion) fully embraces functional programming concepts like higher-order functions, closures, and member functions. Adopting the Strain pattern, or more broadly, the concept of filtering with functions, aligns your code with these modern practices and offers several tangible benefits.

Declarative vs. Imperative Code

A traditional for loop is imperative—you are giving the computer a detailed, step-by-step recipe for how to filter the array. A functional approach like Strain is declarative—you are simply declaring your desired outcome. Compare the two:

// Imperative Approach
evens = [];
numbers = [1, 2, 3, 4, 5];
for (var num in numbers) {
    if (num % 2 == 0) {
        arrayAppend(evens, num);
    }
}

// Declarative Approach (using the concept)
isEven = (num) => num % 2 == 0;
numbers = [1, 2, 3, 4, 5];
evens = Strain.keep(numbers, isEven);

The declarative version is more concise and easier to read. It focuses on the business logic (isEven) rather than the mechanics of looping and appending.

Improved Readability and Maintainability

Code that clearly states its intent is easier for you and your team to understand and maintain. When you see Strain.keep(users, isActive), you immediately know what's happening. The complexity of the iteration is abstracted away, allowing you to focus on the high-level logic.

Encourages Reusability

The predicate functions you create are highly reusable. The same isEven function can be used to filter any array of numbers. An isActive predicate can be used on a collection of users, orders, or subscriptions. This promotes DRY (Don't Repeat Yourself) principles.

Promotes Immutability

By always returning a new collection, the Strain pattern helps you avoid bugs caused by unexpected data mutations. You can pass your original array to multiple functions without worrying that one of them might alter it, affecting the others. This makes state management simpler and more robust.

---

How to Implement the Strain Operation in CFML

Now, let's get practical. We'll build a CFML Component (CFC) from scratch that implements the keep and discard methods. We will use modern CFScript syntax, which is the standard for contemporary CFML development.

The `Strain.cfc` Component

Create a file named Strain.cfc. This component will encapsulate our filtering logic.

// path/to/components/Strain.cfc
component {

    /**
     * Filters a collection, returning a new collection containing only the elements
     * for which the predicate function returns true.
     *
     * @collection The array to be filtered.
     * @predicate  A function that accepts one argument (an element of the collection) and returns a boolean.
     * @return     A new array with the filtered elements.
     */
    public array function keep(required array collection, required function predicate) {
        // Initialize an empty array to store the results.
        var result = [];

        // Iterate over each item in the input collection.
        for (var item in arguments.collection) {
            // Invoke the predicate function with the current item.
            // If the predicate returns true, add the item to our result array.
            if (arguments.predicate(item)) {
                arrayAppend(result, item);
            }
        }

        // Return the new collection containing only the kept items.
        return result;
    }

    /**
     * Filters a collection, returning a new collection containing only the elements
     * for which the predicate function returns false.
     *
     * @collection The array to be filtered.
     * @predicate  A function that accepts one argument (an element of the collection) and returns a boolean.
     * @return     A new array with the filtered elements.
     */
    public array function discard(required array collection, required function predicate) {
        // Initialize an empty array for the results.
        var result = [];

        // Iterate over each item.
        for (var item in arguments.collection) {
            // Invoke the predicate. If it returns false, we keep the item.
            // The '!' inverts the boolean result.
            if (!arguments.predicate(item)) {
                arrayAppend(result, item);
            }
        }

        // Return the new collection of discarded items.
        return result;
    }

}

Code Walkthrough and Explanation

1. The `keep` Method

The keep method is the heart of positive filtering. Its logic is straightforward:

• It defines a function that accepts an array named collection and a function named predicate.
• It creates a local, empty array called result. This ensures we don't modify the original data.
• It uses a for...in loop to iterate through each item in the provided collection.
• The most important line is if (arguments.predicate(item)). Here, we are executing the predicate function that was passed in, using the current item as its argument.
• If the predicate returns true, the item passes the test, and we add it to our result array using arrayAppend().
• Finally, after checking every item, the function returns the result array.

Here is a visual flow of the logic:

    ● Start with [1, 2, 3, 4, 5] & predicate `isEven()`
    │
    ▼
  ┌───────────────────┐
  │ Create empty `result` │
  └─────────┬─────────┘
            │
            ▼
  ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
  │ Loop through collection │
  │         │         │
  │     item = 1      │
  └ ─ ─ ─ ─ ┼ ─ ─ ─ ─ ┘
            │
            ▼
    ◆ isEven(1)? → false
    │
    ├─ Next item = 2
    │
    ▼
    ◆ isEven(2)? → true
    │
    └─────⟶ ┌───────────────┐
            │ Append 2 to `result` │
            └───────────────┘
    │
    ├─ Next item = 3
    │
    ▼
    ◆ isEven(3)? → false
    │
    ├─ Next item = 4
    │
    ▼
    ◆ isEven(4)? → true
    │
    └─────⟶ ┌───────────────┐
            │ Append 4 to `result` │
            └───────────────┘
    │
    ├─ Next item = 5
    │
    ▼
    ◆ isEven(5)? → false
    │
    ▼
  ┌─────────────┐
  │ End of Loop │
  └──────┬──────┘
         │
         ▼
    ● Return `result` [2, 4]

2. The `discard` Method

The discard method is the logical opposite of keep. Its structure is nearly identical, with one critical difference:

The condition is inverted: if (!arguments.predicate(item)). The ! operator is a logical NOT. It flips the boolean result of the predicate. So, if the predicate returns true (meaning the item *matches* the rule), the condition becomes false, and the item is skipped. If the predicate returns false (meaning the item *does not match* the rule), the condition becomes true, and the item is added to the result array.

This flow diagram illustrates the inverted logic:

    ● Start with ["apple", "banana", "avocado"] & predicate `startsWithA()`
    │
    ▼
  ┌───────────────────┐
  │ Create empty `result` │
  └─────────┬─────────┘
            │
            ▼
  ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
  │ Loop through collection │
  │         │         │
  │   item = "apple"  │
  └ ─ ─ ─ ─ ┼ ─ ─ ─ ─ ┘
            │
            ▼
    ◆ !startsWithA("apple")? → !true → false
    │
    ├─ Next item = "banana"
    │
    ▼
    ◆ !startsWithA("banana")? → !false → true
    │
    └─────⟶ ┌────────────────────┐
            │ Append "banana" to `result` │
            └────────────────────┘
    │
    ├─ Next item = "avocado"
    │
    ▼
    ◆ !startsWithA("avocado")? → !true → false
    │
    ▼
  ┌─────────────┐
  │ End of Loop │
  └──────┬──────┘
         │
         ▼
    ● Return `result` ["banana"]

---

Where and How to Use Strain: Practical Examples

Theory is great, but let's see how this pattern shines in real-world scenarios. First, you'll need to instantiate your component. In a modern CFML framework like ColdBox, this would be handled by dependency injection. For a standalone example, you can create it directly:

// In your script file (e.g., index.cfm)
strainer = new path.to.components.Strain();

Example 1: Filtering Numbers

This is the classic example. Let's find all numbers in a list that are multiples of 3.

numbers = [1, 3, 5, 6, 9, 10, 12];

// Define the predicate as an arrow function
isMultipleOfThree = (num) => (num % 3 == 0);

// Use the 'keep' method
multiples = strainer.keep(numbers, isMultipleOfThree);
// multiples will be [3, 6, 9, 12]

// Use the 'discard' method
nonMultiples = strainer.discard(numbers, isMultipleOfThree);
// nonMultiples will be [1, 5, 10]

writeDump(var=[multiples, nonMultiples], label="Number Filtering");

Example 2: Filtering an Array of Structs (Objects)

This is a more common use case. Imagine you have an array of user structs and you want to find all the active administrators.

users = [
    { name: "Alice", role: "admin", active: true },
    { name: "Bob", role: "user", active: true },
    { name: "Charlie", role: "admin", active: false },
    { name: "Diana", role: "admin", active: true }
];

// Define a more complex predicate
isActiveAdmin = (user) => (user.role == "admin" && user.active);

// Get the active admins
activeAdmins = strainer.keep(users, isActiveAdmin);

// Get everyone else
otherUsers = strainer.discard(users, isActiveAdmin);

writeDump(var=[activeAdmins, otherUsers], label="User Filtering");

The activeAdmins array will contain the structs for Alice and Diana.

Example 3: Data Cleansing

Let's say you receive a list of email addresses, but some are empty strings. You can use discard to clean the list.

emails = ["test@example.com", "", "another@test.com", " ", "final@email.com"];

// Predicate to check for empty or blank strings
isBlank = (str) => (trim(str).len() == 0);

// Discard the blank entries to get a clean list
validEmails = strainer.discard(emails, isBlank);
// validEmails will be ["test@example.com", "another@test.com", "final@email.com"]

writeDump(validEmails);

Running with CommandBox

For developers using CommandBox, the de facto CLI for CFML, you can easily test this. Save the above examples in a file like test.cfm, start a server, and view the results.

# Make sure you are in your project root
box install
box server start
# Now open http://127.0.0.1:[port]/test.cfm in your browser

---

Alternative Approaches & Best Practices: Native CFML Member Functions

Building the Strain.cfc is an excellent exercise from the kodikra learning path to understand the mechanics of higher-order functions and filtering. However, in your day-to-day CFML projects, you should leverage the powerful, built-in member functions that provide the same functionality, often with better performance as they are implemented at the engine level.

The primary function you should know is Array.filter().

Using `Array.filter()`

The Array.filter() member function is the direct, idiomatic equivalent of our keep method. It takes a predicate function as an argument and returns a new array containing only the items for which the predicate returned true.

// Using our previous 'users' array
users = [
    { name: "Alice", role: "admin", active: true },
    { name: "Bob", role: "user", active: true },
    { name: "Charlie", role: "admin", active: false },
    { name: "Diana", role: "admin", active: true }
];

// The predicate remains the same
isActiveAdmin = (user) => (user.role == "admin" && user.active);

// Use the native filter() member function
activeAdmins = users.filter(isActiveAdmin);
// activeAdmins is identical to the result from Strain.keep()

Achieving `discard` with `filter()`

CFML doesn't have a built-in discard() or reject() member function. However, you can easily achieve the same result by inverting the logic within your predicate function.

// To get the 'discard' result, we filter for the opposite condition
otherUsers = users.filter((user) => {
    // Return true for users who are NOT active admins
    return !(user.role == "admin" && user.active);
});

This is a common pattern: filter() is used for both keeping and discarding, you just change the logic of the predicate passed to it.

Pros and Cons

Let's summarize the trade-offs between our custom implementation and the native functions.

Aspect	Custom `Strain.cfc`	Native `Array.filter()`
Readability	Very high. `Strain.keep()` and `Strain.discard()` are extremely explicit.	High. `users.filter(isActive)` is very clear. The discard pattern is slightly less direct but still common.
Performance	Good. It's pure CFML code, but involves function call overhead for each item.	Excellent. The iteration is handled by the underlying Java engine, which is almost always faster.
Idiomatic Code	Good for learning. Not standard in production code.	Excellent. This is the expected, modern way to filter arrays in CFML.
Extensibility	High. You can add more methods to your CFC (e.g., for structs, queries).	Limited to what the language provides. You can't add new member functions to the base Array object easily.

Verdict: Learn the concept by building the Strain component. For production applications, use the native Array.filter() member function for its superior performance and idiomatic style.

---

Frequently Asked Questions (FAQ)

1. What is the main difference between `keep` and `discard`?

keep returns a new collection with elements where the predicate function returns true. discard does the opposite, returning a new collection with elements where the predicate returns false. They are two sides of the same filtering coin.

2. Does the Strain operation modify my original array?

No, and this is a critical feature. Both keep and discard (and the native Array.filter()) are immutable operations. They always return a brand new array and leave the original collection untouched, which prevents side effects and makes your code safer.

3. What exactly is a "predicate" in this context?

A predicate is simply a function that accepts a value and returns a boolean (true or false). It's the "test" or "rule" that the filter uses to decide whether to keep or discard an element. In CFML, this can be a traditional function, a component method, or most commonly, a concise arrow function (closure).

4. Why should I use `Array.filter()` if I can build my own `Strain` component?

While building your own is a great learning experience from the kodikra.com curriculum, the native Array.filter() is implemented at a lower level in the CFML engine (Java). This makes it significantly more performant, especially on large arrays. It's also the idiomatic, standard way to perform filtering, making your code more familiar to other CFML developers.

5. Can I use this Strain concept on CFML Structs?

Yes, you can! CFML has a Struct.filter() member function that works similarly to Array.filter(). Its predicate receives two arguments: the key and the value of each element. You could easily extend our Strain.cfc to handle structs as well by checking the input type.

6. Are there any performance concerns with this pattern?

For most web application use cases, the performance is excellent. However, for extremely large datasets (hundreds of thousands or millions of items), iterating in CFML memory can be slower than letting the database do the filtering. If your data is coming from a database, it's almost always more efficient to use a WHERE clause in your SQL query to filter the data before it even reaches your CFML application.

7. Is the Strain/Filter concept unique to CFML?

Not at all! This is a universal concept in programming. JavaScript has Array.prototype.filter(), Python has list comprehensions and a filter() function, Java has Streams with a .filter() method, and so on. Learning this pattern in CFML makes you a better programmer in any language. For more CFML fundamentals, dive deeper into our CFML language guides.

---

Conclusion: Embrace Declarative Filtering

The Strain pattern is more than just a piece of code; it's a shift in mindset. It encourages you to move away from verbose, step-by-step imperative loops and towards a more expressive, declarative style of programming. By defining what you want—the "what" not the "how"—you create code that is cleaner, more reusable, and infinitely more readable.

You've learned how to implement the keep and discard operations from scratch, seen their practical applications with real-world data, and understood how they relate to CFML's powerful native member functions like Array.filter(). This knowledge is a fundamental building block in writing modern, effective, and maintainable CFML.

The next time you need to sift through a collection, pause before you type for (...). Instead, think about the rule you want to apply, encapsulate it in a predicate function, and let a filter do the heavy lifting. Your future self, and your teammates, will thank you.

Disclaimer: All code examples are written in modern CFScript and are compatible with Lucee 5.3+ and Adobe ColdFusion 2018+. For older versions, syntax for function expressions may differ. For a structured learning journey, explore our complete CFML Learning Roadmap.

---

Published by Kodikra — Your trusted Cfml learning resource.