Quand on débute en PHP après avoir pratiqué JavaScript ou Python, on cherche instinctivement une propriété .length pour connaître la taille d’un tableau. En PHP, cette propriété n’existe tout simplement pas. Pour obtenir le length of array php, on utilise une fonction dédiée. Voyons ensemble laquelle choisir et comment l’utiliser correctement dans vos projets.

count() : la fonction standard pour mesurer un array PHP

La réponse à la question « how to check PHP array length » tient en un mot : count(). C’est la fonction officielle, documentée dans le manuel PHP, et utilisée par l’immense majorité des développeurs professionnels. Elle retourne le nombre d’éléments présents dans un tableau.

<?php
$fruits = ['pomme', 'banane', 'cerise', 'mangue'];
$nombre = count($fruits);
echo $nombre; // Affiche : 4
?>

La syntaxe est limpide. On passe le tableau en paramètre, et la fonction renvoie un entier. Pour obtenir le php length of array, il suffit donc d’un seul appel. Pas besoin de boucle, pas besoin de variable intermédiaire.

Un point technique important : la complexité algorithmique de count() sur un tableau est en O(1). Cela signifie que PHP stocke en interne le nombre d’éléments du tableau. La fonction ne parcourt pas le tableau pour les compter un par un. Même sur un array de 100 000 éléments, l’appel reste quasi instantané.

<?php
// Tableau associatif
$utilisateur = [
    'nom' => 'Moreau',
    'prenom' => 'Lucie',
    'role' => 'formatrice',
    'ville' => 'Lyon'
];
echo count($utilisateur); // Affiche : 4

// Tableau vide
$vide = [];
echo count($vide); // Affiche : 0
?>

Que le tableau soit indexé numériquement ou associatif, count() fonctionne de la même manière. C’est la méthode que je recommande systématiquement à mes étudiants en BTS SIO pour déterminer la length of an array php.

sizeof() : un alias de count() à connaître

Si vous croisez du code utilisant sizeof(), ne soyez pas surpris. Cette fonction est un alias strict de count(). Elle produit exactement le même résultat, avec les mêmes performances. La question « does an array have size() or length()? » revient souvent : en PHP, ni l’un ni l’autre n’existe en tant que méthode native d’un array. On utilise des fonctions globales.

<?php
$couleurs = ['rouge', 'vert', 'bleu'];

echo count($couleurs);  // 3
echo sizeof($couleurs); // 3 (identique)
?>

Dans la pratique, je vous conseille de privilégier count() pour une raison simple : c’est le terme que vous retrouverez dans la documentation officielle, dans les tutoriels, et dans la majorité des bases de code open source. Pour approfondir les différences subtiles entre ces deux fonctions, consultez notre guide comparatif sizeof vs count en PHP.

Notez que sizeof() vient du langage C, où elle sert à mesurer la taille en octets d’une variable. En PHP, son comportement est totalement différent : elle compte les éléments, pas les octets. Cette ambiguïté est une raison supplémentaire de préférer count() pour obtenir le length array php.

Compter les éléments d’un tableau multidimensionnel

La fonction count() accepte un second paramètre optionnel : le mode de comptage. Par défaut, elle utilise COUNT_NORMAL (valeur 0), qui ne compte que les éléments du premier niveau. Pour compter tous les éléments, y compris ceux des sous-tableaux, on utilise COUNT_RECURSIVE (valeur 1).

<?php
$classes = [
    'BTS_SIO' => ['Alice', 'Bob', 'Charlie'],
    'BTS_SNIR' => ['David', 'Eve'],
    'Licence_Pro' => ['Frank', 'Grace', 'Henri', 'Irène']
];

// Comptage normal : 3 clés de premier niveau
echo count($classes); // 3

// Comptage récursif : 3 clés + 9 étudiants = 12
echo count($classes, COUNT_RECURSIVE); // 12

// Pour obtenir uniquement le nombre total d'étudiants :
$total_etudiants = count($classes, COUNT_RECURSIVE) - count($classes);
echo $total_etudiants; // 9
?>

Attention, le comptage récursif inclut les clés parentes dans le total. C’est un piège classique. Si vous avez besoin de la php array length uniquement pour les éléments feuilles, pensez à soustraire le nombre de clés du premier niveau comme dans l’exemple ci-dessus.

Pour les tableaux très profondément imbriqués, le comptage récursif peut devenir moins lisible. Dans ce cas, une fonction personnalisée avec array_walk_recursive() sera plus adaptée.

