downloads | documentation | faq | getting help | mailing lists | licenses | wiki | reporting bugs | php.net sites | links | conferences | my php.net

search for in the

array_shift> <array_reverse
Last updated: Fri, 11 Jun 2010

view this page in



array_shift> <array_reverse
Last updated: Fri, 11 Jun 2010
 
add a note add a note User Contributed Notes
array_search
giulio dot provasi at gmail dot com
30-Apr-2010 09:06
If you want a very simple way of searching a value through a multidimensionnal array here's a  trick :

<?php
function recursiveArraySearch($haystack, $needle, $index = null)
{
    $aIt     = new RecursiveArrayIterator($haystack);
    $it    = new RecursiveIteratorIterator($aIt);
   
    while($it->valid())
    {       
        if (((isset($index) AND ($it->key() == $index)) OR (!isset($index))) AND ($it->current() == $needle)) {
            return $aIt->key();
        }
       
        $it->next();
    }
   
    return false;
}
?>

So let's take a misc multi-dimensionnal array :

<?php
$std = new stdClass();
$std->name     = 'luke';
$std->age     = '25';
$std->sex     = 'M';

$array     = array(    array('type'=>'dog', 'name'=>'butch', 'sex'=>'m', 'breed'=>'boxer'),
                    array('type'=>'dog', 'name'=>'fido', 'sex'=>'m', 'breed'=>'doberman'),
                    'simpleValue',
                    array('type'=>'cat', 'name'=>'tiddles','sex'=>'m', 'breed'=>'maine coon'),
                    array('type'=>'horse', 'name'=>'ed','sex'=>'m', 'breed'=>'clydesdale'),
                    $std);

echo recursiveArraySearch($array, '25', 'age');        // returns 5
echo recursiveArraySearch($array, '25', 'name');    // returns false
echo recursiveArraySearch($array, 'simpleValue');    // returns 2
echo recursiveArraySearch($array, 'fido');            // returns 1
?>
kim at steinhaug dot com
19-Mar-2010 08:44
I was looking around for a recursive search by keys in multidimensional arrays. After testing the ones in this thread seems noone accually works. So I put this one together, and it does what you expect it to do.

You need to find the value for the key "han-solo".

<?php
if( ($val = array_search_key('han-solo',$array)) !== false){
  var_dump($val);
} else {
  // No keys with the name "han-solo"
}

function array_search_key( $needle_key, $array ) {
  foreach($array AS $key=>$value){
    if($key == $needle_key) return $value;
    if(is_array($value)){
      if( ($result = array_search_key($needle_key,$value)) !== false)
        return $result;
    }
  }
  return false;
}
?>
camden dot michael at gmail dot com
03-Mar-2010 06:58
I needed a case insensitive array search function for a project...

<?php
/**
 * Performs the same function as array_search except that it is case
 * insensitive
 * @param mixed $needle
 * @param array $haystack
 * @return mixed
 */

function array_nsearch($needle, array $haystack) {
   $it = new IteratorIterator(new ArrayIterator($haystack));
   foreach($it as $key => $val) {
       if(strcasecmp($val,$needle) === 0) {
           return $key;
       }
   }
   return false;
}
?>
jette at nerdgirl dot dk
01-Mar-2010 04:07
I use this function to search the value of arrays of any dimension, and return the result with keys preserved:

<?php
function multiArrayValueSearch($haystack, $needle, &$result, &$aryPath=NULL, $currentKey='') {
  if (is_array($haystack)) {
    $count = count($haystack);
    $iterator = 0;
    foreach($haystack as $location => $straw) {
      $iterator++;
      $next = ($iterator == $count)?false:true;
      if (is_array($straw)) $aryPath[$location] = $location;
        multiArrayValueSearch($straw,$needle,$result,$aryPath,$location);
        if (!$next) {
          unset($aryPath[$currentKey]);
        }
      }
    } else {
      $straw = $haystack;
      if ($straw == $needle) {
        if (!isset($aryPath)) {
          $strPath = "\$result[$currentKey] = \$needle;";
        } else {
          $strPath = "\$result['".join("']['",$aryPath)."'][$currentKey] = \$needle;";
        }
        eval($strPath);
      }
   }
}
?>

Example:

<?php
$ary['ballon']['red'][1] = 'Love';
$ary['ballon']['red'][2] = 'Valentine';
$ary['ballon']['red'][3] = 'Heart';
$ary['ballon']['green'][1] = 'Summertime';
$ary['ballon']['green'][2] = 'Hope';
$ary['ribbon']['yellow'][2] = 'Welcome';
$ary['ribbon']['red'][3] = 'Love';
$ary['ribbon']['red'][4] = 'Love';

echo "<pre>";

//Just call the function with 3 first parameters set:
//  1) The array to search
//  2) The value to find
//  3) A variable to store the result
multiArrayValueSearch($ary,'Love',$match);

print_r($match);
echo "</pre>";
?>

Output:

Array
(
    [ballon] => Array
        (
            [red] => Array
                (
                    [1] => Love
                )

        )

    [ribbon] => Array
        (
            [red] => Array
                (
                    [3] => Love
                    [4] => Love
                )

        )

)

You can easily adapt it to suit your need of matching, by changing line 16 in the function:

<?php
if ($straw == $needle) {
?>
james at bandit.co.nz
29-Jan-2010 01:33
A couple of staple custom PHP array searching functions I rely on in most of my projects;

<?php
    // array_search with partial matches and optional search by key
    function array_find($needle, $haystack, $search_keys = false) {
        if(!is_array($haystack)) return false;
        foreach($haystack as $key=>$value) {
            $what = ($search_keys) ? $key : $value;
            if(strpos($what, $needle)!==false) return $key;
        }
        return false;
    }
   
    // array_search with recursive searching, optional partial matches and optional search by key
    function array_find_r($needle, $haystack, $partial_matches = false, $search_keys = false) {
        if(!is_array($haystack)) return false;
        foreach($haystack as $key=>$value) {
            $what = ($search_keys) ? $key : $value;
            if($needle===$what) return $key;
            else if($partial_matches && @strpos($what, $needle)!==false) return $key;
            else if(is_array($value) && array_find_r($needle, $value, $partial_matches, $search_keys)!==false) return $key;
        }
        return false;
    }
?>

Hope they help someone!
mrjay42 at gmail dot com
13-Nov-2009 02:09
If you search a key position in an associative array (keys are uniques), i suggest this function :
<?php
public function getKeyPositionInArray($haystack, $keyNeedle)
{
    $i = 0;
    foreach($haystack as $key => $value)
    {
        if($key == $keyNeedle)
        {
            return $i;
        }
        $i++;
    }
}
?>
codeslinger at compsalot dot com
02-Oct-2009 07:22
one thing to be very aware of is that array_search() will fail if the needle is a string and the array itself contains values that are mixture of numbers and strings.  (or even a string that looks like a number)

The problem is that unless you specify "strict" the match is done using ==    and in that case any string will match a numeric value of zero which is not what you want.

-----

also, php can lookup an index pretty darn fast.  for many scenarios, it is practical to maintain multiple arrays, one in which the index of the array is the search key and the normal array that contains the data.

<?php

  $normal[$index] = array('key'=>$key, 'data'=>'foo');
  $inverse[$key] = $index;

  //very fast lookup, this beats any other kind of search

  if (array_key_exists($key, $inverse))
  {
    $index = $inverse[$key];
    return $normal[$index];
  }

?>
pi3ch at gmx dot com
29-Sep-2009 04:29
The return value for array_search is confusing if the return key is zero. it is better to double check it with in_array() function.

Example:
<?php

$SampleArray = ('a', 'b', 'c');

$Key = array_search('a', $SampleArray);
$Zero = in_array('a', $SampleArray);

if($Key == NULL && !$Zero)
   echo "Key doesnt exists";
else
   echo "Key exists";

 ?>
pvenakis at efrontlearning dot net
24-Sep-2009 12:02
if $haystack is not an array, for example false from some previous action, the function returns null instead of false in php 5.3.
temporal dot pl at gmail dot com
04-Sep-2009 10:57
Sometimes you need to find a given value in a sorted array or - if not found - detect the place where it should be. After that you can for example split the array into two halves, the  greater and the smaller one.

greenmr, dennis.decoene and php at celerondude had all posted very good binary search functions but these functions all return false if the needle was not found in the haystack. I've tweaked greenmr's code a little:

<?php
function Array_BinarySearch( $needle, $haystack, $comparator , &$probe )
{
    $high = Count( $haystack ) -1;
    $low = 0;
   
    while ( $high >= $low )
    {
        $probe = Floor( ( $high + $low ) / 2 );
        $comparison = $comparator( $haystack[$probe], $needle );
        if ( $comparison < 0 )
        {
            $low = $probe +1;
        }
        elseif ( $comparison > 0 )
        {
            $high = $probe -1;
        }
        else
        {
            return true;
        }
    }
    //The loop ended without a match
    //Compensate for needle greater than highest haystack element
    if($comparator($haystack[count($haystack)-1], $needle) < 0)
    {
        $probe = count($haystack);
    }
    return false;
}
?>

Now, the function returns true if it finds something and false otherwise. If a needle was found, then $probe will contain it's position. Otherwise, $probe will contain position of where the needle would be if it were there :). This is possible because we pass $probe by reference.

Example:

<?php
//ultra-simple comparator :)
function CompareNumbers($obj, $needle)
{
    return $obj - $needle;
}

//use examples
$testArr = array(10, 20, 30, 40, 50);
$res = Array_BinarySearch(30, $testArr, 'CompareNumbers', $probe);
echo (int)$res.' '.$probe.'<br />';
//output is: 1 2 - found at position 2

$res = Array_BinarySearch(45, $testArr, 'CompareNumbers', $probe);
echo (int)$res.' '.$probe.'<br />';
//output is: 0 4 - not found, but it would be at position 4 (between 40 and 45)
 
$res = Array_BinarySearch(-3, $testArr, 'CompareNumbers', $probe);
echo (int)$res.' '.$probe.'<br />';
//output is: 0 0 - not found, but it would be at position 0 (before 10)

$res = Array_BinarySearch(300, $testArr, 'CompareNumbers', $probe);
echo (int)$res.' '.$probe.'<br />';
//output is: 0 5 - not found, but it would be at position 5 (after 50; note, that count($haystack) == 5)
?>

See original greenmr's note for additional details about usage of this binary search: http://php.net/manual/en/function.array-search.php#89413
Nguyen KimKha
23-Aug-2009 05:18
You can remove some values from array, by using unset() and array_search().

<?php

$friends = array( 'Bob', 'Ann', 'Peter' ); // Two persons named 'Bob'
$find = 'Bob';
$key = array_search( $find, $friends ); // Find key of given value
if ($key != NULL || $key !== FALSE) {
    unset($friends[$key]); // remove key from array
}

// Now, $friends = array( 'Ann', 'Peter');

?>
Frank A Cefalu frankcefalu at gmail dot com
18-Aug-2009 06:22
The original function for searching a multidimensional array didn't let you filter by arraykeys.

This one is modified so you can search by array keys or not.

If you want a general search for a value and don't care which specific key to target you dont have to specify it but example.

<?php
$array = ("shoes" => array("test1"=> "123","test2"=>"1234","test3"=>"12345"),
             "shoes2"=> array("test1"=>"324","test2"=>"3515","test3"=>"123131");

array_search_value("123",$array,"test1"); // would return shoes
array_search_value("12223",$array,"test1"); // would return false;
?>
this makes it easier to validate a multi-dimensional array to make sure certain data is present.

Enjoy!

<?php

function array_search_value($needle,$haystack,$arraykey=FALSE) {
    foreach($haystack as $key=>$value) {
        $current_key=$key;

        if($arraykey){
           
            if($needle == $value[$arraykey]){
            return $value['id'];
            }
           
            if(array_search_value($needle,$value[$arraykey]) == true) {
            return $current_key;
            }
           
        }else{
           
            if($needle == $value)
            return $value;
           
            if(array_search_value($needle,$value) == true) {
                return $current_key;
            }
           
           
        }
       
       
    }
    return false;
}
?>
mikeytown2
22-Jul-2009 11:14
Made a function that I used to search the $_SERVER variable ( http://php.net/reserved.variables.server ) for matches to getcwd ( http://php.net/getcwd ) excluding some key's that I don't want. Made this function in response to this http://drupal.org/node/482000 & Mosso's server configuration. Will allow for a more generalized solution.

<?php
/**
 * Returns all key/values in array that match.
 *
 * @param $needle
 *  What your searching for
 * @param $haystack
 *  Array of values
 * @param $a_not
 *  Optional array of key names to exclude
 */
function boost_array_find($needle, $haystack, $a_not = array()) {
  $out = array();
  foreach($haystack as $key=>$value) {
    if (strpos($value, $needle) !== FALSE) {
      $good = TRUE;
      foreach($a_not as $not) {
        if (strpos($key, $not) !== FALSE) {
          $good = FALSE;
        }
      }
      if ($good) {
        $out[$key] = $value;
      }
    }
  }
  return $out;
}

// Example Usage
$document_root = str_replace("\\", '/', getcwd());
$rejects = array('SCRIPT_FILENAME');
$out = boost_array_find($document_root, $_SERVER, $rejects);
print_r($out);
?>

Which should output this on most servers.
Array
(
    [DOCUMENT_ROOT] => path/to/webroot
)

On Mosso's servers it will output this
Array
(
    [PHP_DOCUMENT_ROOT] => path/to/webroot
)
Anonymous
22-Jun-2009 09:51
Here is a cool trick:

<?php
function arr_search ( $array, $expression ) {
    $result = array();
    $expression = preg_replace ( "/([^\s]+?)(=|<|>|!)/", "\$a['$1']$2", $expression );
    foreach ( $array as $a ) if ( eval ( "return $expression;" ) ) $result[] = $a;
    return $result;
}

$data = array (
    array ( "name" => "bill", "age" => 40 ),
    array ( "name" => "john", "age" => 30 ),
    array ( "name" => "jack", "age" => 50 ),
    array ( "name" => "john", "age" => 25 )
);

print_r ( arr_search ( $data, "age>=30" ) );
print_r ( arr_search ( $data, "name=='john'" ) );
print_r ( arr_search ( $data, "age>25 and name=='john'" ) );
?>

-- results --

Array
(
    [0] => Array
        (
            [name] => bill
            [age] => 40
        )

    [1] => Array
        (
            [name] => john
            [age] => 30
        )

    [2] => Array
        (
            [name] => jack
            [age] => 50
        )

)
Array
(
    [0] => Array
        (
            [name] => john
            [age] => 30
        )

    [1] => Array
        (
            [name] => john
            [age] => 25
        )

)
Array
(
    [0] => Array
        (
            [name] => john
            [age] => 30
        )

)
buddel
08-Jun-2009 03:13
the recursive function by tony have a small bug. it failes when a key is 0

here is the corrected version of this helpful function:

<?php
function recursive_array_search($needle,$haystack) {
    foreach($haystack as $key=>$value) {
        $current_key=$key;
        if($needle===$value OR (is_array($value) && recursive_array_search($needle,$value) !== false)) {
            return $current_key;
        }
    }
    return false;
}
?>
tony dot peter at wanadoo dot fr
11-May-2009 07:53
A simple recursive array_search function :

<?php
function recursive_array_search($needle,$haystack) {
    foreach($haystack as $key=>$value) {
        $current_key=$key;
        if($needle===$value OR (is_array($value) && recursive_array_search($needle,$value))) {
            return $current_key;
        }
    }
    return false;
}
?>
n-regen
05-May-2009 05:36
If you only know a part of a value in an array and want to know the complete value, you can use the following function:
<?php
function array_find($needle, $haystack)
{
   foreach ($haystack as $item)
   {
      if (strpos($item, $needle) !== FALSE)
      {
         return $item;
         break;
      }
   }
}
?>
The function returns the complete first value of $haystack that contains $needle.
alex at softservice dot org
29-Apr-2009 04:07
Can be useful for searching in a multi-dimensional array:

<?php
function array_search_in_level($needle, $haystack, $key, &$result, $searchlevel = 0) { 
  while(is_array($haystack) && isset($haystack[key($haystack)])) {
    if($searchlevel == 0 && key($haystack) == $key && $haystack[$key] == $needle) {
      $result = $haystack;
    } elseif($searchlevel > 0) {
      array_search_in_level($needle, $haystack[key($haystack)], $key, $result, $searchlevel - 1);
    }
    next($haystack);
  }
}
?>

Examples:

1. 2-dimensional array, search by both key and value
$arr1 = array(
  1 => array('id' => 1, 'name' => 'Alex', 'gender' => 'male'),
  ...
  12 => array('id' => 12, 'name' => 'John', 'gender' => 'male'),
);


<?php array_search_in_level('John', $arr1, 'name', $result, 1); ?>

$result is:
array(
  'id' => int 12
  'name' => string 'John' (length=4)
  'gender' => string 'male' (length=4)
)

2. 3-dimensional array, search by value only:

<?php
$arr2 = array(
  1 => array('id' => 1, 'name' => 'Alex', 'gender' => 'male'),
  /* ... */
  12 => array('id' => 12, 'name' => 'John', 'gender' => 'male', 'friends' => array('Helen', 'Julia')),
);

array_search_in_level('Helen', $arr1, 0, $result, 2);
?>

$result is:
array(
  0 => string 'Helen' (length=5)
  1 => string 'Julia' (length=5)
)
office at drsoft dot com
02-Apr-2009 12:59
If you wish to search a multidimensional array by keys:

<?php
function extract_values_by_key ( $array, $needle_key, &$out = array () ) {
    foreach ( (array) $array as $key => $value ) {
        if ( ! is_array ( $value ) && $key == $needle_key ) {
            array_push ( $out, $value );
        }
        else {
            extract_values_by_key ( $value, $needle_key, &$out );
        }
    }

    return $out;
}
?>
elie at najberg dot fr
27-Mar-2009 02:04
This is how to search a part of a val in an array :

<?php
      function array_ereg_search($val, $array) {
         
          $i = 0;
          $return = array();
         
          foreach($array as $v) {
             
               if(eregi($val, $v)) $return[] = $i;
               $i++;
              
          }
         
      return $return;
     
      }
?>
greenmr
06-Mar-2009 07:02
Incidentally, the KeyCompare() function I described above is a generalized version. Since array_bsearch() doesn't care about specific return values, just greater then, less than, or equal to zero, when you are comparing two numbers you can greatly simplify the comparison function to something like:

<?php
  function KeyCompare( $obj, $needle ) {
      return $obj['my_key'] - $needle;
  }
?>
greenmr
06-Mar-2009 06:15
As others have noted, if your array is already sorted, a binary search is the way to go. When I realized PHP doesn't have a native one, I came here to see what others had done to implement this workhorse algorithm. While I appreciate those that have posted their own solutions here, none of those implementations met my needs. Also, due mainly to non-optimal loop processing, the code offered required extra post-processing to handle various ways the search loop may have exited. Proper coding of initial conditions and the main loop eliminates this extra processing.

Also, the solutions presented assumed a simple one-dimensional array and basic comparisons. I needed to search an array of user objects, with the comparison performed on one of the object attributes. C/C++ handles the need for comparison flexibility by the binary search function taking a parameter that points to a user function that performs any arbitrarily complex comparison and returns a defined result depending on the relative magnitudes of the compared entities. Since PHP allows similar function reference parameters, I realised it would be quite easy to implement this functionality.

I won't go into an explanation of the algorithm chosen for the main binary search function, google "binary searches" if you don't understand how they work. I will mention however that the ONLY way to exit the main loop in this function is on a match, or a definite fail. The loop will never terminate while the result of the search is indeterminate.

Some solutions I've seen here and elsewhere return the index of the found element on a match, and "false" on a fail. Since PHP treats a zero the same as false in expressions, and zero is a valid array index, using false to designate "not found" gives an ambiguous result in some cases. I chose to use the value -1 to signify a search failure instead.

<?php
    function array_bsearch( $needle, $haystack, $comparator ) {
        $high = Count( $haystack ) -1;
        $low = 0;
       
        while ( $high >= $low ){
            $probe = Floor( ( $high + $low ) / 2 );
            $comparison = $comparator( $haystack[$probe], $needle );
            if ( $comparison < 0 ) {
                $low = $probe +1;
            } elseif ( $comparison > 0 ) {
                $high = $probe -1;
            } else {
                return $probe;
            }
        }
     
      // ---The loop ended without a match
      return -1;
    }
?>

In this function the parameters "$needle" and "$haystack" have the same meaning as for the native array_search() PHP function. The third parameter, "$comparator" is the name of the function to use to determine if an array element matches the needle.

The array_bsearch() function is self-contained, and doesn't need modification no matter how complex the comparison needs to be. The actual comparison is performed by a purpose-written user function that takes two parameters and returns a numerical result. array_bsearch() will call this function each time it needs to compare an array element to the needle. The first parameter passed will be the element to test, and the second will the the needle value passed to array_bsearch(). Note that if you will always search for the same thing your user function can ignore the second parameter and hard-code the test on the first parameter.

The comparison user function must return a positive number if the element is greater than the needle, a negative number if it is smaller than the needle, and zero if they match.

Given a scenario where you want to find the index of a user object loaded from MySQL in an array, where the "my_key" property equals 54. Here's how you could code it using a user function and the new array_bsearch() function.

<?php
  function KeyCompare( $obj, $needle ) {
      if ( $obj['my_key'] < $needle ) {
          return -1;
      } elseif ( $obj['my_key'] > $needle ) {
          return 1;
      } else {
          return 0;
      }
  }

  $index = array_bsearch( 54, $my_array, 'KeyCompare' );
?>

Hope this is helpful to somebody out there.
info at [hidden] dot apanel dot nl
04-Feb-2009 01:27
I made this function after I didnt find a recursive array_search function with a limit and the possibility to inverse the search. So here is it:

<?php

function search_in_array ($needle, $haystack, $inverse = false, $limit = 1) {
   
    # Settings
    $path = array ();
    $count = 0;
   
    # Check if inverse
    if ($inverse == true)
        $haystack = array_reverse ($haystack, true);
       
    # Loop
    foreach ($haystack as $key => $value) {

        # Check for return
        if ($count > 0 && $count == $limit)   
            return $path;
       
        # Check for val
        if ($value === $needle) {
           
            # Add to path
            $path[] = $key;
           
            # Count
            $count++;
           
        } else if (is_array ($value)) {
           
            # Fetch subs
            $sub = search_in_array ($needle, $value, $inverse, $limit);
           
            # Check if there are subs
            if (count ($sub) > 0) {
               
                # Add to path
                $path[$key] = $sub;
               
                # Add to count
                $count += count ($sub);
            }
        }
    }
   
    return $path;
}

?>
helenadeus at gmail dot com
25-Jan-2009 09:05
I was trying to use array_search to retrieve all the values that match a given needle, but it turns out only the first match key is returned. I built this little function, which works just like array_search, but returns all the keys that match a given needle instead. The output is an array.

<?php

$haystack = array('a','b','a','b');

$needle = 'a';

print_r(array_search_all($needle, $haystack));

//Output will be
// Array
// (
//         [0]=>1
//         [1]=>3
// )

function array_search_all($needle, $haystack)
{#array_search_match($needle, $haystack) returns all the keys of the values that match $needle in $haystack

    foreach ($haystack as $k=>$v) {
   
        if($haystack[$k]==$needle){
       
           $array[] = $k;
        }
    }
    return ($array);

   
}

?>
tim_hauber at stev dot net
07-Jan-2009 04:50
A slight addition to array_search_recursive by Alireza Eliaderani below.  The original searched the entire haystack, even if it found the needle at the beginning of the haystack. I must admit I had a little trouble wrapping my head around how to break out of a loop in a recursive function.  This version returns after first occurrence of needle. changes commented.

<?php
function array_search_recursive($needle, $haystack){
    $path=array();
    foreach($haystack as $id => $val)
    {
 
         if($val === $needle) {
              $path[]=$id;
 
             break;
             # ^^this breaks out of loop when it finds needle

         } else if(is_array($val)){
             $found=array_search_recursive($needle, $val);
              if(count($found)>0){
                  $path[$id]=$found;
 
                 break;
                # ^^this breaks out of loop when recursive call found needle
 
             }     
          }
      }
      return $path;
}
?>
azaozz, gmail
21-Dec-2008 01:23
Expanding on the comment by hansen{}cointel.de:

When searching for a string and the array contains 0 (zero), the string is casted to (int) by the type-casting which is always 0 (perhaps the opposite is the proper behaviour, the array value 0 should have been casted to string). That produces unexpected results if strict comparison is not used:

<?php
$a = array(0, "str1", "str2", "str3");
echo "
str1 = ".array_search("str1", $a).",
str2 = ".array_search("str2", $a).",
str3 = ".array_search("str3", $a).",

str1 strict = ".array_search("str1", $a, true).",
str2 strict = ".array_search("str2", $a, true).",
str3 strict = ".array_search("str3", $a, true);
?>

This will return:
str1 = 0, str2 = 0, str3 = 0, str1 strict = 1, str2 strict = 2, str3 strict = 3
grezvany13 [at] notitia.nl
11-Dec-2008 11:32
This function can search for an array or string within an array.

<?php
function array_search_array($needle, $haystack){
    if(is_array($needle) && is_array($haystack)) {
        $tmp = array_diff_assoc($needle, $haystack);
        if(empty($tmp)) return true;
        foreach($haystack as $value) {
            if(is_array($value)) {
                $tmp = array_diff_assoc($needle, $value);
                if(empty($tmp)) return true;
            }
        }
    }
    if(is_array($haystack) && !is_array($needle)) {
        foreach($haystack as $value) {
            if(is_array($value)) {
                $tmp = array_diff_assoc($needle, $value);
                if(empty($tmp)) return true;
            } elseif($needle == $value) return true;
        }
    } elseif($needle == $haystack) return true;
    return false;
}
?>

It's not recursive yet, so please improve it if you feel for it ;)
Alireza Eliaderani
25-Nov-2008 06:42
this function return a multidimensional path of recursively founded $needle in a multidimensional $haystack

<?php
function array_search_recursive($needle, $haystack){
    $path=array();
    foreach($haystack as $id => $val)
    {
 
         if($val === $needle)
              $path[]=$id;
         else if(is_array($val)){
             $found=array_search_recursive($needle, $val);
              if(count($found)>0){
                  $path[$id]=$found;
              }      
          }
      }
      return $path;
}
?>
michi7x7
17-Nov-2008 07:32
If you exit the function whith "return", there is no need to break ;)

i would write it like this:

<?php

function array_search_recursive($needle, $haystack, $path=array())
{
    foreach($haystack as $id => $val)
    {
         $path2=$path;
         $path2[] = $id;
 
         if($val === $needle)
              return $path2;
         else if(is_array($val))
              if($ret = array_search_recursive($needle, $val, $path2))
                   return $ret;
      }
      return false;
}
 
$array = array(
   "a" => array(
       "b" => array("c"),
       "d" => array("e"),
       ),
    "f" => array( "g", "h"),
    );
 
var_dump(array_search_recursive("e", $array));

?>

var dump prints a array: (a, d, 0)
s0i0m at dreamevilconcepts dot com
12-Sep-2008 09:39
I wrote a better array_search_recursive function.  The other functions listed work and will evaluate to true, however, they loop through the stack even after the needle is found: so this function will take the overhead off the cpu =P

<?php

  function array_search_recursive($needle, $haystack)
  {    
    foreach ($haystack as $k => $v)
    {
      for ($i=0; $i<count($v); $i++)
        if ($v[$i] === $needle)
        {
          return true;
          break;
        }
    }
  }

  $access['admin'] = array('nick1');
  $access['voice'] = array('nick2', 'nick3');

  if (array_search_recursive('nick3', $access))
    echo 'yes';
  print_r($access);

?>

I wrote this for an access list that I have implemented into an IRC bot.  See more interesting stuff at dreamevilconcept's forum.
dcez at land dot ru
30-Apr-2008 08:15
Simple way to get variable name by using array_search function:

<?php

function varname($var){

    return (isset($var))? array_search($var, $GLOBALS) : false;

}

$boogie = 'tonight';

echo varname($boogie);

?>
andreas dot damm at maxmachine dot de
04-Apr-2008 12:07
Combining syntax of array_search() and functionality of array_keys() to get all key=>value associations of an array with the given search-value:
<?php
function array_search_values( $m_needle, $a_haystack, $b_strict = false){
    return array_intersect_key( $a_haystack, array_flip( array_keys( $a_haystack, $m_needle, $b_strict)));
}
?>

Usage:
<?php
$array1 = array( 'pre'=>'2', 1, 2, 3, '1', '2', '3', 'post'=>2);
print_r( array_search_values( '2', $array1));
print_r( array_search_values( '2', $array1, true));
print_r( array_search_values( 2, $array1, true));
?>

Will return:
array(4) {
    ["pre"] =>
    string(1) "2"
    [1] =>
    int(2)
    [4] =>
    string(1) "2"
    ["post"] =>
    int(2)
}
array(2) {
    ["pre"] =>
    string(1) "2"
    [4] =>
    string(1) "2"
}
array(2) {
    [1] =>
    int(2)
    ["post"] =>
    int(2)
}
dot dot dot dot dot alexander at gmail dot com
09-Mar-2008 04:30
This is the phpfied version of the array_search function for PHP version under 4.0.5

<?php
if(!function_exists("array_search")){
    function array_search( $needle, $haystack, $strict = FALSE ){
        if( !is_array($haystack) )return FALSE;
        foreach($haystack as $key => $val){
            if(   (  ( $strict ) && ( $needle === $val )  ) || (  ( !$strict ) && ( $needle == $val )  )   )return $key;
        }
        return FALSE;
    }/* endfunction array_search */
}/* endfunction exists array_search*/
?>
mjaning at gmail dot com
06-Feb-2008 07:42
Hi! Based on Chris function, I made another to simplify code and improve diferents features...

With this function you can:
- Filter Key and Values recursively
- Call function many times using previows result
- Final result always will be an array numeric index contenting a value or sigle array key=>value.

Thanks for PHP!

<?php
function array_search_recursive($needle, $haystack, $nodes=array())
{     
  foreach ($haystack as $key1=>$value1)
  {
    if (is_array($value1))
      $nodes = array_search_recursive($needle, $value1, $nodes);
   elseif (($key1 == $needle) or ($value1 == $needle))
      $nodes[] = array($key1=>$value1);
  }
  return $nodes;
}
   
$arg[] = array("column1"=>"Class3");
$arg[] = array("column2"=>"Class1");
$arg[] = array("column3"=>"Class3");
$arg[] = array("column4"=>"Class4");
$arg[] = array("column4"=>"Class3");
$arg[] = "column3";
   
$filter = array_search_recursive("Class3",$arg);
echo "<hr>";var_dump($filter);
   
$filter = array_search_recursive("column3",$filter);
echo "<hr>";var_dump($filter);
?>
pmmout at gmail dot com
29-Jan-2008 12:55
MultiArray find function.
After some time unsuccessful looking for algorithm to find a string in multidimensional array I wrote one:

<?php
function multidimArrayLocate($array, $text){
  foreach($array as $key => $arrayValue){
    if (is_array($arrayValue)){
      if ($key == $text) $arrayResult[$key] = $arrayValue;
      $temp[$key] = multidimArrayLocate($arrayValue, $text);
      if ($temp[$key]) $arrayResult[$key] = $temp[$key];
    }
    else{
      if ($key == $text) $arrayResult[$key] = $arrayValue;
    }
  }
  return $arrayResult;
}
?>
steev at anticulture dot co dot uk
13-Jan-2008 10:46
Just adding my two penneth to someone else's script from below. If you need to easily index your csv use this slightly modified script to parse a csv file into an associative array 2d, indexed by the first column value

<?php
function buildStock($File) {
        $handle = fopen($File, "r");
        $fields = fgetcsv($handle, 1000, ",");

        while($data = fgetcsv($handle, 1000, ",")) {
            $detail[] = $data;
        }
        echo "details";
        var_dump($detail);
        echo "<br />";

        $x = 0;
        $y = 0;

        foreach($detail as $i) {
            foreach($fields as $z) {
                //original code
                //$stock[$x][$z] = $i[$y];
                $stock[$i['0']][$z] = $i[$y];
                $y++;
            }
            $y = 0;
            $x++;
        }
        return $stock;
    }

var_dump(buildStock("conf.csv"));
?>
info at bitandbit dot com dot ar
06-Dec-2007 10:20
Hi! i modify a little the function made by Chris, i thought it might be better to return an array width the keys only, for example array(2) { [0]=>  int(36) [1]=>  int(70) }. by the way chris awesome function, THANKS!
Regards

<?php

/*Erratum from my previous post.
* Returns all the keys to all the needles found
*and put them in an array.
*/

function array_search_recursive($needle, $haystack, $a=0, $nodes_temp=array()){
global $nodes_found;
  $a++;
  foreach ($haystack as $key1=>$value1) {
    $nodes_temp[$a] = $key1;
    if (is_array($value1)){   
      array_search_recursive($needle, $value1, $a, $nodes_temp);
    }
    else if ($value1 === $needle){
      $nodes_found[] = $nodes_temp[$a];
    }
  }
  return $nodes_found;
}
?>
toni dot garcia dot gutsens at gmail dot com
02-Dec-2007 01:35
Make a recursive search on array and return the matches elements in the same structure than the original array and unset empty arrays:

<?php
function array_search_recursive($needle, $haystack,&$tree=Array(),$index=""){
        if (is_array($haystack)){
            if (count($tree)==0) $tree=array_merge(Array(),$haystack);
            foreach($haystack as $k=>$current){
                if (is_array($current)){
                    array_search_recursive($needle,$current,$tree,$index."[$k]");
                    eval("\$a=\$tree{$index}[{$k}];"); // unset all elements = empty array
                    if (count($a)==0)  //is empty?
                        eval("unset(\$tree{$index}[$k]);"); // unset array
                }
                else{
                    if ($current!=$needle){
                        eval("unset(\$tree{$index}[{$k}]);");
                    }
                }
            }
        }
        return $tree;
    }
?>
chris
21-Nov-2007 03:11
<?php

/*Another recursive array_search that works better for me
* Returns all the keys to all the needles found
*and put them in an array.
*/

function array_search_recursive($needle, $haystack, $a=0, $nodes_temp=array()){
global $nodes_found;
  $a++;
  foreach ($haystack as $key1=>$value1) {
    $nodes_temp[$a] = $key1;
    if (is_array($value1)){    
      array_search_recursive($needle, $value1, $a, $nodes_temp);
    }
    else if ($value1 === $needle){
      $nodes_found[] = $nodes_temp;
    }
  } 
  return $nodes_found;
}
?>
kermes [at] thesevens [dot] net
11-Sep-2007 10:09
A variation of previous searches that returns an array of keys that match the given value:

<?php
function array_ksearch($array, $str)
{
    $result = array();
    for($i = 0; $i < count($array); next($array), $i++)
        if(strtolower(current($array)) == strtolower($str))
            array_push($result, key($array);
   
    return $result;
}
?>

Usage would be as follows:
<?php
$testArray = array('one' => 'test1', 'two' => 'test2', 'three' => 'test1', 'four' => 'test2', 'five' => 'test1');
    print_r(array_ksearch($testArray, 'test1'));
?>
robertark at gmail dot com
02-Sep-2007 06:20
A better array_isearch would be to store all results in an array, then return the KEYS stored in $found, such as:

<?php
function array_isearch($str, $array){
  $found = array();
  foreach ($array as $k => $v)
      if (strtolower($v) == strtolower($str)) $found[] = $k;
  return $found;
}
?>

To use, simply have an array to search from then search it, for example:

<?php

function array_isearch($str, $array) {
  $found = array();
  foreach($array as $k => $v)
    if(strtolower($v) == strtolower($str)) $found[] = $k;
  return $found;
}

$stored = "these are an array";
$stored = explode(" ", $stored);

$compare = array("these", "are", "some", "results", "stored", "in", "an", "array");
foreach($stored as $store) {
  $results = array_isearch($store, $compare);
  foreach($results as $key => $result)
    echo "Key: ".$results[$key]."<br />Found: ".$compare[$result]."<br />";
}

?>

Hope this helps :-)

-Rob
php5 site builder
23-May-2007 05:14
If you encounter a situation where condition test is failing on the result of either array_search or in_array, even when using "===" and "!==", make sure to set $strict = true in your array_search() or in_array() function call.

A situation such as :

$arTemp[0] = 1;
$arTemp[1] = 0;
$arTemp[2] = 3;
$arTemp[3] = 5;
$sTempTest = 'BLAH';

$bResult = in_array($sTempTest,$arTemp);
$bResult2 = array_search($sTempTest,$arTemp);

var_dump($bResult);
var_dump($bResult2);

will result in :

boolean true
int 1

Using :

$bResult = in_array($sTempTest,$arTemp,true);
$bResult2 = array_search($sTempTest,$arTemp,true);

will yield :
boolean false
boolean false

This is necessary in any instance where you have an array value equal to the integer zero.  As soon as you put the zero in quotes or double quotes (a string), the evaluation works with in_array & array_search without the $strict parameter being set.
elvenone at gmail dot com
27-Jan-2007 01:10
<?php
                // Search an array in reverse order.
        function array_reverse_search($value, $array) {
             for($i = sizeof($array)-1; $i>=0; $i--) {
                if ($array[$i] == $value) return $i;
             }
            return -1;    
        }
?>
francois at tekwire dot net
18-Jan-2007 10:34
Please note that, in PHP5, if you search for an object in an array using the array_search() function, PHP will return the first object whose properties match, not the same class and instance as your needle. In other words, the object comparison is of type '==', not '===' (see the 'Comparing objects' page).
erick dot xavier at gmail dot com
04-Jan-2007 12:57
Modifing the "multiarray_search" to unordered Array....
<?PHP
function multiarray_search($arrayVet, $campo, $valor){
    while(isset($arrayVet[key($arrayVet)])){
        if($arrayVet[key($arrayVet)][$campo] == $valor){
            return key($arrayVet);
        }
        next($arrayVet);
    }
    return -1;
}

//I.e.:

$myArr = array(
    13 => array(
        "fruit" => "banana"
    ),
    654 => array(
        "fruit" => "apple"
    ),
    2445 => array(
        "fruit" => "nothing more"
    )
);

print(multiarray_search($myArr , "fruit", "apple"));

/*
Output:
654
*/

//and

print(multiarray_search($myArr , "fruit", "orange"));

/*
Output:
-1
*/
?>
otto at twbc dot net
14-Dec-2006 07:06
Unlimited depth array regular expression search, I found it useful, perhaps someone else will too. Searches on the array values only. Key search could be easily added.

<?php
function Array_Search_Preg( $find, $in_array, $keys_found=Array() )
{
    if( is_array( $in_array ) )
    {
        foreach( $in_array as $key=> $val )
        {
            if( is_array( $val ) ) $this->Array_Search_Preg( $find, $val, $keys_found );
            else
            {
                if( preg_match( '/'. $find .'/', $val ) ) $keys_found[] = $key;
            }
        }
        return $keys_found;
    }
    return false;
}
?>
evert_18 at hotmail dot com
13-Nov-2006 02:18
This function can search in multidimensional arrays, no mather how multidimensional the array is!

<?php
function array_search(&$array,$needle)
{
    foreach($array as $key => $value)
    {
        if($value == $needle || $key == $needle)
            return(true);
        else
            if(is_array($value))
                $this->search($value,$needle);
            else
                return(false);
    }
}
?>
dmitry dot polushkin at gmail dot com
22-Oct-2006 05:03
To get the key of the found search value, use:
<?php
$a = array('a', 'b', 'c');
echo array_search(array_search('c', $a), array_keys($a));
?>
jupiter at nospam dot com
29-Sep-2006 09:25
Checks that array value STARTS with the string(needle), while other functions require an exact match OR the needle can be anywhere within.  This function can be manipulated to END with the needle if needed
<?php
// returns first key of haystackarray which array valuestring starts with needlestring, is case-sensitive
function arrayHaystackStartsWithNeedleString($haystackarray, $needlestring) {
    if (is_array($haystackarray)) {  // confirms array
        $needlelength = strlen($needlestring);  // length of string needle
        foreach ($haystackarray as $arraykey => $arrayvalue) {  // gets array value
            $arraypart = substr($arrayvalue, 0, $needlelength);  // first characters of array value
            if ($needlestring == $arraypart) {  // did we find a match
                return $arraykey;  // return will stop loop
            }  // end match conditional
        }  // end loop
    }  // end array check
    return false;  // no matches found if this far
}
?>
I haven't speed tested this, but it should be pretty quick.
Digitally Designed dot co dot uk
28-Sep-2006 09:48
My Function to search a Multidimensional array.

Pass in :

$theNeedle as what you want to find.
$theHaystack as the array
$keyToSearch as what key in the array you want to find the value in.

<?php   

function myMulti_Array_Search($theNeedle, $theHaystack, $keyToSearch)
        {
        foreach($theHaystack as $theKey => $theValue)
            {
            $intCurrentKey = $theKey;   
               
            if($theValue[$keyToSearch] == $theNeedle)
                {
   
                return $intCurrentKey ;
                }
            else
                {
                return 0;
                }
            }
        }

?>
lars-magne
22-Sep-2006 12:19
Further comments on the multidimensional array searches given earlier:

I needed an extended search function which could search in both keys and values in any # dimension array and return all results. Each result contains key/value hit, type (key or value), key path and value (in case result is a key).

<?php

function array_search_ext($arr, $search, $exact = true, $trav_keys = null)
{
  if(!is_array($arr) || !$search || ($trav_keys && !is_array($trav_keys))) return false;
  $res_arr = array();
  foreach($arr as $key => $val)
  {
    $used_keys = $trav_keys ? array_merge($trav_keys, array($key)) : array($key);
    if(($key === $search) || (!$exact && (strpos(strtolower($key), strtolower($search)) !== false))) $res_arr[] = array('type' => "key", 'hit' => $key, 'keys' => $used_keys, 'val' => $val);
    if(is_array($val) && ($children_res = array_search_ext($val, $search, $exact, $used_keys))) $res_arr = array_merge($res_arr, $children_res);
    else if(($val === $search) || (!$exact && (strpos(strtolower($val), strtolower($search)) !== false))) $res_arr[] = array('type' => "val", 'hit' => $val, 'keys' => $used_keys, 'val' => $val);
  }
  return $res_arr ? $res_arr : false;
}

// I.e.:
$haystack[754] = "Norwegian";
$haystack[28]['details']['Norway'] = "Oslo";
$needle = "Norw";

if($results = array_search_ext($haystack, $needle, false))
  foreach($results as $res)
    echo "Found '$needle' in $res[type] '$res[hit]', using key(s) '".implode("', '", $res['keys'])."'. (Value: $res[val])<br />\n";

/* Printed result will be:
Found 'Norw' in val 'Norwegian', using key(s) '754'. (Value: Norwegian)
Found 'Norw' in key 'Norway', using key(s) '28', 'details', 'Norway'. (Value: Oslo)
*/

?>
mark dot php at mhudson dot net
12-Sep-2006 12:49
I was going to complain bitterly about array_search() using zero-based indexes, but then I realized I should be using in_array() instead.

// if ( isset( $_GET['table'] ) and array_search( $_GET['table'], $valid_tables) ) {  // BAD: fails on first[0] element
// if ( isset( $_GET['table'] ) and ( FALSE !== array_search( $_GET['table'], $valid_tables) ) ) { OK: but wasteful and convoluted
   if ( isset( $_GET['table'] ) and in_array( $_GET['table'], $valid_tables) ) { // BETTER

The essence is this: if you really want to know the location of an element in an array, then use array_search, else if you only want to know whether that element exists, then use in_array()
ob at babcom dot biz
28-Aug-2006 09:55
This function is based on the function in comment "array_search" from July 26th 2006.

I added the possibility of defining the key which $Needle shall be searched for.

<?php
// search haystack for needle and return an array of the key path,
// FALSE otherwise.
// if NeedleKey is given, return only for this key
// mixed ArraySearchRecursive(mixed Needle,array Haystack
//                            [,NeedleKey[,bool Strict[,array Path]]])

function ArraySearchRecursive($Needle,$Haystack,$NeedleKey="",
                              $Strict=false,$Path=array()) {
  if(!is_array($Haystack))
    return false;
  foreach($Haystack as $Key => $Val) {
    if(is_array($Val)&&
       $SubPath=ArraySearchRecursive($Needle,$Val,$NeedleKey,
                                     $Strict,$Path)) {
      $Path=array_merge($Path,Array($Key),$SubPath);
      return $Path;
    }
    elseif((!$Strict&&$Val==$Needle&&
            $Key==(strlen($NeedleKey)>0?$NeedleKey:$Key))||
            ($Strict&&$Val===$Needle&&
             $Key==(strlen($NeedleKey)>0?$NeedleKey:$Key))) {
      $Path[]=$Key;
      return $Path;
    }
  }
  return false;
}
?>

Remove unnecessary new lines. I had to add them because of too long lines.
26-Jul-2006 02:19
<?php
/**
 * Searches haystack for needle and returns an array of the key path if it is found in the (multidimensional) array, FALSE otherwise.
 *
 * mixed array_searchRecursive ( mixed needle, array haystack [, bool strict[, array path]] )
 */

function array_searchRecursive( $needle, $haystack, $strict=false, $path=array() )
{
    if( !is_array($haystack) ) {
        return false;
    }

    foreach( $haystack as $key => $val ) {
        if( is_array($val) && $subPath = array_searchRecursive($needle, $val, $strict, $path) ) {
            $path = array_merge($path, array($key), $subPath);
            return $path;
        } elseif( (!$strict && $val == $needle) || ($strict && $val === $needle) ) {
            $path[] = $key;
            return $path;
        }
    }
    return false;
}
?>
gullevek at gullevek dot org
19-Apr-2006 05:31
There were two previous entries for having a recursive search. The first one only searched for values, second one for values with an optional key.

But both of those stopped after they found an entry. I needed, that it searches recursive, with optional key and returns me all matches found in the array.

So I wrote this function:

needle is the value you search, haystack is the array of course, key is the optional key in the array where the needle should be. path should be never set on intial call. its an internal used variable.

It returns an array $path with the array entry 'found' where you can find all found groups. In these groups you have the array which holds the keys to find the data.

I hope this helps some of you.

<?php
    function array_search_recursive_all($needle, $haystack, $key, $path = NULL)
    {
        if (!$path['level'])
            $path['level'] = 0;
        if (!$path['work'])
            $path['work'] = array();
        if (!is_array($haystack))
            $haystack = array();

        // go through the array,
        foreach ($haystack as $_key => $_value)
        {
            // only value matches
            if (is_scalar($_value) && $_value == $needle && !$key)
            {
                $path['work'][$path['level']] = $_key;
                $path['found'][] = $path['work'];
            }
            // key and value matches
            elseif (is_scalar($_value) && $_value == $needle && $_key == $key)
            {
                $path['work'][$path['level']] = $_key;
                $path['found'][] = $path['work'];
            }
            elseif (is_array($_value))
            {
                // add position to working
                $path['work'][$path['level']] = $_key;
                // we will up a level
                $path['level'] += 1;
                // call recursive
                $path = array_search_recursive_all($needle, $_value, $key, $path);
            }
        }
        // cut all that is >= level
        array_splice($path['work'], $path['level']);
        // step back a level
        $path['level'] -= 1;
        return $path;
    }
?>

If you call it with this:

<?php
    $right_side = array ('foo' => 'alpha', 'bar' => 'beta', 'delta' => 'gamma', 'gamma' => 'delta');
    $value = 'beta';
    $key = 'bar';
    $pos = array_search_recursive_all($value, $right_side, $key);
?>

You will find in $pos this data

Array
(
    [level] => -1
    [work] => Array
        (
        )

    [found] => Array
        (
            [0] => Array
                (
                    [0] => bar
                )

        )

)
RichGC
20-Mar-2006 01:54
To expand on previous comments, here are some examples of
where using array_search within an IF statement can go
wrong when you want to use the array key thats returned.

Take the following two arrays you wish to search:

<?php
$fruit_array = array("apple", "pear", "orange");
$fruit_array = array("a" => "apple", "b" => "pear", "c" => "orange");

if ($i = array_search("apple", $fruit_array))
//PROBLEM: the first array returns a key of 0 and IF treats it as FALSE

if (is_numeric($i = array_search("apple", $fruit_array)))
//PROBLEM: works on numeric keys of the first array but fails on the second

if ($i = is_numeric(array_search("apple", $fruit_array)))
//PROBLEM: using the above in the wrong order causes $i to always equal 1

if ($i = array_search("apple", $fruit_array) !== FALSE)
//PROBLEM: explicit with no extra brackets causes $i to always equal 1

if (($i = array_search("apple", $fruit_array)) !== FALSE)
//YES: works on both arrays returning their keys
?>
congaz at yahoo dot dk
10-Mar-2006 03:38
Search a multi-dimensional array on keys!
-------------------------------------------

I needed to search dynamically in a multi-dimen array on keys. I came up with this little neat function. It is so amazingly simple, that I actually didn't think it would work - but it does...

mixed array_searchMultiOnKeys(array, array);

<?php
function array_searchMultiOnKeys($multiArray, $searchKeysArray) {
    // Iterate through searchKeys, making $multiArray smaller and smaller.
    foreach ($searchKeysArray as $keySearch) {
        $multiArray = $multiArray[$keySearch];
        $result = $multiArray;
    }
   
    // Check $result.
    if (is_array($multiArray)) {
        // An array was found at the end of the search. Return true.
        $result = true;
    }
    else if ($result == '') {
        // There was nothing found at the end of the search. Return false.
        $result = false;
    }

    return $result;
// End of function,
}

// --- Test array_searchMultiOnKeys ---
$multiArray['webpages']['downloads']['music'] = 1;
$multiArray['webpages']['downloads']['pressmaterial'] = 5;
$multiArray['webpages']['links'] = 7;

array_searchMultiOnKeys($multiArray, array('webpages', 'links')); // returns 7.
array_searchMultiOnKeys($multiArray, array('webpages', 'downloads')); // returns true.
array_searchMultiOnKeys($multiArray, array('webpages', 'downloads', 'software')); // returns false.

?>

$multiArray / $searchKeysArray can be any size.

Happy hacking...
chappy at citromail dot hu
11-Feb-2006 08:26
If you're searching for strings and you need a case-insensetive script, there's one:

<?php
function array_lsearch($str,$array){
    $found=array();
    foreach($array as $k=>$v){
        if(strtolower($v)==strtolower($str)){
            $found[]=$v;
        }
    }
    $f=count($found);
    if($f===0)return false;elseif($f===1)return $found[0];else return $found;
}
?>

It returns the original string, not the lower. Also good if use strtoupper().
hansen{�}cointel.de
09-Feb-2006 02:26
may be good to take note of PHP's mind-boggling 'fuzzy' (vulgo "magic type-casting") comparison features not only in using the results, but also in the search, too:
<?php
$a=array("a","b",0,"c","d");
echo "a: ".array_search("a",$a);
echo "b: ".array_search("b",$a);
echo "c: ".array_search("c",$a);
echo "d: ".array_search("d",$a);
echo "0: ".array_search("0",$a);
echo "x: ".array_search("x",$a);
echo "1: ".array_search("1",$a);
?>
will result in:
a: 0, b: 1, c: 2, d: 2, 0: 2, x: 2, 1: false

as from "c" on, the first match found in $a is "0", as any string compared to an int is automatically cast to (int)0.
ludwig_von_rocht at yahoo dot com
23-Nov-2005 11:50
Here's a little function I wrote to find the key of the LAST occurrance of something in an array.

<?php
if(!function_exists('array_rsearch')){
    function array_rsearch($search, $array, $strict = false){
        $array = array_reverse($array, true);
        foreach($array as $key => $value){
            if($strict){
                if($value === $search)
                    return $key;
            } else {
                if(strpos($value, $search))
                    return $key;
            }
        }
        return false;
    }
}
?>
mark meves
22-Nov-2005 11:13
A quick-and-dirty array_search_all() that i used for a small
dup-checking routine. 

there are many, many ways to do something like this, not
the worst of which would be to use a relational database
for a dataset any larger than this ;)

-mark meves

<?php
/**
@return array of zero or more keys form $aHaystack whose
    values match $mScalarNeedle using a
    '==', (ie not strict) comparison
*/
function array_search_all($mScalarNeedle,$aHaystack){
    return array_keys( array_filter($aHaystack,
        create_function('$v','return $v == \''.addslashes($mScalarNeedle).'\';')
    ));
}

/*
test it:
*/
$aNicknames = array('jimmy'=>1,'james'=>1,'jim'=>1,
                    'billy'=>2,'william'=>2,'bill'=>2);
foreach(array('jim','bill') as $sName){
    echo "variations for \"$sName\" :(".
        implode(', ', array_search_all($aNicknames[$sName],$aNicknames)).
    ")\n";
}
/* outputs:
variations for "jim" are (jimmy, james, jim)
variations for "bill" are (billy, william, bill)
*/
?>
pornsak at neowin dot net
21-Nov-2004 03:28
This is a modified version of Mark Meves's wonderful function. I needed something that would be able to let me force search the key name where the needle should be found.

<?php
function array_search_recursive($needle, $haystack, $key_lookin="") {

$path = NULL;

    if (!empty($key_lookin) && array_key_exists($key_lookin, $haystack) && $needle === $haystack[$key_lookin]) {
    $path[] = $key_lookin;

    } else {

        foreach($haystack as $key => $val) {
            if (is_scalar($val) && $val === $needle && empty($key_lookin)) {
            $path[] = $key;
            break;
            }       

            elseif (is_array($val) && $path = array_search_recursive($needle, $val, $key_lookin)) {
            array_unshift($path, $key);
            break;
            }
        }
    }

return $path;
}
?>
scripts at webfire dot org
03-Nov-2004 05:13
* Multi-Dimensional Array Search *
If you're searching for a function to search in Multi-Arrays,
this is probably usefull for you.
-------------------------------------------------------------

<?php
function multi_array_search($search_value, $the_array)
{
    if (is_array($the_array))
    {
        foreach ($the_array as $key => $value)
        {
            $result = multi_array_search($search_value, $value);
            if (is_array($result))
            {
                $return = $result;
                array_unshift($return, $key);
                return $return;
            }
            elseif ($result == true)
            {
                $return[] = $key;
                return $return;
            }
        }
        return false;
    }
    else
    {
        if ($search_value == $the_array)
        {
            return true;
        }
        else return false;
    }
}
?>

-------------------------------------------------------------
It will return an Array with the keys from the original array
where your search-string was found or false. e.g.:
-------------------------------------------------------------

<?php
$foo[1]['a']['xx'] = 'bar 1';
$foo[1]['b']['xx'] = 'bar 2';
$foo[2]['a']['bb'] = 'bar 3';
$foo[2]['a']['yy'] = 'bar 4';
$foo['info'][1] = 'bar 5';

$result = multi_array_search('bar 3', $foo);
print_r($result);
?>

-------------------------------------------------------------

Output:

Array
(
      [0] => 2
      [1] => a
      [2] => bb
)

-------------------------------------------------------------

I hope you like it ;)
greetz Udo
�
F�lix Cloutier <felixcca at yahoo dot ca>
22-Oct-2004 12:01
There is no function to count the occurences of needle in haystack, so I made my own one...

<?php
function array_match($needle, $haystack)
{
    if( !is_array($haystack) ) return false;
   
    $i = 0;
    while( (in_array( $needle, $haystack )) != FALSE )
    {
        $i++;
        $haystack[array_search($needle, $haystack)] = md5($needle);
        reset($haystack);
    }
   
    return $i;
}
?>

I know it's a bit crappy, but don't ask me too much, I'm still only 13... ;)
Wouter van Vliet <me at woutervanvliet dot nl>
19-Aug-2004 03:55
I was looking for a way to use a user defined function for array_search and eventually came up writing my own. Which was remarkably simple :P. Let me share this:

<?php
function array_usearch($cb, $ndl, $hs, $strict=false) {
    if (!is_array($hs)) user_error('Third argument to array_usearch is expected to be an array, '.gettype($hs).' given', E_USER_ERROR);
    foreach($hs as $key=>$value) if (call_user_func_array($cb, Array($ndl, $value, $key, $strict))) return $key;
};
?>

I'm not sure if I'm following correct conventions to specify the callback as the first argument, but it seemed most logical to me to not interrupt the order of the other four arguments (mixed needle, array haystack, boole strict).

[so far for my first post to the php notes]
andrey at php dot net
07-Aug-2004 11:56
array_search() has kind of hidden behaviour which comes from the way PHP compares values of different types (PHP is a type-loose language) - so called type juggling.
for example :
<?php
$a=array(0,0,5,0,0);
var_dump(array_search(true, $a));
?>
In the array there are only integers but we give a boolean value TRUE for be the needle. The result is that array_search() returns the first non-negative value in the haystack array. The same way if we pass FALSE it will return the first value that compared with FALSE gives TRUE - for example NULL
<?php
$a=array(1,NULL,5,0,0);
var_dump(array_search(FALSE, $a));
?>
Returns:
int(1)  <-- the key of the NULL value
softexpert [at] libertysurf [dot] fr
03-May-2004 06:51
I use this for searching for a value in a bidimensional array .

<?php
function SearchBiDimArray(&$theArray, $dimNo, $searchValue, $returnIndex = true){
    if(is_array($theArray)){
        $keys = array_keys($theArray[0]);
        $key = $keys[$dimNo];
        $elcount = count($theArray);

        for($i=0; $i < $elcount; $i++){
            if($theArray[$i][$key] === $searchValue){
                if ($returnIndex){
                    return $i;
                }
                else{
                    return $theArray[$i];
                }
            }
        }

    }
    else{
        return array_search($searchValue, $theArray);
    }
}

$theArray = array();
$theArray[0]['firstproperty'] = 'avalue1';
$theArray[0]['secondproperty'] = 'anothervalue1';

$theArray[1]['firstproperty'] = 'avalue2';
$theArray[1]['secondproperty'] = 'anothervalue2';

$theArray[2]['firstproperty'] = 'avalue3';
$theArray[2]['secondproperty'] = 'anothervalue3';

print SearchBiDimArray($theArray, 1, 'anothervalue2', true);
// result is 1

print SearchBiDimArray($theArray, 1, 'anothervalue2', true);
// result is
//Array
//(
//    [firstproperty] => avalue2
//    [secondproperty] => anothervalue2
//)

?>
dcsoboda at oakland dot edu
28-Jan-2004 09:13
I've noticed problems with array_search() when it's handling extremely large arrays.

In one example, I had a 2000 slot array with a 128 char string in each slot, and was searching for a 128 char string within the array.

It regularly returned the wrong key. I even had it print the search string, along with the found key in the array, as a  test, and it would print obvious different strings.

The problem was alleviated when I ran gzcompress() on each array slot (and on my search string, obviously). In this case, no strings were longer than 67 bytes. It performed far faster and had no accuracy problems.
dennis dot decoene at removthis dot moveit dot be
17-Jan-2004 06:41
It has been said before: array_search is VERY slow. Everyone knows binary search is fast by design. Here is an implementation.

<?php
$arr=array(1,3,5,7,9,10,11,13);
$searchfor = 6;
echo binsearch($searchfor, $arr);

/**
 * @return integer
 * @param var $needle
 * @param array $haystack
 * @desc Feed a sorted array to $haystack and a value to search for to $needle.
             It will return false if not found or the index where it was found.
             This function is superfast. Try an array with 50.000 elements and search for something,
             you will be amazed.
*/
function binsearch($needle, $haystack)
{
    $high = count($haystack);
    $low = 0;
   
    while ($high - $low > 1){
        $probe = ($high + $low) / 2;
        if ($haystack[$probe] < $needle){
            $low = $probe;
        }else{
            $high = $probe;
        }
    }

    if ($high == count($haystack) || $haystack[$high] != $needle) {
        return false;
    }else {
        return $high;
    }
}
?>
jwhite at ytztech dot com
19-Nov-2003 02:59
Searching arrays is a very slow process.  I've tried to use as many strings as I can for where an array is called, if possible. Here's a quick test to show the (eye-popping) difference between searching for a match between strings and arrays:

<?php

  $test_string = '';
  for ($i=1; $i <= 500000; $i++) {
    $test_string .= '['.$i.']';
  }

  $test_array = array();
  for ($i=1; $i <= 5000; $i++) {
    $test_array[] = $i;
  }

  $time_str = getmicrotime();
  for ($i=1; $i <= 500000; $i++) {
    strstr($i,$test_string);
  }
  $time_str = getmicrotime() - $time_str;

  $time_array = getmicrotime();
  for ($i=1; $i <= 5000; $i++) {
    array_search($i,$test_array);
  }
  $time_array = getmicrotime() - $time_array;

  echo "<H1>Test Results</H1>\r\n";
  echo "<P>String Test:&nbsp; $time_str seconds.</P>\r\n";
  echo "<P>Array Test:&nbsp; $time_array seconds.</P>\r\n";

   function getmicrotime(){
     list($usec, $sec) = explode(" ",microtime());
     return ((float)$usec + (float)$sec);
   }

?>

This code block takes some time to get going (because of the number of strings to place into memory), the results, even on modest hardware are staggering.  Comparing 500000 strstr() operations to 5000 array_search() operations on a P3-800 with 512 MB of RAM got the following output:

[H1]Test Results[/H1]
[P]String Test: 3.09137701988 seconds.[/P]
[P]Array Test:  4.23609495163 seconds.[/P]

The getmicrotime() function came from the note on microtime(), so that's not mine...credit to "daniel141 at yahoo dot com".

STRINGS RULE!
--
Justin White
YTZ Technical Services, LLC
php at celerondude dot com
12-Nov-2003 11:07
I think array_search uses serial search because they binary search function i wrote here seems to do a better job for records that are not always at the beginning of the array.

Here it is

<?php
function binarySearch ( $a, $t, $l, $r )
{
    if($t<$a[$l]||$t>$a[$r])return NULL;
    while ( $l < $r )
    {
        $m=intval($l+$r)/2;
        if($a[$m]==$t)return $m;
        elseif($t<$a[$m])$r=$m-1;
        elseif($t>$a[$m])$l = $m + 1;
    }
    if($t==$a[$r])
    return $r;
    return NULL;
}
?>

usage:
binarySearch ( array, target, left range, right range );

if your array is a multidimensional array, simply change the comparison method. :)
cue at openxbox dot com
10-Jun-2003 02:50
If you are using the result of array_search in a condition statement, make sure you use the === operator instead of == to test whether or not it found a match.  Otherwise, searching through an array with numeric indicies will result in index 0 always getting evaluated as false/null.  This nuance cost me a lot of time and sanity, so I hope this helps someone.  In case you don't know what I'm talking about, here's an example:

<?php
$code = array("a", "b", "a", "c", "a", "b", "b"); // infamous abacabb mortal kombat code :-P

// this is WRONG
while (($key = array_search("a", $code)) != NULL)
{
 // infinite loop, regardless of the unset
 unset($code[$key]);
}

// this is _RIGHT_
while (($key = array_search("a", $code)) !== NULL)
{
 // loop will terminate
 unset($code[$key]);
}
?>
richard at richard-sumilang dot com
16-Apr-2003 10:59
<?php
/**
     *    Search an array recursivly
     *
     *    This function will search an array recursivly
     *    till it finds what it is looking for. An array
     *    within an array within an array within array
     *    is all good :-)
     *
     *    @author        Richard Sumilang    <[email protected]>
     *    @param        string    $needle        What are you searching for?
     *    @param        array    $haystack    What you want to search in
     *    @return        boolean
     *    @access        public
     */
    function array_search_r($needle, $haystack){
        foreach($haystack as $value){
            if(is_array($value))
                $match=array_search_r($needle, $value);
            if($value==$needle)
                $match=1;
            if($match)
                return 1;
        }
        return 0;
    }
?>
Darkvie
16-Mar-2003 12:53
I wanted to search a  multidimensional array for a value & assign another element of array CONTAINING the searched value.

