Quand on débute en PHP, on cherche souvent l’équivalent de len() en Python ou de .length en JavaScript pour obtenir la taille d’un tableau. La bonne nouvelle : PHP propose une solution simple et directe. Je vous explique dans ce guide comment obtenir le len of array php de manière fiable, avec tous les cas particuliers que vous rencontrerez en BTS SIO ou en production.

count() : la fonction standard pour le len of array en PHP

En PHP, la fonction native pour obtenir la longueur d’un tableau est count(). C’est la réponse directe à la question « how to get a length of array in PHP ». Contrairement à d’autres langages qui utilisent une propriété (.length, .size), PHP utilise une fonction dédiée.

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

La syntaxe est limpide : count($monTableau) retourne un entier correspondant au nombre d’éléments. Cette fonction fonctionne aussi bien avec les tableaux indexés (clés numériques) qu’avec les tableaux associatifs (clés nommées).

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

Un point important : count() ne fait pas la distinction entre les types de clés. Elle compte simplement le nombre de paires clé-valeur au premier niveau du tableau. Pour aller plus loin sur les fonctions de base des tableaux, je vous recommande de consulter mon guide sur la taille d’un array en PHP et le choix de la bonne fonction.

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

Vous tomberez parfois sur sizeof() dans du code PHP existant. 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, la réponse est ni l’un ni l’autre au sens objet du terme, mais sizeof() existe bien comme alias fonctionnel.

<?php
$notes = [12, 15, 8, 19, 14];
echo sizeof($notes);  // Affiche : 5
echo count($notes);   // Affiche : 5
// Résultats strictement identiques
?>

En pratique, je conseille d’utiliser count() plutôt que sizeof(). La raison est simple : count() est le nom officiel dans la documentation officielle PHP, et c’est celui que vos collègues reconnaîtront immédiatement. Pour une comparaison détaillée entre ces deux fonctions, consultez mon article dédié sur sizeof vs count en PHP.

Obtenir la longueur d’un tableau multidimensionnel

Les choses deviennent plus intéressantes avec les tableaux imbriqués. Par défaut, count() ne compte que les éléments du premier niveau. Pour compter récursivement tous les éléments, y compris ceux des sous-tableaux, on utilise le paramètre COUNT_RECURSIVE.

<?php
$classes = [
    'BTS_SIO1' => ['Alice', 'Bob', 'Charlie'],
    'BTS_SIO2' => ['David', 'Eve'],
    'BTS_SLAM' => ['Frank', 'Grace', 'Heidi', 'Ivan']
];

// Comptage de premier niveau
echo count($classes);                    // Affiche : 3

// Comptage récursif
echo count($classes, COUNT_RECURSIVE);   // Affiche : 12
// 3 (clés de premier niveau) + 3 + 2 + 4 (éléments internes) = 12
?>

Attention au piège : le comptage récursif inclut aussi les clés de premier niveau dans le total. Pour obtenir uniquement le nombre d’éléments des sous-tableaux, il faut soustraire le count de premier niveau.

<?php
$totalEleves = count($classes, COUNT_RECURSIVE) - count($classes);
echo $totalEleves; // Affiche : 9 (nombre réel d'élèves)
?>

Cette technique est particulièrement utile quand vous traitez des données issues d’une requête SQL avec des résultats groupés. Si vous travaillez sur des agrégations en base de données, je vous invite à jeter un œil à mon article sur COUNT DISTINCT en SQL pour compléter votre compréhension.

Comportement de count() selon le type de variable

Comprendre comment count() réagit face à différents types de variables est essentiel pour écrire du code robuste. Voici le comportement détaillé, surtout pertinent si vous cherchez à savoir how to count len in PHP de manière fiable.

Le changement majeur entre PHP 7 et PHP 8 concerne le typage strict. En PHP 8, passer autre chose qu’un tableau ou un objet Countable à count() déclenche un TypeError. C’est un progrès pour la qualité du code, mais cela peut casser des applications migrées sans vérification. Pour tester si une variable est vide avant de la compter, consultez mon guide sur les pièges de empty() en PHP.

<?php
// Bonne pratique : vérifier le type avant de compter
$donnees = recupererDonnees(); // Peut retourner null

if (is_array($donnees)) {
    echo count($donnees) . ' éléments trouvés';
} else {
    echo 'Aucune donnée disponible';
}
?>

Alternatives à count() pour mesurer un tableau

Bien que count() soit la solution canonique pour obtenir le php len array, d’autres approches existent selon le contexte.

array_key_last() et array_key_first()

