Tipos de Datos en PHP

PHP admite diez tipos primitivos.

Cuatro tipos escalares:

o boolean

o integer

o float (número de punto flotante, también conocido como double)

o string

Cuatro tipos compuestos:

o array

o object

o callable

o iterable

Y finalmente dos tipos especiales:

LEONOR MARCELA JUSTO SILVESTRE 1
o resource

o NULL

El tipo de una variable usualmente no lo declara el programador; al contrario, es decidido en

tiempo de ejecución por PHP dependiendo del contexto en el que se emplea dicha variable.

Booleanos

Este es el tipo más simple. Un boolean expresa un valor que indica verdad. Puede ser true
(verdadero) o false (falso). Para especificar un literal de tipo boolean se emplean las constantes
true o false. Ambas no son susceptibles a mayúsculas y minúsculas.

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

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

o el boolean false mismo

o el integer 0 y -0 (cero)

o el float 0.0 y -0.0 (cero)

 o el valor string vacío, y el string "0"

o un array con cero elementos

o el tipo especial NULL (incluidas variables no establecidas)

o objetos SimpleXML creados desde etiquetas vacías

Cualquier otro valor se considera como true (incluido cualquier resource y NAN).

Números enteros (Integers) 

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

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

Ejemplo #1 Literales de números enteros

<?php
$a = 1234; // número decimal
$a = -123; // un número negativo
$a = 0123; // número octal (equivale a 83 decimal)
$a = 0x1A; // número hexadecimal (equivale a 26 decimal)
LEONOR MARCELA JUSTO SILVESTRE 2
$a = 0b11111111; // número binario (equivale al 255 decimal)
?>
Formalmente, la estructura de los literales de tipo integer 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
Si PHP encuentra un número fuera de los límites de un integer, se interpretará en su lugar como
un valor de tipo float. También, una operación cuyo resultado sea un número fuera de los límites
de un integer devolverá en su lugar un valor de tipo float.

Ejemplo #2 Desbordamiento de enteros en sistemas de 32 bit

<?php
$número_grande = 2147483647;
var_dump($número_grande);                    // int(2147483647)

$número_grande = 2147483648;
var_dump($número_grande);                    // float(2147483648)

$millón = 1000000;
$número_grande =  50000 * $millón;
var_dump($número_grande);                    // float(50000000000)
?>

Ejemplo #3 Desbordamiento de enteros en sistemas de 64 bit

<?php
$número_grande = 9223372036854775807;
var_dump($número_grande);                    // int(9223372036854775807)

$número_grande = 9223372036854775808;
var_dump($número_grande);                    // float(9.2233720368548E+18
)

$millón = 1000000;
$número_grande =  50000000000000 * $millón;
var_dump($número_grande);                    // float(5.0E+19)
?>

Números de punto flotante 

LEONOR
Los númerosMARCELA
de puntoJUSTO SILVESTRE
flotante (también conocidos como "de coma flotante" en español, y "floats" 3
en inglés) pueden ser especificados usando cualquiera de las siguientes sintaxis:

<?php
$a = 1.234; 
$b = 1.2e3; 
$c = 7E-10;
$d = 1_234.567; // a partir de PHP 7.4.0
?>

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 épsilon de la máquina o unidad de
redondeo, y es la menor diferencia aceptable en los cálculos.

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

<?php
$a = 1.23456789;
$b = 1.23456780;
$épsilon = 0.00001;

