Quand j’ai commencé à enseigner PHP en BTS SIO, une question revenait chaque année dans mes classes : « Madame, on utilise sizeof() ou count() pour compter les éléments d’un tableau ? ». Cette confusion est parfaitement normale. En C ou en Java, sizeof a un rôle très différent de ce qu’il fait en PHP. Je vais vous expliquer précisément ce qui se passe sous le capot, pourquoi ces deux fonctions existent, et laquelle choisir dans vos projets.

sizeof() : un alias officiel de count()

La réponse courte est simple : sizeof() et count() font exactement la même chose en PHP. La documentation officielle PHP le confirme sans ambiguïté : sizeof() est un alias de count(). Cela signifie que lorsque vous appelez sizeof($monTableau), PHP exécute en interne exactement le même code que count($monTableau).

Cette situation existe pour une raison historique. PHP a été conçu pour être accessible aux développeurs venant d’autres langages. En C, sizeof est un opérateur qui retourne la taille en octets d’une variable ou d’un type. Les créateurs de PHP ont ajouté sizeof() comme alias pour que les développeurs C se sentent à l’aise. Mais attention : php array sizeof ne retourne pas la taille en octets comme en C. Il retourne le nombre d’éléments du tableau, exactement comme count().

Dans le code source de PHP (fichier basic_functions.c), les deux fonctions pointent vers la même implémentation interne :

// Extrait simplifié du code source PHP
PHP_FUNCTION(sizeof) {
    // Appelle exactement la même logique que count()
    php_count(INTERNAL_FUNCTION_PARAM_PASSTHRU);
}

Il n’y a donc aucune différence fonctionnelle entre les deux. Pas de différence de vitesse significative, pas de différence de comportement, pas de différence de valeur retournée.

Syntaxe et exemples pratiques

Voyons comment utiliser ces deux fonctions dans des cas concrets. Je vous montre d’abord la syntaxe de base, puis des exemples que j’utilise régulièrement en cours avec mes étudiants.

Syntaxe de base

<?php
// Les deux écritures sont strictement équivalentes
$fruits = ['pomme', 'banane', 'cerise', 'mangue'];

echo count($fruits);   // Affiche 4
echo sizeof($fruits);  // Affiche 4

Les deux fonctions acceptent la même signature :

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

Exemple avec un tableau associatif

<?php
$etudiant = [
    'nom'    => 'Dupont',
    'prenom' => 'Marie',
    'age'    => 22,
    'option' => 'SLAM'
];

$nb = count($etudiant);
echo "Ce tableau contient $nb éléments."; // Affiche 4

Utilisation dans une boucle for

Un cas classique que je vois souvent dans les copies de mes étudiants :

<?php
$notes = [12, 15, 8, 17, 14, 11];
$somme = 0;

for ($i = 0; $i < count($notes); $i++) {
    $somme += $notes[$i];
}

$moyenne = $somme / count($notes);
echo "Moyenne : $moyenne"; // Affiche 12.833...

Conseil de performance : dans une boucle for, stockez le résultat de count() dans une variable plutôt que de l’appeler à chaque itération. Même si PHP optimise ce cas en interne pour les tableaux simples, c’est une bonne habitude :

<?php
$total = count($notes);
for ($i = 0; $i < $total; $i++) {
    $somme += $notes[$i];
}

COUNT_RECURSIVE et tableaux multidimensionnels

Les deux fonctions acceptent un second paramètre qui modifie leur comportement avec les tableaux imbriqués. C’est un point souvent méconnu des débutants, et pourtant très utile quand on manipule des structures de données complexes.

<?php
$classe = [
    'SLAM' => ['Alice', 'Bob', 'Charlie'],
    'SISR' => ['David', 'Emma'],
    'AP'   => ['Fatou', 'Gilles', 'Hugo', 'Inès']
];

// Mode normal : compte uniquement le premier niveau
echo count($classe);                    // Affiche 3
echo count($classe, COUNT_NORMAL);      // Affiche 3 (identique)

// Mode récursif : compte TOUS les éléments à tous les niveaux
echo count($classe, COUNT_RECURSIVE);   // Affiche 12 (3 + 3 + 2 + 4)
echo sizeof($classe, COUNT_RECURSIVE);  // Affiche 12 (même résultat)

Le mode COUNT_RECURSIVE (dont la constante vaut 1) additionne les éléments du tableau parent avec ceux de tous les sous-tableaux. Le résultat 12 se décompose ainsi : 3 clés de premier niveau (SLAM, SISR, AP) plus 3 + 2 + 4 = 9 valeurs dans les sous-tableaux.

Pour obtenir uniquement le nombre total d’étudiants sans compter les clés du premier niveau, il faut soustraire :

<?php
$totalEtudiants = count($classe, COUNT_RECURSIVE) - count($classe);
echo $totalEtudiants; // Affiche 9

