PHP
Types

integers

Gehele getallen in PHP kunnen native worden opgegeven in base 2 (binair), base 8 (octaal), base 10 (decimaal) of base 16 (hexadecimaal).

$my_decimal = 42;
$my_binary = 0b101010;
$my_octal = 052;
$my_hexadecimal = 0x2a;

echo ($my_binary + $my_octal) / 2;
// Output is always in decimal: 42

Gehele getallen zijn 32 of 64 bits lang, afhankelijk van het platform. De constante PHP_INT_SIZE heeft een geheel getal in bytes. PHP_INT_MAX en (sinds PHP 7.0) PHP_INT_MIN zijn ook beschikbaar.

printf("Integers are %d bits long" . PHP_EOL, PHP_INT_SIZE * 8);
printf("They go up to %d" . PHP_EOL, PHP_INT_MAX);

Geheel getal waarden worden automatisch gemaakt als dat nodig is uit floats, booleans en strings. Als een expliciete typecast nodig is, kan dit worden gedaan met de cast (int) of (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)

Overloop van gehele getallen wordt afgehandeld door conversie naar een float:

$too_big_integer = PHP_INT_MAX + 7;
var_dump($too_big_integer);
// Output: float(9.2233720368548E+18)

Er is geen integer divisie operator in PHP, maar het kan worden gesimuleerd met behulp van een impliciete cast, die altijd 'rondt' door gewoon het float-gedeelte weg te gooien. Vanaf PHP versie 7 is een functie voor gehele getallen toegevoegd.

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

(Merk op dat de extra haakjes rond (25 / 4) nodig zijn omdat de (int) cast een hogere prioriteit heeft dan de verdeling)

strings

Een tekenreeks in PHP is een reeks tekens van één byte (er is geen native Unicode-ondersteuning) die op vier manieren kan worden opgegeven:

Enkele geciteerd

Geeft dingen bijna volledig weer "zoals het is". Variabelen en de meeste escape-reeksen worden niet geïnterpreteerd. De uitzondering is dat om een letterlijke enkele quote weer te geven, men eraan kan ontsnappen met een back slash ', en om een back slash weer te geven, men eraan kan ontsnappen met een andere backslash \

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

Dubbel geciteerd

In tegenstelling tot een string met enkele aanhalingstekens worden eenvoudige variabelenamen en escape-reeksen in de tekenreeksen geëvalueerd. Krullende accolades (zoals in het laatste voorbeeld) kunnen worden gebruikt om complexe variabelenamen te isoleren.

$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 een heredoc-reeks worden variabelenamen en escape-reeksen op dezelfde manier ontleed als tekenreeksen met dubbele aanhalingstekens, hoewel accolades niet beschikbaar zijn voor complexe variabelenamen. Het begin van de string wordt begrensd door de <<< identifier en het einde door de identifier , waarbij identifier een geldige PHP-naam is. De eind-ID moet alleen op een regel verschijnen. Er is geen witruimte toegestaan voor of na de identifier, hoewel het net als elke andere regel in PHP moet worden beëindigd door een puntkomma.

$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

Een nowdoc-reeks lijkt op de versie met enkele aanhalingstekens van heredoc, hoewel niet eens de meest basale escape-reeksen worden geëvalueerd. De identifier aan het begin van de string is tussen enkele aanhalingstekens geplaatst.

$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 \\.)"
*/

Boolean

Boolean is een type met twee waarden, aangeduid als true of false .

Deze code stelt de waarde van $foo als true en $bar als false :

$foo = true;
$bar = false;

true en false zijn niet hoofdlettergevoelig, dus TRUE en FALSE kunnen ook worden gebruikt, zelfs FaLsE is mogelijk. Het gebruik van kleine letters komt het meest voor en wordt aanbevolen in de meeste codestijlgidsen, bijvoorbeeld PSR-2 .

Booleans kunnen worden gebruikt als uitspraken als deze:

if ($foo) { //same as evaluating if($foo == true)
    echo "true";
}

Vanwege het feit dat PHP zwak is getypt, wordt $foo hierboven anders dan true of false , het wordt automatisch gedwongen naar een Booleaanse waarde.
De volgende waarden resulteren in false :

• een nulwaarde: 0 (geheel getal), 0.0 (float) of '0' (string)
• een lege string '' of array []
• null (de inhoud van een niet-ingestelde variabele, of toegewezen aan een variabele)

Elke andere waarde resulteert in true .

Om deze losse vergelijking te voorkomen, kunt u een sterke vergelijking afdwingen met === , waarbij waarde en type worden vergeleken. Zie Type Vergelijking voor details.

Om een type naar boolean te converteren, kunt u de (bool) of (boolean) cast vóór het type gebruiken.

var_dump((bool) "1"); //evaluates to true

of roep de boolval functie aan:

var_dump( boolval("1") ); //evaluates to true

Booleaanse conversie naar een string (merk op dat false een lege string oplevert):

var_dump( (string) true ); // string(1) "1"
var_dump( (string) false ); // string(0) ""

Booleaanse conversie naar een geheel getal:

var_dump( (int) true ); // int(1)
var_dump( (int) false ); // int(0)

Merk op dat het tegenovergestelde ook mogelijk is:

var_dump((bool) "");        // bool(false)
var_dump((bool) 1);         // bool(true)

Ook zullen alle niet-nul waar zijn:

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)

Vlotter

$float = 0.123;

Om historische redenen wordt "dubbel" geretourneerd door gettype() in het geval van een float, en niet alleen "float"

