PHP Doku:: Durchsucht ein Array nach einem Wert und liefert bei Erfolg den zugehörigen Schlüssel - function.array-search.html

Verlauf / Chronik / History: (1) anzeigen

Sie sind hier:
Doku-StartseitePHP-HandbuchFunktionsreferenzVariablen- und typbezogene ErweiterungenArraysArray Funktionenarray_search

Ein Service von Reinhard Neidl - Webprogrammierung.

Array Funktionen

<<array_reverse

array_shift>>


86 BenutzerBeiträge:
- Beiträge aktualisieren...
user at www dot mp3s dot pl
28.12.2010 22:25
for case insensitive array_search you could use:

<?php
function array_search_i($str,$array){
    foreach(
$array as $key => $value) {
        if(
stristr($str,$value)) return $key;
    }
    return
false;
}
?>
manchimen [at) yahoo [dot) com
1.11.2010 11:18
Hey all - I needed a function to search for an array in a multi-dimensional array, but only the keys I wanted, not all keys. Hee if my function:

<?php
function my_array_search($needle, $haystack) {
        if (empty(
$needle) || empty($haystack)) {
            return
false;
        }
       
        foreach (
$haystack as $key => $value) {
           
$exists = 0;
            foreach (
$needle as $nkey => $nvalue) {
                if (!empty(
$value[$nkey]) && $value[$nkey] == $nvalue) {
                   
$exists = 1;
                } else {
                   
$exists = 0;
                }
            }
            if (
$exists) return $key;
        }
       
        return
false;
    }
?>

Examples:
<?php
$needle
= array('date_start' => '27-10-2010', 'date_end' => '29-10-2010');