<?php
$total = 0;
array_walk_recursive($classes, function() use (&$total) {
    $total++;
});
echo $total; // 9 (uniquement les valeurs feuilles)
?>

Tableau comparatif des fonctions liées à la taille d’un array

Pour y voir clair entre les différentes fonctions qui gravitent autour de la notion de length php array, voici un récapitulatif complet.

Ce tableau montre clairement que count() reste le choix par défaut. Les autres fonctions répondent à des besoins spécifiques et ne doivent pas être confondues avec la mesure simple du php length array. Si vous travaillez avec des bases de données et souhaitez compter des enregistrements uniques, consultez notre article sur le COUNT unique en SQL qui complète bien cette approche.

Cas pratiques : boucles, conditions et validation

Connaître la php for array length est essentiel dans plusieurs situations concrètes. Voici les cas que je rencontre le plus souvent en formation et en production.

Boucle for classique avec count()

<?php
$produits = ['Clavier', 'Souris', 'Écran', 'Casque'];
$taille = count($produits);

for ($i = 0; $i < $taille; $i++) {
    echo ($i + 1) . '. ' . $produits[$i] . PHP_EOL;
}
?>

Un conseil important : stockez le résultat de count() dans une variable avant la boucle. Même si count() est en O(1), l’appeler à chaque itération dans la condition du for est une mauvaise habitude qui peut poser problème avec d’autres structures de données.

Vérifier qu’un tableau n’est pas vide

<?php
$resultats = recupererDonnees();

if (count($resultats) === 0) {
    echo 'Aucun résultat trouvé.';
} else {
    echo count($resultats) . ' résultats trouvés.';
}

// Alternative plus idiomatique en PHP :
if (empty($resultats)) {
    echo 'Aucun résultat trouvé.';
}
?>

Pour tester si un tableau est vide, empty() est souvent plus lisible que count() === 0. Je vous renvoie à notre guide complet sur PHP empty pour bien comprendre les subtilités de cette fonction.

Pagination avec count()

<?php
$elements = range(1, 97); // 97 éléments
$par_page = 10;
$total_pages = ceil(count($elements) / $par_page);

echo "Total : " . count($elements) . " éléments\n";
echo "Pages : " . $total_pages . "\n"; // 10 pages
?>

Ce pattern de pagination utilise count() combiné à ceil() pour déterminer le nombre de pages. C’est un classique des applications web PHP que vous retrouverez dans pratiquement tous les projets.

Validation de formulaire

<?php
$erreurs = [];

if (strlen($nom) < 2) {
    $erreurs[] = 'Le nom doit contenir au moins 2 caractères.';
}
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
    $erreurs[] = 'L\'adresse email n\'est pas valide.';
}

if (count($erreurs) > 0) {
    foreach ($erreurs as $erreur) {
        echo '<p class="erreur">' . htmlspecialchars($erreur) . '</p>';
    }
} else {
    // Traiter le formulaire
}
?>

Dans cet exemple, count() sert à déterminer si le tableau d’erreurs contient des éléments. C’est un pattern fondamental en validation de données côté serveur.

Erreurs courantes et pièges à éviter

En tant que formatrice, je vois régulièrement les mêmes erreurs liées au php array length. Voici les plus fréquentes.

Piège n°1 : utiliser count() sur une variable non définie

<?php
// ⚠ Depuis PHP 8.0, ceci génère un avertissement :
$resultat = count($variable_inexistante);
// Warning: Undefined variable $variable_inexistante

// Bonne pratique :
$resultat = isset($variable) ? count($variable) : 0;
?>

Depuis PHP 7.2, passer une valeur non comptable (comme null) à count() déclenche un E_WARNING. Avec PHP 8.x, ces avertissements sont encore plus stricts. Vérifiez toujours que votre variable existe et est bien un tableau avant de la compter.

Piège n°2 : confondre count() et strlen()

<?php
$chaine = 'Bonjour';
echo count($chaine); // Retourne 1, PAS 7 !
echo strlen($chaine); // Retourne 7 (nombre de caractères)
?>

Appliquer count() sur une chaîne de caractères retourne toujours 1, car PHP la considère comme un élément scalaire unique. Pour la longueur d’une chaîne, utilisez strlen() ou mb_strlen() pour les caractères multi-octets. Si vous avez besoin d’extraire une portion de chaîne, notre article sur PHP substr vous sera utile.

