PHP How To Find the Keys of A Value In Multidimensional Array

Here is the solution if you are sure that your input array will always be only 2D.

$test = [
  3 => [
    16 => 0,
    17 => 1,
    18 => 2],
  4 => [
    22 => 3,
    23 => 4],
  5 => [
    1 => 5]
];

function myFunction($array, $value){
    foreach($array as $k => $a){
        if(in_array($value, $a)){
            return ([$k,array_keys($a,$value)]);
        }
    }
}
var_dump(myFunction($test, 3));

This will output:

array(2) { [0]=> int(4) [1]=> array(1) { [0]=> int(22) } }

Please mind that second value in returned array is itself an arrray because there can exist more than one 3 in array.

I hope it helps

After seeing what you specifically want:

$array_data = [
  3 => [
    16 => 0,
    17 => 3,
    18 => 2],
  4 => [
    22 => 3,
    23 => 4],
  5 => [
    1 => 5]
];

function findKeysFromValue($search, $array){

    foreach($array as $key => $value){
        $b = [];
        foreach($value as $k => $v){
            if($v != $search){
                unset($array[$key][$k]);
            } else {
                $b[] = $k;
            }
        }
        $array[$key] = $b;
    }

    return array_filter($array,'count');
}

print_r(findKeysFromValue(3, $array_data));

The output would be the following:

Array(
  [3] => Array(
      [0] => 17
    )
  [4] => Array(
      [0] => 22
    )
)

Maybe this will work (I haven't tried it though).

function findInArray($array, $search, $parentPath) {
      foreach ($array as $key => $value) {                
            $currentPath = array_merge($parentPath, $key);
            if (!is_array($value) && $value === $search) {
                return $currentPath;
            } else if (is_array($value)) {
                $res = findInArray($value, $search, $currentPath);
                if ($res !== null) {
                    return $res;
                }
            }
      }
      return null;
}

Call as findInArray($array, 3, [])

This function works with 2 dimens array:

function findKey( $arr, $arrValue ) {
    foreach ( $arr as $key => $value ) {
        foreach ( $value as $subKey => $subValue ) {
            if ( $arrValue == $subValue ) {
                return $subKey;
            }
        }
    }

    return - 1;
}

$mdArray = array(
    12 => array(
        3 => 4,
        4 => 8,
        7 => 9
    ),
    23 => array(
        5  => 5,
        8  => 12,
        11 => 18
    ),
);

echo findKey( $mdArray, 4 ); //3
echo findKey( $mdArray, 5 ); //5
echo findKey( $mdArray, 8 ); //4
echo findKey( $mdArray, 12 ); //8

How about a function that searches for your first key then returns the keys belonging to the first array as an array so you can traverse the values like this:

<?php

    function FindTheKeys($myArray, $myKey)
    {
            foreach ($myArray as $firstkeys => $firstvalues)
            {
                    if ($firstkeys == $myKey)
                    {
                            return array_keys($firstvalues);
                    }
            }
    }

    $myarr = Array
    (
            3 => Array
            (
                    16 => 0,
                    17 => 1,
                    18 => 2
            ),

            4 => Array
            (
                    22 => 3,
                    23 => 4
            ),

            5 => Array
            (
                    1 => 5
            )

    );

    $foundkeys = FindTheKeys($myarr, 3);

    print_r($foundkeys);

?>

The above will return 16, 17, 18 in an array $foundkeys.

How about a recursive function that searches to any depth of array and returns the first value match.

Demonstration : https://eval.in/674271

How: Search the array looking for the value.

• Each time we meet a new array we need to search it.
• so, record the current key in a stack ad then recurse to search it.
• If we find the value then end.
• Otherwise, we throw away the top of the stack and keep looking.

The function that does the work:

/**
 *  This will recurse until it finds the value.
 *  stop on first match 
 *
 *  @param array $haystack - where to look 
 *  @param mixed $needle   - what to look for
 *  @param array $keyPath  - reference to result array that will store the path   
 *
 *  @return  boolean $found
 */
function findKeys(array $haystack, $needle, &$keyPath)
{
     $found = false;

     foreach ($haystack as $key => $value) {

        if (is_array($value)) { // record current key and recurse 
            array_push($keyPath, $key);
            $found = findKeys($value, $needle, $keyPath);   
            if ($found) {
                return $found;
            }             
            array_pop($keyPath);


        } else {
            $found = $value === $needle;
            if ($found) {
                array_push($keyPath, $key);
                break;
            }
        } 
     }

     return $found;   
}

Run it:

$path = array();

$found = findKeys($src, 42, $path);

Sample output:

string(6) "Found:"
bool(true)

Path
Array
(
    [0] => 4
    [1] => 24
    [2] => 126
)

You can avoid one looping by using this.

$matched = [];
foreach($object as $extIndex => $array){
    //Look for value 3 in the array until no value is found
    while (false !== $key = array_search(3, $array)) {
        $matched[] = [$extIndex, $key];
        //Remove the value already found
        unset($array[$key]);
    }

}
print_r($matched);