$haystack = array();
$haystack[] = array('date_start' => '25-10-2010', 'date_end' => '26-10-2010', 'promos' => array('test', 'test1');
$haystack[] = array('date_start' => '27-10-2010', 'date_end' => '28-10-2010', 'promos' => array('test2', 'test3');
$haystack[] = array('date_start' => '27-10-2010', 'date_end' => '29-10-2010', 'promos' => array('test4', 'test5');

$key = my_array_search($needle, $haystack);
// will output (bool)false for not found or (int)key_no with the key number
// this example outputs (int)2
var_dump($key);
?>

I hope this function will help someone!
GuardianGI
23.09.2010 9:42
I needed to check an array for a value but the value only had to match part of a string in the array value so i wrote this little function hope it helps someone out (also some documentation of what used to test if there already was such a function 'couse i was hoping array_search was this.

<?php
function my_array_search($needle = null, $haystack_array = null, $skip = 0)
{
    if(
$needle == null || $haystack_array == null)
        die(
'$needle and $haystack_array are mandatory for functie my_array_search()');
    foreach(
$haystack_array as $key => $eval)
    {
        if(
$skip != 0)$eval = substr($eval, $skip);
        if(
stristr($eval, $needle) !== false) return true;
    }
    return
false;
}

$arr = array('foo', 'bar');

echo
'using in_array<br />';
if(
in_array('ar', $arr) === true)echo 'ar found<br />';
if(
in_array('bar', $arr) === true)echo 'bar found<br />';

echo
'using array_search<br />';
if(
array_search('ar', $arr) !== false)echo 'ar found<br />';
if(
array_search('bar', $arr) !== false)echo 'bar found<br />';

echo
'using my_array_search<br />';
if(
my_array_search('ar', $arr) !== false)echo 'ar found<br />';
if(
my_array_search('bar', $arr) !== false)echo 'bar found<br />';
?>

returns:

using in_array
bar found
using array_search
bar found
using my_array_search
ar found
bar found
j dot vd dot merwe at enovision dot net
22.09.2010 23:42
The getParentStack is also working if you work with JSON records that are encoded. Following sample:

$in = '{"total":"2","records": [{"id":"25"},{"id":"32"}]}'; // string!!!
$json = json_decode( $in, true ); //don't forget the true here

$s = getParentStack(32, $json['records']) ;

then test this with:

if ($s != false)     // then it is found, don't test true here!!!

or test direct with:

if ( getParentStack(32, $json['records']) != false )

It works great with my JSON's thanks Robert Gonzalez
robert at robert-gonzalez dot com
22.09.2010 21:15
I needed a way to find the parent hierarchy of a multidimensional array. Being the rogue that I am, I got to coding before searching the manual and came up with two little functions that will return a parent stack for a first find and a complete parent stack, similar in nature to the solution presented by jette at nerdgirl dot dk without all the extra stuff or use of eval(). ;)

<?php
/**
 * Gets the parent stack of a string array element if it is found within the
 * parent array
 *
 * This will not search objects within an array, though I suspect you could
 * tweak it easily enough to do that
 *
 * @param string $child The string array element to search for
 * @param array $stack The stack to search within for the child
 * @return array An array containing the parent stack for the child if found,
 *               false otherwise
 */
function getParentStack($child, $stack) {
    foreach (
$stack as $k => $v) {
        if (
is_array($v)) {
           
// If the current element of the array is an array, recurse it and capture the return
           
$return = getParentStack($child, $v);
           
           
// If the return is an array, stack it and return it
           
if (is_array($return)) {
                return array(
$k => $return);
            }
        } else {
           
// Since we are not on an array, compare directly
           
if ($v == $child) {
               
// And if we match, stack it and return it
               
return array($k => $child);
            }
        }
    }
   
   
// Return false since there was nothing found
   
return false;
}

/**
 * Gets the complete parent stack of a string array element if it is found
 * within the parent array
 *
 * This will not search objects within an array, though I suspect you could
 * tweak it easily enough to do that
 *
 * @param string $child The string array element to search for
 * @param array $stack The stack to search within for the child
 * @return array An array containing the parent stack for the child if found,
 *               false otherwise
 */
function getParentStackComplete($child, $stack) {
   
$return = array();
    foreach (
$stack as $k => $v) {
        if (
is_array($v)) {
           
// If the current element of the array is an array, recurse it
            // and capture the return stack
           
$stack = getParentStackComplete($child, $v);
           
           
// If the return stack is an array, add it to the return
           
if (is_array($stack) && !empty($stack)) {
               
$return[$k] = $stack;
            }
        } else {
           
// Since we are not on an array, compare directly
           
if ($v == $child) {
               
// And if we match, stack it and return it
               
$return[$k] = $child;
            }
        }
    }
   
   
// Return the stack
   
return empty($return) ? false: $return;
}

// TESTING
$array = array(
   
'balloon' => array(
       
'red' => array(1 => 'Love', 'Valentine', 'Heart',),
       
'green' => array(1 => 'Summertime', 'Hope',),
    ),
   
'ribbon' => array(
       
'yellow' => array(2 => 'Welcome',),
       
'red' => array(3 => 'Love', 'Love',),
    ),
);

$s = getParentStack('Love', $array);
$c = getParentStackComplete('Love', $array);
var_dump($s, $c);
?>

Output:

array
  'balloon' =>
    array
      'red' =>
        array
          1 => string 'Love' (length=4)

array
  'balloon' =>
    array
      'red' =>
        array
          1 => string 'Love' (length=4)
  'ribbon' =>
    array
      'red' =>
        array
          3 => string 'Love' (length=4)
          4 => string 'Love' (length=4)
hanan dot ali dot shaikh at googlemail dot com
17.09.2010 10:14
In this code I write a code to find next and previous element of an array using current element of that array. Let suppose if we are in element 9 and have to access its next and previous element then this code be helpful for someone.

<?php
$myArray
= array(4,5,7,9,10,11,13,19,25);

$currentElement = 9;
$firstElement = current($myArray);
$lastElement = $myArray[sizeof($myArray)-1];

$currentKey = array_search($currentElement, $myArray);
$currentValue = $myArray[$currentKey];

$previousValue = "";
$nextValue = "";
if(
$currentElement!=$lastElement){
   
$nextKey = $currentKey + 1;
   
$nextValue = $myArray[$nextKey];
}

if(
$currentElement!=$firstElement){
   
$previousKey = $currentKey - 1;
   
$previousValue = $myArray[$previousKey];
}

echo
$previousValue."--".$currentValue."--".$nextValue;

?>

Thanks,
Hanan Ali
Yco
3.08.2010 10:35
This a simple and lazy lazy method to search a key name in an array by pattern, and return the value if it isn't empty.

<?php
function array_search_key($p, $a)
{
    foreach (
$a as $k => $v) {
        if(
strstr($k, $p)){
            if(!empty(
$v) || $v > 0){
                return
$v;
            }
        }
    }
}
?>
giulio dot provasi at gmail dot com
30.04.2010 11: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.03.2010 21: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
3.03.2010 19: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
1.03.2010 17: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.01.2010 2: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.11.2009 15: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
2.10.2009 9: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.09.2009 6: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.09.2009 14: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
5.09.2009 0: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.08.2009 19: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.08.2009 20: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
23.07.2009 1: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.06.2009 11: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
8.06.2009 17: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.05.2009 21: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
5.05.2009 19: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.04.2009 6: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
2.04.2009 14: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.03.2009 3: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
6.03.2009 20: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
6.03.2009 19: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
4.02.2009 14: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.01.2009 22: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
7.01.2009 17: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.12.2008 2: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.12.2008 12: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.11.2008 19: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.11.2008 20: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.09.2008 11: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.04.2008 22: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
4.04.2008 2: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
9.03.2008 17: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
6.02.2008 8: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.01.2008 13: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.01.2008 11: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
6.12.2007 11: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
2.12.2007 14: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.11.2007 4: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
12.09.2007 0: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
2.09.2007 8: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.05.2007 19: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.01.2007 14: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.01.2007 11: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
4.01.2007 13: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.12.2006 8: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.11.2006 15: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.10.2006 7: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.09.2006 11: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.09.2006 11: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.09.2006 14: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.09.2006 2: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.08.2006 11: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.07.2006 16: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.04.2006 7: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.03.2006 14: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.03.2006 4: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.02.2006 9: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
9.02.2006 3: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
24.11.2005 0: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
23.11.2005 0: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.11.2004 16: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
3.11.2004 18: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
Flix Cloutier
22.10.2004 14: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
19.08.2004 17: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
8.08.2004 1: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
3.05.2004 20: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.01.2004 10: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.01.2004 19: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.11.2003 3: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.11.2003 12: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.06.2003 4: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.04.2003 12: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    <richard@richard-sumilang.com>
     *    @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.03.2003 13: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
1.03.2003 5: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.06.2002 23: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.05.2002 13: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
2.05.2002 10: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
4.02.2002 22: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 )



PHP Powered Diese Seite bei php.net
The PHP manual text and comments are covered by the Creative Commons Attribution 3.0 License © the PHP Documentation Group - Impressum - mail("TO:Reinhard Neidl",...)