JTagua

Inicio » PHP » Tipos escalares

Archivo de la categoría: Tipos escalares

Tutorial PHP(8): Tipo string.

Una cadena o string es una serie de caracteres, donde un carácter es lo mismo que un byte. Esto significa que PHP solo admite un conjunto de 256 caracteres, y por lo tanto no tiene soporte nativo para Unicode. Una cadena o string puede llegar a alcanzar 2GB de tamaño.

Sintaxis.

Un string literal puede ser especificado de cuatro formas diferentes:

  • comillas simples
  • comillas dobles
  • sintaxis heredoc
  • sintaxis nowdoc (desde PHP 5.3.0)

Comillas simples.

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.

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.

</div>
<div><code> <?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';
?></code></div>
<div></div>
<div><code>

Comillas dobles.

Si un string está encerrado entre comillas dobles (“), PHP interpretará más sentencias de escape como caracteres especiales:

Image1

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.

Heredoc.

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 otro carácter, excepto un punto y coma (;). Esto significa especialemnte 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. Este es \n en los sistemas UNIX, incluyendo Mac OS X. El delimitador de cierre debe también estar seguido por 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, 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.

 

Tutorial PHP(7): Tipo float o punto flotante.

Los números de punto flotante  o float (también conocidos como “flotantes”, “dobles” o “números reales”) pueden ser especificados usando cualquiera de las siguientes sintaxis:

<?php
$a = 1.234;
$b = 1.2e3;
$c = 7E-10;
?>

El tamaño de un flotante depende de la plataforma, aunque un valor común consiste en un máximo de ~1.8e308 con una precisión de aproximadamente 14 dígitos decimales (lo que es un valor de 64 bits en formato IEEE).

Precisión del float.

Los números de punto flotante tienen una precisión limitada. Aunque depende del sistema, PHP típicamente utiliza el formato de doble precisión IEEE 754, el cual dará un error relativo máximo por aproximación del orden de 1.11e-16. Las operaciones aritméticas elementales no podrán dar grandes errores y por supuesto, los errores por propagación deben ser considerados cuando varias operaciones son compuestas.

Adicionalmente, los numeros racionales que son representables exactamente como números de punto flotante en base 10, como 0.1 o 0.7, no tienen una representación exacta como números de punto flotante en base 2, el cual es usado internamente, sin importar el tamaño de la mantisa. Por lo tanto, no se puede convertir en sus contrapartes binarias internas sin una pequeña pérdida de precisión. Esto puede llevar a confundir resultados: Por ejemplo, floor((0.1+0.7)*10) usualmente retornará 7 en lugar del 8 esperado, ya que la representación interna será algo así como 7.9999999999999991118….

Así que nunca se confía en resultados de números flotantes hasta el último dígito y no se comparan números de punto flotante directamente para igualdad. Si es necesaria una mejor precisión, están disponibles las funciones matemáticas de precisión arbitraria y las funciones gmp.

Conversión a float.

Para más información sobre las conversiones de string a float, vea Conversión de cadenas a números. Para valores de otros tipos, la conversión es la misma que si el valor hubiese sido convertido a integer y luego a float.

Comparando floats

Como se indica en la advertencia anterior, comprobar la igualdad de valores de punto flotante es problemático, debido a la forma en que se representan internamente. Sin embargo, hay maneras de hacer comparaciones de los valores de punto flotante que trabajan rodeando a estas limitaciones.

Para comprobar la igualdad de valores de punto flotante, se utiliza un límite superior en el error relativo debido al redondeo. Este valor se conoce como el epsilon de la máquina o unidad de redondeo y es la menor diferencia aceptable en los cálculos.

$a y $b son iguales a 5 dígitos de precisión.

<?php
$a = 1.23456789;
$b = 1.23456780;
$epsilon = 0.00001;

if(abs($a-$b) < $epsilon) {
echo "true";
}
?>

NaN.

Algunas operaciones numéricas pueden resultar en un valor representado por la constante NAN. Este resultado representa un valor no definido o no representable mediante cálculos de coma flotante. Cualquier comparación, ya sea poco rígida o estricta, de esta valor con cualquier otro valor, incluido él mismo tenfrá un resultado de FALSE.

Ya que NAN representa cualquier número de diferentes valores, NAN no debería compararse con otros valores, incluido él mismo; en su lugar debería comprobarse usando la función is_nan().

Tutorial PHP(6): tipo integer

Enteros.

Un entero o integer es un número del conjunto ℤ = {…, -2, -1, 0, 1, 2, …}.

Los integer pueden ser especificados mediante notación decimal (base 10), hexadecimal (base 16), octal (base 8) o binaria (base 2), opcionalmente precedidos por un signo (- o +).

Los literales integer binarios están disponibles desde PHP 5.4.0.

