PHP
variabili
Ricerca…
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
Digitare il controllo
Alcuni documenti relativi a variabili e tipi indicano che PHP non usa la tipizzazione statica. Questo è corretto, ma PHP esegue alcuni controlli di tipo quando si tratta di parametri di funzione / metodo e valori di ritorno (specialmente con PHP 7).
Puoi imporre il controllo dei parametri e del valore di ritorno usando type-hinting in PHP 7 come segue:
<?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: i
gettype()
di PHP per interi e booleani sonointeger
eboolean
rispettivamente. Ma per il suggerimento del tipo per tali variabili è necessario utilizzareint
ebool
. Altrimenti, PHP non ti darà un errore di sintassi, ma si aspetterà che vengano passate le classiinteger
eboolean
.
L'esempio sopra riportato genera un errore nel caso in cui il valore non numerico sia dato come parametro $a
o $b
, e se la funzione restituisce qualcosa di diverso da true
o false
. L'esempio precedente è "loose", in quanto puoi dare un valore float a $a
o $b
. Se desideri applicare rigorosi tipi, ovvero puoi inserire solo numeri interi e non float, aggiungi quanto segue all'inizio del tuo file PHP:
<?php
declare('strict_types=1');
Prima di PHP 7 funzioni e metodi consentivano l'hint di tipo per i seguenti tipi:
-
callable
(una funzione o metodo richiamabile) -
array
(qualsiasi tipo di array, che può contenere anche altri array) - Interfacce (Nome di classe completo o FQDN)
- Classi (FQDN)
Vedi anche: Emissione del valore di una variabile
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
).
Variabili superglobal
Super globals in PHP sono variabili predefinite, che sono sempre disponibili, accessibili da qualsiasi ambito in tutto lo script.
Non è necessario fare una variabile $ globale; per accedervi all'interno di funzioni / metodi, classi o file.
Queste variabili superglobali di PHP sono elencate di seguito:
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 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
- Gli interi corrispondono a
true
se sono diversi da zero, mentre zero 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
- Stringhe vuote
''
e stringa zero'0'
equivalgono 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
- I valori in virgola mobile equivalgono a
true
se sono diversi da zero, mentre i valori zero equivalgono afalse
.-
NAN
(il numero nonNAN
PHP) equivale atrue
, ovveroNAN == 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
chefloatval('-0') == false
.
- Infatti,
-
$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
}