PHP
variabili

Sintassi

• $ variabile = 'valore'; // Assegna variabile generale
• $ oggetto-> proprietà = 'valore'; // Assegna una proprietà dell'oggetto
• ClassName :: $ property = 'valore'; // Assegna una proprietà di classe statica
• $ array [0] = 'valore'; // Assegna un valore a un indice di un array
• $ array [] = 'valore'; // Spingi un oggetto alla fine di un array
• $ array ['key'] = 'valore'; // Assegna un valore di matrice
• echo $ variabile; // Echo (stampa) un valore variabile
• una_qualche_funzione ($ variabile); // Usa variabile come parametro di funzione
• unset ($ variabile); // Annulla l'impostazione di una variabile
• $$ variabile = 'valore'; // Assegna a una variabile variabile
• isset ($ variabile); // Controlla se una variabile è impostata o meno
• vuota ($ variabile); // Controlla se una variabile è vuota o meno

Osservazioni

<?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');

Accesso a una variabile in modo dinamico per nome (variabili variabili)

Le variabili sono accessibili tramite nomi di variabili dinamiche. Il nome di una variabile può essere memorizzato in un'altra variabile, consentendone l'accesso dinamico. Tali variabili sono note come variabili variabili.

Per trasformare una variabile in una variabile variabile, metti un extra $ messo davanti alla tua variabile.

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

Le variabili variabili sono utili per mappare chiamate di funzioni / metodi:

function add($a, $b) {
    return $a + $b;
}

$funcName = 'add';

echo $funcName(1, 2); // outputs 3

Questo diventa particolarmente utile nelle classi PHP:

class myClass {
    public function __construct() {
        $functionName = 'doSomething';
        $this->$functionName('Hello World');
    }

    private function doSomething($string) {
        echo $string; // Outputs "Hello World"
    }
}

È possibile, ma non è necessario inserire $variableName tra {} :

${$variableName} = $value;

I seguenti esempi sono sia equivalenti che di output "baz":

$fooBar = 'baz';
$varPrefix = 'foo';

echo $fooBar;               // Outputs "baz"
echo ${$varPrefix . 'Bar'}; // Also outputs "baz"

L'utilizzo di {} è obbligatorio solo quando il nome della variabile è di per sé un'espressione, come questa:

${$variableNamePart1 . $variableNamePart2} = $value;

Si consiglia comunque di usare sempre {} , perché è più leggibile.

Anche se non è consigliabile farlo, è possibile concatenare questo comportamento:

$$$$$$$$DoNotTryThisAtHomeKids = $value;

È importante notare che l'uso eccessivo di variabili variabili è considerato una cattiva pratica da molti sviluppatori. Dal momento che non sono adatti per l'analisi statica dei moderni IDE, grandi basi di codici con molte variabili variabili (o invocazioni di metodi dinamici) possono diventare rapidamente difficili da mantenere.

Differenze tra PHP5 e PHP7

Un altro motivo per usare sempre {} o () , è che PHP5 e PHP7 hanno un modo leggermente diverso di trattare le variabili dinamiche, il che si traduce in un risultato diverso in alcuni casi.

In PHP7, le variabili dinamiche, le proprietà e i metodi verranno ora valutati rigorosamente in ordine da sinistra a destra, al contrario del mix di casi speciali in PHP5. Gli esempi seguenti mostrano come è cambiato l'ordine di valutazione.

Caso 1: $$foo['bar']['baz']

• Interpretazione di PHP5: ${$foo['bar']['baz']}
• Interpretazione di PHP7: ($$foo)['bar']['baz']

Caso 2: $foo->$bar['baz']

• Interpretazione di PHP5: $foo->{$bar['baz']}
• Interpretazione di PHP7: ($foo->$bar)['baz']

Caso 3: $foo->$bar['baz']()

• Interpretazione di PHP5: $foo->{$bar['baz']}()
• Interpretazione di PHP7: ($foo->$bar)['baz']()

Caso 4: Foo::$bar['baz']()

• Interpretazione di PHP5: Foo::{$bar['baz']}()
• Interpretazione di PHP7: (Foo::$bar)['baz']()

Tipi di dati

Esistono diversi tipi di dati per scopi diversi. PHP non ha definizioni di tipo esplicite, ma il tipo di una variabile è determinato dal tipo di valore assegnato o dal tipo a cui è assegnato. Questa è una breve panoramica sui tipi, per una documentazione dettagliata ed esempi, vedi l'argomento dei tipi PHP .

Esistono i seguenti tipi di dati in PHP: null, booleano, intero, float, stringa, oggetto, risorsa e array.

Nullo

Null può essere assegnato a qualsiasi variabile. Rappresenta una variabile senza valore.

$foo = null;

Ciò invalida la variabile e il suo valore sarebbe indefinito o annullato se chiamato. La variabile viene cancellata dalla memoria ed eliminata dal garbage collector.

booleano

Questo è il tipo più semplice con solo due valori possibili.

$foo = true;
$bar = false;

