PHP
variabler

Syntax

• $ variabel = 'värde'; // Tilldela allmän variabel
• $ object-> property = 'value'; // Tilldela en objektegenskap
• ClassName :: $ egenskap = 'värde'; // Tilldela en statisk klassegenskap
• $ array [0] = 'värde'; // Tilldela ett värde till ett index för en matris
• $ array [] = 'värde'; // Tryck på ett objekt i slutet av en matris
• $ array ['key'] = 'värde'; // Tilldela ett matrisvärde
• echo $ variabel; // Echo (skriv ut) ett variabelt värde
• some_function ($ variabel); // Använd variabel som funktionsparameter
• oskränkt ($ variabel); // Ta bort en variabel
• $$ variabel = 'värde'; // Tilldela en variabel
• isset ($ variabel); // Kontrollera om en variabel är inställd eller inte
• tömma ($ variabel); // Kontrollera om en variabel är tom eller inte

Anmärkningar

<?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;
}

<?php
declare('strict_types=1');

Åtkomst till en variabel dynamiskt med namn (variabla variabler)

Variabler kan nås via dynamiska variabelnamn. Namnet på en variabel kan lagras i en annan variabel, så att den kan komma åt dynamiskt. Sådana variabler kallas variabla variabler.

För att förvandla en variabel till en variabel, lägger du en extra $ -sats framför din variabel.

$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};

Variabla variabler är användbara för att kartlägga funktion / metodsamtal:

function add($a, $b) {
    return $a + $b;
}

$funcName = 'add';

echo $funcName(1, 2); // outputs 3

Detta blir särskilt användbart i PHP-klasser:

class myClass {
    public function __construct() {
        $functionName = 'doSomething';
        $this->$functionName('Hello World');
    }

    private function doSomething($string) {
        echo $string; // Outputs "Hello World"
    }
}

Det är möjligt, men inte nödvändigt att sätta $variableName mellan {} :

${$variableName} = $value;

Följande exempel är både ekvivalenta och utgående "baz":

$fooBar = 'baz';
$varPrefix = 'foo';

echo $fooBar;               // Outputs "baz"
echo ${$varPrefix . 'Bar'}; // Also outputs "baz"

Att använda {} är bara obligatoriskt när variabelns namn i sig är ett uttryck, så här:

${$variableNamePart1 . $variableNamePart2} = $value;

Det rekommenderas ändå att alltid använda {} eftersom det är mer läsbart.

Det rekommenderas inte att göra det, men det är möjligt att kedja detta beteende:

$$$$$$$$DoNotTryThisAtHomeKids = $value;

Det är viktigt att notera att överdriven användning av variabla variabler anses vara en dålig praxis av många utvecklare. Eftersom de inte är väl lämpade för statisk analys av moderna IDE: er kan stora kodbaser med många variabla variabler (eller dynamiska metodinokationer) snabbt bli svåra att underhålla.

Skillnader mellan PHP5 och PHP7

En annan anledning att alltid använda {} eller () är att PHP5 och PHP7 har ett något annat sätt att hantera dynamiska variabler, vilket i vissa fall resulterar i ett annat resultat.

I PHP7 kommer dynamiska variabler, egenskaper och metoder nu att utvärderas strikt i vänster till höger ordning, i motsats till blandningen av specialfall i PHP5. Exemplen nedan visar hur utvärderingsordningen har förändrats.

Fall 1: $$foo['bar']['baz']

• PHP5-tolkning: ${$foo['bar']['baz']}
• PHP7-tolkning: ($$foo)['bar']['baz']

Fall 2: $foo->$bar['baz']

• PHP5-tolkning: $foo->{$bar['baz']}
• PHP7-tolkning: ($foo->$bar)['baz']

Fall 3: $foo->$bar['baz']()

• PHP5-tolkning: $foo->{$bar['baz']}()
• PHP7-tolkning: ($foo->$bar)['baz']()

Fall 4: Foo::$bar['baz']()

• PHP5-tolkning: Foo::{$bar['baz']}()
• PHP7-tolkning: (Foo::$bar)['baz']()

Datatyper

Det finns olika datatyper för olika ändamål. PHP har inte uttryckliga typdefinitioner, men typen av en variabel bestäms av typen av värdet som tilldelas eller av typen som den kastas till. Detta är en kort överblick över typerna, för detaljerad dokumentation och exempel, se PHP-typens ämne .

Det finns följande datatyper i PHP: null, booleska, heltal, flottör, sträng, objekt, resurs och matris.

Null

Noll kan tilldelas vilken variabel som helst. Det representerar en variabel utan värde.

$foo = null;

Detta ogiltigförvarar variabeln och dess värde skulle vara odefinierat eller ogiltigt om det anropas. Variabeln rensas från minnet och raderas av sopor.

Boolean

Detta är den enklaste typen med bara två möjliga värden.

$foo = true;
$bar = false;

