Un string es una serie de caracteres donde un caracter es lo mismo que un byte. Esto significa que PHP solo soporta el conjunto de 256 caracteres y por lo tanto no tiene soporte nativo Unicode. Ver detalles del tipo de dato string.
Nota: string puede llegar a alcanzar 2GB de tamaño.
Un string literal puede ser especificado de cuatro formas diferentes:
La manera más sencilla de especificar un string es encerrarlo entre comillas simples (el caracter ').
Para especificar una comilla simple literal, se escapa con una barra invertida (\). Para especificar una barra invertida literal, se duplica (\\). Todas las otras instancias de barras invertidas serán tratadas como una barra invertida literal: esto significa que otras secuencias de escape que se puedan utilizar, tales como \r or \n, serán mostradas literalmente como se especifican en lugar de tener cualquier significado especial
Nota: A diferencia de las sintaxis de comillas dobles y heredoc, las variables y las sentencias de escape para caracteres especiales no se expandirán cuando estén incluidas dentro de un string con comillas simples.
<?php
echo 'Esto es una cadena sencilla';
echo 'Tambien puede incluir nuevas líneas en
cadenas de esta forma ya que es
correcto hacerlo así';
// Resultado: Arnold una vez dijo: "I'll be back"
echo 'Arnold una vez dijo: "I\'ll be back"';
// Resultado: Ha borrado C:\*.*?
echo 'Ha borrado C:\\*.*?';
// Resultado: Ha borrado C:\*.*?
echo 'Ha borrado C:\*.*?';
// Resultado: Esto no se expandirá: \n una nueva línea
echo 'Esto no se expandirá: \n una nueva línea';
// Resultado: Las variables $tampoco se $expandiran
echo 'Las variables $tampoco se $expandiran';
?>
Si un string está encerrado entre comillas dobles ("), PHP interpretará más sentencias de escape como caracteres especiales:
| Sentencia | Significado |
|---|---|
| \n | avance de línea (LF o 0x0A (10) en ASCII) |
| \r | retorno de carro (CR o 0x0D (13) en ASCII) |
| \t | tabulador horizontal (HT o 0x09 (9) en ASCII) |
| \v | tabulador vertical (VT o 0x0B (11) en ASCII) (desde PHP 5.2.5) |
| \e | escape (ESC o 0x1B (27) en ASCII) (desde PHP 5.4.0) |
| \f | avance de página (FF o 0x0C (12) en ASCII) (desde PHP 5.2.5) |
| \\ | barra invertida |
| \$ | signo del dólar |
| \" | comillas dobles |
| \[0-7]{1,3} | la secuencia de caracteres que coincida con la expresión regular es un caracter en notación octal |
| \x[0-9A-Fa-f]{1,2} | la secuencia de caracteres que coincida con la expresión regular es un caracter en notación hexadecimal |
Al igual que en la delimitación de un string mediante comillas simples, escapar cualquier otro caracter puede dar lugar a que se muestre tambien la barra invertida. Antes de PHP 5.1.1, la barra invertida en \{$var} no se mostraba.
La característica más importante de entrecomillar un string mediante comillas dobles es el hecho que los nombres de las variables son expandidas. Consulte string parsing para más detalles.
Una tercera forma de delimitar un string es mediante la sintaxis heredoc: <<<. Después de este operador, se deberá ofrecer un identificador y después una nueva línea. A continuación va el propio string, y para cerrar la notación se pone el mismo identificador.
El identificador de cierre debe empezar en la primera columna de la nueva línea. Asimismo, el identificador debe seguir las mismas reglas de nomenclatura de las etiquetas en PHP: debe contener solo caracteres alfanuméricos y guiones bajos, y debe empezar con un caracter alfabético o un guión bajo.
Es muy importante señalar que la línea con el identificador de cierre no debe contener ningún caracter, excepto posiblemente un punto y coma (;). Esto significa en particular que el identificador no debe usar sangría, y que no deben existir ningún espacio ni tabulación antes o después del punto y coma. Es muy importante darse cuenta que el primer caracter antes del identificador de cierre debe ser un salto de línea definida por el sistema operativo local. En los sistemas UNIX sería \n, al igual que en Mac OS X. El delimitador de cierre (posiblemente seguido de un punto y coma) también debe ser seguido de un salto de línea.
Si se rompe esta regla y el identificador de cierre no está "limpio", no será considerado como un identificador de cierre, y PHP continuará buscando uno. Si no se encuentra ningún identificador de cierre antes del final del fichero, se producirá un error de análisis en la última línea.
Tampoco se puede emplear Heredocs para inicializar las propiedades de una clase. Desde PHP 5.3, esta limitación solo concierne a los heredocs que contengan variables.
Ejemplo #1 Ejemplo no válido
<?php
class foo {
public $bar = <<<EOT
bar
EOT;
}
?>
El texto heredoc se comporta como un string entre comillas dobles, pero sin tener comillas dobles. Esto significa que las comillas en Heredoc no necesitan ser escapadas, pero los caracteres escapados indicados arriba se pueden seguir empleando. Las variables son expandidas, y se debe tener el mismo cuidado dentro de un Heredoc cuando se quieren expresar variables complejas, al igual que en los string.
Ejemplo #2 Ejemplo de entrecomillado de string Heredoc
<?php
$str = <<<EOD
Ejemplo de una cadena
expandida en varias líneas
empleando la sintaxis heredoc.
EOD;
/* Un ejemplo más complejo con variables. */
class foo
{
var $foo;
var $bar;
function foo()
{
$this->foo = 'Foo';
$this->bar = array('Bar1', 'Bar2', 'Bar3');
}
}
$foo = new foo();
$name = 'MiNombre';
echo <<<EOT
Mi nombre es "$name". Estoy escribiendo un poco de $foo->foo.
Ahora, estoy escribiendo un poco de {$foo->bar[1]}.
Esto debe mostrar una 'A' mayúscula: \x41
EOT;
?>
El resultado del ejemplo sería:
Mi nombre es "MiNombre". Estoy escribiendo un poco de Foo. Ahora, estoy escribiendo un poco de Bar2. Esto debe mostrar una 'A' mayúscula: A
Tambien se puede emplear la sintaxis Heredoc para pasar datos como argumento de una función:
Ejemplo #3 Ejemplo de Heredoc como argumento
<?php
var_dump(array(<<<EOD
foobar!
EOD
));
?>
Desde PHP 5.3.0 es posible inicializar variables estáticas y propiedades/constantes de clase mediante la sintaxis Heredoc:
Ejemplo #4 Usando Heredoc para inicializar valores estáticos
<?php
// Variables estáticas
function foo()
{
static $bar = <<<LABEL
Nada aqui dentro...
LABEL;
}
// Propiedades/Constantes de clase
class foo
{
const BAR = <<<FOOBAR
Ejemplo de constante
FOOBAR;
public $baz = <<<FOOBAR
Ejemplo de propiedad
FOOBAR;
}
?>
PHP 5.3.0 tambien introdujo la posibilidad en Heredoc de emplear las comillas dobles en declaraciones:
Ejemplo #5 Empleando comillas dobles en Heredoc
<?php
echo <<<"FOOBAR"
Hola Mundo!
FOOBAR;
?>
Nowdocs son a las cadenas con comillas simples lo mismo que Heredoc lo es a las comillas dobles. Una cadena nowdoc se especifica de forma análoga a la heredoc, pero no se realiza ningún análisis dentro de nowdoc. Esta construcción es ideal para embeber código PHP o grandes fragmentos de texto sin necesidad de escaparlo. Comparte algunas características comunes con la construcción SGML <![CDATA[ ]]>, donde se declara un fragmento de texto que no debe ser analizado.
Una cadena nowdoc se identifica con la misma sintaxis <<< usada para heredoc, pero el identificador que le sigue esta encerrado entre comillas simples, por ejemplo <<<'EOT'. Todas las reglas para los identificadores heredoc también son aplicables a los identificadores nowdoc, especialmente aquellos que se refieren al empleo del identificador de cierre.
Ejemplo #6 Ejemplo de entrecomillado de string Nowdoc
<?php
$str = <<<'EOD'
Ejemplo de una cadena
expandida en varias líneas
empleando la sintaxis nowdoc.
EOD;
/* Un ejemplo más complejo con variables. */
class foo
{
public $foo;
public $bar;
function foo()
{
$this->foo = 'Foo';
$this->bar = array('Bar1', 'Bar2', 'Bar3');
}
}
$foo = new foo();
$name = 'MiNombre';
echo <<<'EOT'
Mi nombre es "$name". Estoy escribiendo un poco de $foo->foo.
Ahora, estoy escribiendo un poco de {$foo->bar[1]}.
Esto debe mostrar una 'A' mayúscula: \x41
EOT;
?>
El resultado del ejemplo sería:
Mi nombre es "$name". Estoy escribiendo un poco de $foo->foo.
Ahora, estoy escribiendo un poco de {$foo->bar[1]}.
Esto debe mostrar una 'A' mayúscula: \x41Nota:
A diferencia de heredoc, nowdoc puede ser usado en cuaquier contexto de datos estáticos. Un ejemplo típico es la inicialización de propiedades o constantes en una clase:
Ejemplo #7 Ejemplo de datos estáticos
<?php
class foo {
public $bar = <<<'EOT'
bar
EOT;
}
?>
Nota:
El soporte de Nowdoc se añadió en PHP 5.3.0.
Cuando un string es especificado mediante comillas dobles o mediante sintaxis heredoc, las variables dentro de dicha cadena son analizadas.
Existen dos tipos de sintaxis: una simple y otra compleja. La sintaxis simple es la más empleada y conveniente. Proporciona una forma de incluir una variable, un valor de un array o una propiedad de un object dentro de un string con el mínimo esfuerzo.
La sintaxis compleja puede ser reconocida por las llaves que encierran la expresión.
Si se encuentra un signo de dólar ($), el analizador ávidamente cogerá el mayor número de símbolos para formar un nombre de variable válido. Encerrar el nombre de la variable entre llaves permite especificar explícitamente el final del nombre.
<?php
$jugo = "manzana";
echo "El tomó algo de jugo de $jugo.".PHP_EOL;
// Inválido. "s" es un caracter válido para un nombre de variable, pero la variable es $jugo.
echo "El tomó algo de jugo hecho de $jugos.";
?>
El resultado del ejemplo sería:
El tomó algo de jugo de manzana. El tomó algo de jugo hecho de .
De forma parecida, el índice de un array o la propiedad de un object puede ser analizado. Con los índices de los arrays, el corchete de cierre (]) marca el final del índice. La misma regla se puede aplicar a las propiedades de los objetos y a las variables simples.
Ejemplo #8 Ejemplo de sintaxis simple
<?php
$jugos = array("manzana", "naranja", "koolaid1" => "púrpura");
echo "El tomó algo de jugo de $jugos[0].".PHP_EOL;
echo "El tomó algo de jugo de $jugos[1].".PHP_EOL;
echo "El tomó algo de jugo hecho de $jugo[0]s.".PHP_EOL;// No funcionará
echo "El tomó algo de jugo $jugos[koolaid1].".PHP_EOL;
class people {
public $john = "John Smith";
public $jane = "Jane Smith";
public $robert = "Robert Paulsen";
public $smith = "Smith";
}
$people = new people();
echo "$people->john tomó algo de jugo de $jugos[0].".PHP_EOL;
echo "$people->john entonces dijo hola a $people->jane.".PHP_EOL;
echo "La esposa de $people->john's saludó a $people->robert.".PHP_EOL;
echo "$people->robert saludó a los dos $people->smiths."; // No funcionará
?>
El resultado del ejemplo sería:
El tomó algo de jugo de manzana. El tomó algo de jugo de naranja. El tomó algo de jugo hecho de s. El tomó algo de jugo púrpura. John Smith tomó algo de jugo de manzana. John Smith entonces dijo hola a Jane Smith. La esposa de John Smith's saludó a Robert Paulsen. Robert Paulsen saludó a los dos .
Para casos más complejos se debe emplear la sintaxis compleja.
Esta sintaxis no se llama compleja poque sea compleja de aplicar, sino porque permite el empleo de expresiones complejas.
Cualquier variable escalar, elemento de array o propiedad de objeto con una representación de string puede ser incluido a través de esta sintaxis. Simplemente se escribe la expresión del mismo modo en que debe aparecer por fuera del string, y entonces se encierra ente { y }. Dado que { no puede ser escapado, esta sintaxis será reconocida únicamente cuando el $ siga inmediatamente al {. Utilice {\$ para obtener un {$ literal. Algunos ejemplos para que quede más claro:
<?php
// Muestra todos los errores
error_reporting(E_ALL);
$great = 'fantastico';
// No funciona, resultado: Esto es { fantastico}
echo "Esto es { $great}";
// Funciona, resultado: Esto es fantastico
echo "Esto es {$great}";
echo "Esto es ${great}";
// Funciona
echo "Este cuadrado tiene {$square->width}00 centímetros de lado.";
// Funciona, claves entre comillas sólo funcionan utilizando la sintaxis de llaves
echo "Esto funciona: {$arr['key']}";
// Funciona
echo "Funciona: {$arr[4][3]}";
// No funciona por la misma razón que $foo[bar] es incorrecto fuera de una cadena.
// En otras palabras, funcionaría pero solo porque PHP primero busca por una constante
// llamada foo; un error del nivel E_NOTICE (constante no definida) puede ser lanzado.
echo "No funciona: {$arr[foo][3]}";
// Funciona. Cuando se usan arrays multidimensionales, siempre emplee llaves encerrando
// los arrays cuando se encuentre dentro de una cadena
echo "Funciona: {$arr['foo'][3]}";
// Funciona.
echo "Funciona: " . $arr['foo'][3];
echo "Tambien funciona: {$obj->values[3]->name}";
echo "Este es el valor de la variable llamada $name: {${$name}}";
echo "Este es el valor de la variable llamada por el valor de retorno de getName(): {${getName()}}";
echo "Este es el valor de la variable llamada por el valor de retorno de \$object->getName(): {${$object->getName()}}";
//No funciona, imprime: Esto es el valor de retorno de getName(): {getName ()}
echo "Esto es el valor de retorno de getName(): {getName()}";
?>
También es posible acceder a las propiedades de una clase usando variables dentro de cadenas al emplear ésta sintaxis.
<?php
class foo {
var $bar = 'Soy bar.';
}
$foo = new foo();
$bar = 'bar';
$baz = array('foo', 'bar', 'baz', 'quux');
echo "{$foo->$bar}\n";
echo "{$foo->$baz[1]}\n";
?>
El resultado del ejemplo sería:
Soy bar. Soy bar.
Nota:
Funciones, llamadas a métodos, variables estáticas de clases y constantes de clases dentro de {$} funcionan desde PHP 5. Sin embargo, el valor accedido puede ser interpretado como el nombre de la variable en el ámbito en el que la cadena está definida. Empleando llaves simples ({}) no servirá para acceder al valor de retorno de las funciones o métodos, constantes o variables estáticas de clases.
<?php
// Muestra todos los errores.
error_reporting(E_ALL);
class beers {
const softdrink = 'rootbeer';
public static $ale = 'ipa';
}
$rootbeer = 'A & W';
$ipa = 'Alexander Keith\'s';
// Funciona; resultado: Me gusta una A & W
echo "Me gusta una {${beers::softdrink}}\n";
// Tambien funciona; resultado: Me gusta una Alexander Keith's
echo "Me gusta una {${beers::$ale}}\n";
?>
Los caracteres dentro de un string pueden ser accedidos y modificados especificando la posición de caracter deseado (en base a la posición cero del primer caracter del string) empleando los corchetes de array, como en $str[42]. Piense en este caso que un string se comporta como un array de caracteres. Las funciones substr() y substr_replace() pueden ser empleados para extraer y reemplazar más de un caracter.
Nota: Los String también pueden accederse utilizando llaves, como en $str{42}, para el mismo propósito.
Escribir fuera del rango es compensado rellenando el string con espacios.
Los tipos que no sean integer son convertidos a integer. Las compensaciones fuera
de rango emiten E_NOTICE. Las compensaciones negativas
emiten E_NOTICE en la escritura pero en la lectura obtienen
una cadena vacía. Sólo se emplea el primer carácter de un string asignado. La
asignación de un string vacío asigna un byte NULL.
Internamente, las cadenas de PHP son arrays de bytes. Por tanto, acceder o modificar una cadena utilizando los corchetes de array no es seguro con caracteres multi-byte, y sólo debe hacerse con cadenas en codificaciones de un solo bit como ISO-8859-1.
Ejemplo #9 Algunos ejemplos de cadenas
<?php
// Obtención del primer caracter de una cadena
$str = 'Esto es un test.';
$first = $str[0];
// Obtención del tercer caracter de una cadena
$third = $str[2];
// Obtención del último caracter de una cadena
$str = 'Esto sigue siendo un test.';
$last = $str[strlen($str)-1];
// Modificación del último caracter de una cadena
$str = 'Mira el mar';
$str[strlen($str)-1] = 'e';
?>
A partir de PHP 5.4 los índices de cadenas tienen que ser enteros o enteros en forma de cadena, si no se lanzará una advertencia. Anteriormente un índice como "foo" era convertido de manera silenciosa a 0.
Ejemplo #10 Diferencias entre PHP 5.3 y PHP 5.4
<?php
$str = 'abc';
var_dump($str['1']);
var_dump(isset($str['1']));
var_dump($str['1.0']);
var_dump(isset($str['1.0']));
var_dump($str['x']);
var_dump(isset($str['x']));
var_dump($str['1x']);
var_dump(isset($str['1x']));
?>
Muestra el ejemplo de arriba en PHP 5.3:
string(1) "b" bool(true) string(1) "b" bool(true) string(1) "a" bool(true) string(1) "b" bool(true)
Muestra el ejemplo de arriba en PHP 5.4:
string(1) "b" bool(true) Warning: Illegal string offset '1.0' in /tmp/t.php on line 7 string(1) "b" bool(false) Warning: Illegal string offset 'x' in /tmp/t.php on line 9 string(1) "a" bool(false) string(1) "b" bool(false)
Nota:
El acceso a variables de otros tipos (sin incluir arrays u objetos implementando las interfaces apropiadas) utilizando [] o {} silenciosamente retorna
NULL.
Nota:
PHP 5.5 añadió soporte para acceder a caracteres dentro de cadenas literales utilizando [] o {}.
Los string pueden ser concatenados empleando el operador '.' (punto). Fíjese que el operador '+' (suma) no servirá para concatenar. Consulte operadores de string para más información.
Hay una serie de funciones útiles para la manipulación de string.
Consulte la sección de funciones de string para funciones generales, y las funciones de expresiones regulares o las funciones de expresiones regulares compatibles con Perl para funcionalidades avanzadas de búsqueda y sustitución.
Tambien existen funciones para cadenas URL, y funciones para encriptar/desencriptar cadenas (mcrypt y mhash).
Finalmente, tambien existen las funciones para el tipo caracter.
Un valor puede convertirse a una string mediante el forzado (string) o la función strval(). La conversión automática a string tiene lugar en el contexto de una expresióin que necesita un string. Esto ocurre cuando se utilizan las funciones echo o print, o cuando una variables es comparada con un string. Las secciones sobre tipos y Manipulación de tipos pueden ayudarle a enterderlo con más claridad. Consulte tambien la función settype().
El valor TRUE del tipo boolean es convertido en el
string "1". El valor FALSE del tipo
boolean es convertido en el string ""
(la cadena vacía). Esto permite la conversión en ambos sentidos entre los valores de
los tipos boolean y string.
Un integer o float es convertido en un string representando textualmente el número (incluyendo la parte exponencial para los floats. Los números de punto flotante pueden ser convertidos mediante la notación exponencial (4.1E+6).
Nota:
El caracter para el punto decimal se define en el script de configuración regional (categoría LC_NUMERIC). Consulte la función setlocale().
Los arrays siempre se convierten en un string "Array". Debido a esto, tanto echo y print no pueden pos sí mismos mostrar el contenido de un array. Para ver un elemento individualmente, utilice una construcción como echo $arr['foo']. Mire los trucos en la parte inferior para mostrar el contenido por completo.
Los objects en PHP 4 siempre se convierten en un string "Object". Para mostrar los valores de las propiedades de un objeto para depuración, mire los parrafos siguientes. Para obtener el nombre de la clase del objeto emplée la función get_class(). A partir de PHP 5 se puede emplear el método __toString.
Los resources siempre se convierten en strings mediante la estructura "Resource id #1", donde 1 es el número único asignado al resource por PHP en tiempo de ejecución. No debe confiar en esta estructura, ya que está sujeto a cambios. Para obtener el tipo del resource emplee la función get_resource_type().
NULL siempre es convertido a una cadena vacía.
Como se ha indicado anteriormente, la conversión directa de un array, object o resource a un string no proporciona información útil acerca del valor, más allá de su tipo. Consulte las funciones print_r() y var_dump() para obtener maneras más efectivas de inspeccionar el contenido de estos tipos.
La mayoría de los valores de PHP pueden ser convertidos a strings para su almacenamiento permanente. Este método se denomina serialización, y es realizado mediante la función serialize(). Si la máquina PHP está contruida con soporte de WDDX, los valores de PHP tambien pueden ser serializacos como texto XML correctamente formateado.
Cuando una string es evaluada en un contexto numérico, el valor resultante y el tipo se determina como se explica a continuación.
Si el string no contiene ninguno de los caracteres '.', 'e',
o 'E' y el valor numérico está entre los límites del tipo entero (como se
define en PHP_INT_MAX), la string será
evaluada como un integer. En todos los demas casos será
evaluado como un float.
El valor es dado por la parte inicial del string. Si el string empieza con un número válido, éste será el valor usado. De otra forma, el valor será 0 (cero). Se considera número válido a un signo opcional, seguido de uno o más dígitos (opcionalmente puede contener un punto decimal), seguido de un exponente opcional. El exponente es una 'e' o 'E' seguida de uno o más dígitos.
<?php
$foo = 1 + "10.5"; // $foo es float (11.5)
$foo = 1 + "-1.3e3"; // $foo es float (-1299)
$foo = 1 + "bob-1.3e3"; // $foo es integer (1)
$foo = 1 + "bob3"; // $foo es integer (1)
$foo = 1 + "10 Small Pigs"; // $foo es integer (11)
$foo = 4 + "10.2 Little Piggies"; // $foo es float (14.2)
$foo = "10.0 pigs " + 1; // $foo es float (11)
$foo = "10.0 pigs " + 1.0; // $foo es float (11)
?>
Para más información sobre esta conversión, consulte la página del manual UNIX correspondiente a strtod(3).
Para probar cualquiera de los ejemplos en esta sección, copie y pegue los ejemplos e incluya la siguiente línea para ver que está ocurriendo:
<?php
echo "\$foo==$foo; tipo es " . gettype ($foo) . "<br />\n";
?>
No espere obtener el código de un caracter convirtiendolo a un entero, como ocurre en C. Emplee las funciones ord() y chr() para convertir entre código ASCII y caracteres.
En PHP, los string se implementan como una matriz de bytes y con un entero que indica la longitud del buffer. No guarda ninguna información sobre cómo traducir esos bytes, relegando esa tarea al programador. No existe ninguna limitación sobre el valor que puede contener un string; en concreto, está permitido colocar un bytes con valor 0 (“bytes NUL”) en cualquier posición del string (existen algunas funciones, marcadas en este manual como que no utilizan "modo binario seguro", podrían rechazar estos strings para aquellas bibliotecas que ignoren los datos preceden a un byte NUL.)
Este comportamiento de los strings justifica el que no exista un tipo de dato "byte" en PHP – los strings se encargan de esto. Las funciones que no devuelvan datos de texto – por ejemplo, cualquier dato leído a partir de un socket de red – devolverán strings.
Dado que PHP no obliga a utilizar ninguna condificación en particular, uno podría preguntarse cómo se codifican los textos literales. Por ejemplo, ¿es el string "á" equivalente a "\xE1" (ISO-8859-1), "\xC3\xA1" (forma en C UTF-8), "\x61\xCC\x81" (forma en D UTF-8) o cualquier otra representación posible? La resuesta es que un string se codifica en cualesquiera forma en que estuviera el fichero de código. Por tanto, si un fichero de código estuviera escrito en ISO-8859-1, el string se codificará en ISO-8859-1, y así. Sin embargo, esto no es aplicable si Zend Multibyte está habilitado; en ese caso, el fichero de código podría estar escrito en cualquier codificación (declarada explícitamente o bien detectada) para después convertirse a una determinada codificación interna, que será entonces la codificación usada para los textos literales. Tenga presente que existen algunas limitaciones sobre la codificación del código fuente (o en la codificación internal, si Zend Multibyte estuviera habilitado) – esto suele significar que se debe usar uan codificación complatible con el conjunto ASCII, como por ejemplo UTF-8 o ISO-8859-1. Por contra, las codificaciones dependientes de estados, donde un mismo byte se puede utilizar en estados de desplazamiento iniciales y no iniciales, podría generar problemas.
Por supuesto, para poder ser útil, las funciones que operen con texto podrán partir de unos supuestos sobre cómo está codificado el string. Desafortunadamente, respecto a esto existen muchas variaciones en la funciones de PHP:
En resumen, esto significa que para escribir programas Unicode de forma correcta hay que evitar cuidadosamente las funciones que pudean fallar y que muy probablemente vuelvan los datos corruptos, y utilizar en su lugar las funciones que se comportan de forma correcta, generalmente de las extensiones intl y mbstring. Sin embargo, el utilizar funciones que puedan manejar codificaciones Unicode es sólo el principio. No importa qué funciones incorpore el lenguaje; es primordial conocer la especificación Unicode. Por ejemplo, un programa que asuma que sólo hay mayúsculas y minúsculas estará haciendo una suposición erronea.