Tipos de datos en PHP

Los tipos en PHP son una representación de los datos, ya que no requiere que las variables declaren su tipo, porque todos los tipos se convierten de forma automática

Tipo booleano

El tipo booleano simplemente distingue entre dos estados, un estado de éxito o de activado, valor verdadero, true, y un estado de fracaso o de desactivado, valor falso, false

Ambos estados no son susceptibles a mayúsculas y minúsculas

$foo = True; #asigna el valor TRUE a la variable $foo

Normalmente, el resultado de operadores que devuelven un valor de tipo booleano son pasados a una estructura de control

#ejemplo de comprobación de igualdad mediante el operador == que devuelve un booleano
if ($accion == "mostrar_version") {
    echo "La versión es 7.3";
}

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

#...porque podemos ahorrar código escribiendo:
if ($mostrar_separadores) {
    echo "<hr>\n";
}

Tipos numéricos

Los tipos numéricos los podemos dividir en reales y enteros

Tipo numérico entero

• Integer

  enteros en base 10

  Tanto positivos como negativos

• Hexadecimal

  enteros en base 16

  Se coloca antes del número en base 16 0x ó 0X

• Octal

  enteros en base 8

  Colocamos un cero antes de dicho número en octal

• Binario

  enteros en base 2

  Se coloca antes del número en base 2 0b ó 0B

Formalmente, la estructura de los literales de tipo entero es:

decimal : [1-9][0-9]* | 0

hexadecimal : 0[xX][0-9a-fA-F]+

octal : 0[0-7]+

binario : 0b[01]+

entero : [+-]?decimal | [+-]?hexadecimal | [+-]?octal | [+-]?binario

Tipo numérico real

Los reales se componen de una parte entera y otra fraccionaria separada por un punto de la anterior

La parte fraccionaria puede estar compuesta por un indicador de exponente E o e seguido de un número entero que indica el valor del exponente

Formalmente, la estructura de los literales de tipo real es:

LNUM : [0-9]+
DNUM : ([0-9]*[\.]{LNUM}) | ({LNUM}[\.][0-9]*)
EXPONENT_DNUM : [+-]?(({LNUM} | {DNUM}) [eE][+-]? {LNUM})

• Float

  es un valor numérico de coma flotante

  Tanto positivos como negativos

  Su tamaño depende de la plataforma, aunque su valor puede ser como máximo 1.8e308 aproximadamente, con una precisión cercana a los 14 dígitos decimales (formato de 64 bit del IEEE)

  Adicionalmente, los números racionales cuya representación en base 10 es igual a la empleada como número en coma flotante, como 0.1 o 0.7, no tienen una representación exacta como números de punto flotante en base 2, que es la base empleada internamente, sin importar el tamaño de la mantisa

  Por lo tanto, no se pueden convertir a binario sin una pequeña pérdida de precisión

  Pudiendo dar resultado a errores de precisión como por ejemplo, floor( (0.1 + 0.7) * 10); normalmente devolvería 8, sin embargo, nos devolverá 7, ya que en su representación interna será 7.9999999999999991118…

  Por tanto, no se recomienda confiar en los resultados con números en coma flotante y no utilizar la comparación de igualdad entre números de punto flotante directamente

  En caso de necesitar una mayor precisión, utiliza las funciones matemáticas de precisión arbitraria y las funciones de gmp

• Double

  es equivalente al Float y no aporta diferencias sustanciales

  En otros lenguajes tiene doble precisión, pero en PHP se ha mantenido por motivos históricos y es aconsejabla usar mejor las funciones que trabajan con Float

• 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 punto flotante

  Cualquier comparación, ya sea estricta o no, de este valor con cualquier otro valor, incluido él mismo, a excepción de TRUE, tendrá como resultado FALSE

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

$var1 = 20; #decimal
$var2 = 0x14; #hexadecimal (equivale a 20 decimal)
$var3 = 024; #octal (equivale a 20 decimal)
$var4 = 0b‭00010100‬; #binario (equivale a 20 decimal)

