PHP explode(): dividir un string en un array

explode($separator, $string) divide una cadena en cada aparición de $separator y devuelve los trozos como array. explode(',', 'apple,banana,cherry') da ['apple', 'banana', 'cherry'].

<?php
$csv = 'apple,banana,cherry';
$fruits = explode(',', $csv);

print_r($fruits);
echo $fruits[1], "\n";
echo count($fruits), " fruits\n";

El separador puede ser cualquier cadena, no solo un carácter: explode(' and ', 'tea and milk and sugar') funciona igual. La operación contraria, volver a unir un array en una cadena, es implode().

Sintaxis y valor de retorno

explode(string $separator, string $string, int $limit = PHP_INT_MAX): array

Siempre devuelve un array. Si el separador no aparece, el array contiene la cadena completa como único elemento. Eso incluye la cadena vacía, que da un array con una cadena vacía dentro, una fuente habitual de bugs del tipo "mi bucle se ejecuta una vez con una entrada vacía".

<?php
var_dump(explode(',', 'apple'));   // separator not found
var_dump(explode(',', ''));        // empty input
var_dump(explode(',', 'a,,b,'));   // empty pieces are kept

// If an empty string should mean "no items", check before splitting
$input = '';
$tags = $input === '' ? [] : explode(',', $input);
echo count($tags), "\n";

Limitar el número de trozos

El tercer argumento, $limit, cambia cuántos trozos obtienes:

• Un límite positivo devuelve como máximo esa cantidad de trozos. El último trozo contiene el resto de la cadena, separadores incluidos.
• Un límite negativo devuelve todos los trozos salvo los últimos abs($limit).
• Un límite de 0 se trata como 1.

<?php
$path = 'home/ada/projects/site/index.php';

print_r(explode('/', $path, 2));   // first piece, then the rest
print_r(explode('/', $path, -1));  // everything except the file name
print_r(explode('/', $path, 0));   // treated as 1

Un límite positivo es la herramienta adecuada cuando solo importa el primer separador, por ejemplo una línea key=value en la que el valor también puede contener =: explode('=', 'query=a=b', 2) da ['query', 'a=b']. Las secciones siguientes lo usan así.

Para obtener solo el último trozo, guarda antes el array en una variable: $parts = explode('/', $path); $file = end($parts);. Escribir end(explode('/', $path)) sigue devolviendo el valor correcto, pero PHP imprime Notice: Only variables should be passed by reference, porque end() recibe su argumento por referencia.

Dividir una cadena por saltos de línea

explode("\n", $text) divide en los saltos de línea. Usa comillas dobles: entre comillas simples, '\n' es una barra invertida seguida de la letra n, no un salto de línea. El texto de archivos de Windows o de formularios HTML suele terminar las líneas con "\r\n", lo que deja un "\r" suelto al final de cada trozo. preg_split('/\R/', $text) divide en cualquier tipo de salto de línea.

<?php
$text = "first line\r\nsecond line\nthird line";

$pieces = explode("\n", $text);
var_dump($pieces[0]);   // still ends with \r

$lines = preg_split('/\R/', $text);
var_dump($lines);

Recortar los trozos y descartar los vacíos

Una entrada del usuario como "red, green , ,blue" tiene espacios alrededor de los elementos y un elemento vacío en medio. Pasa los trozos por trim() con array_map() y luego elimina las cadenas vacías con array_filter(). array_values() renumera después las claves, porque array_filter() conserva las originales.

<?php
$input = 'red, green , ,blue';

$colors = array_map('trim', explode(',', $input));
$colors = array_values(array_filter($colors, fn($c) => $c !== ''));

print_r($colors);

El callback fn($c) => $c !== '' conserva la cadena "0". Un array_filter($colors) sin callback la descartaría, porque "0" es falsy.

Convertir una cadena en un array asociativo

Los ajustes, las cookies y las cadenas tipo query suelen guardarse como pares key=value. Usa explode dos veces: una para los pares y otra para cada par con un límite de 2, desempaquetando los dos trozos en variables (desestructuración de arrays).

<?php
$settings = 'theme=dark;lang=ja;filter=a=b';

$result = [];
foreach (explode(';', $settings) as $pair) {
    [$key, $value] = explode('=', $pair, 2);
    $result[$key] = $value;
}

print_r($result);
echo $result['lang'], "\n";

Un par sin =, como debug, da un array de un elemento, y la desestructuración imprime Warning: Undefined array key 1. Rellena el resultado hasta dos elementos para evitarlo: [$key, $value] = explode('=', $pair, 2) + [1 => ''];.

Para una query string real de una URL, parse_str() hace esto por ti y además decodifica %20 y +.

Dividir por varios delimitadores

explode() acepta un solo separador. Para dividir en comas, puntos y coma o espacios, usa preg_split() con una clase de caracteres. PREG_SPLIT_NO_EMPTY descarta los trozos vacíos que crearían dos delimitadores seguidos.

<?php
$input = 'php, javascript;python  go|rust';

$words = preg_split('/[\s,;|]+/', $input, -1, PREG_SPLIT_NO_EMPTY);
print_r($words);

Japonés y otro texto UTF-8

explode() compara bytes, y en UTF-8 un carácter completo nunca aparece dentro de los bytes de otro carácter, así que dividir texto japonés por un separador japonés como 、 o una coma de ancho completo funciona correctamente.

<?php
$cities = '東京、大阪、京都';
print_r(explode('、', $cities));

// Split into single characters: mb_str_split counts characters, str_split counts bytes
print_r(mb_str_split('日本語'));

explode vs str_split vs preg_split

explode() no trabaja con expresiones regulares, así que es más rápido que preg_split() y es el que debes usar siempre que el separador sea una cadena fija.

Error frecuente: un separador vacío

Un separador vacío es un error. Desde PHP 8.0, explode('', 'abc') lanza un ValueError en lugar de devolver false, y el script se detiene:

PHP Fatal error:  Uncaught ValueError: explode(): Argument #1 ($separator) cannot be empty in /home/index.php:3

Para dividir una cadena en caracteres, usa str_split('abc') con texto ASCII o mb_str_split($s) con cualquier texto que pueda contener caracteres multibyte.