数组 函数
在线手册：中文 英文
PHP手册

in_array

(PHP 4, PHP 5)

in_array — 检查数组中是否存在某个值

说明

bool in_array ( mixed $needle , array $haystack [, bool $strict ] )

在 haystack 中搜索 needle，如果找到则返回 TRUE，否则返回 FALSE。

如果第三个参数 strict 的值为 TRUE 则 in_array() 函数还会检查 needle 的类型是否和 haystack 中的相同。

Note:

如果 needle 是字符串，则比较是区分大小写的。

Note:

在 PHP 版本 4.2.0 之前，needle 不允许是一个数组。

Example #1 in_array() 例子

<?php
$os = array("Mac", "NT", "Irix", "Linux");
if (in_array("Irix", $os)) {
    echo "Got Irix";
}
if (in_array("mac", $os)) {
    echo "Got mac";
}
?>

第二个条件失败，因为 in_array() 是区分大小写的，所以以上程序显示为： 

Got Irix

Example #2 in_array() 严格类型检查例子

<?php
$a = array('1.10', 12.4, 1.13);

if (in_array('12.4', $a, true)) {
    echo "'12.4' found with strict check\n";
}
if (in_array(1.13, $a, true)) {
    echo "1.13 found with strict check\n";
}
?>

以上例程会输出：

1.13 found with strict check

Example #3 in_array() 中用数组作为 needle

<?php
$a = array(array('p', 'h'), array('p', 'r'), 'o');

if (in_array(array('p', 'h'), $a)) {
    echo "'ph' was found\n";
}
if (in_array(array('f', 'i'), $a)) {
    echo "'fi' was found\n";
}
if (in_array('o', $a)) {
    echo "'o' was found\n";
}
?>

以上例程会输出：

  'ph' was found
  'o' was found

参见 array_search()，array_key_exists() 和 isset()。

参数

needle

The searched value.

Note:

If needle is a string, the comparison is done in a case-sensitive manner.

haystack

The array.

strict

If the third parameter strict is set to TRUE then the in_array() function will also check the types of the needle in the haystack.

返回值

Returns TRUE if needle is found in the array, FALSE otherwise.

更新日志

版本 说明
4.2.0 needle may now be an array.

范例

Example #4 in_array() example

<?php
$os = array("Mac", "NT", "Irix", "Linux");
if (in_array("Irix", $os)) {
    echo "Got Irix";
}
if (in_array("mac", $os)) {
    echo "Got mac";
}
?>

The second condition fails because in_array() is case-sensitive, so the program above will display: 

Got Irix

Example #5 in_array() with strict example

<?php
$a = array('1.10', 12.4, 1.13);

if (in_array('12.4', $a, true)) {
    echo "'12.4' found with strict check\n";
}

if (in_array(1.13, $a, true)) {
    echo "1.13 found with strict check\n";
}
?>

以上例程会输出：

1.13 found with strict check

Example #6 in_array() with an array as needle

<?php
$a = array(array('p', 'h'), array('p', 'r'), 'o');

if (in_array(array('p', 'h'), $a)) {
    echo "'ph' was found\n";
}

if (in_array(array('f', 'i'), $a)) {
    echo "'fi' was found\n";
}

if (in_array('o', $a)) {
    echo "'o' was found\n";
}
?>

以上例程会输出：

  'ph' was found
  'o' was found

参见

数组 函数
在线手册：中文 英文
PHP手册
PHP手册 - N: 检查数组中是否存在某个值

用户评论:

dlancea (08-Mar-2012 12:24)

FYI, the in_arrayr function below is incorrect. It will not continue past the first rested array (and return false if not found). Corrected version is below:

<?php
function in_arrayr( $needle, $haystack ) {
    foreach( $haystack as $v ){
        if( $needle == $v )
            return true;
        elseif( is_array( $v ) )
            if( in_arrayr( $needle, $v ) )
                return true;
    }
    return false;
}
?>

whats happend? (02-Mar-2012 05:02)

$user = array
(
    0 => 307,
    1 => 157,
    2 => 234,
    3 => 200,
    4 => 322,
    5 => 324
);
$node = array
(
    0 => 200,
    1 => 234
);
$node2 = array(200,234);

$a = in_array($user, $node);
$b = in_array($user, $node, true);

$c = in_array($node, $user);
$d = in_array($node, $user, true);

$e = in_array($node, $node2);
$f = in_array($node2, $node);
$g = in_array($node, $node2, true);
$h = in_array($node2, $node, true);

$i = in_array($node, $node);

output
bool(false)
bool(false)
bool(false)
bool(false)
bool(false)
bool(false)
bool(false)
bool(false)
bool(false)