#reales
$var5 = 25.478;
$var6 = 2.3E45;
$var7 = 5.6E-2;
$var8 = -3.789;

Tipo string

Un string es una cadena de caracteres delimitadas por comillas

Donde cada carácter es un byte

Esto significa que PHP solo admite un conjunto de 256 caracteres, y de ahí que no ofrezca soporte nativo para Unicode

Un string sólo puede contener hasta 2 GB de tamaño (2147483647 bytes como máximo)

Un literal de tipo string se puede especificar de cuatro formas diferentes:

• entrecomillado simple

  se especifican entre los carácteres ‘ de apertura y ‘ de cierre

  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

  Hay que tener en cuenta que 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

  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: "Volveré"
  echo 'Arnold una vez dijo: "Volveré"';
  
  #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 $var tampoco se expandirán
  echo 'Las variables $var tampoco se expandirán';

• entrecomillado doble

  se especifican entre los carácteres " de apertura y " de cierre

  La característica más importante del entrecomillado doble de un string es el hecho de que se expanden los nombres de las variables

  PHP interpretará las siguientes secuencias de escape como caracteres especiales:

  Código	Descripción
  \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)

  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}

  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: "Volveré"
  echo "Arnold una vez dijo: \"Volveré\"";
  
  #Resultado: Ha borrado C:\*.*?
  echo "Ha borrado C:\\*.*?";
  
  #Resultado: Ha borrado C:*.*?
  echo "Ha borrado C:\*.*?";
  
  #Resultado: Esto se expandirá: \n una nueva línea
  echo "Esto no se expandirá: \n una nueva línea";
  
  #Resultado: Las variables $var se expandirán
  echo 'Las variables $var se expandirán';

• sintaxis heredoc

  se especifican mediante el los carácteres <<< seguidos del operador EOT y finaliza con el operador EOT seguido del carácter ; de cierre

  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 que 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 el punto y coma

  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

  El primer carácter antes del identificador de cierre debe ser un salto de línea definido por el sistema operativo local

  \n en los sistemas UNIX, incluyendo Mac OS X

  Además, al delimitador de cierre le ha de seguir también, el de 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 contenga variables, ya que es posible inicializar variables estáticas y propiedades / constantes de clase

  En esa versión también se introdujo la posibilidad de entrecomillar el identificador de apertura en Heredoc

  #heredoc en inicialización de clase no válido
  class foo {
      public $bar = <<<EOT
  bar
      EOT;
  }
  
  $str = <<<EOD
  Ejemplo de una cadena
  expandida en varias líneas
  empleando la sintaxis heredoc
  EOD;
  
  #heredoc usando variables y campos de una clase
  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;
  
  /* Que nos daría como resultado:
  
  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
  */
  
  #ejemplo utilizando argumentos
  var_dump(array(<<<EOD
  foobar!
  EOD
  ));
  
  #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;
  }
  
  #Ejemplo de empleo de comillas dobles
  echo <<<"FOOBAR"
  ¡Hola Mundo!
  FOOBAR;

• sintaxis nowdoc (desde PHP 5.3)

  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 PHP o grandes fragmentos de texto sin necesidad de escaparlos

  Comparte algunas características comunes con la construcción 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

  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

  $str = <<<'EOD'
  Ejemplo de una cadena
  expandida en varias líneas
  empleando la sintaxis heredoc
  EOD;
  
  #heredoc usando variables y campos de una clase
  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;
  
  /* Que nos daría como resultado:
  
  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
  */
  
  #Variables estáticas
  class foo {
      public $bar = <<<'EOT'
  bar
  EOT;
  }

Análisis de variables

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:

• 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

• compleja

  puede ser reconocida por las llaves que delimitan la expresión

Sintaxis simple

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

$jugo = "manzana";

#Frase inicial que queremos modificar para añadir el plural
echo "Él tomó algo de jugo de $jugo"; 
#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"

