Ricerca…
Interi
Gli integer in PHP possono essere specificati in modo nativo in base 2 (binario), base 8 (ottale), base 10 (decimale) o base 16 (esadecimale).
$my_decimal = 42;
$my_binary = 0b101010;
$my_octal = 052;
$my_hexadecimal = 0x2a;
echo ($my_binary + $my_octal) / 2;
// Output is always in decimal: 42
Gli interi sono lunghi 32 o 64 bit, a seconda della piattaforma. La costante PHP_INT_SIZE mantiene le dimensioni integer in byte. PHP_INT_MAX e (dal PHP 7.0) PHP_INT_MIN sono anche disponibili.
printf("Integers are %d bits long" . PHP_EOL, PHP_INT_SIZE * 8);
printf("They go up to %d" . PHP_EOL, PHP_INT_MAX);
I valori interi vengono creati automaticamente come necessario da float, booleani e stringhe. Se è necessario un typecast esplicito, può essere eseguito con il cast (int) o (integer) :
$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)
L'overflow dei numeri interi verrà gestito dalla conversione in un float:
$too_big_integer = PHP_INT_MAX + 7;
var_dump($too_big_integer);
// Output: float(9.2233720368548E+18)
Non esiste un operatore di divisione intero in PHP, ma può essere simulato utilizzando un cast implicito, che esegue sempre "round" semplicemente scartando la parte float. A partire dalla versione 7 di PHP, è stata aggiunta una funzione di divisione intera.
$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)
(Si noti che le parentesi aggiuntive intorno a (25 / 4) sono necessarie perché il cast (int) ha una precedenza maggiore rispetto alla divisione)
stringhe
Una stringa in PHP è una serie di caratteri a byte singolo (ovvero non esiste un supporto Unicode nativo) che può essere specificata in quattro modi:
Singolo quotato
Visualizza le cose quasi completamente "così come sono". Le variabili e la maggior parte delle sequenze di escape non saranno interpretate. L'eccezione è che per visualizzare una virgoletta singola letterale, si può scappare con una barra rovesciata ', e per visualizzare una barra rovesciata, si può scappare con un'altra barra rovesciata \
$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"
*/
Doppio virgolette
A differenza di una stringa con quotatura singola, verranno valutati nomi di variabili semplici e sequenze di escape nelle stringhe. Le parentesi graffe (come nell'ultimo esempio) possono essere utilizzate per isolare nomi di variabili complessi.
$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
In una stringa heredoc, i nomi delle variabili e le sequenze di escape vengono analizzati in modo simile alle stringhe con virgolette doppie, sebbene le parentesi non siano disponibili per nomi di variabili complessi. L'inizio della stringa è delimitato da <<< identifier e la fine da identifier , dove identifier è un nome PHP valido. L'identificatore finale deve apparire su una riga da solo. Nessuno spazio bianco è consentito prima o dopo l'identificatore, anche se come qualsiasi riga in PHP, deve anche essere terminato da un punto e virgola.
$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."
*/
Nowdoc
Una stringa nowdoc è come la versione a virgola singola di heredoc, anche se non vengono valutate nemmeno le sequenze di escape più elementari. L'identificatore all'inizio della stringa è racchiuso tra virgolette singole.
$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 è un tipo, con due valori, indicato come true o false .
Questo codice imposta il valore di $foo come true e $bar come false :
$foo = true;
$bar = false;
true e false non fanno distinzione tra maiuscole e minuscole, quindi è possibile utilizzare anche TRUE e FALSE , anche il FaLsE è possibile. L'utilizzo di lettere minuscole è più comune e consigliato nella maggior parte delle guide di stile del codice, ad esempio PSR-2 .
I booleani possono essere usati in istruzioni come questa:
if ($foo) { //same as evaluating if($foo == true)
echo "true";
}
A causa del fatto che PHP è debolmente digitato, se $foo sopra è diverso da true o false , viene automaticamente forzato a un valore booleano.
I seguenti valori risultano false :
- un valore zero:
0(numero intero),0.0(float) o'0'(stringa) - una stringa vuota
''o array[] -
null(il contenuto di una variabile non impostata o assegnata a una variabile)
Qualsiasi altro valore risulta true .
Per evitare questo paragone allentato, puoi applicare un confronto forte usando === , che confronta valore e tipo . Vedi Tipo confronto per i dettagli.
Per convertire un tipo in booleano, puoi usare il cast (bool) o (boolean) prima del tipo.
var_dump((bool) "1"); //evaluates to true
o chiama la funzione boolval :
var_dump( boolval("1") ); //evaluates to true
Conversione booleana in una stringa (si noti che false restituisce una stringa vuota):
var_dump( (string) true ); // string(1) "1"
var_dump( (string) false ); // string(0) ""
Conversione booleana in un intero:
var_dump( (int) true ); // int(1)
var_dump( (int) false ); // int(0)
Si noti che è anche possibile il contrario:
var_dump((bool) ""); // bool(false)
var_dump((bool) 1); // bool(true)
Anche tutti i non zero restituiranno true:
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)
Galleggiante
$float = 0.123;
Per ragioni storiche "double" viene restituito da
gettype()in caso di float e non semplicemente "float"
I float sono numeri in virgola mobile, che consentono una maggiore precisione di output rispetto ai numeri interi semplici.
I float e gli interi possono essere usati insieme a causa del casting loose di PHP di tipi variabili:
$sum = 3 + 0.14;
echo $sum; // 3.14
php non mostra float come numero float come altre lingue, ad esempio:
$var = 1;
echo ((float) $var); //returns 1 not 1.0
avvertimento
Precisione in virgola mobile
(Dalla pagina di manuale di PHP )
I numeri in virgola mobile hanno una precisione limitata. Sebbene dipenda dal sistema, in genere PHP fornisce un errore relativo massimo a causa dell'arrotondamento nell'ordine di 1.11e-16. Le operazioni aritmetiche non elementari possono dare errori più grandi e la propagazione degli errori deve essere presa in considerazione quando si compongono diverse operazioni.
Inoltre, i numeri razionali che sono esattamente rappresentabili come numeri in virgola mobile nella base 10, come 0,1 o 0,7, non hanno una rappresentazione esatta come numeri in virgola mobile in base 2 (binari), che viene usata internamente, indipendentemente dalla dimensione della mantissa . Quindi, non possono essere convertiti nelle loro controparti binarie interne senza una piccola perdita di precisione. Ciò può portare a risultati confusi: ad esempio, floor ((0,1 + 0,7) * 10) restituirà solitamente 7 anziché 8 previsti, poiché la rappresentazione interna sarà qualcosa come 7.9999999999999991118 ....
Quindi non fidarti mai dei risultati di numeri fluttuanti sull'ultima cifra e non confrontare i numeri in virgola mobile direttamente per l'uguaglianza. Se è necessaria una maggiore precisione, sono disponibili le funzioni matematiche di precisione arbitrarie e le funzioni gmp.
callable
Le callebles sono tutto ciò che può essere chiamato come callback. Le cose che possono essere definite "richiamate" sono le seguenti:
Funzioni anonime
Funzioni PHP standard (nota: non costrutti linguistici )
Classi statiche
Classi non statiche ( usando una sintassi alternativa )
Metodi oggetto / classe specifici
Oggetti stessi, purché l'oggetto si trovi nella chiave
0di un arrayEsempio di riferimento a un oggetto come elemento di un array:
$obj = new MyClass();
call_user_func([$obj, 'myCallbackMethod']);
Le callback possono essere indicate con un suggerimento callable partire da PHP 5.4.
$callable = function () {
return 'value';
};
function call_something(callable $fn) {
call_user_func($fn);
}
call_something($callable);
Nullo
PHP rappresenta "nessun valore" con la parola chiave null . È in qualche modo simile al puntatore nullo in linguaggio C e al valore NULL in SQL.
Impostazione della variabile su null:
$nullvar = null; // directly
function doSomething() {} // this function does not return anything
$nullvar = doSomething(); // so the null is assigned to $nullvar
Verifica se la variabile è stata impostata su null:
if (is_null($nullvar)) { /* variable is null */ }
if ($nullvar === null) { /* variable is null */ }
Variabile nullo vs non definita
Se la variabile non è stata definita o è stata annullata, qualsiasi test contro il null avrà esito positivo, ma genererà anche 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 */ }
Pertanto i valori non definiti devono essere verificati con isset :
if (!isset($nullvar)) { /* variable is null or is not even defined */ }
Tipo di confronto
Esistono due tipi di confronto : confronto libero con == e confronto rigoroso con === . Il confronto rigoroso assicura che sia il tipo che il valore di entrambi i lati dell'operatore siano gli stessi.
// 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
Puoi anche usare un confronto forte per verificare se il tipo e il valore non corrispondono usando !== .
Un tipico esempio in cui l'operatore == non è sufficiente, sono funzioni che possono restituire tipi diversi, come strpos , che restituisce false se la searchword non viene trovata e la posizione di corrispondenza ( int ) in caso 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.
Digitare Casting
PHP generalmente indovinerà correttamente il tipo di dati che si intende utilizzare dal contesto in cui è utilizzato, tuttavia a volte è utile forzare manualmente un tipo. Questo può essere ottenuto anteponendo la dichiarazione con il nome del tipo richiesto tra parentesi:
$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
Ma attenzione: non tutti i tipi di cast funzionano come ci si aspetterebbe:
// 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)
risorse
Una risorsa è un tipo speciale di variabile che fa riferimento a una risorsa esterna, ad esempio un file, un socket, un flusso, un documento o una connessione.
$file = fopen('/etc/passwd', 'r');
echo gettype($file);
# Out: resource
echo $file;
# Out: Resource id #2
Esistono diversi (sotto) tipi di risorse. Puoi controllare il tipo di risorsa 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
Potete trovare un elenco completo dei tipi di risorse incorporate qui .
Digitare giocoleria
PHP è un linguaggio debolmente tipizzato. Non richiede la dichiarazione esplicita di tipi di dati. Il contesto in cui viene utilizzata la variabile determina il suo tipo di dati; la conversione viene eseguita automaticamente:
$a = "2"; // string
$a = $a + 2; // integer (4)
$a = $a + 0.5; // float (4.5)
$a = 1 + "2 oranges"; // integer (3)