# echo

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

echo — Affiche une chaîne de caractères

### Description

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ù vous pouvez 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 parentheses

> `<?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 concatenation 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
// Below, the expression 'Hello ' . isset($name) is evaluated first,
// and is always true, so the argument to echo is always $name
echo 'Hello ' . isset($name) ? $name : 'John Doe' . '!';
// The intended behaviour requires additional parentheses
echo 'Hello ' . (isset($name) ? $name : 'John Doe') . '!';
// In PHP prior to 8.0.0, the below outputs "2", rather than "Sum: 3"
echo 'Sum: ' . 1 + 2;
// Again, adding parentheses ensures the intended order of evaluation
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é :

`<?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écifié des chaînes littérales