/* Dándonos como resultado

É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

$jugos = array("manzana", "naranja", "koolaid1" => "púrpura");

echo "Él tomó algo de jugo de $jugos[0]";
echo "Él tomó algo de jugo de $jugos[1]";
echo "Él tomó algo de jugo $jugos[koolaid1]";

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]";
echo "$persona->john entonces dijo hola a $persona->jane";
echo "La esposa de $persona->john saludó a $persona->robert";
echo "$persona->robert saludó a los dos $persona->smiths"; // No funcionará

/* Dándonos como resultado

É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
*/

Sintaxis compleja

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, 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:

#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}";

class cuadrado {
    public $width = 20;
    public $length = 20;
}

#Funciona, muestra: Este cuadrado tiene 20.00 centímetros de lado.
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

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";

/* Dándonos como resultado

Soy bar
Soy bar
*/

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 llaves simples ({}) 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

#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";

Arrays

Un array en PHP es en realidad un mapa ordenado

Un mapa es un tipo de datos que asocia valores con claves

Este tipo se optimiza para varios usos diferentes; se puede emplear como un array, lista (vector), tabla asociativa (tabla hash – una implementación de un mapa), diccionario, colección, pila, cola, etc

Ya que los valores de un array pueden ser otros arrays, también son posibles árboles y arrays multidimensionales

Para crear un array se utiliza la siguiente sintaxis:

$array = array(
    clave  => valor,
    clave2 => valor2,
    clave3 => valor3,
    ...
);

Donde tenemos la función array() que sirve de construcctor y toma como parámetros parejas clave/valor separadas por comas y unidas con los simbolos =>

La coma después del último elemento del array es opcional, pudiéndose omitirse

A partir de PHP 5.4 también se puede usar la sintaxis de array corta, la cual reemplaza la función array() con []

$array = [
    clave  => valor,
    clave2 => valor2,
    clave3 => valor3,
    ...
];

La clave puede ser un integer o un string

Además, las claves deberán cumplir:

• Un strings que contenga un integer válido será amoldado al tipo integer

  La clave "8" en realidad será almacenada como 8

  "08" no será convertido, ya que no es un número integer decimal válido

• Un float será forzado a integer, lo que significa que la parte decimal será eliminada

  La clave 8.7 en realidad será almacenada como 8

• Un booleano será forzado a integer también, es decir, la clave true en realidad será almacenada como 1 y la clave false como 0
• Un null será forzado a string vacío, es decir, la clave null en realidad será almacenada como ""
• Los arrays y los objects no pueden utilizarse como claves

  Si lo hacemos, daremos lugar a una advertencia: Illegal offset type

• Si varios elementos en la declaración del array usan la misma clave, sólo se utilizará la última, siendo los demás sobrescritos

La clave es opcional y si no se especifica, PHP usará el incremento de la clave de tipo integer mayor utilizada anteriormente

$array = array("foo", "bar", "hello", "world");
var_dump($array);

/* Devolverá

array(4) {
  [0]=>
  string(3) "foo"
  [1]=>
  string(3) "bar"
  [2]=>
  string(5) "hello"
  [3]=>
  string(5) "world"
}
*/

Es posible especificar la clave sólo para algunos elementos y excluir a los demás:

$array = array(
         "a",
         "b",
    6 => "c",
         "d",
);
var_dump($array);

/* Devolverá

array(4) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [6]=>
  string(1) "c"
  [7]=>
  string(1) "d"
}
*/

Los elementos de array se pueden acceder utilizando la sintaxis array[key]

$array = array(
    "foo" => "bar",
    42    => 24,
    "multi" => array(
         "dimensional" => array(
             "array" => "foo"
         )
    )
);

var_dump($array["foo"]);
var_dump($array[42]);
var_dump($array["multi"]["dimensional"]["array"]);

/* Devolverá

string(3) "bar"
int(24)
string(3) "foo"
*/

Nota Tanto los corchetes como las llaves pueden ser utilizados de forma intercambiable para acceder a los elementos de un array ($array[42] y $array{42} tendrán el mismo resultado en el ejemplo anterior)

A partir de PHP 5.4 es posible hacer referencia al array del resultado de una llamada a una función o método directamente

En versiones anteriores sólo era posible utilizando una variable temporal

Desde PHP 5.5 es posible hacer referencia directa un elemento de un array literal

