PHP => typer

heltal

Heltal i PHP kan anges naturligt i bas 2 (binär), bas 8 (oktal), bas 10 (decimal) eller bas 16 (hexadecimal.)

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

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

Heltal är 32 eller 64 bitar långa, beroende på plattformen. Konstanten PHP_INT_SIZE har heltalstorlek i byte. PHP_INT_MAX och (sedan PHP 7.0) PHP_INT_MIN är också tillgängliga.

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

Heltalsvärden skapas automatiskt efter behov från flottörer, booleaner och strängar. Om en uttrycklig typecast behövs kan det göras med (int) eller (integer) cast:

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

Heltalsöverskridning hanteras genom konvertering till en flottör:

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

Det finns ingen heltalsdelningsoperatör i PHP, men det kan simuleras med hjälp av en implicit cast, som alltid "rundar" genom att bara kasta flytdelen. Från PHP version 7 lades en heltalsdelningsfunktion till.

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

(Observera att de extra parenteserna runt (25 / 4) behövs eftersom (int) cast har högre prioritet än uppdelningen)

strängar

En sträng i PHP är en serie med en-byte-tecken (det finns inget inbyggt Unicode-stöd) som kan specificeras på fyra sätt:

Enstaka citat

Visar saker nästan helt "som den är". Variabler och de flesta flykt-sekvenser tolkas inte. Undantaget är att för att visa en bokstavlig enstaka offert kan man undkomma den med en ryggstänk ', och för att visa en ryggstänk kan man undvika den med en annan motstreck \

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

Dubbelciterat

Till skillnad från en enda citerad sträng utvärderas enkla variabla namn och flygsekvenser i strängarna. Lockiga hängslen (som i det senaste exemplet) kan användas för att isolera komplexa variabla namn.

$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

I en heredoc-sträng analyseras variabla namn och flykt-sekvenser på liknande sätt som dubbelciterade strängar, även om hängslen inte är tillgängliga för komplexa variabla namn. Början på strängen avgränsas av <<< identifier , och slutet med identifier , där identifier är ett giltigt PHP-namn. Slutidentifieraren måste visas på en rad själv. Inget vitt utrymme är tillåtet före eller efter identifieraren, även om det, liksom alla rader i PHP, måste avslutas med ett semikolon.

$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

En nudoc-sträng är som den enda citerade versionen av heredoc, även om inte ens de mest grundläggande flykt-sekvenserna utvärderas. Identifieraren i början av strängen är lindad i enstaka citat.

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

Boolean

Boolean är en typ som har två värden, betecknade som true eller false .

Den här koden ställer in värdet på $foo som true och $bar som false :

$foo = true;
$bar = false;

true och false är inte skiftlägeskänsligt, så TRUE och FALSE kan också användas, till och med FaLsE är möjligt. Att använda små bokstäver är vanligast och rekommenderas i de flesta kodstylguider, t.ex. PSR-2 .

Booleans kan användas om uttalanden som detta:

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

På grund av det faktum att PHP skrivs svagt, om $foo ovan är annat än true eller false , tvingas det automatiskt till ett booleskt värde.
Följande värden resulterar i false :

ett nollvärde: 0 (heltal), 0.0 (flottör) eller '0' (sträng)
en tom sträng '' eller matris []
null (innehållet i en ouppsatt variabel, eller tilldelad en variabel)

Alla andra värden resulterar i true .

För att undvika denna lösa jämförelse kan du verkställa stark jämförelse med === , som jämför värde och typ . Se Typjämförelse för mer information.

För att konvertera en typ till booleska kan du använda (bool) eller (boolean) cast före typen.

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

eller ring boolval funktionen:

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

Boolesisk konvertering till en sträng (notera att false ger en tom sträng):

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

Boolesisk konvertering till ett heltal:

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

Observera att det motsatta också är möjligt:

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

Även alla icke-noll kommer tillbaka:

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)

Flyta

$float = 0.123;

Av historiska skäl returneras "dubbla" med gettype() i händelse av en flottör, och inte bara "float"

Floats är flytande punktsnummer, som tillåter mer utdataprecision än vanliga heltal.

