PHP
Los tipos
Buscar..
Enteros
Los enteros en PHP se pueden especificar de forma nativa en base 2 (binario), base 8 (octal), base 10 (decimal) o base 16 (hexadecimal).
$my_decimal = 42;
$my_binary = 0b101010;
$my_octal = 052;
$my_hexadecimal = 0x2a;
echo ($my_binary + $my_octal) / 2;
// Output is always in decimal: 42
Los enteros tienen una longitud de 32 o 64 bits, según la plataforma. La constante PHP_INT_SIZE tiene un tamaño de entero en bytes. PHP_INT_MAX y (desde PHP 7.0) PHP_INT_MIN también están disponibles.
printf("Integers are %d bits long" . PHP_EOL, PHP_INT_SIZE * 8);
printf("They go up to %d" . PHP_EOL, PHP_INT_MAX);
Los valores enteros se crean automáticamente según sea necesario a partir de flotadores, valores booleanos y cadenas. Si se necesita un typecast explícito, se puede hacer con el (int) o (integer) cast:
$my_numeric_string = "123";
var_dump($my_numeric_string);
// Output: string(3) "123"
$my_integer = (int)$my_numeric_string;
var_dump($my_integer);
// Output: int(123)
El desbordamiento de enteros se manejará mediante la conversión a un flotador:
$too_big_integer = PHP_INT_MAX + 7;
var_dump($too_big_integer);
// Output: float(9.2233720368548E+18)
No hay un operador de división de enteros en PHP, pero se puede simular utilizando un lanzamiento implícito, que siempre se "redondea" simplemente descartando la parte flotante. A partir de la versión 7 de PHP, se agregó una función de división entera.
$not_an_integer = 25 / 4;
var_dump($not_an_integer);
// Output: float(6.25)
var_dump((int) (25 / 4)); // (see note below)
// Output: int(6)
var_dump(intdiv(25 / 4)); // as of PHP7
// Output: int(6)
(Tenga en cuenta que los paréntesis adicionales alrededor de (25 / 4) son necesarios porque el (int) cast tiene mayor precedencia que la división)
Instrumentos de cuerda
Una cadena en PHP es una serie de caracteres de un solo byte (es decir, no hay soporte nativo de Unicode) que se puede especificar de cuatro maneras:
Cita única
Muestra las cosas casi completamente "como es". Las variables y la mayoría de las secuencias de escape no serán interpretadas. La excepción es que para mostrar una comilla literal, uno puede escapar con una barra diagonal invertida ', y para mostrar una barra diagonal inversa, se puede escapar con otra barra diagonal inversa \
$my_string = 'Nothing is parsed, except an escap\'d apostrophe or backslash. $foo\n';
var_dump($my_string);
/*
string(68) "Nothing is parsed, except an escap'd apostrophe or backslash. $foo\n"
*/
Doble citado
A diferencia de una cadena entre comillas simples, se evaluarán los nombres de variables simples y las secuencias de escape en las cadenas. Se pueden usar llaves (como en el último ejemplo) para aislar nombres de variables complejas.
$variable1 = "Testing!";
$variable2 = [ "Testing?", [ "Failure", "Success" ] ];
$my_string = "Variables and escape characters are parsed:\n\n";
$my_string .= "$variable1\n\n$variable2[0]\n\n";
$my_string .= "There are limits: $variable2[1][0]";
$my_string .= "But we can get around them by wrapping the whole variable in braces: {$variable2[1][1]}";
var_dump($my_string);
/*
string(98) "Variables and escape characters are parsed:
Testing!
Testing?
There are limits: Array[0]"
But we can get around them by wrapping the whole variable in braces: Success
*/
Heredoc
En una cadena heredoc, los nombres de variable y las secuencias de escape se analizan de manera similar a las cadenas entre comillas dobles, aunque las llaves no están disponibles para los nombres de variable complejos. El inicio de la cadena está delimitado por el identifier <<< , y el final por el identifier , donde identifier es cualquier nombre PHP válido. El identificador final debe aparecer en una línea por sí mismo. No se permite ningún espacio en blanco antes o después del identificador, aunque como cualquier línea en PHP, también debe terminar con un punto y coma.
$variable1 = "Including text blocks is easier";
$my_string = <<< EOF
Everything is parsed in the same fashion as a double-quoted string,
but there are advantages. $variable1; database queries and HTML output
can benefit from this formatting.
Once we hit a line containing nothing but the identifier, the string ends.
EOF;
var_dump($my_string);
/*
string(268) "Everything is parsed in the same fashion as a double-quoted string,
but there are advantages. Including text blocks is easier; database queries and HTML output
can benefit from this formatting.
Once we hit a line containing nothing but the identifier, the string ends."
*/
Ahoradoc
Una cadena nowdoc es como la versión de heredoc entre comillas simples, aunque ni siquiera se evalúan las secuencias de escape más básicas. El identificador al principio de la cadena se incluye entre comillas simples.
$my_string = <<< 'EOF'
A similar syntax to heredoc but, similar to single quoted strings,
nothing is parsed (not even escaped apostrophes \' and backslashes \\.)
EOF;
var_dump($my_string);
/*
string(116) "A similar syntax to heredoc but, similar to single quoted strings,
nothing is parsed (not even escaped apostrophes \' and backslashes \\.)"
*/
Booleano
Boolean es un tipo, que tiene dos valores, denotado como true o false .
Este código establece el valor de $foo como true y $bar como false :
$foo = true;
$bar = false;
true y false no distinguen entre mayúsculas y minúsculas, por lo que también se pueden usar TRUE y FALSE , incluso es posible FaLsE . El uso de minúsculas es más común y se recomienda en la mayoría de las guías de estilo de código, por ejemplo, PSR-2 .
Los booleanos se pueden usar en sentencias como esta:
if ($foo) { //same as evaluating if($foo == true)
echo "true";
}
Debido al hecho de que PHP está escrito de forma débil, si $foo anterior es distinto de true o false , se convierte automáticamente en un valor booleano.
Los siguientes valores dan como resultado false :
- un valor cero:
0(entero),0.0(flotante) o'0'(cadena) - una cadena vacía
''o matriz[] -
null(el contenido de una variable no establecida, o asignado a una variable)
Cualquier otro valor resulta en true .
Para evitar esta comparación, puede imponer una comparación sólida utilizando === , que compara valor y tipo . Vea la comparación de tipos para más detalles.
Para convertir un tipo en booleano, puede usar la conversión (bool) o (boolean) antes del tipo.
var_dump((bool) "1"); //evaluates to true
o llame a la función boolval :
var_dump( boolval("1") ); //evaluates to true
Conversión booleana a una cadena (tenga en cuenta que false produce una cadena vacía):
var_dump( (string) true ); // string(1) "1"
var_dump( (string) false ); // string(0) ""
Conversión booleana a un entero:
var_dump( (int) true ); // int(1)
var_dump( (int) false ); // int(0)
Tenga en cuenta que lo contrario también es posible:
var_dump((bool) ""); // bool(false)
var_dump((bool) 1); // bool(true)
También todo lo que no sea cero devolverá verdadero:
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)
Flotador
$float = 0.123;
Por razones históricas,
gettype()devuelve "double" en caso de un flotador, y no simplemente "float"
Los flotantes son números de punto flotante, que permiten una mayor precisión de salida que los enteros planos.
Los flotantes y los enteros se pueden usar juntos debido a la conversión suelta de tipos variables de PHP:
$sum = 3 + 0.14;
echo $sum; // 3.14
php no muestra float como número flotante como otros idiomas, por ejemplo:
$var = 1;
echo ((float) $var); //returns 1 not 1.0
Advertencia
Precisión de punto flotante
(De la página del manual de PHP )
Los números de punto flotante tienen una precisión limitada. Aunque depende del sistema, PHP suele dar un error relativo máximo debido al redondeo en el orden de 1.11e-16. Las operaciones aritméticas no elementales pueden dar errores más grandes, y la propagación de errores debe considerarse cuando se componen varias operaciones.
Además, los números racionales que se pueden representar exactamente como números de punto flotante en la base 10, como 0.1 o 0.7, no tienen una representación exacta como números de punto flotante en la base 2 (binario), que se usa internamente, sin importar el tamaño de la mantisa . Por lo tanto, no pueden convertirse en sus equivalentes binarios internos sin una pequeña pérdida de precisión. Esto puede llevar a resultados confusos: por ejemplo, floor ((0.1 + 0.7) * 10) generalmente devolverá 7 en lugar del esperado 8, ya que la representación interna será algo así como 7.9999999999999991118 ....
Por lo tanto, nunca confíe los resultados de los números flotantes al último dígito, y no compare los números de punto flotante directamente por igualdad. Si es necesaria una mayor precisión, las funciones matemáticas de precisión arbitraria y las funciones gmp están disponibles.
Callable
Callables son cualquier cosa que se puede llamar como una devolución de llamada. Las cosas que pueden denominarse "devolución de llamada" son las siguientes:
Funciones anonimas
Funciones estándar de PHP (nota: no construcciones de lenguaje )
Clases estáticas
Clases no estáticas ( usando una sintaxis alternativa )
Objetos específicos / Métodos de clase
Los objetos mismos, siempre que el objeto se encuentre en la clave
0de una matrizEjemplo de referenciar un objeto como un elemento de matriz:
$obj = new MyClass();
call_user_func([$obj, 'myCallbackMethod']);
Las devoluciones de llamada se pueden denotar mediante una sugerencia de tipo callable partir de PHP 5.4.
$callable = function () {
return 'value';
};
function call_something(callable $fn) {
call_user_func($fn);
}
call_something($callable);
Nulo
PHP representa "sin valor" con la palabra clave null . Es algo similar al puntero nulo en lenguaje C y al valor NULL en SQL.
Configurando la variable a nula:
$nullvar = null; // directly
function doSomething() {} // this function does not return anything
$nullvar = doSomething(); // so the null is assigned to $nullvar
Comprobando si la variable se estableció en nulo:
if (is_null($nullvar)) { /* variable is null */ }
if ($nullvar === null) { /* variable is null */ }
Variable nula vs indefinida
Si la variable no se definió o no se definió, cualquier prueba contra el nulo tendrá éxito, pero también generará un Notice: Undefined variable: nullvar : Notice: Undefined variable: nullvar :
$nullvar = null;
unset($nullvar);
if ($nullvar === null) { /* true but also a Notice is printed */ }
if (is_null($nullvar)) { /* true but also a Notice is printed */ }
Por lo tanto, los valores indefinidos se deben verificar con isset :
if (!isset($nullvar)) { /* variable is null or is not even defined */ }
Comparación de tipos
Hay dos tipos de comparación : comparación suelta con == y comparación estricta con === . La comparación estricta garantiza que tanto el tipo como el valor de ambos lados del operador sean iguales.
// Loose comparisons
var_dump(1 == 1); // true
var_dump(1 == "1"); // true
var_dump(1 == true); // true
var_dump(0 == false); // true
// Strict comparisons
var_dump(1 === 1); // true
var_dump(1 === "1"); // false
var_dump(1 === true); // false
var_dump(0 === false); // false
// Notable exception: NAN — it never is equal to anything
var_dump(NAN == NAN); // false
var_dump(NAN === NAN); // false
También puede usar una comparación sólida para verificar si el tipo y el valor no coinciden con !== .
Un ejemplo típico donde el operador == no es suficiente, son funciones que pueden devolver diferentes tipos, como strpos , que devuelve false si no se encuentra la strpos searchword , y la posición de coincidencia ( int ) de lo contrario:
if(strpos('text', 'searchword') == false)
// strpos returns false, so == comparison works as expected here, BUT:
if(strpos('text bla', 'text') == false)
// strpos returns 0 (found match at position 0) and 0==false is true.
// This is probably not what you expect!
if(strpos('text','text') === false)
// strpos returns 0, and 0===false is false, so this works as expected.
Tipo de fundición
PHP generalmente adivina correctamente el tipo de datos que intenta usar a partir del contexto en el que se usa, sin embargo, a veces es útil forzar manualmente un tipo. Esto se puede lograr prefijando la declaración con el nombre del tipo requerido entre paréntesis:
$bool = true;
var_dump($bool); // bool(true)
$int = (int) true;
var_dump($int); // int(1)
$string = (string) true;
var_dump($string); // string(1) "1"
$string = (string) false;
var_dump($string); // string(0) ""
$float = (float) true;
var_dump($float); // float(1)
$array = ['x' => 'y'];
var_dump((object) $array); // object(stdClass)#1 (1) { ["x"]=> string(1) "y" }
$object = new stdClass();
$object->x = 'y';
var_dump((array) $object); // array(1) { ["x"]=> string(1) "y" }
$string = "asdf";
var_dump((unset)$string); // NULL
Pero tenga cuidado: no todos los tipos de conversión de tipo funcionan como uno podría esperar:
// below 3 statements hold for 32-bits systems (PHP_INT_MAX=2147483647)
// an integer value bigger than PHP_INT_MAX is automatically converted to float:
var_dump( 999888777666 ); // float(999888777666)
// forcing to (int) gives overflow:
var_dump((int) 999888777666 ); // int(-838602302)
// but in a string it just returns PHP_INT_MAX
var_dump((int) "999888777666"); // int(2147483647)
var_dump((bool) []); // bool(false) (empty array)
var_dump((bool) [false]); // bool(true) (non-empty array)
Recursos
Un recurso es un tipo especial de variable que hace referencia a un recurso externo, como un archivo, socket, flujo, documento o conexión.
$file = fopen('/etc/passwd', 'r');
echo gettype($file);
# Out: resource
echo $file;
# Out: Resource id #2
Hay diferentes (sub) tipos de recursos. Puede verificar el tipo de recurso usando get_resource_type() :
$file = fopen('/etc/passwd', 'r');
echo get_resource_type($file);
#Out: stream
$sock = fsockopen('www.google.com', 80);
echo get_resource_type($sock);
#Out: stream
Puede encontrar una lista completa de los tipos de recursos incorporados aquí .
Tipo malabarismo
PHP es un lenguaje débilmente tipado. No requiere declaración explícita de tipos de datos. El contexto en el que se utiliza la variable determina su tipo de datos; la conversión se realiza automáticamente:
$a = "2"; // string
$a = $a + 2; // integer (4)
$a = $a + 0.5; // float (4.5)
$a = 1 + "2 oranges"; // integer (3)