Tipos de datos, varibales y constantes

El tipo de datos que se va a utilizar en una variable normalmente no lo indica el programador; en su lugar, lo decide PHP en tiempo de ejecución dependiendo del contexto en el que se utilice esa variable, es decir; dependiendo del valor o resultado de la expresión que se le asigna.

15-Nov-2016

Tipos de datos

PHP soporta una serie de tipos esenciales o primitivos, divididos en tres grupos (en este módulo sólo comentaremos el primer grupo, ya que para el resto de grupos les dedicaremos capítulos enteros del curso):

Tipos escalares:

  • boolean para valores lógicos
  • integer para números enteros
  • float (número de coma flotante, también conocido como double)
  • string para cadenas de caracteres

Tipos compuestos:

  • array para mapas, matrices y vectores
  • object para instancias de clases

Tipos especiales:

  • resource para referencia a datos externos
  • NULL para representar datos sin valor

Booleanos

Este es el tipo más simple. Un boolean expresa un valor lógico. Puede ser true (verdadero) o false (falso).

Sintaxis

Para especificar un literal boolean, se usan alguna de las palabras clave TRUE o FALSE. Ambas son insensibles a mayúsculas y minúsculas.

<?php
$Correcto = true; // Asigna true a la variable $Correcto
?>

Un valor es considerado como FALSE cuando:

  • 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
  • el tipo especial NULL (incluidas variables no establecidas)

Cualquier otro valor será considerado como TRUE.

Enteros (integer)

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 +).

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.

Los enteros se pueden especificar usando una de las siguientes sintaxis:

<?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)
?>

El tamaño de un integer depende de la plataforma en la que se utilice, aunque usualmente se suele tomar un valor máximo de 32bits con signo.

Nota: Debido a que PHP asigna los tipos en función del contexto en el que se utilizan, la combinación de un tipo entero con un tipo string puede dar como resultado otro entero, si el string se evalúa en un contexto numérico.

<?php
$a = '1234'// $a es una variable de  tipo string
$b = 1+$a  // $a se asume de tipo integer ya que se  evalúa en un contexto numérico
echo $b;     // Da como resultado  1235
?>

Desbordamiento de enteros

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

Nº de punto flotante (float)

Los números de punto flotante (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).

Cadenas de caracteres (string)

Un string es una serie de caracteres donde un carácter 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.

Un string puede llegar a almacenar hasta 2Gb de tamaño.

Un valor de tipo string (literal) puede ser especificado de cuatro formas diferentes:

  • comillas simples '...'
  • comillas dobles "..."
  • sintaxis heredoc (comillas dobles en bloque)
  • sintaxis nowdoc (comillas simples en bloque)

Comillas simples

Es la forma más sencilla de representar un string y la que consume menos ciclos de CPU para su representación, por lo que es la recomendada cuando sólo vamos a manipular cadenas de caracteres puros sin variables ni códigos de escape.

Para especificar una comilla simple dentro de un string encerrado entre comillas simples, tendremos que escribirlo anteponiendo el carácter de barra invertida (\). Para especificar una barra invertida literal, se duplica (\\).

<?php
// Cadena de caracteres
$cadena='Cadena de caracteres’; 
// Me llamo 'Luis Roca' y mi web es minubeinformatica.com
$cadena='Me llamo \'Luis Roca\' y mi web es minubeinformatica.com';
// El archivo se encuentra en c:\wamp64\www
$cadena='El archivo se encuentra en c:\\wamp64\\www';
?>

Esta sintaxis no se puede utilizar para representar caracteres de escape como avance de línea, salto de carro, tabuladores, etc…

Comillas dobles

La característica más importante de entrecomillar un string mediante comillas dobles es el hecho que los nombres de las variables son expandidas. Esto quiere decir que se mostrará como resultado el contenido de la variable en lugar del nombre. En consecuencia esta sintaxis necesita más ciclos de CPU para poder interpretar el contenido.

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

Códigos de escape

Código de escape Significado
\n avance de línea
\r retorno de carro
\t Tabulador horizontal
\v Tabulador vertical
\e Escape
\f Avance de página
\\ Barra invertida
\$ Signo del dólar
\” Dobles comillas
<?php
echo "Esto es una cadena sencilla";

