Affiche une chaîne de caractères

# echo

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

echo — Affiche une chaîne de caractères

### Description

function echo(string `...$expressions`): void

Affiche une ou plusieurs expressions, sans espaces ou nouvelle ligne additionnelle.

`echo` n'est pas une fonction mais une construction du langage. Ses arguments sont une liste d'expressions suivant le mot clé `echo`, séparés par des virgules, et non délimités par des parenthèses. Contrairement à d'autres constructions du langage, `echo` n'a pas de valeur de retour, elle ne peut donc pas être utilisée dans le contexte d'une expression.

`echo` dispose aussi d'une syntaxe courte, où l'on peut faire suivre immédiatement la balise PHP ouvrante d'un signe égal (`=`). Cette syntaxe est disponible même si la directive de configuration short_open_tag est désactivée.

    J'ai <?=$foo?> foo.

La plus grosse différence avec print est que `echo` accepte plusieurs arguments et ne retourne aucune valeur.

### Liste de paramètres

`expressions`

  Une ou plusieurs expressions de chaînes de caractères à afficher, séparées par des virgules. Les valeurs qui ne sont pas des chaînes de caractères seront converties en chaînes de caractères, même si la directive `strict_types` est activée.

### Valeurs de retour

Aucune valeur n'est retournée.

### Exemples

Exemple #1 Exemple avec `echo`

    <?php
    echo "echo ne requiert pas de parenthèses.";

    // Les chaînes peuvent être passées soit individuellement comme plusieurs arguments ou
    // concaténées ensemble et passées en tant qu'un seul argument
    echo 'This ', 'string ', 'was ', 'made ', 'with multiple parameters.', "\n";
    echo 'This ' . 'string ' . 'was ' . 'made ' . 'with concatenation.' . "\n";

    // Aucune nouvelle ligne ou espace n'est ajoutée ; ci-dessous affiche "helloworld", tout sur une ligne
    echo "hello";
    echo "world";

    // Pareil que ci-dessus
    echo "hello", "world";

    echo "This string spans
    multiple lines. The newlines will be
    output as well";

    echo "This string spans\nmultiple lines. The newlines will be\noutput as well.";

    // L'argument peut être n'importe quelle expression qui produit une chaîne de caractères
    $foo = "example";
    echo "foo is $foo"; // foo is example

    $fruits = ["lemon", "orange", "banana"];
    echo implode(" and ", $fruits); // lemon and orange and banana

    // Les expressions qui ne sont pas des chaînes sont converties en chaînes, même si declare(strict_types=1) est utilisé
    echo 6 * 7; // 42

    // Cependant, les exemples suivants fonctionneront :
    ($some_var) ? print 'true' : print 'false'; // print est aussi une construction, mais
                                                // est une expression valide, retournant 1.
                                                // Donc il peut être utilisé dans ce contexte.

    echo $some_var ? 'true': 'false'; // évaluant l'expression d'abord puis la passant à echo

Exemple #2 `echo` n'est pas une expression

    <?php
    // Parce que echo ne se comporte pas comme une expression, le code suivant est invalide.
    ($some_var) ? echo 'true' : echo 'false';
    ?>

### Notes

> Note: Comme ceci est une structure du langage, et non pas une fonction, il n'est pas possible de l'appeler avec les fonctions variables ou arguments nommés.

> Note: Utilisation avec les parenthèses

> Entourer un seul argument de `echo` avec des parenthèses ne lèvera pas une erreur de syntaxe, et produit une syntaxe ressemblant à un appel normal de fonction. Néanmoins, ceci peut être trompeur, car les parenthèses font en réalité partie de l'expression qui est en cours d'affichage, et non partie de la syntaxe de `echo` en lui-même.

> Exemple #3 Utilisation de parenthèses

>     <?php
>     echo "hello", PHP_EOL;
>     // affiche "hello"

>     echo("hello"), PHP_EOL;
>     // affiche également "hello", car ("hello") est une expression valide

>     echo(1 + 2) * 3, PHP_EOL;
>     // affiche "9"; la parenthèse permet 1+2 d'être évalué en premier, puis 3*3
>     // echo voit le résultat de l'expression comme un seul argument

>     echo "hello", " world", PHP_EOL;
>     // affiche "hello world"

>     echo("hello"), (" world"), PHP_EOL;
>     // affiche "hello world"; les parenthèses font partie de chaque expression
>     ?>

> Exemple #4 Expression invalide

>     <?php
>     echo("hello", " world"), PHP_EOL;
>     // Lève une Parse Erreur car ("hello", " world") n'est pas une expression valide
>     ?>

Astuce

Passer plusieurs arguments à `echo` permet d'éviter des complications qui apparaissent à cause de la précédence de l'opération de concaténation en PHP. Par exemple, l'opérateur de concaténation a une précédence supérieure à l'opérateur ternaire, et antérieurement à PHP 8.0.0, avait la même précédence que l'addition et la soustraction :

    <?php
    // Ci-dessous, l'expression 'Hello ' . isset($name) est évaluée en premier,
    // et est toujours true, donc l'argument de echo est toujours $name
    echo 'Hello ' . isset($name) ? $name : 'John Doe' . '!';

    // Le comportement souhaité nécessite des parenthèses supplémentaires
    echo 'Hello ' . (isset($name) ? $name : 'John Doe') . '!';

    // En PHP antérieur à 8.0.0, le code ci-dessous affiche "2", au lieu de "Sum: 3"
    echo 'Sum: ' . 1 + 2;

    // Encore une fois, l'ajout de parenthèses garantit l'ordre d'évaluation souhaité
    echo 'Sum: ' . (1 + 2);

Si plusieurs arguments sont fournis, alors les parenthèses ne seront pas requises pour augmenter la précédence, car chaque expression est séparée :

    <?php
    echo "Hello ", isset($name) ? $name : "John Doe", "!";

    echo "Sum: ", 1 + 2;

### Voir aussi

- print - Affiche une chaîne de caractères
- printf() - Affiche une chaîne de caractères formatée
- flush() - Vide les tampons de sortie du système
- Manière de spécifier des chaînes littérales

`↑` and `↓` to navigate • `Enter` to select • `Esc` to close • `/` to open