archived-doc-fr/reference/strings/functions/echo.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- $Revision$ -->
<!-- EN-Revision: 7a3899eea90f3df8dcfe8fd350900162f3490bed Maintainer: yannick Status: ready -->
<!-- Reviewed: no -->

<refentry xmlns:xlink="http://www.w3.org/1999/xlink" xmlns="http://docbook.org/ns/docbook" xml:id="function.echo">
 <refnamediv>
  <refname>echo</refname>
  <refpurpose>Affiche une chaîne de caractères</refpurpose>
 </refnamediv>

 <refsect1 role="description">
  &reftitle.description;
  <methodsynopsis>
   <type>void</type><methodname>echo</methodname>
   <methodparam rep="repeat"><type>string</type><parameter>expressions</parameter></methodparam>
  </methodsynopsis>
  <simpara>
   Affiche une ou plusieurs expressions, sans espaces ou nouvelle ligne additionnelle.
  </simpara>
  <para>
   <literal>echo</literal> n'est pas une fonction mais une construction du langage.
   Ses arguments sont une liste d'expressions suivant le mot clé <literal>echo</literal>,
   séparés par des virgules, et non délimités par des parenthèses.
   Contrairement à d'autres constructions du langage, <literal>echo</literal>
   n'a pas de valeur de retour, elle ne peut donc pas être utilisée dans
   le contexte d'une expression.
  </para>
  <para>
   <literal>echo</literal> dispose aussi d'une syntaxe courte,
   où vous pouvez faire suivre immédiatement la balise PHP ouvrante d'un
   signe égal (<literal>=</literal>).
   Cette syntaxe est disponible même si la directive de configuration
   <link linkend="ini.short-open-tag"><option>short_open_tag</option></link>
   est désactivée.
   <informalexample>
    <programlisting role="php">
<![CDATA[
J'ai <?=$foo?> foo.
]]>
    </programlisting>
   </informalexample>
  </para>
  <para>
   La plus grosse différence avec <function>print</function> est que
   <literal>echo</literal> accepte plusieurs arguments et ne retourne
   aucune valeur.
  </para>
 </refsect1>

 <refsect1 role="parameters">
  &reftitle.parameters;
  <para>
   <variablelist>
    <varlistentry>
     <term><parameter>expressions</parameter></term>
     <listitem>
      <para>
       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
       <link linkend="language.types.declarations.strict"><literal>strict_types</literal></link>
       est activée.
      </para>
     </listitem>
    </varlistentry>
   </variablelist>
  </para>
 </refsect1>

 <refsect1 role="returnvalues">
  &reftitle.returnvalues;
  <para>
   &return.void;
  </para>
 </refsect1>

 <refsect1 role="examples">
  &reftitle.examples;
  <para>
   <example>
    <title>Exemple avec <literal>echo</literal></title>
    <programlisting role="php">
<![CDATA[
<?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

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

// Cependent, 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
?>
]]>
    </programlisting>
   </example>
  </para>
 </refsect1>

 <refsect1 role="notes">
  &reftitle.notes;
  &note.language-construct;

  <note>
   <title>Utilisation avec les parenthèses</title>
   <para>
    Entourer un seul argument de <literal>echo</literal> 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 <literal>echo</literal>
    en lui-même.
   </para>
   <para>
    <example>
     <title/>
     <programlisting role="php">
      <![CDATA[
<?php
echo "hello";
// outputs "hello"

echo("hello");
// also outputs "hello", because ("hello") is a valid expression

echo(1 + 2) * 3;
// outputs "9"; the parentheses cause 1+2 to be evaluated first, then 3*3
// the echo statement sees the whole expression as one argument

echo "hello", " world";
// outputs "hello world"

echo("hello"), (" world");
// outputs "hello world"; the parentheses are part of each expression

echo("hello", " world");
// Throws a Parse Error because ("hello", " world") is not a valid expression
?>
]]>
     </programlisting>
    </example>
   </para>
  </note>

  <tip>
   <para>
    Passer plusieurs arguments à <literal>echo</literal> 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 :
   </para>
   <programlisting role="php">
<![CDATA[
<?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);
]]>
   </programlisting>
   <para>
    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é :
   </para>
   <programlisting role="php">
<![CDATA[
<?php
echo "Hello ", isset($name) ? $name : "John Doe", "!";

echo "Sum: ", 1 + 2;
]]>
   </programlisting>
  </tip>
 </refsect1>

 <refsect1 role="seealso">
  &reftitle.seealso;
  <para>
   <simplelist>
    <member><function>print</function></member>
    <member><function>printf</function></member>
    <member><function>flush</function></member>
    <member><link linkend="language.types.string">Manière de spécifié des chaînes littérales</link></member>
   </simplelist>
  </para>
 </refsect1>

</refentry>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->