Cette technique est particulièrement pratique quand vous travaillez avec des données JSON décodées ou des résultats de requêtes groupées. Si vous manipulez des structures conditionnelles complexes autour de vos tableaux, je vous recommande de consulter mon guide sur le switch en PHP pour organiser votre logique proprement.

Benchmark : sizeof() vs count() en performance

J’ai mené un benchmark simple pour répondre définitivement à la question de la performance. Voici le script de test que j’utilise avec mes étudiants :

<?php
$tableau = range(1, 10000);
$iterations = 1000000;

// Test count()
$start = microtime(true);
for ($i = 0; $i < $iterations; $i++) {
    count($tableau);
}
$tempsCount = microtime(true) - $start;

// Test sizeof()
$start = microtime(true);
for ($i = 0; $i < $iterations; $i++) {
    sizeof($tableau);
}
$tempsSizeof = microtime(true) - $start;

echo "count()  : {$tempsCount}s\n";
echo "sizeof() : {$tempsSizeof}s\n";

Les résultats sur PHP 8.3 avec un tableau de 10 000 éléments et 1 million d’itérations sont les suivants :

La différence est totalement négligeable. Sur un million d’appels, on parle d’environ 1 milliseconde d’écart. Dans la pratique, votre application ne ressentira jamais cette différence. Le léger surcoût de sizeof() vient de la résolution de l’alias, mais il est si infime qu’il ne constitue en aucun cas un critère de choix.

Pour comparer, une seule requête SQL prend en moyenne entre 1 et 50 millisecondes. Le choix entre sizeof() et count() n’aura jamais d’impact mesurable sur vos temps de réponse. Si vous cherchez à optimiser vos requêtes SQL, mon article sur COUNT DISTINCT en SQL vous sera plus utile.

Comparatif des fonctions liées à la taille d’un tableau

PHP offre plusieurs fonctions pour interroger un tableau. Je vous propose un récapitulatif complet pour ne plus jamais confondre leurs rôles :

Notez bien que strlen() compte les octets d’une chaîne, pas les éléments d’un tableau. C’est une confusion que je rencontre parfois chez les développeurs qui viennent de JavaScript où .length fonctionne aussi bien sur les tableaux que sur les chaînes. En PHP, chaque type a sa propre fonction.

Bonnes pratiques pour vos projets PHP

Après plus de dix ans d’enseignement et de développement professionnel, voici mes recommandations claires concernant l’utilisation de php array sizeof et count() :

Privilégiez count() systématiquement

La communauté PHP et les standards PSR recommandent d’utiliser count() plutôt que sizeof(). Voici pourquoi :

• Clarté sémantique : count() exprime clairement l’intention de compter des éléments
• Pas de confusion avec le C : sizeof évoque la taille mémoire pour les développeurs venant d’autres langages
• Cohérence des outils : PHPStan, Psalm et PHP-CS-Fixer signalent souvent sizeof() comme un alias à remplacer
• Lisibilité en équipe : un standard unique évite les débats inutiles en revue de code

Configurez votre linter

Si vous utilisez PHP-CS-Fixer, ajoutez la règle no_alias_functions dans votre fichier de configuration :

<?php
// .php-cs-fixer.php
return (new PhpCsFixer\Config())
    ->setRules([
        'no_alias_functions' => true,
        // ... vos autres règles
    ]);

Cette règle remplacera automatiquement tous les sizeof() par count() lors du formatage du code. C’est ce que je configure systématiquement dans les projets que je supervise.

Utilisez l’interface Countable pour vos objets

Un point avancé que j’aborde avec mes étudiants en deuxième année : vous pouvez rendre vos propres objets compatibles avec count() en implémentant l’interface Countable :