Le booleane possono essere utilizzate per controllare il flusso del codice.

$foo = true;

if ($foo) {
    echo "true";
} else {
    echo "false";
}

Numero intero

Un numero intero è un numero intero positivo o negativo. Può essere utilizzato con qualsiasi base numerica. La dimensione di un intero dipende dalla piattaforma. PHP non supporta gli interi senza segno.

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

Galleggiante

I numeri in virgola mobile, "doppi" o semplicemente "float" sono numeri decimali.

$foo = 1.23;
$foo = 10.0;
$bar = -INF;
$bar = NAN;

schieramento

Un array è come un elenco di valori. La forma più semplice di un array è indicizzata dal numero intero e ordinata dall'indice, con il primo elemento che giace nell'indice 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

Le matrici possono anche associare una chiave diversa da un indice intero a un valore. In PHP, tutti gli array sono array associativi dietro le quinte, ma quando ci riferiamo a un 'array associativo' distintamente, di solito intendiamo uno che contiene una o più chiavi che non sono interi.

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

Stringa

Una stringa è come una matrice di caratteri.

$foo = "bar";

Come un array, una stringa può essere indicizzata per restituire i suoi singoli caratteri:

$foo = "bar";
echo $foo[0]; // Prints 'b', the first character of the string in $foo.

Oggetto

Un oggetto è un'istanza di una classe. Le sue variabili e metodi sono accessibili con l'operatore -> .

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

Risorsa

Le variabili delle risorse contengono maniglie speciali per i file aperti, le connessioni al database, i flussi, le aree di immagine e simili (come indicato nel manuale ).

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

Per ottenere il tipo di una variabile come stringa, utilizzare la funzione gettype() :

echo gettype(1); // outputs "integer"
echo gettype(true); // "boolean"

Migliori pratiche variabili globali

Possiamo illustrare questo problema con il seguente pseudo-codice

function foo() {
    global $bob;
    $bob->doSomething();
}

La tua prima domanda qui è ovvia

Da dove viene $bob ?

Sei confuso? Buono. Hai appena saputo perché i globali sono confusi e considerati una cattiva pratica .

Se questo fosse un vero programma, il tuo prossimo divertimento sarà quello di rintracciare tutte le istanze di $bob e spero che tu trovi quella giusta (questo peggiora se $bob è usato ovunque). Peggio ancora, se qualcun altro va e definisce $bob (o hai dimenticato e riutilizzato quella variabile) il tuo codice può rompersi (nell'esempio di codice precedente, avere l'oggetto sbagliato, o nessun oggetto, causerebbe un errore fatale).

Poiché praticamente tutti i programmi PHP utilizzano il codice come include('file.php'); il tuo lavoro di mantenimento del codice come questo diventa esponenzialmente più difficile più file aggiungi.

Inoltre, questo rende molto difficile il compito di testare le tue applicazioni. Supponiamo di utilizzare una variabile globale per mantenere la connessione al database:

$dbConnector = new DBConnector(...);

function doSomething() {
    global $dbConnector;
    $dbConnector->execute("...");
}

Per testare questa funzione, è necessario sovrascrivere la variabile globale $dbConnector , eseguire i test e quindi reimpostarla sul valore originale, che è molto incline ai bug:

/**
 * @test
 */
function testSomething() {
     global $dbConnector;

     $bkp = $dbConnector; // Make backup
     $dbConnector = Mock::create('DBConnector'); // Override

     assertTrue(foo());

     $dbConnector = $bkp; // Restore
}

Come evitiamo i Globali?

Il modo migliore per evitare i globals è una filosofia chiamata Dependency Injection . Qui è dove passiamo gli strumenti di cui abbiamo bisogno nella funzione o classe.

function foo(\Bar $bob) {
    $bob->doSomething();
}

Questo è molto più facile da capire e mantenere. Non si può pensare a dove $bob stato impostato perché il chiamante è responsabile per sapere che (ci sta passando quello che dobbiamo sapere). Ancora meglio, possiamo usare le dichiarazioni di tipo per limitare ciò che viene passato.

Quindi sappiamo che $bob è un'istanza della classe Bar o un'istanza di un figlio di Bar , il che significa che sappiamo che possiamo usare i metodi di quella classe. Combinato con un autoloader standard (disponibile da PHP 5.3), ora possiamo rintracciare dove viene definita la Bar . PHP 7.0 o versioni successive include dichiarazioni di tipo espanso, in cui è anche possibile utilizzare i tipi scalari (come int o string ).

Ottenere tutte le variabili definite

get_defined_vars() restituisce una matrice con tutti i nomi e i valori delle variabili definite nell'ambito in cui viene chiamata la funzione. Se si desidera stampare i dati, è possibile utilizzare le funzioni standard per l'output di dati leggibili dall'uomo, come print_r o var_dump .

var_dump(get_defined_vars());

