is_array

(PHP 4, PHP 5)

is_array — Finds whether a variable is an array

Описание

bool is_array ( mixed $var )

Finds whether the given variable is an array.

Список параметров

var

The variable being evaluated.

Возвращаемые значения

Returns TRUE if var is an array, FALSE otherwise.

Примеры

Пример #1 Check that variable is an array

<?php
$yes 
= array('this''is''an array');

echo 
is_array($yes) ? 'Array' 'not an Array';
echo 
"\n";

$no 'this is a string';

echo 
is_array($no) ? 'Array' 'not an Array';
?>

Результат выполнения данного примера:

Array
not an Array

Смотрите также

Коментарии

Автор:
And here is another variation for a function to test if an array is associative. Based on the idea by mot4h.

<?php
function is_associative($array)
{
  if (!
is_array($array) || empty($array))
    return 
false;

 
$keys array_keys($array);
  return 
array_keys($keys) !== $keys;
}
?>
2006-03-30 09:28:03
http://php5.kiev.ua/manual/ru/function.is-array.html
Will check a Multi-Dimentional Array to any specified level.  This is a fix to 11/16/05 submission, which would break since you must supply a foreach with an array. Beware recursive functions shouldn't go over 100 deep or could break the memory stack on server.

<?php
// checks for multiarray to defined depth level recursively
// original $level must be 2 or more, else will instantly return true
function isDeepMultiArray($multiarray$level 2) {  // default is simple multiarray
   
if (is_array($multiarray)) {  // confirms array
       
if ($level == 1) {  // $level reaches 1 after specified # of recursions 
           
return true// returns true to recursive function conditional
       
// end conditional
       
foreach ($multiarray as $array) {  // goes one level deeper into array
           
if (isDeepMultiArray($array$level 1)) {  // check subarray
               
$message "I'm a multiarray"// optional message
               
return $message// best if $message = true so function returns boolean
           
// end recursive function
       
// end loop
   
} else {  // not an array at specified level
   
return false// is also used recursively so can't change to message
   

}

if (
isDeepMultiArray(array(array()), 2)); // beware this returns true eventhough arrays are empty

?>
BTW my notation is consistent with the PEAR manual on coding standards, which is what php.net says to follow. I hope a function like this gets included in PHP6.
2006-05-30 02:42:48
http://php5.kiev.ua/manual/ru/function.is-array.html
The is_associative_array() and is_sequential_array() functions posted by 'rjg4013 at rit dot edu' are not accurate.

The functions fail to recognize indexes that are not in sequence or in order.  For example, array(0=>'a', 2=>'b', 1=>'c') and array(0=>'a', 3=>'b', 5=>'c') would be considered as sequential arrays. A true sequential array would be in consecutive order with no gaps in the indices.

The following solution utilizes the array_merge properties. If only one array is given and the array is numerically indexed, the keys get re-indexed in a continuous way.  The result must match the array passed to it in order to truly be a numerically indexed (sequential) array.  Otherwise it can be assumed to be an associative array (something unobtainable in languages such as C).

The following functions will work for PHP >= 4.

<?php
   
function is_sequential_array($var)
    {
        return (
array_merge($var) === $var && is_numericimplodearray_keys$var ) ) ) );
    }
   
    function 
is_assoc_array($var)
    {
        return (
array_merge($var) !== $var || !is_numericimplodearray_keys$var ) ) ) );
    }
?>

If you are not concerned about the actual order of the indices, you can change the comparison to == and != respectively.
2007-02-26 15:32:39
http://php5.kiev.ua/manual/ru/function.is-array.html
Автор:
A slight modification of what's below:

<?php

function is_assoc($array)
{
    return 
is_array($array) && count($array) !== array_reduce(array_keys($array), 'is_assoc_callback'0);
}

function 
is_assoc_callback($a$b)
{
    return 
$a === $b $a 0;
}

?>
2007-09-11 15:37:14
http://php5.kiev.ua/manual/ru/function.is-array.html
Автор:
Yet another simpler, faster is_assoc():

<?php
function is_assoc($array) {
  foreach (
array_keys($array) as $k => $v) {
    if (
$k !== $v)
      return 
true;
  }
  return 
false;
}
?>

In my tests it runs about twice as fast as Michael/Gabriel's array_reduce() method.

(Speaking of which: Gabriel's version doesn't work as written; it reports associative arrays as numeric if only the first key is non-numeric, or if the keys are numeric but ordered backwards.  Michael solves this problem by comparing array_reduce() to count(), but that costs another function call; it also works to just compare to -1 instead of 0, and therefore return -1 as the ternary else from the callback).
2008-07-16 11:05:41
http://php5.kiev.ua/manual/ru/function.is-array.html
alex frase's example is fast but elanthis at awesomeplay dot com's example is faster and Ilgar's modification of alex's code is faulty (the part " || $_array[$k] !== $v"). Also, Ilgar's suggestion of giving a false return value when the variable isnt an array is not suitable in my opinion and i think checking if the array is empty would also be a suitable check before the rest of the code runs.