Booleans kan användas för att kontrollera flödet av kod.

$foo = true;

if ($foo) {
    echo "true";
} else {
    echo "false";
}

Heltal

Ett heltal är ett heltal positivt eller negativt. Det kan användas med valfri nummerbas. Storleken på ett heltal är plattformsberoende. PHP stöder inte osignerade heltal.

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

Flyta

Flytande punktsnummer, "fördubblar" eller helt enkelt kallas "flyter" är decimaltal.

$foo = 1.23;
$foo = 10.0;
$bar = -INF;
$bar = NAN;

Array

En matris är som en lista med värden. Den enklaste formen av en matris indexeras med heltal och ordnas av indexet, med det första elementet som ligger vid index 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

Arrays kan också koppla en annan nyckel än ett heltalindex till ett värde. I PHP är alla matriser associativa matriser bakom kulisserna, men när vi tydligt refererar till en 'associativ matris', menar vi vanligtvis en som innehåller en eller flera nycklar som inte är heltal.

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

Sträng

En sträng är som en rad tecken.

$foo = "bar";

Som en matris kan en sträng indexeras för att returnera sina enskilda tecken:

$foo = "bar";
echo $foo[0]; // Prints 'b', the first character of the string in $foo.

Objekt

Ett objekt är ett exempel på en klass. Dess variabler och metoder kan nås med operatören -> .

$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".

Resurs

Resursvariabler innehåller specialhandtag för öppnade filer, databasanslutningar, strömmar, bildkanfasområden och liknande (som det anges i manualen ).

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

För att få typen av en variabel som en sträng använder gettype() funktionen gettype() :

echo gettype(1); // outputs "integer"
echo gettype(true); // "boolean"

Bästa praxis för global variabel

Vi kan illustrera detta problem med följande pseudokod

function foo() {
    global $bob;
    $bob->doSomething();
}

Din första fråga här är en uppenbar fråga

Var kom $bob ifrån?

Är du förvirrad? Bra. Du har precis lärt dig varför globaler är förvirrande och betraktas som en dålig praxis .

Om det här var ett riktigt program, är din nästa kul att spåra alla instanser av $bob och hoppas att du hittar rätt (detta blir värre om $bob används överallt). Värre är att om någon annan går och definierar $bob (eller om du glömde och återanvände den variabeln) kan din kod gå sönder (i ovanstående kodeksempel, att ha fel objekt eller inget objekt alls, kan det orsaka ett dödligt fel).

Eftersom praktiskt taget alla PHP-program använder sig av kod som include('file.php'); ditt jobb som upprätthåller sådan kod blir exponentiellt hårdare ju fler filer du lägger till.

Dessutom gör detta uppgiften att testa dina applikationer mycket svårt. Anta att du använder en global variabel för att hålla din databasanslutning:

$dbConnector = new DBConnector(...);

function doSomething() {
    global $dbConnector;
    $dbConnector->execute("...");
}

För att testa den här funktionen måste du åsidosätta den globala $dbConnector variabeln, köra testerna och sedan återställa den till sitt ursprungliga värde, vilket är mycket benäget:

/**
 * @test
 */
function testSomething() {
     global $dbConnector;

     $bkp = $dbConnector; // Make backup
     $dbConnector = Mock::create('DBConnector'); // Override

     assertTrue(foo());

     $dbConnector = $bkp; // Restore
}

Hur undviker vi Globals?

Det bästa sättet att undvika globaler är en filosofi som kallas Dependency Injection . Det är här vi överför verktygen vi behöver till funktionen eller klassen.

function foo(\Bar $bob) {
    $bob->doSomething();
}

Detta är mycket lättare att förstå och underhålla. Det går inte att gissa var $bob har skapats eftersom den som ringer ansvarar för att veta det (det ger oss vad vi behöver veta). Ännu bättre kan vi använda typdeklarationer för att begränsa vad som skickas.

Så vi vet att $bob antingen är en instans av Bar klassen eller en instans av ett barn av Bar , vilket betyder att vi vet att vi kan använda metoderna för den klassen. Kombinerat med en standard autoloader (tillgänglig sedan PHP 5.3) kan vi nu spåra var Bar definieras. PHP 7.0 eller senare innehåller utökade typdeklarationer, där du också kan använda skalartyper (som int eller string ).

Få alla definierade variabler

get_defined_vars() returnerar en matris med alla namn och värden på variablerna definierade i det område som funktionen heter. Om du vill skriva ut data kan du använda standardfunktioner för att mata ut data som kan läsas av människor, som print_r eller var_dump .

var_dump(get_defined_vars());

Obs : Denna funktion returnerar vanligtvis bara 4 superglobaler : $_GET , $_POST , $_COOKIE , $_FILES . Andra superglobaler returneras endast om de har använts någonstans i koden. Detta beror på auto_globals_jit direktivet som är aktiverat som standard. När det är aktiverat $_ENV variablerna $_SERVER och $_ENV när de först används (Just In Time) istället för när skriptet startar. Om dessa variabler inte används i ett skript, kommer detta direktiv att resultera i en prestationsförstärkning.