In the array I am using ($Projects), each item in $Projects contains a "Text_ID" & "Text_Value" field from a database result. I want to search for a "Text_ID" value (456 in this example)  & get it's "Text_Value" value assigned to a variable called $Text_Value.

Here's how I did it:
============================================

<?PHP
//Array I am going to look in:
$Projects[0] = array(123, "Text 1");  
$Projects[1] = array(456, "Text 2");  
$Projects[2] = array(789, "Text 3");  

// This loop goes through every element in $Projects
foreach ($Projects as $key => $ArrayRow)
{   
// Now: $ArrayRow[0] = $Projects[x][0] and $ArrayRow[1] = $Projects[x][1]

// Look for the value "456".  Assign to variable & stop looking if found.
if ($ArrayRow[0] == "456")  {$Text_Value= $ArrayRow[1]; break; }
}
?>

============================================
Hope this helps someone.
-Darkive
retestro_REMOVE at SPAM_esperanto dot org dot il
01-Mar-2003 04:46
If you're interested in finding a line in a file, after you read it into an array using file(), you can not use array_search since the match should be exact, and lines have line-endings ('\n', '\r' or '\n\r') - or else you know for sure what your lines contain physically.

The solution is to traverse the whole array, trim() each entry and then use array_search() - or - use something like the following small function I wrote for myself:

<?php
function search_array($needle, $haystack)
{
        if (!is_array($haystack) || !is_string($needle))
                return false;  // not valid argument types

        @reset($haystack);

        while (list ($key, $value) = each($haystack)) {
                $value = trim($value);  // remove spaces from the beginning and the end
                if ($value === $needle)
                        return $key;  // $needle was found, return the key
        }

        return false;  // no $needle was found in $haystack
}
?>

-----------------------------
Notes:
1. you should check the return value with === since 0 as a key equals to 'false'.
    i.e. if (search_array('my_line', $my_array) === false)  { ... }
2. I have no need in whitespace at the beginning of the line, therefore I use trim(). If it's important to you, use rtrim() or chop() instead.

-
- Sergey.
saltymeat at hotmail dot com
24-Jun-2002 09:03
Here's how you can use array_search() to replace all occurances of a value in an array:

<?php
function array_replace($a, $tofind, $toreplace)
{
    $i = array_search($tofind, $a);
    if ($i === false)
    {
        return $a;
    }
    else
    {
        $a[$i] = $toreplace;
        return array_replace($a, $tofind, $toreplace);
    }
}
?>

Usage:
$a = array(1,2,3);
$a = array_replace($a, 1, 4);
echo $a[0]; // Outputs 4
dakota at dir dot bg
29-May-2002 11:44
For versions later than 4.2.0, the check  isset($key) won't work properly because the function now returns false, which "isset". This change is missing in the Change Log!

So the right way to use the function is:

<?php
$key = array_search($needle, $array);
if ($key!==null&&$key!==false) {
  ...
}
?>

This example will work in both older and newer to 4.2.0 versions.

P.S.: My previous post where isset() is used won't work in newer versions.
swbrown at ucsd dot edu
02-May-2002 08:18
Be absolutely sure to check that your code that uses array_search now checks for 'false' too if you upgrade to PHP 4.2.0!

I was using array_search in my page authentication routines and this change had the fun side-effect of causing my code to always think a user had full permissions!  It was letting anyone click through to our installation of phpMyAdmin.  Not good indeed!
saconner at iastate dot edu
04-Feb-2002 09:16
In PHP versions before 4.2.0 needle was not allowed to be an array.  (funnily enough, at time of posting this note, we're still at ver 4.1.1 )
add a note add a note

array_shift> <array_reverse
Last updated: Fri, 11 Jun 2010
 
 
show source | credits | stats | sitemap | contact | advertising | mirror sites