So here's the modified (is_vector) version

<?php
function is_vector( &$array ) {
   if ( !
is_array($array) || empty($array) ) {
      return -
1;
   }
   
$next 0;
   foreach ( 
$array as $k => $v ) {
      if ( 
$k !== $next ) return true;
     
$next++;
   }
   return 
false;
}
?>

and the modified (alex's is_assoc) version

<?php
function is_assoc($_array) {
    if ( !
is_array($_array) || empty($array) ) {
        return -
1;
    }
    foreach (
array_keys($_array) as $k => $v) {
        if (
$k !== $v) {
            return 
true;
        }
    }
    return 
false;
}
?>
2008-10-16 18:41:01
http://php5.kiev.ua/manual/ru/function.is-array.html
yousef's example was wrong because is_vector returned true instead of false if the key was found
here is the fixed version (only 2 lines differ)
<?php
function is_vector( &$array ) {
   if ( !
is_array($array) || empty($array) ) {
      return -
1;
   }
   
$next 0;
   foreach ( 
$array as $k => $v ) {
      if ( 
$k !== $next ) return false;
     
$next++;
   }
   return 
true;
}
?>
2008-10-28 13:02:12
http://php5.kiev.ua/manual/ru/function.is-array.html
Or you could make use of the array_diff_key and array_key function:

<?php

function is_assoc($var)
{
        return 
is_array($var) && array_diff_key($var,array_keys(array_keys($var)));
}

function 
test($var)
{
        echo 
is_assoc($var) ? "I'm an assoc array.\n" "I'm not an assoc array.\n";
}

// an assoc array
$a = array("a"=>"aaa","b"=>1,"c"=>true);
test($a);

// an array
$b array_values($a);
test($b);

// an object
$c = (object)$a;
test($c);

// other types
test($a->a);
test($a->b);
test($a->c);

?>

The above code outputs:
I'm an assoc array.
I'm not an assoc array.
I'm not an assoc array.
I'm not an assoc array.
I'm not an assoc array.
I'm not an assoc array.
2009-03-03 14:12:19
http://php5.kiev.ua/manual/ru/function.is-array.html
Автор:
Using empty() in the previous example posted by Anonymous will result in a "Fatal error: Can't use function return value in write context".  I suggest using count() instead:

<?php
function is_assoc($array) {
    return (
is_array($array) && !== count(array_diff_key($arrayarray_keys(array_keys($array)))));
}
?>
2009-05-16 17:18:53
http://php5.kiev.ua/manual/ru/function.is-array.html
I've found a faster way of determining an array. If you use is_array() millions of times, you will notice a *huge* difference. On my machine, this method takes about 1/4 the time of using is_array().

Cast the value to an array, then check (using ===) if it is identical to the original.

<?php
if ( (array) $unknown !== $unknown ) {
    echo 
'$unknown is not an array';
} else {
    echo 
'$unknown is an array';
}
?>

You can use this script to test the speed of both methods.

<pre>
What's faster for determining arrays?

<?php

$count 
1000000;

$test = array('im''an''array');
$test2 'im not an array';
$test3 = (object) array('im' => 'not''going' => 'to be''an' => 'array');
$test4 42;
// Set this now so the first for loop doesn't do the extra work.
$i $start_time $end_time 0;

$start_time microtime(true);
for (
$i 0$i $count$i++) {
    if (!
is_array($test) || is_array($test2) || is_array($test3) || is_array($test4)) {
        echo 
'error';
        break;
    }
}
$end_time microtime(true);
echo 
'is_array  :  '.($end_time $start_time)."\n";

$start_time microtime(true);
for (
$i 0$i $count$i++) {
    if (!(array) 
$test === $test || (array) $test2 === $test2 || (array) $test3 === $test3 || (array) $test4 === $test4) {
        echo 
'error';
        break;
    }
}
$end_time microtime(true);
echo 
'cast, === :  '.($end_time $start_time)."\n";

echo 
"\nTested $count iterations."

?>
</pre>

Prints something like:

What's faster for determining arrays?

is_array  :  7.9920151233673
cast, === :  1.8978719711304

Tested 1000000 iterations.
2010-05-28 13:02:05
http://php5.kiev.ua/manual/ru/function.is-array.html
Автор:
I would change the order of the comparison, because if it is really an empty array, it is better to stop at that point before doing several 'cpu & memory intensive' function calls.

In the end on a ratio of 3 not empty arrays to 1 empty array computed for 1000000 iterations it needed 10% less time.
Or the other way round:
It needed approx 3% to 4% more time if the array is not empty, but was at least 4 times faster on empty arrays.

Additionally the memory consumption veritably lesser.

<?php
function is_assoc($array) {
    return (
is_array($array) && (count($array)==|| !== count(array_diff_key($arrayarray_keys(array_keys($array))) )));

?>
2010-06-08 07:22:19
http://php5.kiev.ua/manual/ru/function.is-array.html
function is_associate_array($array)
{
    return $array === array_values($array);
}

or you can add check is_array in functions
2014-10-12 15:49:28
http://php5.kiev.ua/manual/ru/function.is-array.html
Notice that the benchmark results from hperrin at gmail dot com have changed in the meantime:

is_array  :  0.31888604164124
cast, === :  0.58448791503906

(Using PHP 5.6.24, I expect other results with PHP 7)
2016-08-24 16:22:06
http://php5.kiev.ua/manual/ru/function.is-array.html
hperrin's results have indeed changed in PHP 7. The opposite is now true, is_array is faster than comparison:

is_array  :  0.52148389816284
cast, === :  0.84179711341858

Tested 1000000 iterations.
2016-09-05 23:34:16
http://php5.kiev.ua/manual/ru/function.is-array.html
Автор:
Please note that the 'cast to array' check is horrendously out of date.

Running that code against PHP 5.6 results in this:

is_array  :  0.93975400924683
cast, === :  1.2425191402435

So, please use 'is_array', not the horrible casting hack.
2016-10-06 01:40:45
http://php5.kiev.ua/manual/ru/function.is-array.html
An error will be thrown If is_array() is applied to a nonexisting varble.
2018-03-22 18:58:13
http://php5.kiev.ua/manual/ru/function.is-array.html
Автор:
Using is_array prior to an in_array within an if clause will safely escape a check against a variable that could potentially be a non-array when using in_array.  For instance:

NOTE: A real use case might be that we have a list of possible flags which  in a database we have stored whether each of the flags are 0 or 1.  We want a list of the flags which have the value of 1 to be returned. 

Our example here will not use so many technical artifacts, but will be based on similar logic just to get the point across.

<?php

// We have a list of known values
$knownVars = ['apple''orange'];

// A list of values to check
$listToCheck = ['pear''banana'];

// And a method that takes a list of values to check and returns a new list
// of the items from said list that are found to be valid...
public function getValidItemsList$listToCheck /*['pear', 'banana']*/)
{
   
$returnList = [];
    foreach(
$listToCheck as $key => $val)
    {
        if(
in_array($val$knownVars))
        {
           
array_push($returnList$val);
        }
    }

    if(empty(
$returnList))
    {
       
// We have a special case if there were no valid items found, which is the case we are going over
       
return  -1;
    }

   
// Otherwise, normally returns a list of the items that were found to be valid
   
return $returnList;
}

// Call the method and check for any valid items that can be used for some purpose
$validItemsList getValidItemsList($listToCheck);

// In this usage we could potentially get an exception because
// in_array() expects an array for argument #2, checking that the value != -1 does not escape the if statement:
if(isset($validItemsList) && $validItemsList != -&& in_array('apple'$validItemsList))
{
   
//...
}

// In this usage, we break free from the if statement safely:
if(isset($validItemsList) && $validItemsList != -&& is_array($validItemsList) && in_array('apple'$validItemsList))
{
   
//...
}

?>

Hope that can help someone, I know it helped me.
2018-04-12 20:39:39
http://php5.kiev.ua/manual/ru/function.is-array.html
is_assoc() Benchmark:

<?php

function is_assoc1($array) {
    if (!
is_array($array)) return false;
   
$i count($array);
    while (
$i 0) unset($array[--$i]);
    return (bool)
$array;
}

function 
is_assoc2(&$array) {
    if (!
is_array($array)) return false;
   
$i count($array);
    while (
$i 0) {
        if (!isset(
$array[--$i])) return true;
    }
    return 
false;
}

function 
is_assoc3(&$array) {
    if (!
is_array($array)) return false;
   
$i count($array);
    while (
$i 0) {
        if (!
array_key_exists(--$i$array)) return true;
    }
    return 
false;
}

function 
is_assoc4($array) {
    if (!
is_array($array)) return false;
   
ksort($array);
    foreach (
array_keys($array) as $k => $v) {
        if (
$k !== $v) return true;
    }
    return 
false;
}

function 
is_assoc5(&$array) {
    return 
is_array($array) && array_diff_key($arrayarray_keys($array));
}

$arr1 = array(); // not associative
$arr2 $arr3 = array('foo''bar''baz''foo''bar''baz''foo''bar''baz''foo'); // not associative
asort($arr3); // not associative, shuffled keys
$arr4 = array('foo''bar''baz''foo''bar'null'foo''bar''baz''foo'); // not associative but is_assoc2() thinks it is
$arr5 = array(=> 'foo'=> 'bar'=> 'baz'=> 'foo'=> 'bar'=> 'baz''foo3' => 'foo''bar3' => 'bar''baz3' => 'baz''foo4' => 'foo'); // associative

$i $j 0;
$time = array(0.00.00.00.00.0);

for (
$j 0$j 2000$j++) { 
   
$time[0] -= microtime(true);
    for (
$i 0$i 1000$i++) {
        if (
is_assoc1($arr1) || is_assoc1($arr2) || is_assoc1($arr3) || is_assoc1($arr4) || !is_assoc1($arr5)) {
            echo 
'error';
            break;
        }
    }
   
$time[0] += microtime(true);
   
$time[1] -= microtime(true);
    for (
$i 0$i 1000$i++) {
        if (
is_assoc2($arr1) || is_assoc2($arr2) || is_assoc2($arr3) || !is_assoc2($arr4) || !is_assoc2($arr5)) { // $arr4 tweaked
           
echo 'error';
            break;
        }
    }
   
$time[1] += microtime(true);
   
$time[2] -= microtime(true);
    for (
$i 0$i 1000$i++) {
        if (
is_assoc3($arr1) || is_assoc3($arr2) || is_assoc3($arr3) || is_assoc3($arr4) || !is_assoc3($arr5)) {
            echo 
'error';
            break;
        }
    }
   
$time[2] += microtime(true);
   
$time[3] -= microtime(true);
    for (
$i 0$i 1000$i++) {
        if (
is_assoc4($arr1) || is_assoc4($arr2) || is_assoc4($arr3) || is_assoc4($arr4) || !is_assoc4($arr5)) {
            echo 
'error';
            break;
        }
    }
   
$time[3] += microtime(true);
   
$time[4] -= microtime(true);
    for (
$i 0$i 1000$i++) {
        if (
is_assoc5($arr1) || is_assoc5($arr2) || is_assoc5($arr3) || is_assoc5($arr4) || !is_assoc5($arr5)) {
            echo 
'error';
            break;
        }
    }
   
$time[4] += microtime(true);
}

echo 
'is_assoc1(): ' $time[0] . "\n";
echo 
'is_assoc2(): ' $time[1] . "\n";
echo 
'is_assoc3(): ' $time[2] . "\n";
echo 
'is_assoc4(): ' $time[3] . "\n";
echo 
'is_assoc5(): ' $time[4] . "\n";

?>

is_assoc1() - uses unset(), a bit slow, but mem friendly and no function calls
is_assoc2() - uses isset(), fastest one, but returns TRUE whenever array contains NULL
is_assoc3() - fixed is_assoc2(), uses array_key_exists(), fast and memory friendly, and much smarter than the following (no need to check all those keys)
is_assoc4() - alex' version with proper check and key sorting
is_assoc5() - fixed a bit JTS' version, really nice one, but uses too many functions and checks all keys

Results:

is_assoc1(): 2.1628699302673
is_assoc2(): 1.1079933643341
is_assoc3(): 1.7120850086212
is_assoc4(): 3.9194552898407
is_assoc5(): 1.9509885311127
2018-05-10 11:48:52
http://php5.kiev.ua/manual/ru/function.is-array.html
Автор:
The next post is not correct because has problems with blank array index:
https://www.php.net/manual/es/function.is-array.php#89332

The next code use the above link php code

<?php
function is_assoc($var)
{
        return 
is_array($var) && array_diff_key($var,array_keys(array_keys($var)));
}

function 
test($var)
{
        echo 
is_assoc($var) ? "I'm an assoc array.\n" "I'm not an assoc array.\n";
}

// an assoc array
$a = array("a"=>"aaa","b"=>1,"c"=>true);
test($a);

// maybe assoc array?
$b = array(=> "aaa"=> 1=> true); // Index 2 not exist
test($b);
?>

# Output
I'm an assoc array.
I'm an assoc array.

"Associative arrays are arrays that use named keys that you assign to them."
https://www.w3schools.com/php/php_arrays.asp

Solution:

<?php
function is_assoc(array $array)
{
    return 
count(array_filter(array_keys($array), 'is_string')) > 0;
}
function 
test(array $array)
{
    echo 
is_assoc($array) ? "I'm an assoc array.\n" "I'm not an assoc array.\n";
}
// an assoc array
$a = array("a"=>"aaa","b"=>1,"c"=>true);
test($a);
// an array
$b = array(0=>"aaa",1=>1,3=>true);
test($b);
?>

# Output
I'm an assoc array.
I'm not an assoc array.

If you want check pure assoc. array replace > 0 by === count($array)
2019-07-14 21:54:00
http://php5.kiev.ua/manual/ru/function.is-array.html

    Поддержать сайт на родительском проекте КГБ