array_search
(PHP 4 >= 4.0.5, PHP 5)
array_search — Осуществляет поиск данного значения в массиве и возвращает соответствующий ключ в случае удачи
Описание
Ищет в haystack значение needle.
Список параметров
- needle
-
Искомое значение.
Замечание:
Если needle является строкой, сравнение происходит с учетом регистра.
- haystack
-
Массив.
- strict
-
Если третий параметр strict установлен в TRUE, то функция array_search() будет искать идентичные элементы в haystack. Это означает, что также будут проверяться типы needle в haystack, а объекты должны быть одни и тем же экземпляром.
Возвращаемые значения
Возвращает ключ для needle, если он был найден в массиве, иначе FALSE.
Если needle присутствует в haystack более одного раза, будет возвращён первый найденный ключ. Для того, чтобы возвратить ключи для всех найденных значений, используйте функцию array_keys() с необязательным параметром search_value.
Эта функция может возвращать как boolean FALSE, так и не-boolean значение, которое приводится к FALSE. За более подробной информацией обратитесь к разделу Булев тип. Используйте оператор === для проверки значения, возвращаемого этой функцией.
Список изменений
| Версия | Описание |
|---|---|
| 4.2.0 | До PHP 4.2.0, array_search() при неудаче возвращал NULL вместо FALSE. |
Примеры
Пример #1 Пример использования array_search()
<?php
$array = array(0 => 'blue', 1 => 'red', 2 => 'green', 3 => 'red');
$key = array_search('green', $array); // $key = 2;
$key = array_search('red', $array); // $key = 1;
?>
Смотрите также
- array_keys() - Возвращает все или некоторое подмножество ключей массива
- array_values() - Выбирает все значения массива
- array_key_exists() - Проверяет, присутствует ли в массиве указанный ключ или индекс
- in_array() - Проверяет, присутствует ли в массиве значение
- PHP Руководство
- Индекс функций
- Справочник функций
- Расширения, относящиеся к переменным и типам
- Массивы
- array_change_key_case
- array_chunk
- array_combine
- array_count_values
- array_diff_assoc
- array_diff_key
- array_diff_uassoc
- array_diff_ukey
- array_diff
- array_fill_keys
- array_fill
- array_filter
- array_flip
- array_intersect_assoc
- array_intersect_key
- array_intersect_uassoc
- array_intersect_ukey
- array_intersect
- array_key_exists
- array_keys
- array_map
- array_merge_recursive
- array_merge
- array_multisort
- array_pad
- array_pop
- array_product
- array_push
- array_rand
- array_reduce
- array_replace_recursive
- array_replace
- array_reverse
- array_search
- array_shift
- array_slice
- array_splice
- array_sum
- array_udiff_assoc
- array_udiff_uassoc
- array_udiff
- array_uintersect_assoc
- array_uintersect_uassoc
- array_uintersect
- array_unique
- array_unshift
- array_values
- array_walk_recursive
- array_walk
- array
- arsort
- asort
- compact
- count
- current
- each
- end
- extract
- in_array
- key
- krsort
- ksort
- list
- natcasesort
- natsort
- next
- pos
- prev
- range
- reset
- rsort
- shuffle
- sizeof
- sort
- uasort
- uksort
- usort
Коментарии
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 )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!
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.
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
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.
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
<?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;
}
?>
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]);
}
?>
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. :)
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: $time_str seconds.</P>\r\n";
echo "<P>Array Test: $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
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;
}
}
?>
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.
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
//)
?>
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
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]
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... ;)
* 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
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;
}
?>
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)
*/
?>
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;
}
}
?>
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.
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().
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...
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
?>
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
)
)
)
<?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;
}
?>
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.
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()
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)
*/
?>
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;
}
}
}
?>
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.
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));
?>
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);
}
}
?>
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;
}
?>
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
*/
?>
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).<?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;
}
?>
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.
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
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'));
?>
<?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;
}
?>
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;
}
?>
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"));
?>
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;
}
?>
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);
?>
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*/
?>
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)
}
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);
?>
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.
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)
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;
}
?>
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 ;)
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
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;
}
?>
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);
}
?>
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;
}
?>
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.
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;
}
?>
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;
}
?>
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;
}
?>
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)
)
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.
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;
}
?>
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;
}
?>
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
)
)
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.
<?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
)
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;
}
?>
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');
?>
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: function.array-search#89413
if $haystack is not an array, for example false from some previous action, the function returns null instead of false in php 5.3.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";
?>
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];
}
?>
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++;
}
}
?>
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!
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) {
?>
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;
}
?>
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;
}
?>
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
?>
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;
}
}
}
}
?>
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
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)
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
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
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!
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;
}
?>
for searching case insensitive better this:
<?php
array_search(strtolower($element),array_map('strtolower',$array));
?>
Recently I had to get all locations of a one-dimensional non-associative array (needle, not array of needles) in another one-dimensional non-associative array (haystack) without using more memory than necessary. I haven't found any satisfactory way to do that, so I wrote the following function, inspired by the array_slice() source code.
Notes:
0. $offset, $length and $strict behave the same way as those for array_slice() and array_search();
1. this function doesn't use foreach or array_slice(), neither does it modify $needle or $haystack, so no temporary copies are needed/created, regardless of whether the arguments are passed by reference or not -- useful when dealing with very large haystacks and needles;
2. $needle and $haystack are typecast to array if they're not arrays;
3. you can specify the $start position to start searching from in the $haystack (default is 0);
4. negative $start values can be used if you want to specify the starting position from the end of $haystack.
5. you can specify the search $length, starting from $start; a negative value stops the search at that many elements from the end of the haystack;
6. pass true as the fifth argument to do a strict search (not tested on objects);
7. the function returns an array if it finds one or more occurrences of $needle in the $haystack, false on failure.
8. keys are preserved;
9. if you want to get only the first location of $needle in $haystack, returned as an integer rather than array -- in other words, to make an array_match() function instead of array_match_all() -- remove this line:
$results = array();
and replace:
if ($found)
{
$results[] = $i;
$i += $ncount - 1;
}
}
if (!empty($results))
return $results;
else
return false;
with:
if ($found)
return $i;
}
return false;
And now the function:
<?php
function array_match_all($needle, $haystack, $offset = 0, $length = 0, $strict = false)
{
if (!is_array($needle))
$needle = (array) $needle;
if (!is_array($haystack))
$haystack = (array) $haystack;
$offset = (int) $offset;
$length = (int) $length;
$strict = ($strict != false);
$ncount = count($needle);
$hcount = count($haystack);
// Empty arrays? Really? Also, no point in dealing with a needle larger than the haystack.
if (($hcount == 0) || ($ncount == 0) || ($ncount > $hcount))
return false;
// Is offset beyond the upper bound?
if ($offset > $hcount - $ncount)
return false;
// If offset is specified from the end of haystack, is it beyond the lower bound?
elseif ($offset < 0 && ($offset = $hcount + $offset) < 0)
$offset = 0;
// Determine the length.
if ($length == 0)
$length = $hcount;
if ($length < 0)
$length = $hcount - $offset + $length;
elseif ($offset + $length > $hcount)
$length = $hcount - $offset;
// Is the needle larger than the portion of the haystack we are searching in?
if (($length <= 1) || ($ncount > $length))
return false;
// Determine the actual search length.
$length = $offset + $length - $ncount + 1;
$results = array();
for ($i = $offset; $i < $length; ++$i)
{
$found = true;
for ($j = 0; $j < $ncount; ++$j)
{
if (($strict && ($haystack[$i + $j] !== $needle[$j])) || (!$strict && ($haystack[$i + $j] != $needle[$j])))
{
$found = false;
break;
}
}
if ($found)
{
$results[] = $i;
$i += $ncount - 1;
}
}
if (empty($results))
return false;
else
return $results;
}
?>
I found a simple script to remove certain values from a array.
I use it when using the scandir function, because i don't want certain items in the array (like the ., .. folders and the thumbs.db)
<?php
$music = scandir("music");
unset($music[array_search('.',$music)]); // Removing the . directory
unset($music[array_search('..',$music)]); // Removing the .. directory
unset($music[array_search('Thumbs.db',$music)]); // Removing the Thumbs.db file
unset($music[array_search('thumbs.db',$music)]); // Removing the thumbs.db file
?>
Array AFTER/BEFORE Function
function made to mimic the jQuery function to insert items/arrays into another array before or after a specific key. It is split into two functions for reuse to find the offset of a key. it detects if the array is associative (can also be manually controlled) and adds the keys where needed. if the inserted array is associative then any overlapping keys will be replaced by the new ones.
array_insert(array &$original , mixed $insert=null , var $position='after' , $key=null [, $keep_keys=true])
options for $position = (after|before)
<?php
function key_offset(&$array, $searchKey){
if(is_array($array) && array_key_exists($searchKey, $array)){
$counter = 0;
foreach($array as $key => $value){
if($searchKey == $key){
return $counter;
} else {
$counter++;
}
}
}
}
function array_insert(&$original, $insert=null, $position='after', $key=null, $sens=true){
if(!empty($insert)){
$after = $position == 'after' ? true : false;
$insert = (array)$insert;
$assoc = (array_keys($insert) !== range(0, count($insert)-1));
$keep_keys = is_string($insert) || !$assoc || $sens;
if(!empty($key) && array_key_exists($key, $original)){
$start = key_offset($original, $key);
$start = $after ? $start+1 : $start;
if(!$keep_keys){
array_Splice($original,$start,0,$insert);
} else {
$keys = array_Keys($original);
$values = array_Values($original);
$insert = (array)$insert;
$rKeys = array_Keys($insert);
$rValues = array_Values($insert);
array_Splice($keys,$start,0,$rKeys);
array_Splice($values,$start,0,$rValues);
$original = array_Combine($keys,$values);
}
} else {
$original = $after ? array_merge($original, $insert) : array_merge($insert, $original);
}
}
}
$insert = array('omg'=> 'it works', 'this_is' => 'awsome', 'r' =>103,104);
$insert2 = range(11,15);
$insert3 = array(100=>101,102,103,104);
$original=range(1,10);
array_insert($original, $insert, 'after', 4);
$original=range(1,10);
array_insert($original, $insert, 'after', 4, false);
$original=range(1,10);
array_insert($original, $insert2, 'after', 4);
$original=range(1,10);
array_insert($original, $insert3, 'after', 4);
/*
Array
(
[0] => 104
[1] => 2
[2] => 3
[3] => 4
[4] => 5
[omg] => it works
[this_is] => awsome
[r] => 103
[5] => 6
[6] => 7
[7] => 8
[8] => 9
[9] => 10
)
Array
(
[0] => 1
[1] => 2
[2] => 3
[3] => 4
[4] => 5
[5] => it works
[6] => awsome
[7] => 103
[8] => 104
[9] => 6
[10] => 7
[11] => 8
[12] => 9
[13] => 10
)
Array
(
[0] => 11
[1] => 12
[2] => 13
[3] => 14
[4] => 15
[5] => 6
[6] => 7
[7] => 8
[8] => 9
[9] => 10
)
Array
(
[0] => 1
[1] => 2
[2] => 3
[3] => 4
[4] => 5
[100] => 101
[101] => 102
[102] => 103
[103] => 104
[5] => 6
[6] => 7
[7] => 8
[8] => 9
[9] => 10
)
*/
?>
Here is a version of binary search that is done via recursion instead of iteration. Remember that your data needs to be presorted!
<?php
static function Bin_Search(&$needle, &$haystack, $start, $end) {
if($end < $start)
{
return false;
}
$mid = (int)(($end - $start) / 2) + $start;
if($haystack[$mid] > $needle)
{
return Bin_Search($needle, $haystack, $start, $mid - 1);
}
else if($haystack[$mid] < $needle)
{
return Bin_Search($needle, $haystack, $mid + 1, $end);
}
else
{
return true;
}
}
?>
Example of a recursive binary search that returns the index rather than boolean.<?php
// returns the index of needle in haystack
function binSearch($needle, $haystack)
{
// n is only needed if counting depth of search
global $n;
$n++;
// get the length of passed array
$l = count($haystack);
// if length is 0, problem
if($l <= 0)
{
return -1;
}
// get the mid element
$m = (($l+($l%2))/2);
// if mid >= length (e.g. l=1)
if($m >= $l)
{
$m = $m-1;
}
// get the indexed element to compare to the passed element and branch accordingly
$compare = $haystack[$m];
switch(true)
{
case($compare>$needle):
{
// recurse on the lower half
$new_haystack = array_slice($haystack, 0, $m);
$c = count($new_haystack);
$r = binSearch($needle, $new_haystack);
// return current index - (length of lower half - found index in lower half)
return $m - ($c - $r);
break;
}
case($compare<$needle):
{
// recurse on the upper half
$new_haystack = array_slice($haystack, $m, ($l-$m));
$c = count($new_haystack);
$r = binSearch($needle, $new_haystack);
// return current position + found index in upper half
return $m + $r;
break;
}
case($compare==$needle):
{
// found it, so return index
return $m;
break;
}
}
}
?>
Better solution of multidimensional searching.
<?php
function multidimensional_search($parents, $searched) {
if (empty($searched) || empty($parents)) {
return false;
}
foreach ($parents as $key => $value) {
$exists = true;
foreach ($searched as $skey => $svalue) {
$exists = ($exists && IsSet($parents[$key][$skey]) && $parents[$key][$skey] == $svalue);
}
if($exists){ return $key; }
}
return false;
}
$parents = array();
$parents[] = array('date'=>1320883200, 'uid'=>3);
$parents[] = array('date'=>1320883200, 'uid'=>5);
$parents[] = array('date'=>1318204800, 'uid'=>5);
echo multidimensional_search($parents, array('date'=>1320883200, 'uid'=>5)); // 1
?>
This is a multidimensional recursive find function :
<?php
function GetArrKey( $findArr, $key_arr, $depth=0 )
{
if( count($key_arr) <= $depth || !array_key_exists($key_arr[$depth], $findArr) )
return NULL;
else if( count($key_arr) == $depth+1 )
return $findArr[$key_arr[$depth]];
return self::GetArrKey( $findArr[$key_arr[$depth]], $key_arr, $depth+1 );
}
?>
Using :
<?php
$findArray = array( "first_dim" => array( "first_dim_in_1" => array( "first_dim_in_1_val_1", "first_dim_in_1_val_2", "first_dim_in_1_val_3" ), "first_dim_in_2" => array( "first_dim_in_2_val_1", "first_dim_in_2_val_2", "first_dim_in_2_val_3" ) ), "second_dim" => array( "second_dim_in" => "test", "second_dim_in_val_1"));
var_dump( GetArrKey( $findArray, array( "first_dim", "first_dim_in_2" ) ) );
/*
Prints :
array( "first_dim_in_2_val_1", "first_dim_in_2_val_2", "first_dim_in_2_val_3" )
*/
//----------------------------------------------------//
var_dump(GetArrKey( $findArray, array( "first_dim", "first_dim_in_2", 0 ) ) );
/*
Prints :
string(20) => "first_dim_in_2_val_1"
*/
//----------------------------------------------------//
var_dump(GetArrKey( $findArray, array( "second_dim", 0 ) ) );
/*
Prints :
string(4) => "test"
*/
//----------------------------------------------------//
var_dump(GetArrKey( $findArray, array( "second_dim", 0 ) ) );
/*
Prints :
string(4) => "test"
*/
//----------------------------------------------------//
var_dump(GetArrKey( $findArray, array( "second_dim", 1 ) ) );
/*
Prints :
string(19) => "second_dim_in_val_1"
*/
//----------------------------------------------------//
var_dump(GetArrKey( $findArray, array( "second_dim", 1, 1 ) ) );
/*
Prints :
std_object => NULL
*/
?>
Some thing that I wrote from a while, for what ever usefull purpose
This retrieves recursively a value from an array using a path-like notation.
with:
$delimiter path delimiter
$strict if false, the search will allow gaps between path's components
<?php
function path_through_array($path, $array, $delimiter = '.', $strict = false)
{
$path_token = explode($delimiter, $path);
$head = array_shift($path_token);
if (isset($array[$head]) && (0 == count($path_token)))
{
return $array[$head];
}
else if (isset($array[$head]))
{
return path_through_array(implode($delimiter, $path_token), $array[$head], $delimiter, $strict);
}
else if ($strict == true)
{
return false;
}
foreach ($array as $key=>$value)
{
if (is_array($value))
{
$found = path_through_array($path, $value, $delimiter, $strict);
if(false != $found)
{
return $found;
}
}
}
return false;
}
//use:
$array1 = array('path' => array('to' => array('get' => array('something' => 'bar')), 'somethingelse'), 'foo' => 'anotherthing');
$val1 = path_through_array('path.to.get.something', $array1); // => will return : 'bar'
$val2 = path_through_array('path.to.get', $array1); // => will return : array('something'=>'bar')
$val3 = path_through_array('path/to/get/something', $array1, '/'); // => will return : 'bar'
$val4 = path_through_array('path.to.something', $array1); // => will return : 'bar'
$val5 = path_through_array('path.to.something', $array1, '.', true); // => will return : false
I built a function to find the numeric index of a key in an array.
<?php
/**
* Array key index
* @author Nate Ferrero
*/
function array_key_index(&$arr, $key) {
$i = 0;
foreach(array_keys($arr) as $k) {
if($k == $key) return $i;
$i++;
}
}
I had an array of arrays and needed to find the key of an element by comparing actual reference.
Beware that even with strict equality (===) php will equate arrays via their elements recursively, not by a simple internal pointer check as with class objects. The === can be slow for massive arrays and also crash if they contain circular references.
This function performs reference sniffing in order to return the key for an element that is exactly a reference of needle.
<?php
function array_ref_search(&$v, array &$s)
{
if(is_object($v)){ return array_search($v, $s, true); }
foreach($s as $rK => &$rV)
{ // reference sniff
$tV = $v;
if( ($rV === ($v = 1)) && ($rV === ($v = 0)) ){
$v = $tV; return $rK; }
$v = $tV;
}
return false; // use null for php < 4.2.0
}
$list = array();
$list['A'] = &$valA; $list['B'] = &$valB;
$valA = 1; $valB = 1;
echo 'array_ref_search: ', array_ref_search($valB, $list), '</br>'; // key 'B'
echo 'array_search: ', array_search($valB, $list, true), '</br>'; // key 'A'
$valA = array(1,2,3); $valB = array(1,2,3);
echo 'array_ref_search: ', array_ref_search($valB, $list), '</br>'; // key 'B'
echo 'array_search: ', array_search($valB, $list, true), '</br>'; // key 'A' because ($valA === $valB) is true by elements
$valB[] = &$valB; // circular reference
echo 'array_ref_search: ', array_ref_search($valB, $list), '</br>'; // key 'B'
echo 'array_search: ', array_search($valB, $list, true), '</br>'; // crash because ($valB === $valB) causes infinite loop
?>