Piège n°3 : oublier que les clés ne sont pas consécutives

<?php
$notes = [0 => 15, 3 => 12, 7 => 18];
echo count($notes); // 3 (et non 8)

// La boucle for classique échouera ici :
for ($i = 0; $i < count($notes); $i++) {
    echo $notes[$i]; // Notice: Undefined offset pour $i = 1 et 2
}

// Utilisez foreach à la place :
foreach ($notes as $cle => $valeur) {
    echo "Clé $cle : $valeur\n";
}
?>

Ce piège est classique quand on supprime des éléments d’un tableau avec unset() : les indices ne sont pas réindexés automatiquement. La fonction count() retourne bien le nombre d’éléments existants, mais les indices peuvent avoir des trous.

Fonctions complémentaires pour manipuler vos arrays

Au-delà de la simple mesure du length of array php, PHP offre un arsenal complet de fonctions pour travailler avec les tableaux. En voici les plus utiles en complément de count().

array_keys() : compter les clés

<?php
$config = [
    'host' => 'localhost',
    'port' => 3306,
    'db' => 'ma_base',
    'charset' => 'utf8mb4'
];

$cles = array_keys($config);
echo count($cles); // 4
// $cles = ['host', 'port', 'db', 'charset']
?>

La fonction array_keys() retourne un tableau contenant toutes les clés. Combinée avec count(), elle permet de compter spécifiquement le nombre de clés, ce qui est utile pour les tableaux associatifs complexes. Ce principe de comptage des clés se retrouve aussi en SQL avec le COUNT DISTINCT.

in_array() : vérifier si un élément existe

<?php
$langages = ['PHP', 'JavaScript', 'Python', 'Java'];

if (in_array('PHP', $langages)) {
    echo 'PHP est dans la liste !';
}

// Mode strict recommandé :
if (in_array('PHP', $langages, true)) {
    echo 'PHP trouvé avec vérification de type.';
}
?>

Pour vérifier si un PHP array contains un élément spécifique, in_array() est la fonction à utiliser. Je recommande toujours le mode strict (troisième paramètre à true) pour éviter les comparaisons lâches qui peuvent produire des résultats inattendus.

array_count_values() : compter les occurrences

<?php
$votes = ['oui', 'non', 'oui', 'oui', 'non', 'abstention', 'oui'];
$resultats = array_count_values($votes);

print_r($resultats);
// Array ( [oui] => 4 [non] => 2 [abstention] => 1 )
?>

Cette fonction est l’équivalent PHP du count php avec regroupement. Elle compte combien de fois chaque valeur apparaît dans le tableau. C’est particulièrement utile pour des statistiques rapides ou pour compter les éléments d’un array avec une valeur spécifique.

asort() : trier en préservant les clés

La question « what is asort() in PHP? » revient souvent dans les forums. La fonction asort() trie un tableau par valeurs en ordre croissant tout en conservant l’association entre les clés et les valeurs. C’est la différence majeure avec sort(), qui réindexe les clés numériquement.

<?php
$notes = [
    'Alice' => 15,
    'Bob' => 12,
    'Charlie' => 18,
    'David' => 14
];

asort($notes);
print_r($notes);
// Array ( [Bob] => 12 [David] => 14 [Alice] => 15 [Charlie] => 18 )

// Le nombre d'éléments reste identique après le tri
echo count($notes); // 4
?>

Notez que asort() modifie le tableau en place (elle retourne un booléen, pas un nouveau tableau). Le php array size reste inchangé après un tri : aucun élément n’est ajouté ni supprimé. Si vous cherchez à trier des données issues d’une base SQL, notre guide sur SQL ORDER BY avec plusieurs colonnes complète bien cette approche.

Performance et benchmarks : count() face aux alternatives

Pour les projets à fort trafic, la question des performances se pose légitimement. J’ai réalisé des benchmarks sur PHP 8.3 avec des tableaux de tailles variées pour mesurer le temps d’exécution de count().

Le résultat est sans appel : count() en mode normal conserve un temps constant quelle que soit la taille du tableau. C’est parce que PHP maintient un compteur interne dans la structure HashTable qui sous-tend chaque array. La documentation officielle de count() sur php.net confirme ce comportement.

En revanche, le mode récursif et la boucle manuelle voient leur temps augmenter linéairement. La conclusion est simple : pour obtenir le length of an array php, count() en mode normal est toujours le choix optimal.

Objets Countable