Disponibles depuis PHP 7.3, ces fonctions ne retournent pas directement la longueur, mais permettent d’obtenir la dernière ou la première clé. Pour un tableau indexé séquentiellement à partir de 0, array_key_last($tab) + 1 donne la longueur. Mais attention : si les clés ne sont pas séquentielles, le résultat sera faux.

<?php
$sequentiel = ['a', 'b', 'c', 'd'];
echo array_key_last($sequentiel) + 1; // 4 (correct)

$nonSequentiel = [0 => 'x', 5 => 'y', 10 => 'z'];
echo array_key_last($nonSequentiel) + 1; // 11 (incorrect !)
echo count($nonSequentiel);              // 3 (correct)
?>

iterator_count() pour les itérateurs

Quand vous travaillez avec des générateurs ou des objets Traversable qui n’implémentent pas Countable, iterator_count() parcourt l’itérateur pour compter les éléments. C’est utile, mais consomme l’itérateur.

<?php
function genererNombres(int $max): Generator {
    for ($i = 1; $i <= $max; $i++) {
        yield $i;
    }
}

$gen = genererNombres(100);
echo iterator_count($gen); // Affiche : 100
// Attention : le générateur est maintenant épuisé
?>

L’interface Countable pour vos classes

Si vous créez vos propres classes qui encapsulent des collections, implémentez l’interface Countable. Cela permet d’utiliser count() directement sur vos objets, ce qui rend le code plus naturel et conforme aux standards PHP. Cette approche s’inscrit dans les bonnes pratiques de la programmation orientée objet, un sujet central en BTS SIO option SLAM.

<?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('Clavier');
$panier->ajouter('Souris');
$panier->ajouter('Écran');

echo count($panier); // Affiche : 3
?>

Performances et benchmarks : php len array en pratique

Une question légitime se pose : count() est-elle performante sur de gros tableaux ? La réponse est oui. PHP stocke en interne le nombre d’éléments d’un tableau dans une structure appelée HashTable. L’appel à count() sur un tableau classique a donc une complexité en O(1) : le résultat est immédiat, quelle que soit la taille du tableau.

Comme le montre ce benchmark, count() et sizeof() ont des performances constantes. En revanche, compter manuellement avec une boucle for est linéaire en O(n) et donc à proscrire. PHP optimise en interne le stockage de la taille ; la consulter via count() revient à lire un simple entier en mémoire.

Un point important pour les boucles : évitez d’appeler count() dans la condition d’un for si le tableau ne change pas pendant l’itération. Bien que le coût soit minime, c’est une bonne habitude de programmation que de stocker le résultat dans une variable.

<?php
$elements = range(1, 10000);

// Moins propre (appel répété, même si peu coûteux)
for ($i = 0; $i < count($elements); $i++) {
    // traitement
}

// Plus propre
$total = count($elements);
for ($i = 0; $i < $total; $i++) {
    // traitement
}

// Encore mieux : utiliser foreach quand c'est possible
foreach ($elements as $element) {
    // traitement
}
?>

La boucle foreach est d’ailleurs la manière idiomatique de parcourir un tableau en PHP. Pour approfondir les structures de contrôle, la documentation PHP sur les boucles for est une excellente ressource.

Erreurs fréquentes et pièges à éviter

En formation BTS SIO, je vois régulièrement les mêmes erreurs liées au len array php. Voici les plus courantes et comment les corriger.

Piège 1 : confondre count() et strlen()

C’est l’erreur classique quand on vient de Python où len() fonctionne sur tout. En PHP, strlen() mesure la longueur d’une chaîne de caractères, tandis que count() mesure la taille d’un tableau. Utilisez la bonne fonction selon le type de données. Pour manipuler des chaînes, consultez mon article sur PHP substr et l’extraction de sous-chaînes.

<?php
$texte = "Bonjour le monde";
$mots = explode(' ', $texte); // Découpe en tableau

echo strlen($texte);  // 16 (nombre de caractères)
echo count($mots);    // 3 (nombre de mots)
?>

Piège 2 : count() sur une variable potentiellement null

En PHP 8+, passer null à count() génère une erreur fatale. Toujours vérifier avec is_array() ou utiliser l’opérateur de coalescence nulle.

<?php
// Dangereux en PHP 8+
$resultat = $connexion->query($sql)->fetchAll();
$nombre = count($resultat); // TypeError si fetchAll() retourne null

// Sûr
$nombre = is_array($resultat) ? count($resultat) : 0;

// Alternative avec l'opérateur ??
$nombre = count($resultat ?? []);
?>

Piège 3 : oublier que les clés comptent dans COUNT_RECURSIVE