function getArray() {
    return array(1, 2, 3);
}

#en PHP 5.4
$secondElement = getArray()[1];

#antes de esa versión
$tmp = getArray();
$secondElement = $tmp[1];

#como un array literal
list(, $secondElement) = getArray();

Nota Intentar acceder a una clave de un array que no se ha definido es lo mismo que el acceder a cualquier otra variable no definida: se emitirá un mensaje de error de nivel E_NOTICE, y el resultado será NULL

Un array existente puede ser modificado estableciendo explícitamente valores en él

Esto se realiza asignando valores al array, especificando la clave entre corchetes

Esta también se puede omitir, resultando en un par de corchetes vacíos ([])

/*
clave puede ser un integer o un string
valor puede ser cualquier valor de cualquier tipo
*/

$arr[clave] = valor;
$arr[] = valor;

Si $arr aún no existe, se creará, siendo también esta forma una alternativa de crear un array

Sin embargo, se desaconsejada esta práctica porque que si $arr ya contiene algún valor (un string de una variable de petición), este estará en su lugar y [] puede significar realmente el operador de acceso a cadenas

Siempre es mejor inicializar variables mediante una asignación directa

Para cambiar un valor determinado se debe asignar un nuevo valor a ese elemento empleando su clave

Para quitar una pareja clave/valor, se debe llamar a la función unset()

Iterables

Un Iterable es un seudotipo introducido en PHP 7.1

Acepta cualquier array u objeto que implemente la interfaz Traversable

Estos dos tipos se recorren con foreach y se pueden emplear con yield from dentro de un generador

Iterable se puede usar para indicar que una función requiere un conjunto de valores, pero que no importa la forma del conjunto ya que se utilizará con foreach

Si un valor no es un array o una instancia de Traversable, se lanzará un TypeError

function foo(iterable $iterable) {
    foreach ($iterable as $valor) {
        //resto del código
    } 
}

Los parámetros declarados como iterable pueden usar NULL o un array como valor predeterminado

Objetos

Los objetos se componen de un conjunto de valores, propiedades y un conjunto de métodos aplicados a esos valores

Son estos métodos los que nos permiten modificar el estado de dicho objeto, es decir, el valor de sus propiedades

Vamos a crear un objeto Universitario de ejemplo en el que tendremos las propiedades: Nombre, Apellido, Edad y Dni

La instancia del objeto la crearemos mediante el operador new de la siguiente forma:

class Univers {
    public $nom;
    public $apell;
    public $edad;
    public $dni;
}

$alumno = new Univers(); #La instancia del objeto

Es posible inicializar todas las variables para que tengan el tipo que queremos, para ello usaremos el constructor de la clase pasándole los argumentos que necesitemos

A partir de PHP 7 podemos especificar además el tipo del argumento

Mediante la palabra reservada $this podremos referenciar al objeto actual

class Univers {
    public $nom;
    public $apell;
    public $edad;
    public $dni;

    public function __construct( string $nom, string $apell, int $edad, int $dni ) {
        $this->nom = $nom;
        $this->apell = $apell;
        $this->edad = $edad;
        $this->dni = $dni;
    }
}

$alumno = new Univers("Juan", "Delgado", 12, 44565789); #La instancia del objeto

Las propiedades de un objeto pueden describirse mediante otros objetos

class Nota_M {
    public $curso1;
    public $curso2;
    public $curso3;
    public $final;

    public function __construct( float $curso1, float $curso2, float $curso3, float $final) {
        $this->curso1 = $curso1;
        $this->curso2 = $curso2;
        $this->curso1 = $curso3;
        $this->final = $final;
    }
}

class Univers {
    public $nom;
    public $apell;
    public $edad;
    public $dni;
    public $expediente;

    public function __construct( string $nom, string $apell, int $edad, int $dni, Nota_M $expediente ) {
        $this->nom = $nom;
        $this->apell = $apell;
        $this->edad = $edad;
        $this->dni = $dni;
        $this->expediente= $expediente;
    }
}

