Introduction

Searching an array of structs in ColdFusion is straightforward, but the most efficient approach depends on how often you search and what key you search by. If you only search occasionally, a simple loop is fine. If you search the same data repeatedly, build an index instead of scanning the array every time.

Simple Linear Search

For a one-off lookup, a loop is the clearest solution.

1people = [
2    { id = 1, name = "Ava" },
3    { id = 2, name = "Ben" },
4    { id = 3, name = "Cara" }
5];
6
7found = 0;
8
9for (person in people) {
10    if (person.id == 2) {
11        found = person;
12        break;
13    }
14}
15
16writeDump(found);

This is O(n) time, which means it checks items until it finds a match or reaches the end. For small arrays, that is usually perfectly acceptable.

Use arrayFind or arrayFilter for Clarity

In modern ColdFusion or Lucee, closures can make the intent more readable.

1people = [
2    { id = 1, name = "Ava" },
3    { id = 2, name = "Ben" },
4    { id = 3, name = "Cara" }
5];
6
7position = arrayFind(people, function(item) {
8    return item.id == 2;
9});
10
11if (position > 0) {
12    writeDump(people[position]);
13}

This is still a linear search. It is not inherently faster than a loop, but it can be easier to read when the predicate is simple.

If you need all matches rather than the first one:

1matches = arrayFilter(people, function(item) {
2    return item.name == "Ben";
3});
4
5writeDump(matches);

Again, the time complexity is still linear.

The Real Optimization: Build an Index

If you search by id often, scanning an array repeatedly is wasteful. Convert the array into a struct keyed by the searchable field.

1people = [
2    { id = 1, name = "Ava" },
3    { id = 2, name = "Ben" },
4    { id = 3, name = "Cara" }
5];
6
7peopleById = {};
8
9for (person in people) {
10    peopleById[person.id] = person;
11}
12
13writeDump(peopleById[2]);

That changes repeated lookups from "scan the array again" to direct key access. If the dataset is large or frequently queried, this is where the real performance gain comes from.

Decide Based on Access Pattern

Ask these questions first:

• Do I search once or many times
• Do I search by one key or many keys
• Do I need the original order preserved
• Can the data structure be changed

If you need order plus fast lookup, keep both:

• an array for ordered iteration
• a struct for indexed lookup

That is a common and practical design.

Handling Missing Keys Safely

When searching arrays of structs, do not assume every struct has every key.

position = arrayFind(people, function(item) {
    return structKeyExists(item, "id") && item.id == 2;
});

This avoids runtime errors when the incoming data is inconsistent.

If you build an index, validate before inserting:

1for (person in people) {
2    if (structKeyExists(person, "id")) {
3        peopleById[person.id] = person;
4    }
5}

That is better than discovering malformed data in the middle of a request path.

When the Data Should Not Be an Array of Structs

Sometimes the search problem reveals that the current shape of the data is wrong for the job. If the primary use case is repeated lookup by key, a struct of structs may be the natural data model from the start.

1peopleById = {
2    1 = { id = 1, name = "Ava" },
3    2 = { id = 2, name = "Ben" },
4    3 = { id = 3, name = "Cara" }
5};
6
7writeDump(peopleById[2]);

Do not keep an array of structs just because it is familiar if the application really needs indexed access.

Database-Sized Data Belongs in the Database

If the array came from a query and the dataset is large, the best optimization may be to avoid searching in ColdFusion entirely. Push the filter into SQL and let the database use indexes.

The more rows you pull into application memory only to search again, the less efficient the design becomes.

Common Pitfalls

• Assuming arrayFind is faster than a loop when both are doing a linear scan.
• Re-scanning the same array many times instead of building an index.
• Ignoring missing keys in partially formed structs.
• Keeping an array structure when the real access pattern is key-based lookup.
• Pulling large datasets from the database only to filter them in application code.

Summary

• For one-off searches, a simple loop or arrayFind is fine.
• For repeated lookups by key, build a struct-based index.
• Choose the data structure based on how the data is accessed, not just how it was first created.
• Validate key existence when the input data may be inconsistent.
• If the source is a database, consider solving the search there instead of in ColdFusion.