Para usar la notación octal, se antepone al número un 0 (cero).

Para usar la notación hexadecimal, se antepone al número un 0x.

Para usar la notación binaria, se antepone al número un 0b.

Ejemplo 1 Enteros literales.

<?php
$a = 1234; // número decimal
$a = -123; // un número negativo
$a = 0123; // número octal (equivalente a 83 decimal)
$a = 0x1A; // número hexadecimal (equivalente a 26 decimal)
$a = 0b11111111; // número binario (equivalente al 255 decimal)
?>
El tamaño de un integer depende de la plataforma, aunque un valor máximo de aproximadamente dos mil millones es el valor usual (para 32 bits con signo). Las plataformas de 64-bits normalmente tienen un valor máximo de aproximadamente 9E18. PHP no admite integers sin signo. El tamaño de un integer puede ser determinado mediante la constante PHP_INT_SIZE y el valor máximo mediante la constante PHP_INT_MAX desde PHP 4.4.0 y PHP 5.0.5.

Desbordamiento de enteros.

Si PHP encuentra un número fuera de los límites de un integer, se interpretará como un float (coma flotante) en su lugar. Tambien, una operación cuyo resultado es un número fuera de los límites de un integer devolverá en su lugar un float.

División entera.

No existe operador de división de integer en PHP. 1/2produce el float 0.5. El valor puede ser forzado a ser un integer redondeando por defecto, o mediante la función round() que permite un mayor control sobre el redondeo.

<?php
var_dump(25/7);         // float(3.5714285714286)
var_dump((int) (25/7)); // int(3)
var_dump(round(25/7));  // float(4)
?>

Conversión a enteros.

Para convertir explicitamente un valor a integer, se puede emplear tanto (int) como (integer). Sin embargo, la mayoría de las veces la conversión no es necesaria, ya que un valor es convertido de forma automática cuando un operador, función o estructura de control necesite un argumento del tipo integer. Un valor tambien puede ser convertido a integer mediante la función intval().

Desde booleanos.

FALSE produce 0 (cero), y TRUE produce 1 (uno).

Desde números de punto flotante.

Cuando se convierte de un float a un integer, el número será redondeado hacia cero.

Si el float esta por debajo de los límites de un integer (normalmente +/- 2.15e+9 = 2^31 en plataformas de 32 bits y +/- 9.22e+18 = 2^63 en plataformas de 64 bits), el resultado es indefinido, debido a que float no tiene la precisión suficiente para ofrecer el resultado como un integer exacto. No se mostrará ninguna advertencia, ni siquiera un aviso cuando esto ocurre!

Tutorial PHP(5): Tipo boolean.

boolean

Este es el tipo más simple. Un boolean expresa un valor de verdad. Puede ser TRUE o FALSE. Para especificar un literal boolean, use alguna de las palabras clave TRUE o FALSE. Ambas son insensibles a mayúsculas y minúsculas.

<?php
$foo = True; // asigna el valor TRUE a $foo
?>

Normalmente, el resultado de un operador que devuelve un valor boolean es pasado a una estructura de control.

<?php
// == es un operador que prueba por
// igualdad y devuelve un booleano
if ($accion == "mostrar_version") {
echo "La versión es 1.23";
}

// esto no es necesario...
if ($mostrar_separadores == TRUE) {
echo "<hr>\n";
}

// ...porque se puede escribir simplemente:
if ($mostrar_separadores) {
echo "<hr>\n";
}
?>

Conversión a booleano.

Para convertir explícitamente un valor a boolean, use el moldeamiento (bool) o (boolean). Sin embargo, en la mayoría de casos no es necesario usar el moldeamiento, ya que un valor será convertido automáticamente si un operador, función o estructura de control requiere un argumento tipo boolean. Cuando se realizan conversiones a boolean, los siguientes valores son considerados FALSE:

  • el boolean FALSE mismo
  • el integer 0 (cero)
  • el float 0.0 (cero)
  • el valor string vacío, y el string “0”
  • un array con cero elementos
  • un object con cero variables miembro (sólo en PHP 4)
  • el tipo especial NULL (incluyendo variables no definidas)
  • objetos SimpleXML creados desde etiquetas vacías

Cualquier otro valor es considerado TRUE (incluyendo cualquier resource).

Advertencia-1 es considerado TRUE, como cualquier otro número diferente a cero (¡ya sea negativo o positivo!)
<?php
var_dump((bool) "");        // bool(false)
var_dump((bool) 1);         // bool(true)
var_dump((bool) -2);        // bool(true)
var_dump((bool) "foo");     // bool(true)
var_dump((bool) 2.3e5);     // bool(true)
var_dump((bool) array(12)); // bool(true)
var_dump((bool) array());   // bool(false)
var_dump((bool) "false");   // bool(true)
?>