Floats och heltal kan användas tillsammans på grund av PHP: s lösa gjutning av variabla typer:

$sum = 3 + 0.14;

echo $sum; // 3.14

php visar inte float som floatnummer som andra språk, till exempel:

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

Varning

Flytande precision

(Från PHP manuell sida )

Flyttalsnummer har begränsad precision. Även om det beror på systemet ger PHP vanligtvis ett maximalt relativt fel på grund av avrundning i storleksordningen 1.11e-16. Icke elementära aritmetiska operationer kan ge större fel och fel förökning måste beaktas när flera operationer förvärras.

Dessutom har rationella siffror som är exakt representerbara som flytande punktnummer i bas 10, som 0,1 eller 0,7, inte en exakt representation som flytpunktsnummer i bas 2 (binär), som används internt, oavsett storlek på mantissen . Därför kan de inte konverteras till sina interna binära motsvarigheter utan en liten förlust av precision. Detta kan leda till förvirrande resultat: till exempel kommer golv ((0,1 + 0,7) * 10) vanligtvis att returnera 7 istället för de förväntade 8, eftersom den interna representationen kommer att vara något som 7.9999999999999991111 ...

Så lita aldrig på flytande talresultat till den sista siffran, och jämför inte flytande punktnummer direkt för jämlikhet. Om högre precision är nödvändig finns de godtyckliga precisionsmatematikfunktionerna och gmpfunktionerna tillgängliga.

inlösbara

Callables är allt som kan kallas som ett återuppringning. Saker som kan kallas "återuppringning" är följande:

Anonyma funktioner
Standard PHP-funktioner (Obs: inte språkkonstruktioner )
Statiska klasser
icke-statiska klasser ( med en alternativ syntax )
Specifika objekt / klassmetoder
Objekt själva, så länge objektet finns i nyckel 0 i en matris
Exempel på att hänvisa till ett objekt som ett arrayelement:

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

Callbacks kan betecknas med callable typ antydan som PHP 5.4.

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

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

call_something($callable);

Null

PHP representerar "inget värde" med null nyckelordet. Det är något som liknar nollpekaren i C-språk och NULL-värdet i SQL.

Ställer in variabeln till null:

$nullvar = null; // directly

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

Kontrollera om variabeln var inställd på noll:

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

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

Noll vs odefinierad variabel

Om variabeln inte definierades eller inte har ställts in, kommer alla tester mot noll att lyckas, men de kommer också att generera ett 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 */ }

Därför måste odefinierade värden kontrolleras med isset :

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

Typjämförelse

Det finns två typer av jämförelser : lös jämförelse med == och strikt jämförelse med === . Strikt jämförelse säkerställer att både typen och värdet på operatörens båda sidor är desamma.

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

Du kan också använda en stark jämförelse för att kontrollera om typ och värde inte matchar med !== .

Ett typiskt exempel där operatören == inte räcker, är funktioner som kan returnera olika typer, som strpos , som returnerar false om searchword inte hittas, och matchningspositionen ( int ) annars:

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.

Skriv gjutning

PHP kommer generellt korrekt att gissa den datatyp som du tänker använda från det sammanhang som den används i, men ibland är det bra att manuellt tvinga fram en typ. Detta kan åstadkommas genom att prefixera deklarationen med namnet på den begärda typen inom parentes:

$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

Men var försiktig: inte alla typgjutningar fungerar som man kan förvänta sig:

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

Resurser

En resurs är en speciell typ av variabel som refererar till en extern resurs, till exempel en fil, socket, ström, dokument eller anslutning.

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

echo gettype($file);
# Out: resource

echo $file;
# Out: Resource id #2

Det finns olika (sub-) resurstyper. Du kan kontrollera get_resource_type() med 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

Du hittar en komplett lista över inbyggda resurstyper här .

Skriv jonglering

PHP är ett svagt typspråk. Det kräver ingen uttrycklig deklaration av datatyper. Det sammanhang där variabeln används bestämmer dess datatyp; konvertering sker automatiskt:

$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

Licensierat under CC BY-SA 3.0

Inte anslutet till Stack Overflow

PHP
typer

Sök…