Standardvärden för oinitialiserade variabler

Även om det inte är nödvändigt i PHP är det dock en mycket bra praxis att initiera variabler. Oinitialiserade variabler har ett standardvärde av sin typ beroende på sammanhanget i vilket de används:

Oinställd OCH oreferenser

var_dump($unset_var); // outputs NULL

Boolean

echo($unset_bool ? "true\n" : "false\n"); // outputs 'false' 

Sträng

$unset_str .= 'abc';
var_dump($unset_str); // outputs 'string(3) "abc"'

Heltal

$unset_int += 25; // 0 + 25 => 25
var_dump($unset_int); // outputs 'int(25)'

Float / dubbel

$unset_float += 1.25;
var_dump($unset_float); // outputs 'float(1.25)'

Array

$unset_arr[3] = "def";
var_dump($unset_arr); //  outputs array(1) {  [3]=>  string(3) "def" }

Objekt

$unset_obj->foo = 'bar';
var_dump($unset_obj); // Outputs: object(stdClass)#1 (1) {  ["foo"]=>  string(3) "bar" }

Att förlita sig på standardvärdet för en oinitialiserad variabel är problematiskt när det gäller att inkludera en fil i en annan som använder samma variabelnamn.

Truthiness och variabel värde och identisk operatör

I PHP har variabla värden en associerad "sanningighet" så att även icke-booleska värden kommer att motsvara true eller false . Detta gör att alla variabler kan användas i ett villkorat block, t.ex.

if ($var == true) { /* explicit version */ }
if ($var) { /* $var == true is implicit */ }

Här är några grundläggande regler för olika typer av variabla värden:

• Strängar med icke längd utan noll är lika med true inklusive strängar som endast innehåller vitrum såsom ' ' .
• Tomma strängar '' motsvarar false .

$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

• Heltal motsvarar true om de inte är noll, medan noll motsvarar false .

$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 motsvarar false

$var = null;
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

• Tomma strängar '' och sträng noll '0' motsvarar false .

$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

• Flytande värden motsvarar true om de inte är noll, medan nollvärden motsvarar false .
  • NAN (PHP: s Not-a-Number) motsvarar true , dvs. NAN == true är true . Detta beror på att NAN är ett flytande NAN är noll .
  • Nollvärden inkluderar både +0 och -0 enligt definitionen av IEEE 754. PHP skiljer inte mellan +0 och -0 i sin dubbelprecision flytande punkt, dvs floatval('0') == floatval('-0') är true .
    • Faktum är att floatval('0') === floatval('-0') .
    • Dessutom är både floatval('0') == false och floatval('-0') == false .

$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

IDENTISK OPERATOR

I PHP-dokumentationen för jämförande operatörer finns det en identisk operatör === . Denna operatör kan användas för att kontrollera om en variabel är identisk med ett referensvärde:

$var = null;
$var_is_null = $var === null; // true
$var_is_true = $var === true; // false
$var_is_false = $var === false; // false

Den har en motsvarande inte identisk operatör !== :

$var = null;
$var_is_null = $var !== null; // false
$var_is_true = $var !== true; // true
$var_is_false = $var !== false; // true

Den identiska operatören kan användas som ett alternativ till språkfunktioner som is_null() .

ANVÄND FALL MED strpos()

strpos($haystack, $needle) språkfunktion används för att hitta indexet där $needle förekommer i $haystack , eller om det alls inträffar. strpos() -funktionen är skiftlägeskänslig; om fall-okänslig hitta är vad du behöver kan du gå med stripos($haystack, $needle)

De strpos & stripos fungerar innehåller även tredje parameter offset (int), som om den anges, kommer att söka starta denna antal tecken räknat från början av strängen. Till skillnad från strrpos och strripos kan förskjutningen inte vara negativ

Funktionen kan returnera:

• 0 om $needle hittas i början av $haystack ;
• ett heltal utan noll som anger indexet om $needle finns någon annanstans än början i $haystack ;
• och värderar false om $needle inte finns någonstans i $haystack .

Eftersom både 0 och false har sanningsenhet false i PHP men representerar distinkta situationer för strpos() , är det viktigt att skilja mellan dem och använda samma operatör === att leta exakt efter false och inte bara ett värde som motsvarar false .

$idx = substr($haystack, $needle);
if ($idx === false) 
{
    // logic for when $needle not found in $haystack
} 
else
{
    // logic for when $needle found in $haystack
}

Alternativt använder du den inte identiska operatören:

$idx = substr($haystack, $needle);
if ($idx !== false) 
{
    // logic for when $needle found in $haystack
} 
else
{
    // logic for when $needle not found in $haystack
}