$nota_media = new Nota_M(6.5, 7.95, 8.12, 7.23); #La instancia del objeto
$alumno = new Univers("Juan", "Delgado", 12, 44565789, $nota_media); #La instancia del objeto

La definición de métodos asociados a un objeto puede precisarse en la definición del objeto

Por ejemplo, para el objeto universitario definimos una función que muestre el nombre, edad, apellidos, dni y notas medias del alumno

Para acceder a las propiedades o a los métodos usaremos el operador ->

class Nota_M {
    public $curso1;
    public $curso2;
    public $curso3;
    public $final;

    public function __construct( float $curso1, float $curso2, float $curso3, float $final) {
        $this->curso1 = $curso1;
        $this->curso2 = $curso2;
        $this->curso1 = $curso3;
        $this->final = $final;
    }
}

class Univers {
    public $nom;
    public $apell;
    public $edad;
    public $dni;
    public $expediente;

    public function __construct( string $nom, string $apell, int $edad, int $dni, Nota_M $expediente ) {
        $this->nom = $nom;
        $this->apell = $apell;
        $this->edad = $edad;
        $this->dni = $dni;
        $this->expediente= $expediente;
    }

    public function Datos() : string {
        public $output = '';

        $output .= 'Nombre: ' . $this->nom;
        $output .= ' Apellido: ' . $this->apell;
        $output .= ' Edad: ' . $this->edad;
        $output .= ' dni: ' . $this->dni;
        $output .= ' Curso1: ' . $this->expediente->curso1;
        $output .= ' Curso2: ' . $this->expediente->curso2;
        $output .= ' Curso3: ' . $this->expediente->curso3;
        $output .= ' Final: ' . $this->expediente->final;

        return $output;
    }
}

$nota_media = new Nota_M(6.5, 7.95, 8.12, 7.23); #La instancia del objeto
$alumno = new Univers("Juan", "Delgado", 12, 44565789, $nota_media); #La instancia del objeto

echo $alumno->Datos();

Recursos

Un valor tipo resource es una variable especial, que contiene una referencia a un recurso externo

Los recursos son creados y usados por funciones especiales

Puede obtenerse el tipo de recurso mediante la función get_resource_type()

Gracias al sistema de conteo de referencias introducido con el Motor Zend de PHP 4, un recurso que ya no es referenciado es detectado automáticamente y es liberado por el recolector de basura

Por esta razón, rara vez se necesita liberar la memoria manualmente

Nota Los enlaces persistentes con bases de datos son una excepción a esta regla

No son destruidos por el recolector de basura, al ser conexiones persistentes

Valor nulo

En PHP a las variables se les puede asignar un valor que indica el valor vacío, este valor es el valor 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 la función unset()

La constante NULL es insensible a mayúsculas o minúsculas

$var = NULL;

La conversión de tipos de datos

Antes que nada, recordar que PHP no necesita declaración de tipos

El contenido de la variable se convertirá automáticamente en el transcurso del programa según su uso

El esquema de conversión del tipo se basa en el principio siguiente: el tipo asociado corresponde al del operando de la izquierda

Esto se debe a que la evaluación se realiza de izquierda a derecha

$una_string = "7";
$un_numero = 42;

$x = $una_string + $un_numero;
$y = $un_numero + $una_string;
echo $x . '' . $y;

La primera expresión convertirá la variable $un_numero en una cadena de caracteres porque el operando de la izquierda $una_string es una cadena de caracteres

Esta expresión concatena las dos cadenas de caracteres y el resultado de x es: "742"

Por el contrario, la segunda expresión convierte la cadena $una_string en un valor numérico porque el operando de la izquierda $un_numero, es un número

Esta segunda expresión suma los dos números y el resultado de y es: 49

La conversión de tipos no puede hacerse en todos los casos posibles: ciertas cadenas de caracteres no pueden convertirse en número

Tales conversiones generan un error

$una_string = "Pepe";
$un_numero = 578;
$y = $un_numero + $una_string; #ERROR: "Pepe" no puede convertirse en número

El comportamiento de la conversión automática en array está actualmente sin definir

