Find a Row Key by Column Value in a PHP 2D Array

You will learn how to search rows in a PHP array of associative arrays and return the key of the first row whose uid matches a requested value. You will also learn why a loop is normally the correct approach, how array_search() and array_column() work, and how to handle the important 0 versus false result safely.

A PHP “2D array” is commonly an outer array containing inner arrays. In this example:

• The outer array is the list of users.
• Each inner array is one user record.
• uid, name, and pic_square are keys inside a record.
• The outer key (0, 1, 2) is the row position or row key you want to find.

To find a user by uid, PHP must inspect user records until it finds a match. This is called a linear search. It is usually written with foreach because it is clear, works with any outer keys, and can stop as soon as a match is found.

For an ordinary unsorted array, there is no general shortcut that avoids checking entries in the worst case. If lookups happen frequently, the faster design is to build an index keyed by UID once, then retrieve users directly by UID.

Imagine a stack of employee cards. Each card has a UID written on it, and the stack has numbered slots: 0, 1, and 2.

To find UID 40489, you read cards from the top until you find the right one. The slot number of that card is the result.

A loop is the act of checking cards one at a time. An index is like reorganizing the cards into labelled drawers, where the drawer label is the UID. After that preparation, finding a card is nearly immediate.

Use foreach when you want the first matching row key.

function search_by_uid(array $users, $uid): ?int
{
    foreach ($users as $key => $user) {
        if (isset($user['uid']) && (string) $user['uid'] === (string) $uid) {
            return $key;
        }
    }

    return null;
}

$userdb = array(
    array('uid' => '100', 'name' => 'Sandra Shush'),
    array('uid' => '5465', 'name' => 'Stefanie Mcmohn'),
    array('uid' => '40489', 'name' => 'Michael')
);

echo (, );   
 (, ); 

Consider this call:

$result = search_by_uid($userdb, 40489);

The function behaves as follows:

1. The first iteration sets $key to 0 and $user['uid'] to '100'.
2. '100' does not match '40489', so the loop continues.
3. The second iteration sets $key to 1 and checks '5465'.
4. '5465' does not match '40489', so the loop continues.
5. The third iteration sets $key to 2 and checks '40489'.
6. The values match, so return $key immediately returns 2.
7. Code after return is not executed. This early return prevents unnecessary checks.

Searching an array of records by one field is common in small applications and data-processing scripts:

• Finding a user record from a UID loaded from JSON or a CSV file.
• Locating a product row by SKU before updating its quantity.
• Finding an API response item by its id.
• Matching an uploaded file record by filename or internal identifier.
• Checking whether a configuration entry exists before modifying it.

For small arrays or one-off searches, a foreach loop is simple and appropriate. For large datasets stored permanently, use a database query with an indexed column instead of loading every record into PHP first.

In real PHP codebases, developers typically place this logic in a small, reusable function or repository method and define a clear “not found” result.

Guard against malformed rows

function findUserKeyByUid(array $users, string $uid): ?int
{
    foreach ($users as $key => $user) {
        if (!is_array($user) || !array_key_exists('uid', $user)) {
            continue;
        }

        if ($user['uid'] === $uid) {
            return $key;
        }
    }

    return null;
}

Build an index for repeated lookups

If many lookups use the same user list, build a UID-to-key map once:

$keysByUid = array();

foreach ($userdb as  => ) {
    [() []] = ;
}

 = [] ?? ; 

Treating key 0 as “not found”

0 is a valid result, but it is falsey in PHP. Do not write this:

$key = array_search('100', array_column($userdb, 'uid'));

if (!$key) {
    echo 'Not found'; // Incorrect: the matching key is 0
}

Check specifically for false instead:

if ($key === false) {
    echo 'Not found';
}

Returning false without documenting it

If a function may return either an integer or false, callers must handle both. Returning null for “not found” is often clearer when you write your own function.

function search_by_uid(): ?
{
    
}

// Recommended: find the first matching outer key.
function search_by_uid(array $users, $uid): ?int
{
    foreach ($users as $key => $user) {
        if (isset($user['uid']) && (string) $user['uid'] === (string) $uid) {
            return $key;
        }
    }

    return null;
}

// Concise alternative (PHP 5.5+).
$key = array_search('40489', array_column($userdb, 'uid'), true);

if ($key !== false) {
    // Found; $key can validly be 0.
}

• Use foreach ($array as $key => $row) to access both row key and row data.

How do I get the key of the first matching array in PHP?

Loop through the outer array with foreach ($users as $key => $user). When the desired field matches, return $key.

Does array_search() return the array key or the position?

It returns the key of the matching value. With a normal zero-based list, that is often the position too. With custom keys, it returns the custom key.

Why must I use === false after array_search()?

The first item has key 0, and 0 is falsey in PHP. === false distinguishes a real key of 0 from the “not found” value false.

Is array_column() plus array_search() faster than foreach?

Usually not for one lookup. Both require a linear scan, and array_column() also creates a new array. Use it primarily for readability when it fits your code.

What should the search function return when no UID matches?

Return null in a custom function, or handle when using . Document the choice so callers can check it correctly.

• PHP associative arrays — Inner user records use named keys such as uid and name.
• foreach loops — The core control structure for inspecting each row and its outer key.
• array_search() — Finds the key of a value in a one-dimensional array.
• array_column() — Extracts one field, such as all UIDs, from a list of records.
• Strict comparison (===) — Prevents unexpected matches caused by PHP type juggling.
• Early returns and guard clauses — Make search functions efficient and easy to read.
• Hash maps and lookup tables — Support efficient repeated lookups after building an index.
• Database indexes — The scalable equivalent when records are stored in a database.