strval()

Introduction

strval() est une fonction PHP intégrée qui renvoie la représentation sous forme de chaîne d'une valeur scalaire. C'est la façon explicite et lisible de dire « donne-moi cette valeur en tant que chaîne » — la même conversion que PHP effectue implicitement lorsque vous utilisez echo ou que vous concaténez une valeur avec ., mais écrite explicitement pour que votre intention soit claire.

Cette page explique ce que strval() retourne pour chaque type de données, comment elle gère null, les booléens, les flottants, les tableaux et les objets, et quand vous devriez l'utiliser à la place d'un cast ou de ses fonctions cousines telles que intval(), floatval() et boolval().

Syntaxe

strval(mixed $value): string

strval() prend un seul argument, $value, et renvoie une string qui le représente. Elle fonctionne sur tout scalaire (int, float, bool, string), sur null, et sur les objets qui implémentent __toString(). Passer un tableau produit la chaîne littérale "Array" et déclenche un avertissement (voir Cas limites).

Exemple de base

Convertir un entier, un flottant et un booléen en chaînes de caractères :

$var1 est un entier, $var2 un flottant et $var3 un booléen. Chacun est converti en sa forme chaîne. Notez que true devient "1" — cela surprend souvent les débutants, et c'est la bizarrerie la plus importante à retenir.

Conversion de chaque type

strval() suit les règles standard de jugement de type de PHP. Le tableau ci-dessous liste le résultat pour chaque type scalaire et pour null.

Les règles false → "" et null → "" valent la peine d'être mémorisées — elles sont la cause classique des bugs « pourquoi ma sortie est-elle vide ? » :

<?php
var_dump(strval(false));  // string(0) ""
var_dump(strval(null));   // string(0) ""
var_dump(strval(true));   // string(1) "1"
?>

strval() vs. cast vs. concaténation

Ces trois approches produisent le même résultat pour les scalaires, donc le choix est une question de lisibilité :

<?php
$n = 42;

$a = strval($n);   // "42" — explicit, named, greppable
$b = (string) $n;  // "42" — language cast
$c = "$n";         // "42" — string interpolation
$d = $n . "";      // "42" — concatenation trick (avoid)
?>

Préférez strval() ou le cast (string) lorsque vous souhaitez être explicite. strval() brille dans une situation qu'un cast ne peut pas égaler : c'est un callable, vous pouvez donc le passer à des fonctions d'ordre supérieur comme array_map() :

<?php
$numbers = [1, 2, 3, 4];

// Turn every element into a string in one line.
$strings = array_map('strval', $numbers);

print_r($strings);
// Array
// (
//     [0] => 1
//     [1] => 2
//     [2] => 3
//     [3] => 4
// )

var_dump($strings[0]); // string(1) "1"
?>

Vous ne pouvez pas écrire array_map('(string)', $numbers) — il n'existe pas de callable pour un cast — donc strval est la façon propre d'appliquer un cast sur une collection.

Flottants : attention à la précision

Les flottants sont formatés à l'aide de la directive ini precision de PHP (14 chiffres significatifs par défaut), et les très grands ou très petits nombres passent en notation scientifique. Cela signifie que strval() n'est pas le bon outil pour afficher des montants monétaires ou des sorties à décimale fixe — utilisez number_format() ou sprintf() pour cela.

<?php
echo strval(0.1 + 0.2) . "\n";   // 0.3   (precision rounds the float error)
echo strval(1.0) . "\n";         // 1     (trailing ".0" is dropped)
echo strval(1.0e21) . "\n";      // 1.0E+21  (scientific notation)

// For a fixed two-decimal price, use sprintf instead:
echo sprintf('%.2f', 1.0) . "\n"; // 1.00
?>

Cas limites : tableaux et objets

strval() est destinée aux scalaires. Deux cas non scalaires se comportent de façon particulière :

Les tableaux se convertissent en la chaîne littérale "Array" et déclenchent un avertissement — ce n'est presque jamais ce que vous souhaitez. Pour transformer un tableau en texte, utilisez implode() ou json_encode() :

<?php
$data = [1, 2, 3];

echo strval($data);            // Warning: Array to string conversion -> "Array"
echo implode(', ', $data);     // 1, 2, 3
echo json_encode($data);       // [1,2,3]
?>

Les objets se convertissent en appelant leur méthode __toString(). Si la classe n'en définit pas, PHP lève une Error :

<?php
class Money
{
    public function __construct(private float $amount) {}

    public function __toString(): string
    {
        return sprintf('$%.2f', $this->amount);
    }
}

echo strval(new Money(5)); // $5.00
?>

Quand utiliser strval()

• Appliquer un cast sur une collection avec array_map('strval', $items) — le cas d'usage par excellence.
• Forcer la sémantique de chaîne avant une comparaison stricte (===) ou avant de passer à une API ou une fonction qui type-hinte string.
• Code auto-documenté, où un strval() nommé est plus clair qu'un cast (string) brut.

Pour les conversions inverses, consultez les fonctions complémentaires intval(), floatval() et boolval(). Pour inspecter le type d'une valeur avant de la convertir, utilisez gettype() ou modifiez-le en place avec settype().

Conclusion

strval() retourne la forme chaîne d'une valeur scalaire, en reflétant les règles de conversion implicites de PHP mais en exprimant votre intention explicitement. Retenez ses trois particularités : true devient "1", false et null deviennent tous deux la chaîne vide "", et les tableaux produisent "Array" accompagné d'un avertissement. Utilisez-la lorsque vous avez besoin d'un callable de conversion en chaîne (notamment avec array_map), et utilisez number_format() ou sprintf() lorsque vous avez besoin d'un formatage numérique contrôlé.

Pratique