PHP
Variables
Buscar..
Sintaxis
- $ variable = 'valor'; // Asignar variable general
- $ objeto-> propiedad = 'valor'; // Asignar una propiedad de objeto
- ClassName :: $ property = 'value'; // Asignar una propiedad de clase estática
- $ array [0] = 'valor'; // Asignar un valor a un índice de una matriz
- $ array [] = 'valor'; // Empujar un elemento al final de una matriz
- $ array ['key'] = 'value'; // Asignar un valor de matriz
- echo $ variable; // Eco (imprimir) un valor variable
- some_function ($ variable); // Usar variable como parámetro de función
- unset ($ variable); // Desarmar una variable
- $$ variable = 'valor'; // Asignar a una variable variable
- isset ($ variable); // Comprobar si una variable está configurada o no
- vacío ($ variable); // Compruebe si una variable está vacía o no
Observaciones
Verificación de tipos
Parte de la documentación sobre variables y tipos menciona que PHP no utiliza la escritura estática. Esto es correcto, pero PHP realiza algunas comprobaciones de tipo cuando se trata de parámetros de función / método y valores de retorno (especialmente con PHP 7).
Puede aplicar la comprobación de tipos de parámetros y valores de retorno utilizando las sugerencias de tipo en PHP 7 de la siguiente manera:
<?php
/**
* Juggle numbers and return true if juggling was
* a great success.
*/
function numberJuggling(int $a, int $b) : bool
{
$sum = $a + $b;
return $sum % 2 === 0;
}
Nota: el
gettype()
PHP para enteros y booleanos esinteger
yboolean
respectivamente. Pero para el tipo de sugerencia para tales variables necesita usarint
ybool
. De lo contrario, PHP no le dará un error de sintaxis, pero esperará que se pasen las clasesinteger
yboolean
.
El ejemplo anterior genera un error en caso de que el valor no numérico se da como tampoco el $a
o $b
parámetro, y si la función devuelve algo más que true
o false
. El ejemplo anterior es "suelto", ya que puede dar un valor flotante a $a
o $b
. Si desea imponer tipos estrictos, lo que significa que solo puede ingresar números enteros y no flotantes, agregue lo siguiente al comienzo de su archivo PHP:
<?php
declare('strict_types=1');
Antes de que las funciones y los métodos de PHP 7 permitieran el tipo de sugerencias para los siguientes tipos:
-
callable
(una función o método llamable) -
array
(cualquier tipo de matriz, que también puede contener otras matrices) - Interfaces (Nombre de Clase Totalmente Calificada, o FQDN)
- Clases (FQDN)
Véase también: Salida del valor de una variable
Acceso a una variable dinámicamente por nombre (variables variables)
Se puede acceder a las variables a través de nombres de variables dinámicas. El nombre de una variable se puede almacenar en otra variable, lo que permite acceder a ella de forma dinámica. Tales variables son conocidas como variables variables.
Para convertir una variable en una variable, coloque un $
extra en frente de su variable.
$variableName = 'foo';
$foo = 'bar';
// The following are all equivalent, and all output "bar":
echo $foo;
echo ${$variableName};
echo $$variableName;
//similarly,
$variableName = 'foo';
$$variableName = 'bar';
// The following statements will also output 'bar'
echo $foo;
echo $$variableName;
echo ${$variableName};
Las variables variables son útiles para mapear funciones / llamadas de método:
function add($a, $b) {
return $a + $b;
}
$funcName = 'add';
echo $funcName(1, 2); // outputs 3
Esto se vuelve particularmente útil en las clases de PHP:
class myClass {
public function __construct() {
$functionName = 'doSomething';
$this->$functionName('Hello World');
}
private function doSomething($string) {
echo $string; // Outputs "Hello World"
}
}
Es posible, pero no es necesario poner $variableName
entre {}
:
${$variableName} = $value;
Los siguientes ejemplos son tanto equivalentes como de salida "baz":
$fooBar = 'baz';
$varPrefix = 'foo';
echo $fooBar; // Outputs "baz"
echo ${$varPrefix . 'Bar'}; // Also outputs "baz"
Usar {}
solo es obligatorio cuando el nombre de la variable es en sí mismo una expresión, como esta:
${$variableNamePart1 . $variableNamePart2} = $value;
Sin embargo, se recomienda usar siempre {}
, porque es más legible.
Si bien no se recomienda hacerlo, es posible encadenar este comportamiento:
$$$$$$$$DoNotTryThisAtHomeKids = $value;
Es importante tener en cuenta que el uso excesivo de variables variables es considerado como una mala práctica por muchos desarrolladores. Debido a que no son muy adecuados para el análisis estático de los IDE modernos, las grandes bases de código con muchas variables (o invocaciones de métodos dinámicos) pueden convertirse rápidamente en difíciles de mantener.
Diferencias entre PHP5 y PHP7
Otra razón para usar siempre {}
o ()
, es que PHP5 y PHP7 tienen una forma ligeramente diferente de tratar con variables dinámicas, lo que resulta en un resultado diferente en algunos casos.
En PHP7, las variables dinámicas, las propiedades y los métodos ahora se evaluarán estrictamente en el orden de izquierda a derecha, a diferencia de la combinación de casos especiales en PHP5. Los siguientes ejemplos muestran cómo ha cambiado el orden de evaluación.
Caso 1: $$foo['bar']['baz']
- Interpretación de PHP5:
${$foo['bar']['baz']}
- Interpretación de PHP7:
($$foo)['bar']['baz']
Caso 2: $foo->$bar['baz']
- Interpretación de PHP5:
$foo->{$bar['baz']}
- Interpretación de PHP7:
($foo->$bar)['baz']
Caso 3: $foo->$bar['baz']()
- Interpretación de PHP5:
$foo->{$bar['baz']}()
- Interpretación de PHP7:
($foo->$bar)['baz']()
Caso 4: Foo::$bar['baz']()
- Interpretación de PHP5:
Foo::{$bar['baz']}()
- Interpretación de PHP7:
(Foo::$bar)['baz']()
Tipos de datos
Hay diferentes tipos de datos para diferentes propósitos. PHP no tiene definiciones de tipo explícitas, pero el tipo de una variable está determinado por el tipo de valor que se asigna, o por el tipo al que se convierte. Esta es una breve descripción general de los tipos, para una documentación detallada y ejemplos, consulte el tema de tipos de PHP .
Existen los siguientes tipos de datos en PHP: nulo, booleano, entero, flotante, cadena, objeto, recurso y matriz.
Nulo
Nulo puede ser asignado a cualquier variable. Representa una variable sin valor.
$foo = null;
Esto invalida la variable y su valor sería indefinido o nulo si se llama. La variable se borra de la memoria y el recolector de basura la elimina.
Booleano
Este es el tipo más simple con solo dos valores posibles.
$foo = true;
$bar = false;
Los booleanos se pueden utilizar para controlar el flujo de código.
$foo = true;
if ($foo) {
echo "true";
} else {
echo "false";
}
Entero
Un número entero es un número entero positivo o negativo. Puede ser utilizado con cualquier base numérica. El tamaño de un entero es dependiente de la plataforma. PHP no soporta enteros sin signo.
$foo = -3; // negative
$foo = 0; // zero (can also be null or false (as boolean)
$foo = 123; // positive decimal
$bar = 0123; // octal = 83 decimal
$bar = 0xAB; // hexadecimal = 171 decimal
$bar = 0b1010; // binary = 10 decimal
var_dump(0123, 0xAB, 0b1010); // output: int(83) int(171) int(10)
Flotador
Los números de punto flotante, "dobles" o simplemente llamados "flotadores" son números decimales.
$foo = 1.23;
$foo = 10.0;
$bar = -INF;
$bar = NAN;
Formación
Una matriz es como una lista de valores. La forma más simple de una matriz está indexada por entero y ordenada por el índice, con el primer elemento en el índice 0.
$foo = array(1, 2, 3); // An array of integers
$bar = ["A", true, 123 => 5]; // Short array syntax, PHP 5.4+
echo $bar[0]; // Returns "A"
echo $bar[1]; // Returns true
echo $bar[123]; // Returns 5
echo $bar[1234]; // Returns null
Las matrices también pueden asociar una clave que no sea un índice entero a un valor. En PHP, todas las matrices son matrices asociativas detrás de las escenas, pero cuando nos referimos a una 'matriz asociativa' claramente, por lo general nos referimos a una que contiene una o más claves que no son enteros.
$array = array();
$array["foo"] = "bar";
$array["baz"] = "quux";
$array[42] = "hello";
echo $array["foo"]; // Outputs "bar"
echo $array["bar"]; // Outputs "quux"
echo $array[42]; // Outputs "hello"
Cuerda
Una cadena es como una matriz de caracteres.
$foo = "bar";
Al igual que una matriz, una cadena se puede indexar para devolver sus caracteres individuales:
$foo = "bar";
echo $foo[0]; // Prints 'b', the first character of the string in $foo.
Objeto
Un objeto es una instancia de una clase. Se puede acceder a sus variables y métodos con el operador ->
.
$foo = new stdClass(); // create new object of class stdClass, which a predefined, empty class
$foo->bar = "baz";
echo $foo->bar; // Outputs "baz"
// Or we can cast an array to an object:
$quux = (object) ["foo" => "bar"];
echo $quux->foo; // This outputs "bar".
Recurso
Las variables de recursos tienen identificadores especiales para archivos abiertos, conexiones de base de datos, flujos, áreas de lienzo de imágenes y similares (como se indica en el manual ).
$fp = fopen('file.ext', 'r'); // fopen() is the function to open a file on disk as a resource.
var_dump($fp); // output: resource(2) of type (stream)
Para obtener el tipo de una variable como una cadena, use la función gettype()
:
echo gettype(1); // outputs "integer"
echo gettype(true); // "boolean"
Mejores prácticas de variables globales
Podemos ilustrar este problema con el siguiente pseudo-código
function foo() {
global $bob;
$bob->doSomething();
}
Tu primera pregunta aquí es obvia.
¿De dónde vino
$bob
?
¿Estas confundido? Bueno. Acaba de aprender por qué los globales son confusos y se consideran una mala práctica .
Si se tratara de un programa real, su siguiente diversión es ir rastreando todas las instancias de $bob
y espero que encuentre la correcta (esto empeora si $bob
se usa en todas partes). Peor aún, si alguien más va y define $bob
(o si olvidó y reutilizó esa variable), su código puede romperse (en el ejemplo de código anterior, tener el objeto equivocado o no tener ningún objeto, causaría un error fatal).
Dado que prácticamente todos los programas PHP hacen uso de código como include('file.php');
su trabajo para mantener un código como este se vuelve exponencialmente más difícil cuanto más archivos agregue.
Además, esto hace que la tarea de probar sus aplicaciones sea muy difícil. Supongamos que utiliza una variable global para mantener su conexión de base de datos:
$dbConnector = new DBConnector(...); function doSomething() { global $dbConnector; $dbConnector->execute("..."); }
Para realizar una prueba unitaria de esta función, debe anular la variable global $dbConnector
, ejecutar las pruebas y luego restablecerla a su valor original, que es muy propenso a errores:
/** * @test */ function testSomething() { global $dbConnector; $bkp = $dbConnector; // Make backup $dbConnector = Mock::create('DBConnector'); // Override assertTrue(foo()); $dbConnector = $bkp; // Restore }
¿Cómo evitamos los Globales?
La mejor manera de evitar los globales es una filosofía llamada inyección de dependencia . Aquí es donde pasamos las herramientas que necesitamos a la función o clase.
function foo(\Bar $bob) {
$bob->doSomething();
}
Esto es mucho más fácil de entender y mantener. No se puede adivinar dónde se configuró $bob
porque la persona que llama es responsable de saberlo (nos pasa lo que necesitamos saber). Mejor aún, podemos usar declaraciones de tipo para restringir lo que se está pasando.
Así que sabemos que $bob
es una instancia de la clase Bar
o una instancia de un hijo de Bar
, lo que significa que sabemos que podemos usar los métodos de esa clase. Combinado con un autocargador estándar (disponible desde PHP 5.3), ahora podemos rastrear dónde se define Bar
. PHP 7.0 o posterior incluye declaraciones de tipo expandido, donde también puede usar tipos escalares (como int
o string
).
Variables superglobales
Los superglobales en PHP son variables predefinidas, que están siempre disponibles, a las que se puede acceder desde cualquier ámbito a lo largo del script.
No hay necesidad de hacer $ variable global; Para acceder a ellos dentro de funciones / métodos, clases o archivos.
Estas variables superglobal de PHP se enumeran a continuación:
Obteniendo todas las variables definidas
get_defined_vars()
devuelve una matriz con todos los nombres y valores de las variables definidas en el ámbito en el que se llama la función. Si desea imprimir datos, puede usar funciones estándar para generar datos legibles para el ser humano, como print_r
o var_dump
.
var_dump(get_defined_vars());
Nota : esta función generalmente devuelve solo 4 superglobales : $_GET
, $_POST
, $_COOKIE
, $_FILES
. Otros superglobales se devuelven solo si se han utilizado en algún lugar del código. Esto se debe a la directiva auto_globals_jit
que está habilitada de forma predeterminada. Cuando está habilitado, las variables $_SERVER
y $_ENV
se crean cuando se usan por primera vez (Just In Time) en lugar de cuando se inicia el script. Si estas variables no se usan dentro de un script, tener esta directiva activada resultará en una ganancia de rendimiento.
Valores por defecto de variables no inicializadas
Aunque no es necesario en PHP, sin embargo, es una muy buena práctica inicializar variables. Las variables sin inicializar tienen un valor predeterminado de su tipo según el contexto en el que se utilizan:
Sin establecer y sin referencia
var_dump($unset_var); // outputs NULL
Booleano
echo($unset_bool ? "true\n" : "false\n"); // outputs 'false'
Cuerda
$unset_str .= 'abc';
var_dump($unset_str); // outputs 'string(3) "abc"'
Entero
$unset_int += 25; // 0 + 25 => 25
var_dump($unset_int); // outputs 'int(25)'
Flotar / doble
$unset_float += 1.25;
var_dump($unset_float); // outputs 'float(1.25)'
Formación
$unset_arr[3] = "def";
var_dump($unset_arr); // outputs array(1) { [3]=> string(3) "def" }
Objeto
$unset_obj->foo = 'bar';
var_dump($unset_obj); // Outputs: object(stdClass)#1 (1) { ["foo"]=> string(3) "bar" }
Confiar en el valor predeterminado de una variable no inicializada es problemático en el caso de incluir un archivo en otro que use el mismo nombre de variable.
Valor de verdad variable y operador idéntico.
En PHP, los valores de las variables tienen una "veracidad" asociada, por lo que incluso los valores no booleanos equivaldrán a true
o false
. Esto permite que cualquier variable se use en un bloque condicional, por ejemplo,
if ($var == true) { /* explicit version */ }
if ($var) { /* $var == true is implicit */ }
Aquí hay algunas reglas fundamentales para diferentes tipos de valores de variables:
- Las cadenas con longitud distinta de cero equivalen a
true
incluidas las cadenas que solo contienen una hoja blanca como' '
. - Las cadenas vacías
''
equivalen afalse
.
$var = '';
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true
$var = ' ';
$var_is_true = ($var == true); // true
$var_is_false = ($var == false); // false
- Los enteros equivalen a
true
si son distintos de cero, mientras que cero equivale afalse
.
$var = -1;
$var_is_true = ($var == true); // true
$var = 99;
$var_is_true = ($var == true); // true
$var = 0;
$var_is_true = ($var == true); // false
-
null
equivale afalse
$var = null;
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true
- Las cadenas vacías
''
y la cadena cero'0'
equivalen afalse
.
$var = '';
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true
$var = '0';
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true
- Los valores de punto flotante equivalen a
true
si son distintos de cero, mientras que los valores de cero equivalen afalse
.-
NAN
(Not-a-Number de PHP) equivale atrue
, es decir,NAN == true
estrue
. Esto se debe a queNAN
es un valor de punto flotante distinto de cero . - Los valores cero incluyen tanto +0 como -0 según lo definido por IEEE 754. PHP no distingue entre +0 y -0 en su punto flotante de doble precisión, es decir,
floatval('0') == floatval('-0')
estrue
.- De hecho,
floatval('0') === floatval('-0')
. - Además, ambos
floatval('0') == false
yfloatval('-0') == false
.
- De hecho,
-
$var = NAN;
$var_is_true = ($var == true); // true
$var_is_false = ($var == false); // false
$var = floatval('-0');
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true
$var = floatval('0') == floatval('-0');
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true
OPERADOR IDENTICO
En la Documentación PHP para operadores de comparación , hay un operador idéntico ===
. Este operador se puede usar para verificar si una variable es idéntica a un valor de referencia:
$var = null;
$var_is_null = $var === null; // true
$var_is_true = $var === true; // false
$var_is_false = $var === false; // false
¡Tiene un operador no idéntico correspondiente !==
:
$var = null;
$var_is_null = $var !== null; // false
$var_is_true = $var !== true; // true
$var_is_false = $var !== false; // true
El operador idéntico se puede usar como una alternativa a las funciones de lenguaje como is_null()
.
CAJA DE USO CON strpos()
La función de lenguaje strpos($haystack, $needle)
se usa para ubicar el índice en el que $needle
aparece en $haystack
, o si ocurre en absoluto. La función strpos()
mayúsculas y minúsculas; Si lo que necesita es un hallazgo que no distingue entre mayúsculas y minúsculas, puede ir con stripos($haystack, $needle)
La función strpos
& stripos
también contiene el offset
tercer parámetro (int) que, si se especifica, la búsqueda iniciará este número de caracteres contados desde el principio de la cadena. A diferencia de strrpos y strripos, el offset no puede ser negativo
La función puede devolver:
-
0
si se encuentra$needle
al comienzo de$haystack
; - un entero distinto de cero que especifica el índice si
$needle
se encuentra en algún lugar distinto al principio en$haystack
; - y el valor es
false
si no se encuentra$needle
en$haystack
.
Debido a que tanto 0
como false
tienen una verdad false
en PHP pero representan situaciones distintas para strpos()
, es importante distinguir entre ellos y usar el operador idéntico ===
para buscar exactamente false
y no solo un valor que equivale a false
.
$idx = substr($haystack, $needle);
if ($idx === false)
{
// logic for when $needle not found in $haystack
}
else
{
// logic for when $needle found in $haystack
}
Alternativamente, utilizando el operador no idéntico :
$idx = substr($haystack, $needle);
if ($idx !== false)
{
// logic for when $needle found in $haystack
}
else
{
// logic for when $needle not found in $haystack
}