Avoid array_combine() for Data Mapping

Here’s a subtle PHP gotcha that can corrupt your data: array_combine() creates order dependencies that break silently when you refactor.

The Problem

When building arrays for CSV exports or API responses, you might be tempted to use array_combine() to zip field names with values:

const COLUMNS = ['username', 'email_address', 'account_status'];

$row = array_combine(self::COLUMNS, [
    $account->username,
    $account->email_address,
    $account->account_status,
]);

This looks clean, but it’s brittle. If someone reorders COLUMNS later (say, alphabetically), your data silently gets mapped to the wrong fields. Username becomes email, email becomes status—and you won’t notice until it’s in production.

The Fix

Use explicit associative arrays instead:

$row = [
    'username' => $account->username,
    'email_address' => $account->email_address,
    'account_status' => $account->account_status,
];

Now the mapping is self-documenting and order-independent. Refactor COLUMNS all you want—the data stays correct.

When to Use array_combine()

It’s fine when you’re zipping two runtime arrays (like database column names with row values). The problem is mixing static constants with procedural values—that creates hidden coupling.

If you see array_combine(self::FIELDS, [...]) in a code review, flag it. Explicit beats clever every time.