// Resultado:  El nombre de mi web es: “MiNubeInformatica”
echo  "El  nombre de mi web es: \"MiNubeInformatica\"";
$var1 = 10;
$var2 = 5;
$suma = $var1+$var2;
//  Resultado: Las variables $var1 y $var2 contienen 10 y 5. Sumadas dan como  resultado: 15
echo "Las variables \$var1 y \$var2 contienen $var1 y $var2. Sumadas dan  como resultado: $suma";
?>

Sintaxis heredoc

Una tercera forma de delimitar un string es mediante la sintaxis heredoc: <<< (tres signos <). Después de este operador, se deberá de escribir un nombre o 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, es decir al principio de una nueva línea sin espacios a la izquierda.

<?php
$CadenaHeredoc = <<< HDOC
<p>Esto es un texto  largo encerrado entre los identificadores ’HDOC’</p><p>Su contenido  es equivalente a la utilización de las dobles comillas.</p>
HDOC;
echo $CadenaHeredoc;
$Nombre = "Luis";
$Comentario = <<< COMENT
<p>$Nombre: Para poder enviar este formulario es necesario  rellenar todos los campos marcados con un asterisco. </p>
COMENT;
echo $Comentario;
/* Resultado:
Esto es un texto largo encerrado entre los  identificadores ’HDOC’

Su contenido es equivalente a la  utilización de las dobles comillas.

Luis: Para poder enviar este formulario es  necesario rellenar todos los campos marcados con un asterisco.
*/
?>

Resulta práctico a la hora de asignar o mostrar grandes cantidades de texto en las que necesitamos representar códigos de escape o contenidos de variables.

En el vídeo demostrativo que acompaña a este módulo, encontrareís más información acerca del uso de la sintaxis heredoc, con ejemplos y explicaciones más detalladas, además os muestro como podemos expandir el resultado de una función o el contenido de una constante utilizando esta sintaxis.

Sintaxis nowdoc

Nowdoc 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 sintaxis es ideal para embeber código PHP o grandes fragmentos de texto sin necesidad de escaparlo.

Una cadena nowdoc se identifica con la misma sintaxis <<< usada para heredoc, pero el identificador que le sigue está encerrado entre comillas simples, por ejemplo <<<'EOT'.

<?php
    $str = <<<'PARRAFO'
    <p>Ejemplo de una cadena  expandida<br />
    en varias líneas  empleando<br />
    la sintaxis nowdoc.</p>
PARRAFO;
    echo $str;
    $Nombre = "Luis";
    $Comentario = <<< 'COMENT'
    <p>"$Nombre":  Para poder enviar este formulario es necesario rellenar todos los campos  marcados con un asterisco. </p>
COMENT;
    // Esta vez la variable $Nombre no se  expandirá para mostrar su contenido
    echo $Comentario;

/* Resultado:
Ejemplo de una cadena expandida
en varias líneas
empleando  la sintaxis nowdoc.

"$Nombre": Para poder enviar este  formulario es necesario rellenar todos los campos marcados con un asterisco.
*/
?>

NULO

El valor especial NULL representa una variable sin valor. NULL es el único valor posible del tipo null.

Una variable es considerada null si:

  • se le ha asignado la constante NULL.
  • no se le ha asignado un valor todavía.
  • se ha destruido con unset().

Sintaxis
No hay más que un valor de tipo null, y es la constante NULL insensible a mayúsculas/minúsculas.

<?php
    $var = null;
?>

Variables en PHP

En PHP las variables se representan con un signo de dólar $, seguido por el nombre de la variable. El nombre de la variable es sensible a minúsculas y mayúsculas (case-sensitive).

Los nombres de variables siguen las mismas reglas que otras etiquetas en PHP. Un nombre de variable válido tiene que empezar con una letra o un carácter de subrayado (‘_’), seguido de cualquier número de letras, números y caracteres de subrayado.

PHP no requiere (ni soporta) la definición explicita de tipos en la declaración de variables. El tipo de una variable normalmente no lo indica el programador; en su lugar, lo decide PHP en tiempo de ejecución dependiendo del contexto en el que se utilice esa variable.

Si se quisiese obligar a que una variable se convierta a un tipo concreto, se podría moldear (forzar) la variable o usar la función settype() para ello.