janis dot janovskis at gmail dot com (29-Feb-2012 07:03)

Since sometimes in_array returns strange results - see notes above.
I was able to find value in array by this quite a simple function;
<?php
/**
* $find <mixed> value to find
* $array<array> array to search in
*/

function _value_in_array($array, $find){
 $exists = FALSE;
 if(!is_array($array)){
   return;
}
foreach ($array as $key => $value) {
  if($find == $value){
       $exists = TRUE;
  }
}
  return $exists;
}

// Note
// You can't use wildcards and it does not check variable type
?>

rajeevroy15 at gmail dot com dot com (30-Nov-2011 12:51)

is_array function checks only array only and giving incorrect result with multi-dimensional arrays.

Here is a custom function which will give the solution to check Array or Object and Checking of multi-dimensional arrays and objects as well.

<?php

function in_object($val, $obj){

    if($val == ""){
        trigger_error("in_object expects parameter 1 must not empty", E_USER_WARNING);
        return false;
    }
    if(!is_object($obj)){
        $obj = (object)$obj;
    }

    foreach($obj as $key => $value){
        if(!is_object($value) && !is_array($value)){
            if($value == $val){
                return true;
            }
        }else{
            return in_object($val, $value);
        }
    }
    return false;
}
?>
Usage  :
<?php

$array = array("a", "b", "c"=>array("x", "y"=>array("p", "q"=>"r")));

if(in_object("r", $arrX)){
    echo "r is there ";
}else{
    echo "Its not there ";
}
?>

beingmrkenny at gmail dot com (27-Oct-2011 11:35)

Loose checking returns some crazy, counter-intuitive results when used with certain arrays. It is completely correct behaviour, due to PHP's leniency on variable types, but in "real-life" is almost useless.

The solution is to use the strict checking option.

<?php

// Example array

$array = array(
    'egg' => true,
    'cheese' => false,
    'hair' => 765,
    'goblins' => null,
    'ogres' => 'no ogres allowed in this array'
);

// Loose checking -- return values are in comments

// First three make sense, last four do not

in_array(null, $array); // true
in_array(false, $array); // true
in_array(765, $array); // true
in_array(763, $array); // true
in_array('egg', $array); // true
in_array('hhh', $array); // true
in_array(array(), $array); // true

// Strict checking

in_array(null, $array, true); // true
in_array(false, $array, true); // true
in_array(765, $array, true); // true
in_array(763, $array, true); // false
in_array('egg', $array, true); // false
in_array('hhh', $array, true); // false
in_array(array(), $array, true); // false

?>

chris at axxis dot gr (27-Sep-2011 03:49)

It's funny how PHP has an in_array method, but not an in_object one. Here is a simple function which will check if a value can be found within an object.

<?php
  // in_object method
  // to check if a value in an object exists.
  function in_object($value,$object) {
    if (is_object($object)) {
      foreach($object as $key => $item) {
        if ($value==$item) return $key;
      }
    }
    return false;
  }
?>
 
