array ( 0 => 'index.php', 1 => 'PHP Manual', ), 'head' => array ( 0 => 'UTF-8', 1 => 'es', ), 'this' => array ( 0 => 'function.echo.php', 1 => 'echo', 2 => 'Muestra una string', ), 'up' => array ( 0 => 'ref.strings.php', 1 => 'Funciones de strings', ), 'prev' => array ( 0 => 'function.crypt.php', 1 => 'crypt', ), 'next' => array ( 0 => 'function.explode.php', 1 => 'explode', ), 'alternatives' => array ( ), 'source' => array ( 'lang' => 'es', 'path' => 'reference/strings/functions/echo.xml', ), 'history' => array ( ), ); $setup["toc"] = $TOC; $setup["toc_deprecated"] = $TOC_DEPRECATED; $setup["parents"] = $PARENTS; manual_setup($setup); contributors($setup); ?>

echo

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

echo — Muestra una string

Descripción

echo(string ...$expressions): void

Muestra una o varias expresiones, sin espacios o nueva línea adicionales.

echo no es una función sino una construcción del lenguaje. Sus argumentos son una lista de expresiones que siguen la palabra clave echo, separados por comas, y no delimitados por paréntesis. A diferencia de otras construcciones del lenguaje, echo no tiene valor de retorno, por lo que no puede ser utilizada en el contexto de una expresión.

echo también dispone de una sintaxis corta, donde se puede hacer seguir inmediatamente la etiqueta PHP de apertura con un signo igual (=). Esta sintaxis está disponible incluso si la directiva de configuración short_open_tag está desactivada.

Tengo <?=$foo?> foo.

La mayor diferencia con print es que echo acepta múltiples argumentos y no retorna ningún valor.

Parámetros

expressions

Una o varias expresiones de string a mostrar, separadas por comas. Los valores que no son strings serán convertidos a strings, incluso si la directiva strict_types está activada.

Valores devueltos

No se retorna ningún valor.

Ejemplos

Ejemplo #1 Ejemplo con echo

<?php
echo "echo no requiere paréntesis.";

// Las strings pueden ser pasadas individualmente como múltiples argumentos o
// concatenadas y pasadas como un solo argumento
echo 'Esta ', 'string ', 'fue ', 'creada ', 'con múltiples parámetros.', "\n";
echo 'Esta ' . 'string ' . 'fue ' . 'creada ' . 'con concatenación.' . "\n";

// Ninguna nueva línea o espacio es añadido; lo siguiente muestra "helloworld", todo en una línea
echo "hola";
echo "mundo";

// Igual que lo anterior
echo "hola", "mundo";

echo "Esta string abarca
múltiples líneas. Los saltos de línea serán
mostrados también";

echo "Esta string abarca\nmúltiples líneas. Los saltos de línea serán\nmostrados también.";

// El argumento puede ser cualquier expresión que produzca una string
$foo = "ejemplo";
echo "foo es $foo"; // foo es ejemplo

$frutas = ["limón", "naranja", "plátano"];
echo implode(" y ", $frutas); // limón y naranja y plátano

// Las expresiones que no son strings son convertidas a strings, incluso si declare(strict_types=1) es utilizado
echo 6 * 7; // 42

// Sin embargo, los siguientes ejemplos funcionarán:
($some_var) ? print 'true' : print 'false'; // print también es una construcción, pero
// es una expresión válida, retornando 1.
// Por lo tanto puede ser utilizada en este contexto.

echo $some_var ? 'true': 'false'; // evaluando la expresión primero y luego pasándola a echo

Ejemplo #2 echo no es una expresión

<?php
// Debido a que echo no se comporta como una expresión, el siguiente código es inválido.
($some_var) ? echo 'true' : echo 'false';
?>

Notas

Nota: Como esto es una estructura del lenguaje, y no una función, no es posible llamarla con las funciones variables o argumentos nombrados.

Nota: Uso con paréntesis

Rodear un solo argumento de echo con paréntesis no generará un error de sintaxis, y produce una sintaxis similar a una llamada normal de función. Sin embargo, esto puede ser engañoso, ya que los paréntesis son en realidad parte de la expresión que se está mostrando, y no parte de la sintaxis de echo en sí mismo.

Ejemplo #3 Uso de paréntesis

<?php
echo "hola", PHP_EOL;
// muestra "hola"

echo("hola"), PHP_EOL;
// también muestra "hola", ya que ("hola") es una expresión válida

echo(1 + 2) * 3, PHP_EOL;
// muestra "9"; el paréntesis permite que 1+2 sea evaluado primero, luego 3*3
// echo ve el resultado de la expresión como un solo argumento

echo "hola", " mundo", PHP_EOL;
// muestra "hola mundo"

echo("hola"), (" mundo"), PHP_EOL;
// muestra "hola mundo"; los paréntesis son parte de cada expresión
?>

Ejemplo #4 Expresión inválida

<?php
echo("hola", " mundo"), PHP_EOL;
// Genera un error de análisis ya que ("hola", " mundo") no es una expresión válida
?>

Sugerencia

Pasar múltiples argumentos a echo permite evitar complicaciones que aparecen debido a la precedencia de la operación de concatenación en PHP. Por ejemplo, el operador de concatenación tiene una precedencia mayor que el operador ternario, y anteriormente a PHP 8.0.0, tenía la misma precedencia que la suma y la resta:

<?php
// A continuación, la expresión 'Hola ' . isset($name) es evaluada primero,
// y siempre es verdadera, por lo que el argumento para echo siempre es $name
echo 'Hola ' . isset($name) ? $name : 'John Doe' . '!';

// El comportamiento deseado requiere paréntesis adicionales
echo 'Hola ' . (isset($name) ? $name : 'John Doe') . '!';

// En PHP anterior a 8.0.0, lo siguiente muestra "2", en lugar de "Suma: 3"
echo 'Suma: ' . 1 + 2;

// Nuevamente, añadir paréntesis asegura el orden de evaluación deseado
echo 'Suma: ' . (1 + 2);

Si se proporcionan múltiples argumentos, entonces los paréntesis no serán necesarios para aumentar la precedencia, ya que cada expresión está separada:

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

echo "Suma: ", 1 + 2;

Ver también