count

(PHP 4, PHP 5, PHP 7, PHP 8)

count — 统计数组或 Countable 对象中的所有元素

说明

count(Countable|array $value, int $mode = COUNT_NORMAL): int

当与数组一起使用时，统计数组中的所有元素。当与实现 Countable 接口的对象一起使用时，它将返回方法 Countable::count() 的返回值。

参数

value: 一个数组或 Countable 对象。
mode: 如果可选的 mode 参数设置为 COUNT_RECURSIVE（或 1），count() 将递归地统计数组。这对于统计多维数组的所有元素特别有用。

注意
count() 可以检测递归以避免无限循环，但每次这样做时都会发出一个 E_WARNING（如果数组中包含自身多次），并返回一个可能比预期更高的计数。

返回值

返回 value 中的元素数量。在 PHP 8.0.0 之前，如果参数既不是 array 也不是实现 Countable 接口的 object，则将返回 1，除非 value 为 null，在这种情况下将返回 0。

变更日志

版本	说明
8.0.0	count() 现在将在传递给 `value` 参数的无效可计数类型上抛出 TypeError。
7.2.0	count() 现在将在传递给 `value` 参数的无效可计数类型上产生警告。

范例

范例 #1 count() 示例

<?php
$a[0] = 1;
$a[1] = 3;
$a[2] = 5;
var_dump(count($a));

$b[0] = 7;
$b[5] = 9;
$b[10] = 11;
var_dump(count($b));
?>

以上示例将输出

int(3)
int(3)

范例 #2 count() 非 Countable|array 示例（不好的示例 - 不要这样做）

<?php
$b[0] = 7;
$b[5] = 9;
$b[10] = 11;
var_dump(count($b));

var_dump(count(null));

var_dump(count(false));
?>

以上示例将输出

int(3)
int(0)
int(1)

以上示例在 PHP 7.2 中的输出

int(3)

Warning: count(): Parameter must be an array or an object that implements Countable in … on line 12
int(0)

Warning: count(): Parameter must be an array or an object that implements Countable in … on line 14
int(1)

以上示例在 PHP 8 中的输出

int(3)

Fatal error: Uncaught TypeError: count(): Argument #1 ($var) must be of type Countable .. on line 12

范例 #3 递归 count() 示例

<?php
$food = array('fruits' => array('orange', 'banana', 'apple'),
 'veggie' => array('carrot', 'collard', 'pea'));

// 递归计数
var_dump(count($food, COUNT_RECURSIVE));

// 常规计数
var_dump(count($food));

?>

以上示例将输出

int(8)
int(2)

范例 #4 Countable 对象

<?php
class CountOfMethods implements Countable
{
 private function someMethod()
 {
 }

 public function count(): int
 {
 return count(get_class_methods($this));
 }
}

$obj = new CountOfMethods();
var_dump(count($obj));
?>

以上示例将输出

int(2)

参见

is_array() - 判断变量是否为数组
isset() - 判断变量是否已声明且不为 null
empty() - 判断变量是否为空
strlen() - 获取字符串长度
is_countable() - 验证变量的内容是否为可计数的值
数组

改进此页面

了解如何改进此页面 • 提交拉取请求 • 报告错误

＋添加说明

用户贡献说明 18 个说明

down

141

onlyranga at gmail dot com ¶

10 年前

[编辑说明：array at from dot pl 指出 count() 是一个廉价的操作；但是，仍然存在函数调用开销。]


如果要遍历大型数组，不要在循环中使用 count() 函数，这会降低性能，将 count() 的值复制到一个变量中，并在循环中使用该变量以提高性能。


例如


// 不好的方法


for($i=0;$i<count($some_arr);$i++)
{

// 计算
}



// 好的方法


$arr_length = count($some_arr);
for($i=0;$i<$arr_length;$i++)
{

// 计算
}

down

olja dot fb at gmail dot com ¶

1年前

在示例#3中，给定为