This is very useful if an object has been created dynamically (especially from external code, which you don't control, as in an application-plugin, CMS, etc), and you don't know the object's properties.
The above function will return the property, so you will be able to use it in your code later on.

Here is a very good basic example of how useful this function is!

<?php
  class My_Class {
    function __construct($key, $value) {
      $this->$key = $value;
      // As you can see, this is a dynamic class, its properties and values can be unknown...
    }
  }

  function in_object($value,$object) {
    if (is_object($object)) {
      foreach($object as $key => $item) {
        if ($value==$item) return $key;
      }
    }
    return false;
  }
 
  function manipulate_property($value,$object) {
    if ($property = in_object($value,$object)) {
      // value found. I can now use this property.
      // I can simply echo'it (makes no sense, as I could instead simply echo "value")
      echo "<br />I found the property holding this value: ".$object->$property;
      // or (here comes the good part)
      // change the property
      $object->$property = "This is a changed value!";
      echo "<br />I changed the value to: ".$object->$property;
      // or return it for use in my program flow
      return $property;
    } else {
      echo "Value NOT FOUND!<br />";
      return false;
    }
  }
 
  // imagine if some function creates the class conditionally...
  if ( 1 == 1) {
    $class = new My_Class("property","Unchanged Value");
  } else {
    $class = new My_Class("property","Some Other Value");
  }
 
  // now let's check if the value we want exists, and if yes, let's have some fun with it...
  $property = manipulate_property("Unchanged Value",$class);
  if ($property) {
    $my_variable = $class->$property;
    echo "<br />This is my variable now:".$my_variable;
  } else $my_variable = $some_other_variable;
?>

Just run it to see for yourself!

Lea Hayes (05-Aug-2011 01:40)

Determine whether an object field matches needle.

Usage Example:
---------------

<?php
$arr = array( new stdClass(), new stdClass() );
$arr[0]->colour = 'red';
$arr[1]->colour = 'green';
$arr[1]->state  = 'enabled';

if (in_array_field('red', 'colour', $arr))
   echo 'Item exists with colour red.';
if (in_array_field('magenta', 'colour', $arr))
   echo 'Item exists with colour magenta.';
if (in_array_field('enabled', 'state', $arr))
   echo 'Item exists with enabled state.';
?>

Output:
--------
Item exists with colour red.
Item exists with enabled state.

<?php
function in_array_field($needle, $needle_field, $haystack, $strict = false) {
    if ($strict) {
        foreach ($haystack as $item)
            if (isset($item->$needle_field) && $item->$needle_field === $needle)
                return true;
    }
    else {
        foreach ($haystack as $item)
            if (isset($item->$needle_field) && $item->$needle_field == $needle)
                return true;
    }
    return false;
}
?>

Ray dot Paseur at Gmail dot com (01-Aug-2011 05:20)

Be VERY careful about testing for strings in arrays that might also contain integers.  In this snippet, the range() function turns the numeric values into integers, and loose data typing finds a match with zero.

Outputs:
PHP in_array() FOUND @#%?!!
@#%?!! == 0 AT POSITION 26 BECAUSE OF LOOSE TYPE

<?php // RAY_temp_in_array.php
error_reporting(E_ALL);
echo "<pre>";

// THE ALLOWABLE SELECTIONS
$alpha = range('A','Z');
$alpha = array_merge($alpha, range('0', '9'));

// LOOK FOR A BOGUS SELECTION
$str = '@#%?!!';
if (in_array($str, $alpha))
{
    echo "PHP in_array() FOUND $str ";
}
else
{
    echo "$str IS NOT IN ARRAY";
}

// SEARCH THE ARRAY FOR THE KEY OF THE STRING
$key = array_search($str, $alpha);
echo "<br/>$str == $alpha[$key] AT POSITION $key";

if ($str == 0) echo " BECAUSE OF LOOSE TYPE";
?>

Anonymous (18-Jun-2011 08:16)

known issue
when checking a string vs a integer

$testarray = array(0,1,2,3,4);

in_array("bla", $a) returns true
in_array("bla6", $a) returns true
in_array("6bla", $a) returns false

"bla" as a integer value returns the number zero
"bla6" as a integer value returns the number zero
 "6bla" returns the number six as its the only vaild part of that

if you checking for unknown types eg string vs integer
then you would need the strict value to be true.

Sascha Luedi (28-Feb-2011 05:33)

strange behaviour of in_array:

If you have an array like:
<?php
$a = array(0,1,2,3,4,5);
in_array("bla", $a) returns true
in_array("bla6", $a) returns true
in_array("6bla", $a) returns false
?>

If you have an array like (without 0):
<?php
$a = array(1,2,3,4,5);
in_array("bla", $a) returns false
in_array("6bla", $a) returns false
in_array("5bla", $a) returns true
?>

so better use strict arg!

Joris Meijer (15-Feb-2011 01:31)

A good option if your array contains objects and you wish to recursively search it (eg. with in_arrayr), is to use json_encode and json_decode first:

<?php

$array = json_decode(json_encode($array_with_objects), true);

?>

In my opinion this is more elegant than a recursive in_array function which converts the objects into arrays while searching for a key and/or value.

user at NOSPAM at fullservicead dot com (02-Feb-2011 04:52)

After reading all other notes about performance,
I made a little test.

fill an array in a loop with random characters,
shuffle it
search on it using 4 methods.

I tried to have haystack as array and string; hence the strstr.

I tried it on 9, 99, 999, 9999 elements and the results
remain in the same order:

9999 elements

Function :  execution time in miliseconds.

strstr : 1.2994079589844
fast_in_array : 1.0655579566956
isset : 0.99128198623657 //Winner, used from another note here.
in_array : 2.9410798549652

One last detail, I moved my functions around in the script to make sure there was no memory caching, reiteration op or whatever, it's all the same. in_array is the slowest and the use of isset($array[$NEEDLE]) the fastest.

I hope it saves somebody else the trouble.

bosdilooda at gmail dot com (21-Jan-2011 08:07)

There should be a big red warning sign here because this function behaves in mysterious ways...

let haystack be an array of integers:

$arr = array(1,2,3,4,5);

let $needle be a string of "2foobar"

then

in_array($needle,$arr)

will return true because string ("2foobar") evaluates to integer (2).

Sabrina (28-Nov-2010 09:29)

Here's another way to get around the case-sensitive issue with in_array:

<?php
function in_arrayi($needle, $haystack)
{
    for($h = 0 ; $h < count($haystack) ; $h++)
    {
        $haystack[$h] = strtolower($haystack[$h]);
    }
    return in_array(strtolower($needle),$haystack);
}
?>

This is good for parsing URI's or preventing SQL injection.

ctulek at gmail dot com (30-Aug-2010 07:07)

If you have an array like:
$arr = array(0,1,2,3,4,5);

in_array(NULL, $arr) returns true because you have 0 in your array. That is, in_array does not use === for equal check.

Willian Gustavo Veiga (16-Jun-2010 03:41)

I wrote a function that search for a property value of an object in an array of objects:

<?php
function property_value_in_array($array, $property, $value) {
    $flag = false;

    foreach($array as $object) {
        if(!is_object($object) || !property_exists($object, $property)) {
            return false;       
        }

        if($object->$property == $value) {
            $flag = true;
        }
    }
   
    return $flag;
}

$obj1 = new StdClass();
$obj2 = new StdClass();
$obj3 = new StdClass();

$obj1->name = 'Object 1';
$obj1->age = 12;

$obj2->name = 'Object 2';
$obj2->age = 13;

$obj3->name = 'Object 3';
$obj3->age = 14;

/* It returns true because there is the "14" value in the "age" property of an object within the array. */
echo property_value_in_array(array($obj1, $obj2, $obj3), 'age', 14);
?>

Svinto (22-May-2010 07:53)

in_array() will always return true if a value in the haystack is of type bool(true).
This always hold except when the needle is of type bool(false).

Code:
<?php
$haystack = array(true);
$needle = "anything except bool(false)";
$result = in_array($needle, $haystack);
var_dump($result); #Will always be true
?>

Solution:
run in_array() with strict set to true.
<?php
in_array($needle, $haystack, true);
?>

Tested on PHP 5.2.6

bogdan AT bogdanconstantinescu DOT com (21-Apr-2010 04:01)

If you found yourself in need of a multidimensional array in_array like function you can use the one below. Works in a fair amount of time

<?php

    function in_multiarray($elem, $array)
    {
        $top = sizeof($array) - 1;
        $bottom = 0;
        while($bottom <= $top)
        {
            if($array[$bottom] == $elem)
                return true;
            else
                if(is_array($array[$bottom]))
                    if(in_multiarray($elem, ($array[$bottom])))
                        return true;
                   
            $bottom++;
        }       
        return false;
    }
?>

jv at vip dot ie (14-Feb-2010 12:46)

If you're working with very large 2 dimensional arrays (eg 20,000+ elements) it's much faster to do this...

<?php
$needle = 'test for this';

$flipped_haystack = array_flip($haystack);

if ( isset($flipped_haystack[$needle]) )
{
  print "Yes it's there!";
}
?>

I had a script that went from 30+ seconds down to 2 seconds (when hunting through a 50,000 element array 50,000 times).

Remember to only flip it once at the beginning of your code though!

natan dot volkovich at gmail dot com (30-Nov-2009 10:10)

If you're trying to find out whether or not at least a single value of an array matches a value in your haystack then use "array_intersect" instead of "in_array".

<?php
$needle = array(1,2);
$haystack = array(0,1,2);

echo "in_array: ".(int)in_array($needle, $haystack); // returns 0
echo "array_intersect: ".(int)array_intersect((array)$needle, $haystack); // returns 1
?>

vladimir at vingrad dot ru (14-Nov-2009 11:14)

This function has Problem with UTF-8. To solve this Problem use:

in_array( mb_strtolower($tag, "UTF-8"), $arr)

thomas dot sahlin at gmail dot com (05-Oct-2009 08:53)

If you're creating an array yourself and then using in_array to search it, consider setting the keys of the array and using isset instead since it's much faster.

<?php

$slow = array('apple', 'banana', 'orange');

if (in_array('banana', $slow))
    print('Found it!');

$fast = array('apple' => 'apple', 'banana' => 'banana', 'orange' => 'orange');

if (isset($fast['banana']))
    print('Found it!');

?>

me at bubjavier dot com (14-Sep-2009 12:15)

in case your haystack is undefined or not set:

<?php

$fruitExists = in_array('mango', (array) $_SESSION["fruits"]);

?>

will return false if the haystack is not an array.

robin at robinnixon dot com (25-Jul-2009 08:38)

This function is five times faster than in_array(). It uses a binary search and should be able to be used as a direct replacement:

<?php
function fast_in_array($elem, $array)
{
   $top = sizeof($array) -1;
   $bot = 0;

   while($top >= $bot)
   {
      $p = floor(($top + $bot) / 2);
      if ($array[$p] < $elem) $bot = $p + 1;
      elseif ($array[$p] > $elem) $top = $p - 1;
      else return TRUE;
   }
    
   return FALSE;
}
?>

john at dwarven dot co dot uk (01-Jul-2009 12:34)

I just struggled for a while with this, although it may be obvious to others.

If you have an array with mixed type content such as:

<?php

 $ary = array (
   1,
   "John",
   0,
   "Foo",
   "Bar"
 );

?>

be sure to use the strict checking when searching for a string in the array, or it will match on the 0 int in that array and give a true for all values of needle that are strings strings.

<?php

var_dump( in_array( 2, $ary ) );

// outputs FALSE

var_dump( in_array( 'Not in there', $ary ) );

// outputs TRUE

var_dump( in_array( 'Not in there', $ary, TRUE ) );

// outputs FALSE

?>

MarkAndrewSlade at gmail dot com (17-Apr-2009 06:46)

This function will generate a PHP_NOTICE if you are looking for data of type A in an array containing data of type B if casting A to B would generate a PHP_NOTICE.  This may not be obvious.  For example:

<?php

$o = new stdClass;
$a = array(1, 2, $o);
in_array(5, $a);

?>

The output here is:

Notice: Object of class stdClass could not be converted to int in /some/script.php on line 5

Thingmand (09-Mar-2009 07:58)

A little function to use an array of needles:

<?php
function array_in_array($needles, $haystack) {

    foreach ($needles as $needle) {

        if ( in_array($needle, $haystack) ) {
            return true;
        }
    }

    return false;
}
?>

brouwer dot p at gmail dot com (08-Mar-2009 10:55)

If made a in_array function that checks if the specified key matches. It works recursivly so it doesn't matter how deep your input array is.
<?php
  function myInArray($array, $value, $key){
    //loop through the array
    foreach ($array as $val) {
      //if $val is an array cal myInArray again with $val as array input
      if(is_array($val)){
        if(myInArray($val,$value,$key))
          return true;
      }
      //else check if the given key has $value as value
      else{
        if($array[$key]==$value)
          return true;
      }
    }
    return false;
  }
?>

Kelvin J (28-Feb-2009 01:04)

For a case-insensitive in_array(), you can use array_map() to avoid a foreach statement, e.g.:

<?php
    function in_arrayi($needle, $haystack) {
        return in_array(strtolower($needle), array_map('strtolower', $haystack));
    }
?>

selmand [at] gmail.com (13-Feb-2009 12:38)

Removes same text with in_array in a string.

<?

$hizmet="aeg,akai,aeg,arcelik,aeg,arcelik,klima,kombi";

// alots of same stings

$x=explode(",",$hizmet);

$t= array();
$k=0;
for($i=0;$i<sizeof($x);$i++){ // this for remove its
    //echo $x[$i]."\n";
    if(!in_array($x[$i],$t))
    {
        $t[$k]=$x[$i];
        $k++;
    }
   
}

for($i=0;$i<sizeof($t);$i++){ // rebuilding $hizmet strings.
   
    echo $t[$i].",";
   
}

?>

soxred93 at gmail dot com (28-Jan-2009 09:37)

Here's a simple little function I wrote that is a case insensitive version of in_array():

<?php
    function in_arrayi( $needle, $haystack ) {
        $found = false;
        foreach( $haystack as $value ) {
            if( strtolower( $value ) == strtolower( $needle ) ) {
                $found = true;
            }
        }   
        return $found;
    }
?>

jordigirones at gmail dot com (21-Jan-2009 03:54)

function similar to in_array but implements LIKE '<string>%'

<?php
   function in_array_like($referencia,$array){
      foreach($array as $ref){
        if (strstr($referencia,$ref)){         
          return true;
        }
      }
      return false;
    }
?>

rhill at xenu-directory dot net (17-Jan-2009 09:05)

I found out that in_array will *not* find an associative array within a haystack of associative arrays in strict mode if the keys were not generated in the *same order*:

<?php

$needle = array(
    'fruit'=>'banana', 'vegetable'=>'carrot'
    );

$haystack = array(
    array('vegetable'=>'carrot', 'fruit'=>'banana'),
    array('fruit'=>'apple', 'vegetable'=>'celery')
    );

echo in_array($needle, $haystack, true) ? 'true' : 'false';
// Output is 'false'

echo in_array($needle, $haystack) ? 'true' : 'false';
// Output is 'true'

?>

I had wrongly assumed the order of the items in an associative array were irrelevant, regardless of whether 'strict' is TRUE or FALSE: The order is irrelevant *only* if not in strict mode.

james dot ellis at gmail dot com (30-Oct-2008 05:17)

Be aware of oddities when dealing with 0 (zero) values in an array...

This script:
<?php
$array = array('testing',0,'name');
var_dump($array);
//this will return true
var_dump(in_array('foo', $array));
//this will return false
var_dump(in_array('foo', $array, TRUE));
?>

It seems in non strict mode, the 0 value in the array is evaluating to boolean FALSE and in_array returns TRUE. Use strict mode to work around this peculiarity.
This only seems to occur when there is an integer 0 in the array. A string '0' will return FALSE for the first test above (at least in 5.2.6).

james dot randell at hotmail dot co dot uk (16-Sep-2008 10:54)

Small method i built for my Array module, after looking through the manual I wanted a small compact way of making a wildcard search through an arrays values, and returning only those that it found.

<?php

    /**
     * Takes a needle and haystack (just like in_array()) and does a wildcard search on it's values.
     *
     * @param    string        $string        Needle to find
     * @param    array        $array        Haystack to look through
     * @result    array                    Returns the elements that the $string was found in
     */
    function find ($string, $array = array ())
    {       
        foreach ($array as $key => $value) {
            unset ($array[$key]);
            if (strpos($value, $string) !== false) {
                $array[$key] = $value;
            }
        }       
        return $array;
    }
?>

alishahnovin at hotmail dot com (02-Sep-2008 08:43)

Here's a function that does an in_array, but takes wildcards in the needle, and also can be case sensitive/insensitive...

A few points:
-It doesn't use foreach, but for, which is quicker
-I didn't use regex to search with a wildcard for the reason that the needle could be unpredictable if it's user-input, and rather than having to escape metacharacters, I decided it would be easier to do a plain text comparison.
-Needles with wildcards can come in many forms such as:

Str*ng
S*r*ng*
*rng
*i*n*

so a split is being done on that string, and each part is then compared with the current item. If the first part is not found, the comparison is done, and we move on. If it IS found, we move on to the next part of the needle, while chopping off the initial part of the haystack string. This is to ensure that each comparison of a needle part is looking at the next part of the haystack string.

For example:

needle: "Bo*bo"
haystack[0] = "Bob is lazy"

On the first pass, when searching "Bo", we then modify the haystack[0] to be: "b is lazy" so that "bo" is compared with that. Otherwise, we'd be comparing "bo" with "Bob is lazy", and returning true incorrectly.

I haven't fully tested the function, so let me know if you spot any bugs, or have any questions.

<?php

function in_wildarray($needle, $haystack, $case_sensitive=true) {
    $is_wild = (strpos($needle,"*")===true)? true : false;
    $needles = ($is_wild)? explode("*", $needle) : array();
    $needle = ($case_sensitive)? $needle : strtolower($needle);
    for($i=0;$i<count($haystack);$i++) {
        $haystack_str = ($case_sensitive)? haystack[$i] : strtolower($haystack[$i]);
        if ($is_wild) {
            $found = false;
            for($x=0;$x<count($needles);$x++) {
                $needle_part = trim($needles[x]);
                $needle_index = strpos($haystack_str, $needle_part);
                if ($needle_index===false) {
                    $found = false;
                    break; //break out of the loop, because string part is not found in the haystack string
                } else {
                    $found = true;
                    //chop off the start of the string to the needle_index
                    //so we can be sure that the found items are in the correct order
                    //and we are avoiding the potential of finding duplicate characters
                    $haystack_str = substr($haystack_str, 0, $needle_index);
                }
            }
            if ($found) { return true; }
        } elseif (!$is_wild && $haystack_str == $needle) {
            return true;
        }
    }
    return false;
}

?>

As the code is right now, when there are wild cards, it will treat the initial segment as though it's preceded with a wild card. In other words, the first segment will be searched, not simply at the beginning of the string, but anywhere. Because it's a simple fix, I'll leave it to others. :)

crashrox at gmail dot com (21-Jul-2008 04:34)

Recursive in array using SPL

<?php
function in_array_recursive($needle, $haystack) {

    $it = new RecursiveIteratorIterator(new RecursiveArrayIterator($haystack));

    foreach($it AS $element) {
        if($element == $needle) {
            return true;
        }
    }

    return false;
}
?>

Martijn Wieringa (19-May-2008 10:20)

When using numbers as needle, it gets tricky:

Note this behaviour (3rd statement):

in_array(0, array(42)) = FALSE
in_array(0, array('42')) = FALSE
in_array(0, array('Foo')) = TRUE
in_array('0', array('Foo')) = FALSE

sick949 at hotmail dot com (05-Mar-2008 11:43)

A first idea for a function that checks if a text is in a specific column of an array.
It does not use in_array function because it doesn't check via columns.
Its a test, could be much better. Do not use it without test.

<?php

function in_array_column($text, $column, $array)
{
    if (!empty($array) && is_array($array))
    {
        for ($i=0; $i < count($array); $i++)
        {
            if ($array[$i][$column]==$text || strcmp($array[$i][$column],$text)==0) return true;
        }
    }
    return false;
}

?>

guitar king (29-Jan-2008 07:52)

In PHP 4, the first argument seems not allowed to be an object. In PHP 5, also objects are allowed as $needle.

f d0t fesser att gmx d0t net (16-Oct-2007 11:20)

In case you have to check for unknown or dynamic variables in an array, you can use the following simple work-around to avoid misleading checks against empty and zero values (and only these "values"!):

<?php
  in_array($value, $my_array, empty($value) && $value !== '0');
?>

The function empty() is the right choice as it turns to true for all 0, null and ''.
The '0' value (where empty() returns true as well) has to be excluded manually (as this is handled by in_array correctly!).

Examples:
<?php
  $val = 0;
  $res = in_array($val, array('2007'));
?>

leads incorrectly to true where

<?php
  $val = 0;
  $res = in_array($val, array('2007'), empty($val) && $val !== '0');
?>

leads correctly to false (strict check!) while

<?php
  $val = 2007;
  $res = in_array($val, array('2007'), empty($val) && $val !== '0');
?>

still correctly finds the '2007' ($res === true) because it ignores strict checking for that value.

info at b1g dot de (02-Aug-2007 06:44)

Be careful with checking for "zero" in arrays when you are not in strict mode.
in_array(0, array()) == true
in_array(0, array(), true) == false

Quaquaversal (21-May-2007 04:48)

A simple function to type less when wanting to check if any one of many values is in a single array.

<?php
function array_in_array($needle, $haystack) {
    //Make sure $needle is an array for foreach
    if(!is_array($needle)) $needle = array($needle);
    //For each value in $needle, return TRUE if in $haystack
    foreach($needle as $pin)
        if(in_array($pin, $haystack)) return TRUE;
    //Return FALSE if none of the values from $needle are found in $haystack
    return FALSE;
}
?>

Bodo Graumann (16-Mar-2007 06:43)

Be careful!

in_array(null, $some_array)
seems to differ between versions

with 5.1.2 it is false
but with 5.2.1 it's true!

musik at krapplack dot de (04-Jun-2006 01:52)

I needed a version of in_array() that supports wildcards in the haystack. Here it is:

<?php
function my_inArray($needle, $haystack) {
    # this function allows wildcards in the array to be searched
    foreach ($haystack as $value) {
        if (true === fnmatch($value, $needle)) {
            return true;
        }
    }
    return false;
}

$haystack = array('*krapplack.de');
$needle = 'www.krapplack.de';

echo my_inArray($needle, $haystack); # outputs "true"
?>

Unfortunately, fnmatch() is not available on Windows or other non-POSIX compliant systems.

Cheers,
Thomas

rick at fawo dot nl (09-Apr-2006 04:23)

Here's another deep_in_array function, but this one has a case-insensitive option :)
<?
function deep_in_array($value, $array, $case_insensitive = false){
    foreach($array as $item){
        if(is_array($item)) $ret = deep_in_array($value, $item, $case_insensitive);
        else $ret = ($case_insensitive) ? strtolower($item)==$value : $item==$value;
        if($ret)return $ret;
    }
    return false;
}
?>

sandrejev at gmail dot com (22-Feb-2006 03:11)

Sorry, that deep_in_array() was a bit broken.

<?php
function deep_in_array($value, $array) {
    foreach($array as $item) {
        if(!is_array($item)) {
            if ($item == $value) return true;
            else continue;
        }
       
        if(in_array($value, $item)) return true;
        else if(deep_in_array($value, $item)) return true;
    }
    return false;
}
?>

kitchin (05-Feb-2006 02:52)

Here's a gotcha, and another reason to always use strict with this function.

$x= array('this');
$test= in_array(0, $x);
var_dump($test); // true

$x= array(0);
$test= in_array('that', $x);
var_dump($test); // true

$x= array('0');
$test= in_array('that', $x);
var_dump($test); // false

It's hard to think of a reason to use this function *without* strict.

This is important for validating user input from a set of allowed values, such as from a <select> tag.

(14-Jan-2006 05:44)

in_arrayr -- Checks if the value is in an array recursively

Description
bool in_array (mixed needle, array haystack)

<?php
function in_arrayr($needle, $haystack) {
        foreach ($haystack as $v) {
                if ($needle == $v) return true;
                elseif (is_array($v)) return in_arrayr($needle, $v);
        }
        return false;
}
// i think it works
?>

adrian foeder (08-Nov-2005 09:21)

hope this function may be useful to you, it checks an array recursively (if an array has sub-array-levels) and also the keys, if wanted:

<?php
function rec_in_array($needle, $haystack, $alsokeys=false)
    {
        if(!is_array($haystack)) return false;
        if(in_array($needle, $haystack) || ($alsokeys && in_array($needle, array_keys($haystack)) )) return true;
        else {
            foreach($haystack AS $element) {
                $ret = rec_in_array($needle, $element, $alsokeys);
            }
        }
       
        return $ret;
    }
?>

tacone at gmx dot net (03-Aug-2005 03:05)

Beware of type conversion!

This snippet will unset every 0 key element form the array, when cycling an array which contains at least one _num value.
This is because php tries to convert every element of $forbidden_elements to integer when encountering a numeric index into array.
So $array[0] it's considered equal to (int)'_num'.

<?php
$forbidden_elements=array('_num');
    foreach ($array as $key=>$value){       
        if (in_array($key,$forbidden_elements)){               
                unset ($array[$key]);       
            }
}
?>

The following example works, anway you can use strict comparison as well.

<?php
$forbidden_elements=array('_num');
    foreach ($array as $key=>$value){       
        if (in_array($key,$forbidden_elements) && is_string($key)){               
                unset ($array[$key]);       
            }
}
?>

Aragorn5551 at gmx dot de (11-Jun-2005 01:26)

If you have a multidimensional array filled only with Boolean values like me, you need to use 'strict', otherwise in_array() will return an unexpected result.

Example:

<?php
$error_arr = array('error_one' => FALSE, 'error_two' => FALSE, array('error_three' => FALSE, 'error_four' => FALSE));

if (in_array (TRUE, $error_arr)) {
   echo 'An error occurred';
}
else {
   echo 'No error occurred';
}
?>

This will return 'An error occurred' although theres no TRUE value inside the array in any dimension. With 'strict' the function will return the correct result 'No error occurred'.

Hope this helps somebody, cause it took me some time to figure this out.

gordon at kanazawa-gu dot ac dot jp (08-Jan-2003 01:05)

case-insensitive version of in_array:

<?php
function is_in_array($str, $array) {
  return preg_grep('/^' . preg_quote($str, '/') . '$/i', $array);
}
?>

pingjuNOSPAM at stud dot NOSPAM dot ntnu dot no (25-Nov-2002 02:56)

if the needle is only a part of an element in the haystack, FALSE will be returned, though the difference maybe only a special char like line feeding (\n or \r).

tom at orbittechservices dot com (10-Aug-2002 03:17)

I searched the general mailing list and found that in PHP versions before 4.2.0 needle was not allowed to be an array.

Here's how I solved it to check if a value is in_array to avoid duplicates;

<?php
$myArray = array(array('p', 'h'), array('p', 'r'));

$newValue = "q";
$newInsert = array('p','q');

$itBeInThere = 0;
foreach ($myArray as $currentValue) {
  if (in_array ($newValue, $currentValue)) {
    $itBeInThere = 1;
  }
if ($itBeInThere != 1) {
  array_unshift ($myArray, $newInsert);
}
?>

one at groobo dot com (07-May-2002 11:14)

Sometimes, you might want to search values in array, that does not exist. In this case php will display nasty warning:
Wrong datatype for second argument in call to in_array() .

In this case, add a simple statement before the in_array function:

<?php
if (sizeof($arr_to_searchin) == 0 || !in_array($value, $arr_to_searchin)) { /*...*/ }
?>

In this case, the 1st statement will return true, omitting the 2nd one.

jon at gaarsmand dot dk (09-Apr-2002 04:53)

If you want to search a multiple array for a value - you can use this function - which looks up the value in any of the arrays dimensions (like in_array() does in the first dimension).
Note that the speed is growing proportional with the size of the array - why in_array is best if you can determine where to look for the value.

Copy & paste this into your code...

<?php
function in_multi_array($needle, $haystack)
{
    $in_multi_array = false;
    if(in_array($needle, $haystack))
    {
        $in_multi_array = true;
    }
    else
    {   
        for($i = 0; $i < sizeof($haystack); $i++)
        {
            if(is_array($haystack[$i]))
            {
                if(in_multi_array($needle, $haystack[$i]))
                {
                    $in_multi_array = true;
                    break;
                }
            }
        }
    }
    return $in_multi_array;
}
?>