¿Cómo verificar si existe un valor específico en una clave específica en cualquier subarreglo de un arreglo multidimensional?

Necesito buscar en una matriz multidimensional un valor específico en cualquiera de los subarreglos indexados.

En otras palabras, necesito verificar una sola columna de la matriz multidimensional para obtener un valor. Si el valor existe en cualquier parte de la matriz multidimensional, me gustaría devolver true de lo contrario false

$my_array = array(    
    0 =>  array(  
        "name"   => "john",  
        "id"    =>  4  
    ),  
    1   =>  array(  
        "name" =>  "mark",  
        "id" => 152  
    ), 
    2   =>  array(  
        "name" =>  "Eduard",  
        "id" => 152  
    )
);

Me gustaría saber la forma más rápida y eficiente de verificar si la matriz $my_array contiene un valor con la clave “id”. Por ejemplo, si id => 152 en cualquier lugar de la matriz multidimensional, me gustaría true.

Nada será más rápido que un simple bucle. Puede mezclar y combinar algunas funciones de matriz para hacerlo, pero también se implementarán como un bucle.

function whatever($array, $key, $val) {
    foreach ($array as $item)
        if (isset($item[$key]) && $item[$key] == $val)
            return true;
    return false;
}

La forma más sencilla es esta:

$my_array = array(    
    0 =>  array(  
        "name"   => "john",  
        "id"    =>  4  
    ),  
    1   =>  array(  
        "name" =>  "mark",  
        "id" => 152  
    ), 
    2   =>  array(  
        "name" =>  "Eduard",  
        "id" => 152  
    )
);

if (array_search(152, array_column($my_array, 'id')) !== FALSE) {
  echo 'FOUND!';
} else {
  echo 'NOT FOUND!';
}

**PHP >= 5.5

simplemente puedes usar esto

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

Supongamos esta matriz multidimensional:

$userdb=Array
(
(0) => Array
    (
        (uid) => '100',
        (name) => 'Sandra Shush',
        (url) => 'urlof100'
    ),

(1) => Array
    (
        (uid) => '5465',
        (name) => 'Stefanie Mcmohn',
        (pic_square) => 'urlof100'
    ),

(2) => Array
    (
        (uid) => '40489',
        (name) => 'Michael',
        (pic_square) => 'urlof40489'
    )
);

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

Aquí hay una versión actualizada de la respuesta de Dan Grossman que se adaptará a matrices multidimensionales (lo que buscaba):

function find_key_value($array, $key, $val)
{
    foreach ($array as $item)
    {
        if (is_array($item) && find_key_value($item, $key, $val)) return true;

        if (isset($item[$key]) && $item[$key] == $val) return true;
    }

    return false;
}

Si tiene que hacer muchas búsquedas de “id” y debería ser muy rápido, debe usar una segunda matriz que contenga todas las “id” como claves:

$lookup_array=array();

foreach($my_array as $arr){
    $lookup_array[$arr['id']]=1;
}

Ahora puede verificar una identificación existente muy rápido, por ejemplo:

echo (isset($lookup_array[152]))?'yes':'no';

Una buena solución puede ser proporcionada por @Elias Van Ootegan en un comentario que es:

$ids = array_column($array, 'id', 'id');
echo isset($ids[40489])?"Exist":"Not Exist";

Lo probé y funcionó para mí, gracias amigo.

editado

Nota: funcionará en PHP 5.5+

TMTOWTDI. Aquí hay varias soluciones en orden de complejidad.

(Sigue una breve introducción sobre la complejidad):O(n) o “gran o” significa el peor escenario de caso donde n significa el número de elementos en la matriz, y o(n) o “pequeña o” significa mejor de los casos. Larga historia de matemáticas discretas, tú realmente solo tiene que preocuparse por el peor de los casosy asegúrese de que no sea n ^ 2 o n!. Es más una medida de cambio en el tiempo de computación como n aumenta de lo que es el tiempo total de computación. Wikipedia tiene un buen artículo sobre la complejidad del tiempo computacional.

Si la experiencia me ha enseñado algo, es que pasar demasiado tiempo optimizando la pequeña o de sus programas es una clara pérdida de tiempo que es mejor emplear en hacer algo, cualquier cosa, mejor.

Solución 0: O(n) / o(1) complejidad:

Esta solución tiene el mejor de los casos de 1 comparación: 1 iteración a través del bucle, pero solo siempre que el valor coincidente esté en la posición 0 de la matriz. El peor de los casos es que no está en la matriz y, por lo tanto, tiene que iterar sobre cada elemento de la matriz.

foreach ($my_array as $sub_array) {
    if (@$sub_array['id'] === 152) {
        return true;
    }
}
return false;

Solución 1: O(n) / o(n) complejidad:

Esta solución debe recorrer toda la matriz sin importar dónde esté el valor coincidente, por lo que siempre será n iteraciones a través de la matriz.

return 0 < count(
    array_filter(
        $my_array,
        function ($a) {
            return array_key_exists('id', $a) && $a['id'] == 152;
        }
    )
);

Solución 2: O(n log n) / o(n log n) complejidad:

Una inserción hash es donde el log n viene de; n inserciones hash = n * log n. Hay una búsqueda hash al final que es otra log n pero no está incluido porque así es como funciona la matemática discreta.

$existence_hash = [];
foreach ($my_array as $sub_array) {
    $existence_hash[$sub_array['id']] = true;
}
return @$existence_hash['152'];