<?php
$food = array('fruits' => array('orange', 'banana', 'apple'),
 'veggie' => array('carrot', 'collard', 'pea'));

// 递归计数
var_dump(count($food, COUNT_RECURSIVE));
?>

输出为 int(8)，可能会让一些读者误解，就像我最初一样：人们可能会认为键和内部数组的条目都被计数了。

<?php
// 否：
'fruits', 'orange', 'banana', 'apple', 
'veggie', 'carrot', 'collard', 'pea'
?>

但实际上，键在 count 函数中没有被计数，为什么仍然是 8 - 因为内部数组被计数为条目，以及它们的内部元素。

<?php
// 是：
array('orange', 'banana', 'apple'), 'orange', 'banana', 'apple', 
array('carrot', 'collard', 'pea'), 'carrot', 'collard', 'pea'
?>

down

lucasfsmartins at gmail dot com ¶

5年前

如果你使用的是 PHP 7.2+，你需要注意 “Changelog” 并使用类似这样的代码。

<?php
$countFruits = is_array($countFruits) || $countFruits instanceof Countable ? count($countFruits) : 0;
?>

你可以组织你的代码以确保变量是一个数组，或者你可以扩展 Countable，这样你就不必进行此检查。

down

Anonymous ¶

4年前

对于不可数对象

$count = count($data);
print "Count: $count\n";

警告：count()：参数必须是一个数组或实现 Countable 的对象，在 example.php 的第 159 行。

#快速解决方法是将不可数对象强制转换为数组。

$count = count((array) $data);
print "Count: $count\n";

Count: 250

down

danny at dannymendel dot com ¶

17年前

实际上，当涉及到多维数组时，我发现以下函数更有用，因为你不希望遍历数组树的所有层级。


// $limit 设置为递归的次数
<?php 
function count_recursive ($array, $limit) { 
 $count = 0; 
 foreach ($array as $id => $_array) { 
 if (is_array ($_array) && $limit > 0) { 
 $count += count_recursive ($_array, $limit - 1); 
 } else { 
 $count += 1; 
 } 
 } 
 return $count; 
} 
?>

down

pied-pierre ¶

9年前

一个单行函数，用于查找数组中非数组元素的数量，递归地。

function count_elt($array, &$count=0){
foreach($array as $v) if(is_array($v)) count_elt($v,$count); else ++$count;
return $count;
}

down

alexandr at vladykin dot pp dot ru ¶

17年前

我的函数返回多维数组中元素的数量，取决于数组的深度。（几乎和 COUNT_RECURSIVE 一样，但你可以指定你想深入到哪个深度）。


<?php 
 function getArrCount ($arr, $depth=1) { 
 if (!is_array($arr) || !$depth) return 0; 
 
 $res=count($arr); 
 
 foreach ($arr as $in_ar) 
 $res+=getArrCount($in_ar, $depth-1); 
 
 return $res; 
 } 
?>

down

-1

php_count at cubmd dot com ¶

7年前

之前所有带有 $depth 选项的递归计数解决方案在数组包含自身多次的情况下不会避免无限循环。
这是一个可行的解决方案


<?php 
 /** 
 * 递归地计算数组中的元素。行为与原生 count() 函数的 $depth 选项完全相同。
 * 也就是说，它还会为父元素增加 +1 到总数，而不仅仅是计算其子元素。
 * @param $arr 
 * @param int $depth 
 * @param int $i (内部) 
 * @return int 
 */ 
 public static function countRecursive(&$arr, $depth = 0, $i = 0) { 
 $i++; 
 /** 
 * 如果深度为 0，则使用原生 count 函数 
 */ 
 if (empty($depth)) { 
 return count($arr, COUNT_RECURSIVE); 
 } 
 $count = 0; 
 /** 
 * 这只会在方法第一次被调用并且 $arr 不是数组时才会发生 
 */ 
 if (!is_array($arr)) { 
 return count($arr); 
 } 
 
 // 如果此键存在，则表示你已经遍历了此数组 
 if (isset($arr['__been_here'])) { 
 return 0; 
 } 
 
 $arr['__been_here'] = true; 
 
 foreach ($arr as $key => &$value) { 
 if ($key !== '__been_here') { 
 if (is_array($value) && $depth > $i) { 
 $count += self::countRecursive($value, $depth, $i); 
 } 
 
 $count++; 
 } 
 } 
 
 // 你需要在完成时将其取消设置，因为你正在使用引用... 
 unset($arr['__been_here']); 
 return $count; 
 } 
