Wie kann überprüft werden, ob ein bestimmter Wert an einem bestimmten Schlüssel in einem beliebigen Subarray eines mehrdimensionalen Arrays vorhanden ist?

Ich muss ein mehrdimensionales Array nach einem bestimmten Wert in einem der indizierten Subarrays durchsuchen.

Mit anderen Worten, ich muss eine einzelne Spalte des mehrdimensionalen Arrays auf einen Wert überprüfen. Wenn der Wert irgendwo im mehrdimensionalen Array vorhanden ist, möchte ich zurückkehren true Andernfalls false

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

Ich würde gerne wissen, wie ich am schnellsten und effizientesten überprüfen kann, ob das Array $my_array enthält einen Wert mit dem Schlüssel “id”. Zum Beispiel, wenn id => 152 Irgendwo im mehrdimensionalen Array möchte ich true.

Nichts ist schneller als eine einfache Schleife. Sie können dazu einige Array-Funktionen mischen und anpassen, aber sie werden auch nur als Schleife implementiert.

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

Der einfachste Weg ist dieser:

$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

einfach kannst du das verwenden

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

Nehmen wir dieses mehrdimensionale Array an:

$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'));

Hier ist eine aktualisierte Version von Dan Grossmans Antwort, die mehrdimensionale Arrays berücksichtigt (wonach ich gesucht habe):

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;
}

Wenn Sie viele “id”-Lookups machen müssen und es wirklich schnell gehen soll, sollten Sie ein zweites Array verwenden, das alle “ids” als Schlüssel enthält:

$lookup_array=array();

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

Jetzt können Sie sehr schnell nach einer vorhandenen ID suchen, zum Beispiel:

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

Eine gute Lösung kann von bereitgestellt werden @Elias Van Ootegan in einem Kommentar, der lautet:

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

Ich habe es versucht und für mich gearbeitet, danke Kumpel.

Bearbeitet

Hinweis: Es funktioniert in PHP 5.5+

TMTOWTDI. Hier sind einige Lösungen in der Reihenfolge ihrer Komplexität.

(Es folgt eine kurze Einführung in die Komplexität):O(n) oder “großes o” bedeutet am schlimmsten Fallbeispiel wo n bedeutet die Anzahl der Elemente im Array und o(n) oder “kleines o” bedeutet Beste Fall Szenario. Lange diskrete Mathematikgeschichte, kurz gesagt, Sie man muss sich nur um das Worst-Case-Szenario kümmernund stellen Sie sicher, dass dies nicht der Fall ist n ^ 2 oder n!. Es ist eher ein Maß für die Änderung der Rechenzeit als n größer als die Gesamtrechenzeit. Wikipedia hat einen guten Artikel über Rechen- bzw. Zeitkomplexität.

Wenn mich die Erfahrung eines gelehrt hat, dann ist es, dass es eine deutliche Zeitverschwendung ist, zu viel Zeit damit zu verbringen, das little-o Ihrer Programme zu optimieren.

Lösung 0: O(n) / o(1) Komplexität:

Diese Lösung hat ein Best-Case-Szenario von 1 Vergleich – 1 Iteration durch die Schleife, aber nur vorausgesetzt, der passende Wert steht an Position 0 des Arrays. Im schlimmsten Fall ist es nicht im Array und muss daher über jedes Element des Arrays iterieren.

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

Lösung 1: O(n) / o(n) Komplexität:

Diese Lösung muss das gesamte Array durchlaufen, unabhängig davon, wo sich der übereinstimmende Wert befindet, also wird es immer sein n Iterationen durch das Array.

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

Lösung 2: O(n log n) / o(n log n) Komplexität:

Eine Hash-Einfügung ist, wo die log n kommt von; n Hash-Einfügungen = n * log n. Am Ende gibt es eine Hash-Suche, die eine andere ist log n aber es ist nicht enthalten, weil diskrete Mathematik genau so funktioniert.

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