Debido a que PHP soporta el indexado de string mediante compensaciones mediante la misma sintaxis empleada en el indexado de arrays, los siguientes ejemplos son válidos para todas las versiones de PHP:

$a = 'car'; #$a es un string
$a[0] = 'b'; #$a sigue siendo un string
echo $a; #devuelve 'bar' en vez de 'car', ya que hemos modificado el valor de la posición 0 del array

Forzado de tipos

El forzado de tipos (casting) 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

Se permiten las tabulaciones y espacios dentro de los paréntesis, por lo que los siguientes ejemplos son funcionalmente equivalentes:

$foo = (int) $bar;
$foo = ( int ) $bar;

Ejemplo de forzado literal de strings y variables a strings binarios

$binary = (binary) $string;
$binary = b"cadena binaria";

Las comillas dobles permiten evitar forzar una variable a string, ya que el resultado es equivalente

$foo = 10; #$foo es un integer
$str = "$foo"; #$str es un string
$fst = (string) $foo; #$fst es también un string

#Esta igualdad nos muestra que "son lo mismo"
if ($fst === $str) {
    echo "son lo mismo";
}

Conversión a booleano

Para convertir explícitamente un valor al tipo boolean, use el forzado de tipo (bool) o (boolean)

Sin embargo, en la mayoría de casos es innecesario, ya que un valor será convertido automáticamente si un operador, función o estructura de control requiere un argumento de tipo boolean

Un valor también puede ser convertido al tipo boolean mediante la función boolval()

Cuando se realizan conversiones a boolean, los siguientes valores se consideran FALSE:

• el boolean FALSE
• 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 (incluidas variables no establecidas)
• objetos SimpleXML creados desde etiquetas vacías

Cualquier otro valor se considera como TRUE (incluso una variable resource)

Nota: -1 se considera TRUE, como cualquier otro número distinto de cero (ya sea negativo o positivo)

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)

Conversión a números enteros

Para convertir explícitamente un valor al tipo integer, use el forzado de tipo (int) o (integer)

Sin embargo, en la mayoría de casos es innecesario, ya que un valor será convertido automáticamente si un operador, función o estructura de control requiere un argumento de tipo integer

Un valor también puede ser convertido al tipo integer mediante la función intval()

Si un resource es convertido a integer, el resultado será el número de recurso único asignado al resource por PHP durante la ejecución

Desde booleanos

FALSE producirá 0 (cero), y TRUE producirá 1 (uno)

Desde números de punto flotante

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

Si el valor de tipo 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 distintas de Windows), 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 ocurra

Nota A partir de PHP 7, en lugar de ser indefinidos y dependientes de la plataforma, NaN e Infinity siempre serán cero al forzar el tipo a integer

Nota Nunca se debe convertir una fracción desconocida a un integer, ya que a veces puede conducir a resultados inesperados

echo (int) ( (0.1 + 0.7) * 10 ); # el resultado ¡muestra 7 cuando debería ser 8!

Desde cadenas de caracteres

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

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

No espere obtener el código de un carácter convirtiéndolo a integer, como ocurre en C

Emplee las funciones ord() y chr() para convertir los carácteres a su código ASCII

Desde otros tipos

El comportamiento de la conversión de integer a otros tipos es indefinido

No confíe en ningún comportamiento observado, ya que puede cambiar sin previo aviso

Conversión a número de punto flotante

Para convertir explícitamente un valor al tipo float, use el forzado de tipo (float) o (double) o(real)

Sin embargo, en la mayoría de casos es innecesario, ya que un valor será convertido automáticamente si un operador, función o estructura de control requiere un argumento de tipo float

Un valor también puede ser convertido al tipo float mediante la función floatval()

Desde cadenas de caracteres

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’ seguido de uno o más dígitos

$foo = 1 + "10.5"; #$foo es float (11.5)
$foo = 1 + "-1.3e3"; #$foo es float (-1299)
$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)

Desde otros tipos

La conversión es la misma que si el valor hubiese sido convertido primero a integer y luego a float

A partir de PHP 5, se genera un aviso si se intenta convertir un object a float

Conversión a cadena