if(abs($a-$b) < $épsilon) {
    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 punto
flotante. Cualquier comparación, ya sea estricta o no, de este valor con cualquier otro valor,
incluido él mismo, pero excepto true, tendrá un resultado de false.

Cadenas de caracteres (Strings) 

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.

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

o Entrecomillado simple. La manera más sencilla de especificar un string es delimitarlo con

comillas simples (el carácter ').

o Entrecomillado doble. Si un string está delimitado con comillas dobles (")

o Sintaxis
LEONOR heredoc.
MARCELA JUSTOUna tercera forma de delimitar un string es mediante la sintaxis
SILVESTRE 4
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.

o Sintaxis nowdoc (desde PHP 5.3.0) 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.

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.

<?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."
?>

La sintaxis compleja puede ser reconocida por las llaves que delimitan la expresión.

<?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;
LEONOR MARCELA JUSTO SILVESTRE 5
echo "$persona->robert saludó a los dos $persona->smiths."; // No funcionará
?>

Sintaxis compleja (llaves)

Esta sintaxis no se llama compleja porque sea compleja, sino porque permite el empleo de
expresiones complejas.

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

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.
Los string pueden ser concatenados empleando el operador '.' (punto). Fíjese que el operador '+'
(suma) no servirá para concatenar.

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.

Cadenas numéricas 

Una cadena PHP se considera numérica si se puede interpretar como int o float .

Formalmente a partir de PHP 8.0.0:

ESPACIOS BLANCOS \ s *

LNUM [0-9] +

DNUM ([0-9] *) [\.] {LNUM}) | ({LNUM} [\.] [0-9] *)

EXPONENT_DNUM (({LNUM} | {DNUM}) [eE] [+ -]? {LNUM})

INT_NUM_STRING {WHITESPACES} [+ -]? {LNUM} {ESPACIOS BLANCOS}

LEONOR MARCELA JUSTO SILVESTRE 6
FLOAT_NUM_STRING {WHITESPACES} [+ -]? ({DNUM} | {EXPONENT_DNUM}) {WHITESPACES}

NUM_STRING ({INT_NUM_STRING} | {FLOAT_NUM_STRING})

Cuando una cadena necesita ser evaluada como un número (por ejemplo, operaciones

aritméticas, declaración de tipo int , etc.), se toman los siguientes pasos para determinar el
resultado:

1. Si la cadena es numérica, resuélvala en un int si la cadena es una cadena numérica entera

y se ajusta a los límites de los límites de tipo int (según lo definido por PHP_INT_MAX); de
lo contrario, resuélvala en un flotante.

2. Si el contexto permite cadenas numéricas iniciales y la cadena es una, resuelva en un int si

la parte inicial de la cadena es una cadena numérica entera y se ajusta a los límites de los
límites de tipo int (según lo definido por PHP_INT_MAX); de lo contrario, resuelva en
un flotante . Además se genera un error de nivel E_WARNING.

3. La cadena no es numérica, arroja un TypeError.

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, y posiblemente más. 

Un array puede ser creado con el constructor del lenguaje array(). Éste toma cualquier número de
parejas clave => valor como argumentos.
array(
clave => valor,
clave2 => valor2,
clave3 => valor3,
...
)
La clave puede ser un integer o un string. El valor puede ser de cualquier tipo.

La clave es opcional. Si no se especifica, PHP usará el incremento de la clave de tipo integer mayor

utilizada anteriormente.

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

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 ([]).
$arr[clave] = valor;
LEONOR MARCELA
$arr[] JUSTO SILVESTRE
= valor; 7
// clave puede ser un integer o un string
// valor puede ser cualquier valor de cualquier tipo

Iterables 

Iterable se puede usar como tipo de parámetro para indicar que una función requiere un conjunto
de valores, pero que no importa la forma del dicho conjunto ya que se utiizará con foreach. Si un
valor no es un array o una instancia de Traversable, se lanzará un TypeError.

<?php

function foo(iterable $iterable) {
    foreach ($iterable as $valor) {
        // ...
    } 
}

?>

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

Ejemplo de valor predeterminado de un parámetro iterable

<?php

function foo(iterable $iterable = []) {
    // ...
}

?>

Objetos

Para crear un nuevo object, utilice la sentencia new para instanciar una clase:

<?php
class foo
{
    function hacer_algo()
    {
        echo "Haciendo algo."; 
    }
}

$bar = new foo;
LEONOR MARCELA JUSTO SILVESTRE 8
$bar->hacer_algo();
?>

Si un object se convierte en un object, éste no se modifica. 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. 

<?php
$obj = (object) array('1' => 'foo');
var_dump(isset($obj->{'1'})); // muestra 'bool(false)'
var_dump(key($obj)); // muestra 'int(1)'
?>

Para cualquier otro valor, una variable miembro llamada scalar contendrá el valor.

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

Dado que las variables resource contienen gestores especiales a archivos abiertos, conexiones con
bases de datos, áreas de pintura de imágenes y cosas por el estilo, la conversión a
tipo resource carece de sentido.
Gracias al sistema de conteo de referencias introducido con el Motor Zend, 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.

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:

o se le ha asignado la constante null.

o no se le ha asignado un valor todavía.

o se ha destruido con unset().

<?php
$var = NULL;       
?>

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

retornará un valor null.

LEONOR MARCELA JUSTO SILVESTRE 9

Llamadas de retorno (Callbacks / Callables)

Las llamadas de retorno, o retrollamadas, se pueden indicar con la declaración de tipo callable a

partir de PHP 5.4. Esta documentación utilizó la información del tipo callback con el mismo
propósito.

Una función de PHP se pasa por su nombre como un string. Se puede utilizar cualquier función
nativa o definida por el usuario, exceptuando contrucciones del lenguaje, tales
como: array(), echo, empty(), eval(), exit(), isset(), list(), print o unset().

Un método de un object instanciado se pasa como un array que contiene un object en el índice 0 y

el nombre del método en el índice 1. Está permitido el acceso a métodos protegidos y privados
desde dentro de una clase.

Los métodos de clase estáticos también se pueden pasar sin instanciar un object de dicha clase,
pasando el nombre de la clase en lugar de un object en el índice 0. A partir de PHP 5.2.3, también
es posible pasar 'NombreDeClase::nombreDeMetodo'.

Declaraciones de tipo 
Se pueden agregar declaraciones de tipo a argumentos de función, valores de retorno y, a partir
de PHP 7.4.0, propiedades de clase. Se aseguran de que el valor sea del tipo especificado en el
momento de la llamada; de lo contrario, se lanza un TypeError .

A partir de PHP 7.1.0, las declaraciones de tipo se pueden marcar como anulables al anteponer el
nombre
LEONOR delMARCELA
tipo con un signo
JUSTO de interrogación ( ?). Esto significa que el valor puede ser del tipo
SILVESTRE 10
especificado o null

Para detectar errores simples en las declaraciones de tipos de unión, los tipos redundantes que se
pueden detectar sin realizar la carga de clases darán como resultado un error en tiempo de
compilación. Esto incluye:

o Cada tipo de nombre resuelto solo puede ocurrir una vez. Los tipos como int|string|
INTresultan en un error.

o Si se usa bool , no se puede usar falso adicionalmente.

o Si se usa un objeto , los tipos de clase no se pueden usar adicionalmente.

o Si se usa iterable , array y Traversable no se pueden usar adicionalmente.

Manipulación de tipos 

PHP no requiere (ni soporta) la definición explicita de tipos en la declaración de variables; el tipo
de la variable se determina por el contexto en el cual se emplea la variable. Es decir, si se asigna un
valor string a una variable $var, entonces $var se convierte en un string. Si un valor integer es
entonces asignado a la misma variable $var, ésta se convierte en integer.
Un ejemplo de la conversión de tipos automática de PHP es el operador suma '+'. Si al menos uno
de los operandos es float, entonces ambos operandos son evaluados como floats y el resultado
será un float. De otra manera, los operandos seran interpretados como integers, y el resultado
será entonces integer.

<?php
$foo = "0";  // $foo es string (ASCII 48)
$foo += 2;   // $foo es ahora un integer (2)
$foo = $foo + 1.3;  // $foo es ahora un float (3.3)
$foo = 5 + "10 Cerditos pequeñitos"; // $foo es integer (15)
$foo = 5 + "10 Cerdos pequeños";     // $foo es integer (15)
?>

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.

<?php
$foo = 10;   // $foo es un integer
$bar = (boolean) $foo;   // $bar es un boolean
?>

Los siguientes forzados de tipos están permitidos:

o (int), (integer) - forzado a integer

o (bool),
LEONOR (boolean)
MARCELA JUSTO- forzado a boolean
SILVESTRE 11
o (float), (double), (real) - forzado a float

o (string) - forzado a string

o (array) - forzado a array

o (object) - forzado a object

o (unset) - forzado a NULL (PHP 5)

LEONOR MARCELA JUSTO SILVESTRE 12