?>

down

-1

asma mechtaba ¶

2年前

count 和 sizeof 是别名，对一个起作用的，对另一个也起作用。

down

-2

Christoph097 ¶

2年前

空值会被计数。
<?php
$ar[] = 3;
$ar[] = null;
var_dump(count($ar)); //int(2)
?>

down

-5

buyatv at gmail dot com ¶

7年前

当数组中只有一个子数组时，你无法获取子数组的计数。

$a = array ( array ('a','b','c','d'));
$b = array ( array ('a','b','c','d'), array ('e','f','g','h'));

echo count($a); // 4，而不是 1，预期为 1
echo count($b); // 2，预期值

down

-7

Gerd Christian Kunze ¶

10 年前

获取二维数组的最大宽度和最大高度？

注意
第一维 = Y（高度）
第二维 = X（宽度）
例如，数据库结果数组中的行和列

<?php
$TwoDimensionalArray = array( 0 => array( 'key' => 'value', ...), ... );
?>

所以对于 Y（maxHeight）
<?php
$maxHeight = count( $TwoDimensionalArray )
?>

而对于 X（maxWidth）
<?php
$maxWidth = max( array_map( 'count', $TwoDimensionalArray ) );
?>

简单吧？ ;-)

down

-8

JumpIfBelow ¶

9年前

正如我在很多代码中看到的，不要使用 count 来遍历数组。
Onlyranga 说你可以在 for 循环之前声明一个变量来存储它。
我同意他的/她的方法，只有在你需要在每次循环中计算数组大小的时候，才应该在测试中使用 count。

你也可以在 for 循环中执行它，这样你就不需要“搜索”变量设置的位置了。
例如：
<?php
 $array = [1, 5, 'element'];
 for($i = 0, $c = count($array); $i < $c; $i++)
 var_dump($array[$i]);
?>

down

-5

vojtaripa at gmail dot com ¶

4年前

要获取内部数组的计数，你可以执行类似的操作

$inner_count = count($array[0]);
echo ($inner_count);

down

-17

buyatv at gmail dot com ¶

7年前

你不能在数组中使用单个子数组的键来获取子数组的计数

$a = array("a"=>"appple", "b"=>array('a'=>array(1,2,3),'b'=>array(1,2,3)));
$b = array("a"=>"appple", "b"=>array(array('a'=>array(1,2,3),'b'=>array(1,2,3)), array(1,2,3),'b'=>array(1,2,3)), array('a'=>array(1,2,3),'b'=>array(1,2,3))));

echo count($a['b']); // 2 NOT 1, expect 1
echo count($b['b']); // 3, expected

down

-4

max at schimmelmann dot org ¶

4年前

在特殊情况下，你可能只想统计数组的第一层，以确定你有多少条目，而它们还有 N 个键值对。

<?php

$data = [
 'a' => [
 'bla1' => [
 0 => 'asdf',
 1 => 'asdf',
 2 => 'asdf',
 ],
 'bla2' => [
 0 => 'asdf',
 1 => 'asdf',
 2 => 'asdf',
 ],
 'bla3' => [
 0 => 'asdf',
 1 => 'asdf',
 2 => 'asdf',
 ],
 'bla4' => [
 0 => 'asdf',
 1 => 'asdf',
 2 => 'asdf',
 ],
 ],
 'b' => [
 'bla1' => [
 0 => 'asdf',
 1 => 'asdf',
 2 => 'asdf',
 ],
 'bla2' => [
 0 => 'asdf',
 1 => 'asdf',
 2 => 'asdf',
 ],
 ],
 'c' => [
 'bla1' => [
 0 => 'asdf',
 1 => 'asdf',
 2 => 'asdf',
 ]
 ]
];
$count = array_sum(array_values(array_map('count', $data)));
// will return int(7)
var_dump($count);