Para convertir explícitamente un valor al tipo string, use el forzado de tipo (string)

Sin embargo, en la mayoría de casos es innecesario, ya que un valor será convertido automáticamente si un operador, función o estructura de control requiere un argumento de tipo string

Un valor también puede ser convertido al tipo string mediante la función strval()

También hay una conversión automática cuando se utilizan las funciones de visualización echo o print

Desde booleanos

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

Desde números

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 (por ejemplo 4.1E+6)

Nota El carácter para el punto decimal se define en la variable locale del script (categoría LC_NUMERIC). Consulte la función setlocale()

Desde arrays

Los arrays siempre son convertidos al string "Array"

Por esta razón, 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’]

Puede utilizar la función print_r para realizar la conversión y visualizar el contenido del array completo

Desde object

Los object desde PHP 4 siempre son convertidos al string "Object"

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

Puede utilizar las funciones print_r o var_dump() para ver medios más efectivos de inspeccionar el contenido de estos tipos

Desde resource

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 durante la ejecución, siempre será única para un recurso dado dentro del tiempo de vida de ese 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()

Puede utilizar las funciones print_r o var_dump() para ver medios más efectivos de inspeccionar el contenido de estos tipos

Desde NULL

NULL siempre es convertido a un string vacío ""

Desde otros tipos

La mayoría de los valores de PHP pueden ser convertidos a un string para su almacenamiento permanente

A este método se le denomina serialización, y es realizado mediante la función serialize()

Como el motor de PHP se construyó con soporte para WDDX, los valores de PHP también pueden ser serializados como texto XML bien formado

Conversión a array

Desde object

Si convierte un object a un array, el resultado es un array cuyos elementos son las propiedades del object

Las claves son los nombres de las variables miembro, con algunas excepciones notables: las variables privadas tienen el nombre de la clase al comienzo del nombre de la variable; las variables protegidas tienen un caracter ‘*’ al comienzo del nombre de la variable

Estos valores adicionados al inicio tienen bytes nulos a los lados

Esto puede dar en algunos comportamientos inesperados:

class A {
    private $A; #Este campo se convertirá en '\0A\0A'
}

class B extends A {
    private $A; #Este campo se convertirá en '\0B\0A'
    public $AA; #Este campo se convertirá en 'AA'
}

var_dump( (array) new B() ); #debería haber dos claves llamadas 'AA', pero una de ellas se llama '\0A\0A'

Desde NULL

Si convierte un valor NULL a array, obtiene un array vacío

Desde otros tipos

Para cualquiera de los tipos: integer, float, string, boolean y resource, convertir un valor a un array resulta en un array con un solo elemento, con índice 0, y el valor del escalar que fue convertido

En otras palabras, (array) $scalarValue es exactamente lo mismo que array($scalarValue)

Conversión a object

Si un object se convierte en un object, éste no se modifica

Desde otros tipos

Si un valor de cualquier otro tipo se convierte en un object, se crea una nueva instancia de la clase stdClass incorporada

Si el valor es NULL, la nueva instancia estará vacía

Un array se convierte en un object con las propiedades nombradas como claves y los valores correspondientes, con la excepción de las claves numéricas, las cuales serán inaccesibles a menos que sean recorridas

$obj = (object) array('1' => 'foo');
var_dump( isset($obj->{'1'}) ); #devuelve 'bool(false)'
var_dump( key($obj) ); #devuelve 'int(1)'

$obj = (object) 'ciao'; #Para cualquier otro valor, una variable miembro llamada scalar contendrá el valor
echo $obj->scalar; #devuelve 'ciao'

Conversión a recurso

Dado que las variables resource contienen gestores especiales a archivos abiertos, conexiones con bases de datos, áreas gráficas para imágenes y cosas por el estilo, la conversión a tipo resource carece de sentido

Conversión a NULL

Nota Esta característica ha sido declarada obsoleta a partir de PHP 7.2 y su uso está totalmente desaconsejado

Convertir una variable a null usando (unset) $var no eliminará la variable ni destruirá su valor

Sólo retornará un valor NULL