Un string, o cadena, es una serie de caracteres donde cada carácter es lo mismo que un byte. Esto significa que PHP solo admite un conjunto de 256 caracteres, y de ahí que no ofrezca soporte nativo para Unicode. Véanse los detalles del tipo string.
Nota: Un string puede llegar a alcanzar hasta 2 GB de tamaño (2147483647 bytes máximo).
Un literal de tipo string se puede especificar de cuatro formas diferentes:
La manera más sencilla de especificar un string es delimitarlo con comillas
simples (el carácter ').
Para especificar una comilla simple literal, se ha de escapar con una barra invertida
(\). Para especificar una barra invertida literal, se duplica
(\\). Todas las demás instancias de barras invertidas serán tratadas
como una barra invertida literal: esto significa que otras secuencias de escape que
podrían utilizarse, tales como \r o \n,
serán mostradas literalmente tal y como se especifican, en lugar de tener cualquier otro
significado especial.
Nota: A diferencia de las sintaxis de entrecomillado doble y heredoc, las variables y las sentencias de escape para caracteres especiales no se expandirán cuando estén incluidas dentro de un string entre comillas simples.
<?php
echo 'Esto es una cadena sencilla';
echo 'También se pueden incluir nuevas líneas en
un string 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 $expandirán
echo 'Las variables $tampoco se $expandirán';
?>Si un string está delimitado con comillas dobles ("), PHP interpretará las siguientes secuencias de escape como caracteres especiales:
| Secuencia | 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.4) |
\f |
avance de página (FF o 0x0C (12) en ASCII) (desde PHP 5.2.5) |
\\ |
barra invertida |
\$ |
signo de dólar |
\" |
comillas dobles |
\[0-7]{1,3} |
la secuencia de caracteres que coincida con la expresión regular es un carácter en notación octal, que silenciosamente desborda para encajar en un byte (p.ej. "\400" === "\000") |
\x[0-9A-Fa-f]{1,2} |
la secuencia de caracteres que coincida con la expresión regular es un carácter en notación hexadecimal |
\u{[0-9A-Fa-f]+} |
la secuencia de caracteres que coincida con la expresión regular es un punto de código de Unicode, la cual será imprimida al string como dicha representación UTF-8 del punto de código (añadido en PHP 7.0.0) |
Al igual que en el entrecomillado simple de un string, escapar cualquier
otro carácter puede dar lugar a que se muestre también la barra invertida. Antes de
PHP 5.1.1, no se mostraba la barra invertida de \{$var}.
La característica más importante del entrecomillado doble de un string es el hecho de que se expanden los nombres de las variables. Consulte el análisis de string para más detalles.
Una tercera forma de delimitar un string es mediante la sintaxis heredoc:
<<<. Después de este operador, se deberá proporcionar un
identificador y justo 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 carácter 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 otro carácter, excepto un punto y coma (;).
Esto, en especial, significa que el identificador
no debe estar sangrado, y que no debe existir ningún espacio
ni tabulación antes o después del punto y coma. Es muy importante observar que
el primer carácter antes del identificador de cierre debe ser un salto de línea
definido por el sistema operativo local. Este es \n en
los sistemas UNIX, incluyendo Mac OS X. Al delimitador de cierre le ha de seguir
tambíen una nueva línea.
Si se rompe esta regla y el identificador de cierre no está "limpio", no será considerado como un identificador de cierre, por lo que PHP continuará buscando uno. Si no se encuentra ningún identificador de cierre apropiado antes del final del fichero, se producirá un error de análisis en la última línea.
No se puede emplear Heredoc para inicializar las propiedades de una clase. Desde PHP 5.3, esta limitación es válida solamente para un heredoc 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 no es necesario escapar las comillas en un heredoc, aunque se puede seguir empleando los códigos de escape indicados arriba. Pese a que las variables son expandidas, se debe tener el mismo cuidado al expresar variables complejas en un heredoc que en un string.
Ejemplo #2 Ejemplo de entrecomillado de string en 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();
$nombre = 'MiNombre';
echo <<<EOT
Mi nombre es "$nombre". Estoy escribiendo un poco de $foo->foo.
Ahora, estoy escribiendo un poco de {$foo->bar[1]}.
Esto debería 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 debería mostrar una 'A' mayúscula: A
También se puede emplear la sintaxis Heredoc para pasar datos como argumentos de una función:
Ejemplo #3 Ejemplo de Heredoc en argumentos
<?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 Usar Heredoc para inicializar valores estáticos
<?php
// Variables estáticas
function foo()
{
static $bar = <<<LABEL
Nada aquí...
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 también introdujo la posibilidad de entrecomillar el identificador de apertura en Heredoc:
Ejemplo #5 Emplear comillas dobles en Heredoc
<?php
echo <<<"FOOBAR"
¡Hola Mundo!
FOOBAR;
?>
Nowdoc es a los string con comillas simples lo mismo que Heredoc lo es a los string con
comillas dobles. Un nowdoc se especifica de forma análoga a un heredoc, pero
no se realiza ningún análisis dentro del nowdoc. La construcción
es ideal para embeber código de PHP o grandes fragmentos de texto sin necesidad de
escaparlos. Comparte algunas características comunes con la construcción
<![CDATA[ ]]> de SGML, donde se declara un bloque de
texto que no se analiza.
Un nowdoc se identifica con la misma secuencia empleada para heredoc,
<<<, pero el identificador que le sigue está delimitado con
comillas simples, p.ej., <<<'EOT'. Todas las reglas
para los identificadores de heredoc también son aplicables a los identificadores de
nowdoc, especialmente aquellas que se refieren al empleo del identificador de cierre.
Ejemplo #6 Ejemplo de entrecomillado de string de Nowdoc
<?php
$str = <<<'EOD'
Ejemplo de un string
expandido 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();
$nombre = 'MiNombre';
echo <<<'EOT'
Mi nombre es "$nombre". Estoy escribiendo un poco de $foo->foo.
Ahora, estoy escribiendo un poco de {$foo->bar[1]}.
Esto debería mostrar una 'A' mayúscula: \x41
EOT;
?>El resultado del ejemplo sería:
Mi nombre es "$nombre". Estoy escribiendo un poco de $foo->foo.
Ahora, estoy escribiendo un poco de {$foo->bar[1]}.
Esto debería mostrar una 'A' mayúscula: \x41Ejemplo #7 Ejemplo de datos estáticos
<?php
class foo {
public $bar = <<<'EOT'
bar
EOT;
}
?>Nota:
El soporte para Nowdoc se añadió en PHP 5.3.0.
Cuando un string es especificado mediante comillas dobles o mediante heredoc, las variables que haya dentro de dicho string se analizarán.
Existen dos tipos de sintaxis: una simple y otra compleja. La sintaxis simple es la más empleada y práctica. Proporciona una forma de embeber 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 delimitan la expresión.
Si se encuentra un signo de dólar ($), el analizador tomará
el mayor número de símbolos para formar un nombre de variable válido.
Delimitar el nombre de la variable con llaves permite especificar explícitamente
el final del nombre.
<?php
$jugo = "manzana";
echo "Él tomó algo de jugo de $jugo.".PHP_EOL;
// Inválido. "s" es un carácter válido para un nombre de variable, pero la variable es $jugo.
echo "Él tomó algo de jugo hecho de $jugos.";
// Válido. Explícitamente especifica el final del nombre de la variable encerrándolo entre llaves:
echo "Él tomó algo de jugo hecho de ${jugo}s."
?>El resultado del ejemplo sería:
Él tomó algo de jugo de manzana. Él tomó algo de jugo hecho de . Él tomó algo de jugo hecho de manzanas.
De forma parecida, se puede analizar el índice de un array o la
propiedad de un object. 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 "Él tomó algo de jugo de $jugos[0].".PHP_EOL;
echo "Él tomó algo de jugo de $jugos[1].".PHP_EOL;
echo "Él tomó algo de jugo $jugos[koolaid1].".PHP_EOL;
class persona {
public $john = "John Smith";
public $jane = "Jane Smith";
public $robert = "Robert Paulsen";
public $smith = "Smith";
}
$persona = new persona();
echo "$persona->john tomó algo de jugo de $jugos[0].".PHP_EOL;
echo "$persona->john entonces dijo hola a $persona->jane.".PHP_EOL;
echo "La esposa de $persona->john saludó a $persona->robert.".PHP_EOL;
echo "$persona->robert saludó a los dos $persona->smiths."; // No funcionará
?>El resultado del ejemplo sería:
Él tomó algo de jugo de manzana. Él tomó algo de jugo de naranja. Él 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 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 porque sea compleja, sino porque permite el empleo de expresiones complejas.
Cualquier variable escalar, elemento de array o propiedad de objeto con una
representación de tipo string puede ser incluido a través de esta sintaxis.
Simplemente se escribe la expresión del mismo modo en que aparecería por fuera del
string, y delimitándola con { 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
// Mostrar todos los errores
error_reporting(E_ALL);
$genial = 'fantástico';
// No funciona, muestra: Esto es { fantástico}
echo "Esto es { $genial}";
// Funciona, muestra: Esto es fantástico
echo "Esto es {$genial}";
// Funciona
echo "Este cuadrado tiene {$cuadrado->width}00 centímetros de lado.";
// Funciona, las claves entre comillas sólo funcionan usando la sintaxis de llaves
echo "Esto funciona: {$arr['clave']}";
// Funciona
echo "Esto funciona: {$arr[4][3]}";
// Esto no funciona por la misma razón que $foo[bar] es incorrecto fuera de un string.
// En otras palabras, aún funcionaría, pero solamente porque PHP primero busca una
// constante llamada foo; se emitirá un error de nivel E_NOTICE
// (constante no definida).
echo "Esto está mal: {$arr[foo][3]}";
// Funciona. Cuando se usan arrays multidimensionales, emplee siempre llaves que delimiten
// a los arrays cuando se encuentre dentro de un string
echo "Esto funciona: {$arr['foo'][3]}";
// Funciona.
echo "Esto funciona: " . $arr['foo'][3];
echo "Esto también funciona: {$obj->valores[3]->nombre}";
echo "Este es el valor de la variable llamada $nombre: {${$nombre}}";
echo "Este es el valor de la variable llamada por el valor devuelto por getNombre(): {${getNombre()}}";
echo "Este es el valor de la variable llamada por el valor devuelto por \$objeto->getNombre(): {${$objeto->getNombre()}}";
//No funciona, muestra: Esto es el valor devuelto por getNombre(): {getNombre()}
echo "Esto es el valor devuelto por getNombre(): {getNombre()}";
?>Con esta sintaxis, también es posible acceder a las propiedades de una clase empleando variables dentro de un string.
<?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:
Las funciones, llamadas a métodos, variables de clase estáticas 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 está definido el string. El empleo de simples llaves ({}) no servirá para acceder al valor devuelto por las funciones o métodos, o los valores de las constantes de clase o variables de clase estáticas.
<?php
// Mostrar todos los errores.
error_reporting(E_ALL);
class cervezas {
const refresco = 'zarzaparrilla';
public static $ale = 'ipa';
}
$zarzaparrilla = 'A & W';
$ipa = 'Alexander Keith\'s';
// Funciona; muestra: Me gusta una A & W
echo "Me gusta una {${cervezas::refresco}}\n";
// También funciona; muestra: Me gusta una Alexander Keith's
echo "Me gusta una {${cervezas::$ale}}\n";
?>Se puede acceder y modificar los caracteres dentro de un string especificando el índice de base cero del carácter deseado después del string empleando los corchetes de array, como en $str[42]. Piense en un string como un array de caracteres, en este caso. Las funciones substr() y substr_replace() pueden ser empleadas para extraer o reemplazar más de un carácter.
Nota: También se puede acceder a un string utilizando llaves, como en $str{42}, con el mismo propósito.
Escribir en un índice fuera del rango rellenará el string con espacios.
Los tipos que no sean integer son convertidos a integer.
Los índices ilegales emiten un error de nivel E_NOTICE.
Los índices negativos emiten un error de nivel E_NOTICE en la escritura, aunque se
lea un string vacío. 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, los string de PHP son arrays de bytes. Por tanto, acceder o modificar un string utilizando los corchetes de array no es seguro con caracteres multibyte, dado que sólo se realiza con los string de codificaciones monobyte, como ISO-8859-1.
Ejemplo #9 Algunos ejemplos de string
<?php
// Obtener el primer carácter de un string
$str = 'Esto es una prueba.';
$primero = $str[0];
// Obtener el tercer carácter de un string
$tercero = $str[2];
// Obtener el último carácter de un string
$str = 'Esto sigue siendo una prueba.';
$último = $str[strlen($str)-1];
// Modificar el último carácter de un string
$str = 'Mira el mar';
$str[strlen($str)-1] = 'l';
?>
A partir de PHP 5.4, los índices de string tienen que ser de tipo integer o integer en forma de string, si no, se emitirá
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']));
?>Salida del ejemplo anterior en PHP 5.3:
string(1) "b" bool(true) string(1) "b" bool(true) string(1) "a" bool(true) string(1) "b" bool(true)
Salida del ejemplo anterior 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 que implementen las interfaces apropiadas) utilizando
[]o{}, silenciosamente retornanull.
Nota:
PHP 5.5 añadió soporte para acceder a caracteres dentro de literales de tipo string utilizando
[]o{}.
Los string pueden ser concatenados empleando el operador '.' (punto). Fíjese que el operador '+' (suma) no servirá para concatenar. Consulte los 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 compatibles con Perl para características avanzadas de búsqueda y sustitución.
También existen funciones para string de URL, y funciones para encriptar/desencriptar string (mcrypt y mhash).
Finalmente, también existen las funciones para el tipo carácter.
Un valor puede convertirse a un string empleando el molde
(string) o mediante la función strval().
La conversión automática a string tiene lugar en el ámbito de
una expresión donde sea necesario un string. Esto ocurre cuando se utilizan
las funciones echo o print, o cuando
se compara una variable con un string. Las secciones sobre
Tipos y
Manipulación de tipos lo
aclararán. Consulte también la función settype().
El valor true del tipo boolean es convertido al string
"1". El valor false del tipo boolean es convertido
al string "" (el string vacío). Esto permite la conversión
en ambos sentidos entre los valores de los tipos boolean y string.
Un integer o float es convertido a un
string que representa textualmente el número (incluyendo
la parte exponencial para los float. Los números de punto flotante
pueden ser convertidos mediante la notación exponencial (4.1E+6).
Nota:
El carácter para el punto decimal se define en el localismo del script (categoría LC_NUMERIC). Consulte la función setlocale().
Los arrays siempre son convertidos al string
"Array". Debido a esto, echo y
print no pueden por sí mismos mostrar el contenido de un
array. Para ver un único elemento individualmente, utilice una construcción
como echo $arr['foo']. Vea los consejos de más abajo para mostrar
el contenido completo.
Los object en PHP 4 siempre son convertidos al string
"Object". Para mostrar los valores de las propiedades de un objeto
para su depuración, lea los párrafos siguientes. Para obtener el nombre de la clase de
un objeto, emplee la función get_class(). A partir de PHP 5, se puede
emplear el método __toString cuando
sea relevante.
Un resource siempre es convertido a string con la
estructura "Resource id #1", donde 1
es el número de recurso asignado al resource por PHP durante
la ejecución. A pesar de que no se debe depender de la estructura exacta, debido a que
está sujeta a cambios, siempre será única para un recurso dado
dentro del tiempo de vida de un script en ejecución (es decir, una petición web o
proceso CLI), por lo que no será reutilizada. Para obtener el tipo de un resource,
emplee la función get_resource_type().
null siempre es convertido a un string vacío.
Como se indicó 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 ver medios más efectivos de inspeccionar el contenido de estos tipos.
La mayoría de los valores de PHP pueden ser convertidos a un string para su almacenamiento permanente. Este método se denomina serialización, y es realizado mediante la función serialize(). Si el motor de PHP se construyó con soporte para WDDX, los valores de PHP también pueden ser serializacos como texto XML bien formado.
Cuando un string es evaluado 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 integer (tal como
está definido por PHP_INT_MAX), el string
será evaluado como un integer. En todos los demás casos será
evaluado como un float.
El valor es dado por la parte inicial del string. Si el string empieza con un dato numérico válido, éste será el valor empleado. De lo contrario, el valor será 0 (cero). Un dato numérico válido es 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 pequeños cerdos"; // $foo es integer (11)
$foo = 4 + "10.2 pequeños cerditos"; // $foo es float (14.2)
$foo = "10.0 cerdos " + 1; // $foo es float (11)
$foo = "10.0 cerdos " + 1.0; // $foo es float (11)
?>Para más información sobre esta conversión, consulte la página del manual de Unix para a strtod(3).
Para probar cualesquiera de los ejemplos de esta sección, copie y péguelos e incluya la siguiente línea para ver lo que está sucediendo:
<?php
echo "\$foo==$foo; tipo : " . gettype ($foo) . "<br />\n";
?>No espere obtener el código de un carácter convirtiéndolo a un integer, como ocurre en C. Emplee las funciones ord() y chr() para convertir entre código códigos ASCII y caracteres.
En PHP, los string se implementan como un array de bytes y con un número
entero que indica la longitud del búfer. No posee ninguna información sobre cómo
traducir esos bytes a caracteres, relegando esa tarea al programador.
No existe ninguna limitación sobre los valores que pueden componer un string; en
concreto, está permitido colocar bytes con valor 0 (“bytes NUL”)
en cualquier posición del string (aunque existen algunas funciones, citadas en este manual como
“no seguras a nivel binario”, que podrían rechazar estos string para aquellas
bibliotecas que ignoren los datos que siguen a un byte NUL.)
Este comportamiento del tipo string justifica que no exista un tipo de dato "byte" en PHP – los string se encargan de esto. Las funciones que no devuelven datos de texto – por ejemplo, cualquier dato leído a partir de un socket de red – devolverán valores de tipo string.
Dado que PHP no obliga a utilizar ninguna condificación en particular, uno podría
preguntarse cómo se codifican los literales de tipo string. Por ejemplo, ¿es el string
"á" equivalente a "\xE1" (ISO-8859-1),
"\xC3\xA1" (UTF-8, forma C),
"\x61\xCC\x81" (UTF-8, forma D) o cualquier otra representación
posible? La respuesta es que un string será codificado en cualquiera forma en que
estuviera codificado el fichero del script. Por tanto, si un script estuviera escrito en
ISO-8859-1, el string se codificará en ISO-8859-1, etc. Sin embargo,
esto no es aplicable si está habilitado Zend Multibyte; en ese caso, el script
podría estar escrito en cualquier codificación (la cual es declarada explícitamente o
es detectada) para después convertirse a una determinada codificación interna, que será
entonces la codificación usada para los literales de tipo string.
Tenga presente que existen algunas limitaciones sobre la codificación del script (o en
la codificación interna, si Zend Multibyte estuviera habilitado); esto suele significar
que dicha codificación debería ser compatible con un superconjunto de ASCII, tal como
UTF-8 o ISO-8859-1. Por contra, las codificaciones dependientes del estado donde
se pueden utilizar los mismos valores de byte en estados de desplazamiento iniciales y no iniciales,
podrían generar problemas.
Por supuesto, para poder ser útiles, las funciones que operen con texto podrían partir de unos supuestos sobre cómo está codificado el string. Desafortunadamente, respecto a esto existen muchas variaciones en las funciones de PHP:
strtoupper("á") podría devolver "Á" si el
localismo está correctamente establecido y á está
codificado con un único byte. Si está codificado en UTF-8, no se devolverá un resultado
correcto, y el string resultante podría devolverse corrupto, en función del
localismo en uso.
u).
Debido a su propósito especial, la función
utf8_decode() asume una codificación UTF-8, mientras que la
función utf8_encode() asume una codificación ISO-8859-1.
En resumen, para escribir programas de forma correcta usando Unicode hay que evitar cuidadosamente las funciones que puedan fallar y que muy probablemente corrompan los datos, y utilizar en su lugar las funciones que se comporten de forma correcta, generalmente las de las extensiones intl y mbstring. Sin embargo, el uso de funciones que pueden 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 errónea.
The documentation does not mention, but a closing semicolon at the end of the heredoc is actually interpreted as a real semicolon, and as such, sometimes leads to syntax errors.
This works:
<?php
$foo = <<<END
abcd
END;
?>
This does not:
<?php
foo(<<<END
abcd
END;
);
// syntax error, unexpected ';'
?>
Without semicolon, it works fine:
<?php
foo(<<<END
abcd
END
);
?>In PHP 8.2 using ${var} in strings is deprecated, use {$var} instead:
<?php
$juice = "apple";
// Valid. Explicitly specify the end of the variable name by enclosing it in braces:
echo "He drank some juice made of {$juice}s.";
?>You can use the complex syntax to put the value of both object properties AND object methods inside a string. For example...
<?php
class Test {
public $one = 1;
public function two() {
return 2;
}
}
$test = new Test();
echo "foo {$test->one} bar {$test->two()}";
?>
Will output "foo 1 bar 2".
However, you cannot do this for all values in your namespace. Class constants and static properties/methods will not work because the complex syntax looks for the '$'.
<?php
class Test {
const ONE = 1;
}
echo "foo {Test::ONE} bar";
?>
This will output "foo {Test::one} bar". Constants and static properties require you to break up the string.md5('240610708') == md5('QNKCDZO')
This comparison is true because both md5() hashes start '0e' so PHP type juggling understands these strings to be scientific notation. By definition, zero raised to any power is zero.easy transparent solution for using constants in the heredoc format:
DEFINE('TEST','TEST STRING');
$const = get_defined_constants();
echo <<<END
{$const['TEST']}
END;
Result:
TEST STRINGSimple function to create human-readably escaped double-quoted strings for use in source code or when debugging strings with newlines/tabs/etc.
<?php
function doubleQuote($str) {
$ret = '"';
for ($i = 0, $l = strlen($str); $i < $l; ++$i) {
$o = ord($str[$i]);
if ($o < 31 || $o > 126) {
switch ($o) {
case 9: $ret .= '\t'; break;
case 10: $ret .= '\n'; break;
case 11: $ret .= '\v'; break;
case 12: $ret .= '\f'; break;
case 13: $ret .= '\r'; break;
default: $ret .= '\x' . str_pad(dechex($o), 2, '0', STR_PAD_LEFT);
}
} else {
switch ($o) {
case 36: $ret .= '\$'; break;
case 34: $ret .= '\"'; break;
case 92: $ret .= '\\\\'; break;
default: $ret .= $str[$i];
}
}
}
return $ret . '"';
}
?>String conversion to numbers.
Unfortunately, the documentation is not correct.
«The value is given by the initial portion of the string. If the string starts with valid numeric data, this will be the value used. Otherwise, the value will be 0 (zero).»
It is not said and is not shown in examples throughout the documentation that, while converting strings to numbers, leading space characters are ignored, like with the strtod function.
<?php
echo " \v\f \r 1234" + 1; // 1235
var_export ("\v\f \r 1234" == "1234"); // true
?>
However, PHP's behaviour differs even from the strtod's. The documentation says that if the string contains a "e" or "E" character, it will be parsed as a float, and suggests to see the manual for strtod for more information. The manual says
«A hexadecimal number consists of a "0x" or "0X" followed by a nonempty sequence of hexadecimal digits possibly containing a radix character, optionally followed by a binary exponent. A binary exponent consists of a 'P' or 'p', followed by an optional plus or minus sign, followed by a nonempty sequence of decimal digits, and indicates multiplication by a power of 2.»
But it seems that PHP does not recognise the exponent or the radix character.
<?php
echo "0xEp4" + 1; // 15
?>
strtod also uses the current locale to choose the radix character, but PHP ignores the locale, and the radix character is always 2E. However, PHP uses the locale while converting numbers to strings.
With strtod, the current locale is also used to choose the space characters, I don't know about PHP.Here is a possible gotcha related to oddness involved with accessing strings by character past the end of the string:
$string = 'a';
var_dump($string[2]); // string(0) ""
var_dump($string[7]); // string(0) ""
$string[7] === ''; // TRUE
It appears that anything past the end of the string gives an empty string.. However, when E_NOTICE is on, the above examples will throw the message:
Notice: Uninitialized string offset: N in FILE on line LINE
This message cannot be specifically masked with @$string[7], as is possible when $string itself is unset.
isset($string[7]); // FALSE
$string[7] === NULL; // FALSE
Even though it seems like a not-NULL value of type string, it is still considered unset.Leading zeroes in strings are (least-surprise) not treated as octal.
Consider:
$x = "0123" + 0;
$y = 0123 + 0;
echo "x is $x, y is $y"; //prints "x is 123, y is 83"
in other words:
* leading zeros in numeric literals in the source-code are interpreted as "octal", c.f. strtol().
* leading zeros in strings (eg user-submitted data), when cast (implicitly or explicitly) to integer are ignored, and considered as decimal, c.f. strtod().<?php
\\Example # 10 Simple Syntax - Solution for the last "echo" line.
class people {
public $john = "John Smith";
public $jane = "Jane Smith";
public $robert = "Robert Paulsen";
public $smith = "Smith";
}
$people = new people();
echo "$people->john then said hello to $people->jane.".PHP_EOL;
echo "$people->john's wife greeted $people->robert.".PHP_EOL;
echo "$people->robert greeted the two $people->smiths";
\\Won't work
\\Outputs: Robert Paulsen greeted the two
/**Solution:**\
echo "$people->robert greeted the two $people->smith\x08s";
\\Will work
\\Outputs: Robert Paulsen greeted the two Smiths
?>Here is an easy hack to allow double-quoted strings and heredocs to contain arbitrary expressions in curly braces syntax, including constants and other function calls:
<?php
// Hack declaration
function _expr($v) { return $v; }
$_expr = '_expr';
// Our playground
define('qwe', 'asd');
define('zxc', 5);
$a=3;
$b=4;
function c($a, $b) { return $a+$b; }
// Usage
echo "pre {$_expr(1+2)} post\n"; // outputs 'pre 3 post'
echo "pre {$_expr(qwe)} post\n"; // outputs 'pre asd post'
echo "pre {$_expr(c($a, $b)+zxc*2)} post\n"; // outputs 'pre 17 post'
// General syntax is {$_expr(...)}
?>To save Your mind don't read previous comments about dates ;)
When both strings can be converted to the numerics (in ("$a" > "$b") test) then resulted numerics are used, else FULL strings are compared char-by-char:
<?php
var_dump('1.22' > '01.23'); // bool(false)
var_dump('1.22.00' > '01.23.00'); // bool(true)
var_dump('1-22-00' > '01-23-00'); // bool(true)
var_dump((float)'1.22.00' > (float)'01.23.00'); // bool(false)
?>