<?php
    $nombre  = 'Carmen';
    $Nombre  = 'Luis';
    echo "($nombre, $Nombre)";
    // Imprime (Carmen, Luis) ya que PHP es  sensible al uso de mayúsculas y minúsculas
    
    $4site  = 'aun no';   // Inválido; comienza con un número
    $_4site  = 'aun no'// Válido; comienza con un carácter de subrayado
    $täyte  = 'mansikka'; // Válido; 'ä' es ASCII (Extendido)  228
    Puntos = 10;          // Inválido; no comienza  con el signo $
?>

Obtener el tipo de dato de una variable

Cuando deseemos conocer el tipo de dato de una variable utilizaremos la función gettype:

string gettype($variable)

Devuelve un literal con el nombre del tipo al que pertenece la variable.

<?php
    echo gettype(100).'<BR/ >';
    echo gettype(100.56).'<BR/ >';
    echo gettype(TRUE).'<BR/  >';
    echo gettype("HOLA").'<BR/ >';
    $var=100;
    $var2='Hola Mundo';
    echo gettype($var).'<BR/ >';
    echo gettype($var2).'<BR/ >';

/* Resultado:
integer
double
boolean
string
integer
string
*/
?>

Forzado de tipos

Es la técnica por medio de la cual forzamos, obligamos que el contenido de una variable sea o se convierta a un tipo de datos determinado.

Generalmente el forzado de tipos no será necesario ya que el propio PHP identifica y asigna los tipos según el contexto donde se utilice el valor.

El forzado de tipos en PHP funciona de la misma manera que en C:, donde el nombre del tipo deseado se escribe entre paréntesis antes de la variable que se quiera forzar.

Están permitidos los siguientes forzados de tipos:

  • (int), (integer) - forzado a integer
  • (bool), (boolean) - forzado a boolean
  • (float), (double), (real) - forzado a float
  • (string) - forzado a string
  • (array) - forzado a array
  • (object) - forzado a object
<?php
    // $numero es un integer según el contexto  de la asignación
    $numero = 47;
    
    // $var es un boolean al forzar el tipo de  la variable $numero y se le asigna el valor true
    $var = (boolean) $numero;
    
    // $num es un string según el contexto de  la asignación
    $num = '100';
    echo '<p>'.$num.'<br/>Es de tipo: '.gettype($num).'</p>';
    
    // $num es un integer al forzar el valor
    $num = (int) '100';
    echo '<p>'.$num.'<br/>Es de tipo: '.gettype($num).'</p>';

/* Resultado:
  100
  Es de tipo: string

  100
  Es de tipo: integer
*/
?>

Constantes en PHP

Una constante es un identificador para expresar un valor simple. Como el nombre sugiere, este valor no puede variar durante la ejecución del script.

Una constante es sensible a mayúsculas por defecto. Por convención, los identificadores es decir; los nombres de constantes suelen declararse en mayúsculas.

Un nombre de constante válido empieza con una letra o un carácter de subrayado, seguido por cualquier número de letras, números, o subrayados.

El alcance de una constante es global, Es decir, es posible acceder a ellas sin preocuparse por el ámbito de alcance.

Sintaxis

Las constantes se definen usando la función define() o con la palabra reservada const fuera de la definición de una clase a partir PHP 5.3.0.

define('DTO',0.10); // El identificador tiene que ir encerrado entre  comillas
const DTO=0.10;     // El identificador NO tiene que ir  encerrado entre comillas
  • Una vez definida la constante, no puede ser modificada ni eliminada.
  • Solo se puede definir como constantes valores escalares (boolean, integer, float y string).
  • Para obtener el valor de una constante solo es necesario especificar su nombre. A diferencia de las variables, no se tiene que especificar el prefijo $.
<?php
    $USUARIO = 'Carmen';
    $precio = 120;
    define('USUARIO','Luis');
    define('DTO',0.10);
    const  ABIERTO=false;
    echo $USUARIO; # Carmen variable
    echo USUARIO;  # Luis constante
    echo ABIERTO;  # false
    $importe=$precio*DTO; # realiza el cálculo  con un integer (variable) y un float (constante)
    // El  descuento aplicable es de: 12 €
    echo  "El descuento  aplicable es de: $importe €";
?>

Video Demostrativo