Nota : questa funzione di solito restituisce solo 4 superglobali : $_GET , $_POST , $_COOKIE , $_FILES . Altri superglobali vengono restituiti solo se sono stati utilizzati da qualche parte nel codice. Ciò è dovuto alla direttiva auto_globals_jit che è abilitata per impostazione predefinita. Quando è abilitato, le variabili $_SERVER e $_ENV vengono create quando vengono utilizzate per la prima volta (Just In Time) anziché quando inizia lo script. Se queste variabili non vengono utilizzate all'interno di uno script, avere questa direttiva attiva comporterà un guadagno in termini di prestazioni.

Valori predefiniti di variabili non inizializzate

Sebbene non sia necessario in PHP, è comunque una buona pratica inizializzare le variabili. Le variabili non inizializzate hanno un valore predefinito del loro tipo in base al contesto in cui vengono utilizzate:

Unset AND unreferenced

var_dump($unset_var); // outputs NULL

booleano

echo($unset_bool ? "true\n" : "false\n"); // outputs 'false' 

Stringa

$unset_str .= 'abc';
var_dump($unset_str); // outputs 'string(3) "abc"'

Numero intero

$unset_int += 25; // 0 + 25 => 25
var_dump($unset_int); // outputs 'int(25)'

Float / doppia

$unset_float += 1.25;
var_dump($unset_float); // outputs 'float(1.25)'

schieramento

$unset_arr[3] = "def";
var_dump($unset_arr); //  outputs array(1) {  [3]=>  string(3) "def" }

Oggetto

$unset_obj->foo = 'bar';
var_dump($unset_obj); // Outputs: object(stdClass)#1 (1) {  ["foo"]=>  string(3) "bar" }

Affidarsi al valore predefinito di una variabile non inizializzata è problematico nel caso di includere un file in un altro che utilizza lo stesso nome di variabile.

Verità di valore variabile e operatore identico

In PHP, i valori delle variabili hanno una "verità" associata, quindi anche i valori non booleani saranno uguali a true o false . Ciò consente a qualsiasi variabile di essere utilizzata in un blocco condizionale, ad es

if ($var == true) { /* explicit version */ }
if ($var) { /* $var == true is implicit */ }

Ecco alcune regole fondamentali per diversi tipi di valori variabili:

• Le stringhe con lunghezza diversa da zero corrispondono a true includendo stringhe contenenti solo spazi bianchi come ' ' .
• Le stringhe vuote '' corrispondono 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

• Gli interi corrispondono a true se sono diversi da zero, mentre zero 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

• Stringhe vuote '' e stringa zero '0' equivalgono 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

• I valori in virgola mobile equivalgono a true se sono diversi da zero, mentre i valori zero equivalgono a false .
  • NAN (il numero non NAN PHP) equivale a true , ovvero NAN == true è true . Questo perché NAN è un valore in virgola mobile diverso da zero .
  • I valori zero includono sia +0 che -0 come definito da IEEE 754. PHP non distingue tra +0 e -0 nella virgola mobile a precisione doppia, ovvero floatval('0') == floatval('-0') è true .
    • Infatti, floatval('0') === floatval('-0') .
    • Inoltre, sia floatval('0') == false che 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

OPERATORE IDENTICO

Nella Documentazione di PHP per gli operatori di confronto , esiste un operatore identico === . Questo operatore può essere utilizzato per verificare se una variabile è identica a un valore di riferimento:

$var = null;
$var_is_null = $var === null; // true
$var_is_true = $var === true; // false
$var_is_false = $var === false; // false

Ha un operatore corrispondente non identico !== :

$var = null;
$var_is_null = $var !== null; // false
$var_is_true = $var !== true; // true
$var_is_false = $var !== false; // true

L'operatore identico può essere utilizzato in alternativa alle funzioni del linguaggio come is_null() .

USE CASE WITH strpos()

La funzione di linguaggio strpos($haystack, $needle) viene utilizzata per individuare l'indice in cui $needle verifica in $haystack o se si verifica del tutto. La funzione strpos() è case sensitive; se la ricerca insensibile alle maiuscole e alle minuscole è ciò di cui hai bisogno puoi andare con gli stripos($haystack, $needle)

La funzione strpos & stripos contiene anche il terzo parametro offset (int) che, se specificato, ricerca avvia questo numero di caratteri contati dall'inizio della stringa. A differenza di strrpos e strripos, l'offset non può essere negativo

La funzione può restituire:

• 0 se $needle viene trovato all'inizio di $haystack ;
• un numero intero diverso da zero che specifica l'indice se $needle viene trovato in un punto diverso da quello in $haystack ;
• e valore false se $needle non viene trovato da nessuna parte in $haystack .

Poiché sia 0 che false hanno verità false in PHP ma rappresentano situazioni distinte per strpos() , è importante distinguere tra loro e utilizzare l'operatore identico === per cercare esattamente false e non solo un valore che 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
}

In alternativa, utilizzando l'operatore non identico :

$idx = substr($haystack, $needle);
if ($idx !== false) 
{
    // logic for when $needle found in $haystack
} 
else
{
    // logic for when $needle not found in $haystack
}