Depuis PHP 5.1, les objets peuvent implémenter l’interface Countable pour fonctionner avec count(). C’est le cas de nombreuses classes du framework Laravel (Collection) ou de Doctrine (ArrayCollection).

<?php
class Panier implements Countable
{
    private array $articles = [];

    public function ajouter(string $article): void
    {
        $this->articles[] = $article;
    }

    public function count(): int
    {
        return count($this->articles);
    }
}

$panier = new Panier();
$panier->ajouter('Livre PHP');
$panier->ajouter('Câble USB');

echo count($panier); // 2
?>

Cette interface est documentée dans le manuel PHP sur l’interface Countable. Elle permet de rendre vos propres classes compatibles avec count(), ce qui est une bonne pratique orientée objet.

Bonnes pratiques pour gérer la taille de vos tableaux

Après plusieurs années d’enseignement et de développement, voici les recommandations que je partage systématiquement avec mes étudiants et mes collègues développeurs.

Utilisez toujours count() plutôt que sizeof()

Même si les deux fonctions sont identiques techniquement, count() est le standard communautaire. Les outils d’analyse statique comme PHPStan et les règles PSR encouragent son usage. En utilisant count(), votre code sera immédiatement compréhensible par tout développeur PHP.

Typez vos paramètres

<?php
// ❌ Risqué : $items pourrait être null
function traiter($items) {
    $nb = count($items); // Warning si null en PHP 8+
}

// ✅ Sûr : le typage garantit un tableau
function traiter(array $items): void {
    $nb = count($items); // Toujours valide
}
?>

Le typage strict (declare(strict_types=1)) combiné au type hint array élimine la classe entière de bugs liés à l’appel de count() sur des valeurs non comptables. C’est une pratique que j’impose dans tous mes projets depuis PHP 7.4.

Préférez foreach à for + count()

En PHP, foreach est presque toujours plus lisible et plus sûr qu’une boucle for avec un index numérique. Réservez la boucle for aux cas où vous avez réellement besoin de l’indice pour accéder aux éléments voisins ou pour modifier le tableau en cours d’itération.

<?php
$noms = ['Alice', 'Bob', 'Charlie'];

// ❌ Verbose et fragile
for ($i = 0; $i < count($noms); $i++) {
    echo $noms[$i];
}

// ✅ Clair et robuste
foreach ($noms as $nom) {
    echo $nom;
}
?>

Si vous travaillez avec des dates dans vos tableaux, pensez à combiner ces techniques avec les outils de manipulation temporelle décrits dans notre guide PHP DateTime.

Combinez count() avec les opérations sur les tableaux

<?php
// Compter les éléments filtrés
$ages = [15, 22, 17, 30, 16, 25, 19];
$majeurs = array_filter($ages, fn($age) => $age >= 18);
echo count($majeurs); // 4

// Vérifier si deux tableaux ont la même taille
$questions = ['Q1', 'Q2', 'Q3'];
$reponses = ['R1', 'R2'];

if (count($questions) !== count($reponses)) {
    throw new InvalidArgumentException(
        'Le nombre de réponses ne correspond pas au nombre de questions.'
    );
}
?>

Ces patterns sont courants dans le développement professionnel. La combinaison de array_filter() et count() permet notamment de compter les éléments d’un array avec une valeur spécifique sans écrire de boucle manuelle. Pour échanger autour de ces bonnes pratiques avec d’autres développeurs, n’hésitez pas à rejoindre un forum PHP actif.

Utilisez les enums PHP 8.1+ avec vos tableaux

<?php
enum Statut: string {
    case Actif = 'actif';
    case Inactif = 'inactif';
    case Suspendu = 'suspendu';
}

$utilisateurs = [
    ['nom' => 'Alice', 'statut' => Statut::Actif],
    ['nom' => 'Bob', 'statut' => Statut::Inactif],
    ['nom' => 'Charlie', 'statut' => Statut::Actif],
];

$actifs = array_filter(
    $utilisateurs,
    fn($u) => $u['statut'] === Statut::Actif
);
echo count($actifs); // 2
?>

Les enums PHP apportent une sécurité de type supplémentaire lorsque vous filtrez et comptez des éléments dans vos tableaux. C’est une fonctionnalité moderne qui renforce la fiabilité de votre code.

Lucie Moreau

Formatrice IT indépendante depuis 2016, ancienne étudiante BTS SIO SLAM. 6 ans d'expérience en entreprise.