PHP
Variables

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

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

<?php
declare('strict_types=1');

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

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 a false .

$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 a false .

$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 a false

$var = null;
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

• Las cadenas vacías '' y la cadena cero '0' equivalen a false .

$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 a false .
  • NAN (Not-a-Number de PHP) equivale a true , es decir, NAN == true es true . Esto se debe a que NAN 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') es true .
    • De hecho, floatval('0') === floatval('-0') .
    • Además, ambos floatval('0') == false y floatval('-0') == false .

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