<?php
class Promotion implements Countable
{
    private array $etudiants = [];

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

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

$promo = new Promotion();
$promo->ajouter('Alice');
$promo->ajouter('Bob');

echo count($promo); // Affiche 2

Cette approche est bien plus élégante que d’exposer un getter getNombreEtudiants(). Elle s’intègre naturellement dans le langage. Pour structurer vos classes avec des valeurs prédéfinies, pensez aux énumérations PHP qui complètent très bien ce pattern.

Pièges courants avec PHP 8 et versions récentes

Depuis PHP 7.2 et surtout PHP 8.0, le comportement de count() et sizeof() a évolué sur certains cas limites. Voici les pièges que je signale systématiquement à mes étudiants :

Passer null déclenche un warning

<?php
// PHP 7.x : retourne 0 silencieusement
// PHP 8.0+ : retourne 0 MAIS génère un E_WARNING
$valeur = null;
echo count($valeur); // Warning: count(): Parameter must be an array or Countable

Pour éviter ce warning, vérifiez toujours le type avant d’appeler count() :

<?php
$donnees = fetchFromApi(); // Peut retourner null

// Mauvaise pratique
$nb = count($donnees); // Warning si null

// Bonne pratique : coalescence null
$nb = count($donnees ?? []);

// Ou vérification explicite
$nb = is_array($donnees) ? count($donnees) : 0;

Compter une chaîne de caractères

<?php
$texte = "Bonjour";
echo count($texte); // Retourne 1 (pas 7 !)
echo strlen($texte); // Retourne 7

C’est un piège classique : count() sur un scalaire retourne 1 (car PHP considère toute variable non-tableau comme un élément unique). Pour la longueur d’une chaîne, utilisez strlen() ou mb_strlen() pour les chaînes multi-octets.

Compter un booléen ou un entier

<?php
echo count(42);    // Retourne 1, Warning en PHP 8.0+
echo count(true);  // Retourne 1, Warning en PHP 8.0+
echo count(false); // Retourne 1, Warning en PHP 8.0+

En PHP 8.0+, passer un type non supporté génère un avertissement. Depuis PHP 8.2, les déprécations liées aux types se sont encore renforcées. Prenez l’habitude de typer vos paramètres pour éviter ces situations. Si vous gérez des structures conditionnelles multiples, mon article sur les instructions case en PHP peut vous aider à organiser ces vérifications.

Obtenir la taille mémoire d’un tableau en PHP

Une recherche fréquente autour de php array sizeof concerne la taille en octets d’un tableau, et non le nombre de ses éléments. C’est justement la confusion héritée du C que j’évoquais plus tôt.

PHP ne dispose pas d’un équivalent direct au sizeof du C pour mesurer la mémoire. Mais vous pouvez utiliser memory_get_usage() avec une astuce :

<?php
$avant = memory_get_usage();
$tableau = range(1, 10000);
$apres = memory_get_usage();

$tailleOctets = $apres - $avant;
echo "Taille approximative : " . number_format($tailleOctets) . " octets";
// Affiche environ 528 096 octets pour 10 000 entiers

Pour un calcul plus précis, la fonction serialize() donne une estimation de la taille sérialisée :

<?php
$tableau = ['nom' => 'Dupont', 'age' => 25, 'ville' => 'Lyon'];
$taille = strlen(serialize($tableau));
echo "Taille sérialisée : $taille octets"; // Environ 70 octets

Gardez à l’esprit que la taille en mémoire d’un tableau PHP est bien supérieure à la somme de ses valeurs. Chaque entrée du tableau consomme environ 32 à 72 octets de surcharge (overhead) pour stocker les métadonnées internes (hash, pointeurs, type). Un tableau de 1 000 entiers occupe environ 36 Ko en mémoire, alors que les 1 000 entiers eux-mêmes ne représentent que 8 Ko de données brutes.

Alternatives pour vérifier un tableau

Selon ce que vous cherchez à faire, count() n’est pas toujours la meilleure option. Voici un guide décisionnel rapide que je distribue à mes étudiants :

Vérifier si un tableau est vide

<?php
$tableau = [];

// Fonctionne mais pas optimal
if (count($tableau) === 0) { /* ... */ }

// Préférez empty() : plus lisible et plus rapide
if (empty($tableau)) { /* ... */ }

// Ou la comparaison directe (encore plus rapide)
if ($tableau === []) { /* ... */ }

La comparaison $tableau === [] est la plus performante car elle ne nécessite aucun appel de fonction. Mais empty() gère aussi le cas où la variable n’est pas définie, ce qui la rend plus sûre dans certains contextes.

Vérifier si une valeur existe

<?php
$fruits = ['pomme', 'banane', 'cerise'];

// Recherche par valeur
if (in_array('banane', $fruits, true)) {
    echo "Trouvé !";
}

// Recherche par clé
if (array_key_exists('nom', $etudiant)) {
    echo "La clé existe.";
}

// Alternative plus rapide pour les clés
if (isset($etudiant['nom'])) {
    echo "La clé existe et n'est pas null.";
}

Notez le troisième paramètre true de in_array() : il active la comparaison stricte (type + valeur). Sans ce paramètre, PHP fait une comparaison lâche qui peut produire des résultats surprenants (0 == "pomme" retourne true en PHP 7). Pour gérer des structures de données plus complexes avec des switch imbriqués, consultez mon article sur le switch dans un switch en PHP.

Compter les occurrences de chaque valeur

<?php
$reponses = ['oui', 'non', 'oui', 'oui', 'non', 'peut-être'];
$frequences = array_count_values($reponses);
print_r($frequences);
// Array ( [oui] => 3 [non] => 2 [peut-être] => 1 )

Cette fonction est l’équivalent PHP du COUNT ... GROUP BY en SQL. D’ailleurs, si vous travaillez en parallèle sur des requêtes SQL, mon guide sur les commentaires SQL vous aidera à documenter vos requêtes complexes. Et pour les opérations d’agrégation SQL, la fonction ROUND en SQL complète souvent un COUNT dans les rapports.

Lucie Moreau

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