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.

PHP 5.x 5.3
$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 0 di un array

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


Modified text is an extract of the original Stack Overflow Documentation
Autorizzato sotto CC BY-SA 3.0
Non affiliato con Stack Overflow