// will return 31
var_dump(count($data, 1));
?>

down

-31

ThisIsNotImportant ¶

8 年前

关于二维数组，你可以用很多方法来计算元素

<?php
$MyArray = array ( array(1,2,3),
 1,
 'a',
 array('a','b','c','d') );

// 所有元素
echo count($MyArray ,COUNT_RECURSIVE); // 输出 11（9 个值 + 2 个数组）

// 第一级元素
echo count($MyArray ); // 输出 4（2 个值 + 2 个数组）

// 两个级别的值，但只有值
echo(array_sum(array_map('count',$MyArray ))); // 输出 9（9 个值）

// 只有第二级值
echo (count($MyArray ,COUNT_RECURSIVE)-count($MyArray )); // 输出 7（(所有元素) - (第一个元素)）
?>

down

-11

XavDeb ¶

4年前

如果你想知道三维数组中包含最大数量值的子数组，这里有一个尝试（可能不是最好的方法，但它有效）

function how_big_is_the_biggest_sub ($array) {
// 我们解析第一级
foreach ($array AS $key => $array_lvl2) {
// 在第二级中，我们计算第三级的最大值
$lvl2_nb = array_map( 'count', $array_lvl2) ;
$max_nb = max($lvl2_nb);
// 我们存储匹配的键，这可能很有用
$max_key = array_search($max_nb, $lvl2_nb);
$max_nb_all[$max_key.'|'.$key] = $max_nb;
        }
// 现在我们想要所有第二级的最大值，所以再执行一次
$real_max = max($max_nb_all);
$real_max_key = array_search($real_max, $max_nb_all);
list($real_max_key2, $real_max_key1) = explode('|', $real_max_key);
// 准备结果
$biggest_sub['max'] = $real_max;
$biggest_sub['key1'] = $real_max_key1;
$biggest_sub['key2'] = $real_max_key2;
        
return $biggest_sub;
}
/*
$cat_poids_max['M']['Juniors'][] = 55;
$cat_poids_max['M']['Juniors'][] = 61;
$cat_poids_max['M']['Juniors'][] = 68;
$cat_poids_max['M']['Juniors'][] = 76;
$cat_poids_max['M']['Juniors'][] = 100;

$cat_poids_max['M']['Seniors'][] = 55;
$cat_poids_max['M']['Seniors'][] = 60;
$cat_poids_max['M']['Seniors'][] = 67;
$cat_poids_max['M']['Seniors'][] = 75;
$cat_poids_max['M']['Seniors'][] = 84;
$cat_poids_max['M']['Seniors'][] = 90;
$cat_poids_max['M']['Seniors'][] = 100;
//....
$cat_poids_max['F']['Juniors'][] = 52;
$cat_poids_max['F']['Juniors'][] = 65;
$cat_poids_max['F']['Juniors'][] = 74;
$cat_poids_max['F']['Juniors'][] = 100;

$cat_poids_max['F']['Seniors'][] = 62;
$cat_poids_max['F']['Seniors'][] = 67;
$cat_poids_max['F']['Seniors'][] = 78;
$cat_poids_max['F']['Seniors'][] = 86;
$cat_poids_max['F']['Seniors'][] = 100;
*/
$biggest_sub = how_big_is_the_biggest_sub($cat_poids_max);
echo "<li> ".$biggest_sub['key1']." ==> ".$biggest_sub['key2']." ==> ".$biggest_sub['max']; // 显示：M ==> Seniors ==> 7

＋添加说明