Floats zijn drijvende-kommagetallen, die meer uitvoerprecisie toestaan dan gewone gehele getallen.

Floats en gehele getallen kunnen samen worden gebruikt vanwege PHP's losse casting van variabele typen:

$sum = 3 + 0.14;

echo $sum; // 3.14

php toont float niet als floatnummer zoals andere talen, bijvoorbeeld:

$var = 1;
echo ((float) $var); //returns 1 not 1.0

Waarschuwing

Drijvende punt precisie

(Van de PHP manual page )

Zwevende puntnummers hebben een beperkte precisie. Hoewel het afhankelijk is van het systeem, geeft PHP meestal een maximale relatieve fout als gevolg van afronding in de volgorde van 1.11e-16. Niet-elementaire rekenkundige bewerkingen kunnen grotere fouten geven en foutpropagatie moet worden overwogen wanneer verschillende bewerkingen worden samengesteld.

Bovendien hebben rationale getallen die exact kunnen worden weergegeven als drijvende-kommagetallen in basis 10, zoals 0,1 of 0,7, geen exacte weergave als drijvende-kommagetallen in basis 2 (binair), die intern worden gebruikt, ongeacht de grootte van de mantisse . Daarom kunnen ze niet worden omgezet in hun interne binaire tegenhangers zonder een klein verlies aan precisie. Dit kan tot verwarrende resultaten leiden: bijvoorbeeld floor ((0.1 + 0.7) * 10) retourneert meestal 7 in plaats van de verwachte 8, omdat de interne representatie zoiets is als 7.9999999999999991118 ....

Vertrouw dus nooit zwevende nummerresultaten tot het laatste cijfer, en vergelijk drijvende-kommagetallen niet direct voor gelijkheid. Als een hogere precisie nodig is, zijn de willekeurige wiskundige precisiefuncties en gmp-functies beschikbaar.

Callable

Oproepbaarheden zijn alles dat kan worden teruggebeld. Dingen die een "callback" kunnen worden genoemd, zijn de volgende:

• Anonieme functies

• Standaard PHP-functies (let op: geen taalconstructies )

• Statische klassen

• niet-statische klassen ( met een alternatieve syntaxis )

• Specifieke object- / klassenmethoden

• Objecten zelf, zolang het object wordt gevonden in sleutel 0 van een array

  Voorbeeld van een verwijzing naar een object als een array-element:

 $obj = new MyClass();
 call_user_func([$obj, 'myCallbackMethod']);

Callbacks kunnen worden aangegeven met een callable hint vanaf PHP 5.4.

$callable = function () {
    return 'value';
};

function call_something(callable $fn) {
    call_user_func($fn);
}

call_something($callable);

Nul

PHP staat voor "geen waarde" met het null trefwoord. Het is enigszins vergelijkbaar met de nulaanwijzer in C-taal en met de NULL-waarde in SQL.

De variabele op nul instellen:

$nullvar = null; // directly

function doSomething() {} // this function does not return anything
$nullvar = doSomething(); // so the null is assigned to $nullvar

Controleren of de variabele op nul is ingesteld:

if (is_null($nullvar)) { /* variable is null */ }

if ($nullvar === null) {  /* variable is null */ }

Null versus ongedefinieerde variabele

Als de variabele niet is gedefinieerd of is uitgeschakeld, zijn alle tests tegen de nul succesvol, maar genereren ze ook een 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 */ }

Daarom moeten niet-gedefinieerde waarden worden gecontroleerd met isset :

if (!isset($nullvar)) {  /* variable is null or is not even defined */  }

Type vergelijking

Er zijn twee soorten vergelijkingen : losse vergelijking met == en strikte vergelijking met === . Strikte vergelijking zorgt ervoor dat zowel het type als de waarde van beide zijden van de operator hetzelfde zijn.

// 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

U kunt ook een sterke vergelijking gebruiken om te controleren of type en waarde niet overeenkomen met !== .

Een typisch voorbeeld waarbij de operator == niet voldoende is, zijn functies die verschillende typen kunnen retourneren, zoals strpos , die false retourneren als het searchword niet wordt gevonden en anders de overeenkomstpositie ( int ):

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.

Type Casting

PHP zal in het algemeen het gegevenstype dat u wilt gebruiken, correct raden uit de context waarin het wordt gebruikt, maar soms is het handig om een type handmatig te forceren. Dit kan worden bereikt door de verklaring vooraf te laten gaan door de naam van het vereiste type tussen haakjes:

$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

Maar wees voorzichtig: niet alle typen casts werken zoals je zou verwachten:

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

Middelen

Een resource is een speciaal type variabele die verwijst naar een externe resource, zoals een bestand, socket, stream, document of verbinding.

$file = fopen('/etc/passwd', 'r');

echo gettype($file);
# Out: resource

echo $file;
# Out: Resource id #2

Er zijn verschillende (sub) soorten bronnen. U kunt het get_resource_type() controleren met 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

U kunt hier een volledige lijst met ingebouwde brontypen vinden .

Type Jongleren

PHP is een zwak getypte taal. Het vereist geen expliciete verklaring van gegevenstypen. De context waarin de variabele wordt gebruikt, bepaalt het gegevenstype; conversie gebeurt automatisch:

$a = "2";             // string 
$a = $a + 2;          // integer (4) 
$a = $a + 0.5;        // float (4.5)
$a = 1 + "2 oranges"; // integer (3)