Comme je l’ai montré plus haut, COUNT_RECURSIVE inclut les clés des sous-tableaux dans le décompte total. N’oubliez pas de soustraire le count de premier niveau si vous voulez uniquement les éléments imbriqués.

Piège 4 : compter les valeurs uniques

Si vous cherchez le nombre de valeurs distinctes dans un tableau, count() seul ne suffit pas. Combinez-le avec array_unique().

<?php
$tags = ['php', 'javascript', 'php', 'python', 'javascript', 'php'];

echo count($tags);                    // 6 (total)
echo count(array_unique($tags));      // 3 (valeurs uniques)
?>

Cette logique est l’équivalent PHP du COUNT unique en SQL que vous utilisez côté base de données.

Cas pratiques : boucles, conditions et validations

Voyons comment utiliser count() dans des situations concrètes que vous rencontrerez en projet.

Valider un formulaire avec un nombre minimum de sélections

<?php
$competencesSelectionnees = $_POST['competences'] ?? [];

if (!is_array($competencesSelectionnees)) {
    $erreur = 'Format invalide';
} elseif (count($competencesSelectionnees) < 3) {
    $erreur = 'Veuillez sélectionner au moins 3 compétences';
} elseif (count($competencesSelectionnees) > 10) {
    $erreur = 'Maximum 10 compétences autorisées';
} else {
    // Traitement valide
    sauvegarderCompetences($competencesSelectionnees);
}
?>

Paginer des résultats

<?php
$articles = recupererTousLesArticles();
$totalArticles = count($articles);
$parPage = 12;
$totalPages = (int) ceil($totalArticles / $parPage);
$pageCourante = max(1, min($totalPages, (int)($_GET['page'] ?? 1)));

$debut = ($pageCourante - 1) * $parPage;
$articlesPage = array_slice($articles, $debut, $parPage);

echo "Page $pageCourante sur $totalPages ($totalArticles articles au total)";
?>

Construire une requête SQL dynamique

<?php
$conditions = [];
$parametres = [];

if (!empty($_GET['ville'])) {
    $conditions[] = 'ville = :ville';
    $parametres[':ville'] = $_GET['ville'];
}
if (!empty($_GET['age_min'])) {
    $conditions[] = 'age >= :age_min';
    $parametres[':age_min'] = (int) $_GET['age_min'];
}

$sql = 'SELECT * FROM utilisateurs';
if (count($conditions) > 0) {
    $sql .= ' WHERE ' . implode(' AND ', $conditions);
}

$stmt = $pdo->prepare($sql);
$stmt->execute($parametres);
$resultats = $stmt->fetchAll();
echo count($resultats) . ' utilisateurs trouvés';
?>

Dans cet exemple, on utilise count() à deux reprises : d’abord pour vérifier s’il y a des conditions à ajouter à la requête, puis pour afficher le nombre de résultats. Notez l’utilisation de implode() pour joindre les conditions. Ce type de construction dynamique est courant dans les projets web ; pour aller plus loin sur le tri des résultats, consultez mon article sur SQL ORDER BY avec plusieurs colonnes.

Vérifier si un tableau est vide

Pour tester si un tableau est vide, vous avez deux options. La première utilise count(), la seconde utilise empty(). Les deux fonctionnent, mais empty() est légèrement plus lisible dans ce contexte précis, et elle ne déclenche pas de TypeError sur null en PHP 8. Pour approfondir les subtilités de empty(), mon guide sur PHP empty couvre tous les cas limites.

<?php
$panier = [];

// Deux manières équivalentes
if (count($panier) === 0) {
    echo 'Votre panier est vide';
}

if (empty($panier)) {
    echo 'Votre panier est vide';
}
?>

Synthèse et bonnes pratiques

Après avoir exploré toutes les facettes du len of array php, voici les règles que j’applique systématiquement dans mes projets et que je transmets à mes étudiants. Que vous prépariez votre BTS SIO ou que vous développiez une application en production, ces principes vous éviteront bien des bugs.

Retenez surtout que PHP, contrairement à Python ou JavaScript, n’a pas de propriété .length ou de fonction universelle len(). Chaque type a sa propre fonction : count() pour les tableaux, strlen() pour les chaînes, mb_strlen() pour les chaînes multi-octets. Cette séparation peut sembler rigide au départ, mais elle rend le code plus explicite et prévient les erreurs de type. Si vous avez des questions ou souhaitez échanger avec d’autres développeurs PHP, les forums PHP francophones sont une excellente ressource communautaire.

Lucie Moreau

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