PHP
Zmienne

Składnia

• $ zmienna = „wartość”; // Przypisz zmienną ogólną
• $ object-> property = 'value'; // Przypisz właściwość obiektu
• ClassName :: $ property = 'value'; // Przypisz właściwość klasy statycznej
• $ array [0] = 'wartość'; // Przypisz wartość do indeksu tablicy
• $ array [] = 'wartość'; // Wciśnij element na końcu tablicy
• $ array ['key'] = 'wartość'; // Przypisz wartość tablicy
• echo $ zmienna; // Echo (wydrukuj) wartość zmiennej
• some_function ($ zmienna); // Użyj zmiennej jako parametru funkcji
• unset (zmienna $); // Odłącz zmienną
• Zmienna $$ = „wartość”; // Przypisz do zmiennej zmiennej
• isset (zmienna $); // Sprawdź, czy zmienna jest ustawiona, czy nie
• pusty (zmienna $); // Sprawdź, czy zmienna jest pusta, czy nie

Uwagi

<?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');

Dynamiczny dostęp do zmiennej według nazwy (zmienne zmienne)

Dostęp do zmiennych można uzyskać poprzez nazwy zmiennych dynamicznych. Nazwę zmiennej można zapisać w innej zmiennej, co umożliwia dynamiczny dostęp do niej. Takie zmienne są znane jako zmienne zmienne.

Aby zmienić zmienną w zmienną zmienną, umieszczasz dodatkowy $ przed swoją zmienną.

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

Zmienne zmienne są przydatne do mapowania wywołań funkcji / metod:

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

$funcName = 'add';

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

Staje się to szczególnie pomocne w klasach PHP:

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

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

Możliwe jest, ale nie jest wymagane, aby wstawić $variableName pomiędzy {} :

${$variableName} = $value;

Następujące przykłady są zarówno równoważne, jak i wyjściowe „baz”:

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

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

Użycie {} jest obowiązkowe tylko wtedy, gdy sama nazwa zmiennej jest wyrażeniem, takim jak to:

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

Niemniej jednak zaleca się zawsze używać {} , ponieważ jest bardziej czytelny.

Chociaż nie jest to zalecane, możliwe jest połączenie tego zachowania:

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

Należy zauważyć, że nadmierne użycie zmiennych zmiennych jest uważane przez wielu programistów za złą praktykę. Ponieważ nie są one dobrze przystosowane do analizy statycznej przez nowoczesne środowiska IDE, duże bazy kodu z wieloma zmiennymi zmiennymi (lub wywołaniami metod dynamicznych) mogą szybko stać się trudne do utrzymania.

Różnice między PHP5 a PHP7

Innym powodem, dla którego zawsze należy używać {} lub () , jest to, że PHP5 i PHP7 mają nieco inny sposób radzenia sobie ze zmiennymi dynamicznymi, co w niektórych przypadkach skutkuje odmiennym wynikiem.

W PHP7 zmienne dynamiczne, właściwości i metody będą teraz oceniane ściśle w kolejności od lewej do prawej, w przeciwieństwie do kombinacji specjalnych przypadków w PHP5. Poniższe przykłady pokazują, jak zmieniła się kolejność oceny.

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

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

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

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

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

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

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

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

Typy danych

Istnieją różne typy danych do różnych celów. PHP nie ma wyraźnych definicji typów, ale typ zmiennej zależy od typu przypisanej wartości lub typu, do którego jest rzutowany. Oto krótkie omówienie typów, szczegółowa dokumentacja i przykłady znajdują się w temacie Typy PHP .

Istnieją następujące typy danych w PHP: null, boolean, integer, float, string, object, resource and array.

Zero

Null można przypisać do dowolnej zmiennej. Reprezentuje zmienną bez wartości.

$foo = null;

To unieważnia zmienną i jej wartość byłaby niezdefiniowana lub nieważna, gdyby została wywołana. Zmienna jest usuwana z pamięci i usuwana przez moduł odśmiecający.

Boolean

Jest to najprostszy typ z tylko dwiema możliwymi wartościami.

$foo = true;
$bar = false;

Wartości logiczne można wykorzystać do kontrolowania przepływu kodu.

$foo = true;

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

Liczba całkowita

Liczba całkowita jest liczbą całkowitą dodatnią lub ujemną. Można go używać z dowolną bazą liczb. Rozmiar liczby całkowitej zależy od platformy. PHP nie obsługuje liczb całkowitych bez znaku.

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

Pływak

Liczby zmiennoprzecinkowe, „podwójne” lub po prostu nazywane „liczbami zmiennoprzecinkowymi” są liczbami dziesiętnymi.

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

Szyk

Tablica jest jak lista wartości. Najprostsza forma tablicy jest indeksowana liczbą całkowitą i uporządkowana według indeksu, przy czym pierwszy element znajduje się pod indeksem 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

Tablice mogą również kojarzyć wartość inną niż indeks liczby całkowitej. W PHP wszystkie tablice są tablicami asocjacyjnymi za kulisami, ale kiedy wyraźnie mówimy o „tablicy asocjacyjnej”, zwykle mamy na myśli taki, który zawiera jeden lub więcej kluczy, które nie są liczbami całkowitymi.

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

Strunowy

Ciąg jest jak tablica znaków.

$foo = "bar";

Podobnie jak tablica, ciąg może być indeksowany w celu zwrócenia jego poszczególnych znaków:

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

Obiekt

Obiekt jest instancją klasy. Do jego zmiennych i metod można uzyskać dostęp za pomocą operatora -> .

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

Ratunek

Zmienne zasobów posiadają specjalne uchwyty do otwieranych plików, połączeń z bazami danych, strumieni, obszarów obrazów i tym podobnych (jak podano w instrukcji ).

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

Aby uzyskać typ zmiennej jako ciąg, użyj funkcji gettype() :

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

Najlepsze praktyki dotyczące zmiennych globalnych

Możemy zilustrować ten problem za pomocą następującego pseudokodu

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

Twoje pierwsze pytanie tutaj jest oczywiste

Skąd wziął się $bob ?

Jesteś zmieszany? Dobry. Właśnie dowiedziałeś się, dlaczego globale są mylące i uważałeś za złą praktykę .

Gdyby to był prawdziwy program, twoja kolejna frajda to śledzenie wszystkich wystąpień $bob i mieć nadzieję, że znajdziesz właściwy (pogorszy się, jeśli $bob jest używany wszędzie). Co gorsza, jeśli ktoś inny przejdzie i zdefiniuje $bob (lub zapomnisz i ponownie użyłeś tej zmiennej), twój kod może się zepsuć (w powyższym przykładzie kodu, posiadanie niewłaściwego obiektu lub brak obiektu spowoduje błąd krytyczny).

Ponieważ praktycznie wszystkie programy PHP wykorzystują kod taki jak include('file.php'); Twoje zadanie utrzymywania takiego kodu staje się wykładniczo trudniejsze wraz ze wzrostem liczby dodawanych plików.

Utrudnia to również testowanie aplikacji. Załóżmy, że używasz zmiennej globalnej do utrzymywania połączenia z bazą danych:

$dbConnector = new DBConnector(...);

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

Aby przetestować tę funkcję w jednostce, musisz przesłonić globalną zmienną $dbConnector , uruchomić testy, a następnie zresetować ją do pierwotnej wartości, która jest bardzo podatna na błędy:

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

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

     assertTrue(foo());

     $dbConnector = $bkp; // Restore
}

Jak unikamy globałów?

Najlepszym sposobem na uniknięcie globalizacji jest filozofia o nazwie Dependency Injection . W tym miejscu przekazujemy potrzebne narzędzia do funkcji lub klasy.

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

Jest to o wiele łatwiejsze do zrozumienia i utrzymania. Nie ma zgadywania, gdzie został ustawiony $bob , ponieważ dzwoniący jest odpowiedzialny za to, aby wiedzieć (przekazuje nam to, co musimy wiedzieć). Co więcej, możemy użyć deklaracji typu, aby ograniczyć to, co jest przekazywane.

Wiemy więc, że $bob jest albo instancją klasy Bar , albo instancją potomka Bar , co oznacza, że wiemy, że możemy korzystać z metod tej klasy. W połączeniu ze standardowym autoloaderem (dostępnym od PHP 5.3) możemy teraz prześledzić, gdzie zdefiniowany jest Bar . PHP 7.0 lub nowszy zawiera deklaracje typu rozszerzonego, w których można również używać typów skalarnych (takich jak int lub string ).

Uzyskiwanie wszystkich zdefiniowanych zmiennych

get_defined_vars() zwraca tablicę ze wszystkimi nazwami i wartościami zmiennych zdefiniowanych w zakresie, w którym wywoływana jest funkcja. Jeśli chcesz wydrukować dane, możesz użyć standardowych funkcji do wysyłania danych czytelnych dla ludzi, takich jak print_r lub var_dump .

var_dump(get_defined_vars());

Uwaga : Ta funkcja zwykle zwraca tylko 4 superglobale : $_GET , $_POST , $_COOKIE , $_FILES . Inne superglobale są zwracane tylko wtedy, gdy zostały użyte gdzieś w kodzie. Wynika to z dyrektywy auto_globals_jit która jest domyślnie włączona. Po włączeniu zmienne $_SERVER i $_ENV są tworzone, gdy są używane po raz pierwszy (Just In Time), a nie podczas uruchamiania skryptu. Jeśli te zmienne nie są używane w skrypcie, włączenie tej dyrektywy spowoduje wzrost wydajności.

Domyślne wartości niezainicjowanych zmiennych

Chociaż nie jest to konieczne w PHP, bardzo dobrą praktyką jest inicjowanie zmiennych. Niezainicjowane zmienne mają domyślną wartość swojego typu w zależności od kontekstu, w którym są używane:

Unset AND unreferenced

var_dump($unset_var); // outputs NULL

Boolean

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

Strunowy

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

Liczba całkowita

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

Float / double

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

Szyk

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

Obiekt

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

Poleganie na domyślnej wartości niezainicjowanej zmiennej jest problematyczne w przypadku włączenia jednego pliku do innego, który używa tej samej nazwy zmiennej.

Zmienna wartość Prawdziwość i operator identyczny

W PHP zmienne wartości mają przypisaną „truthiness” więc nawet wartości niż wartość logiczna będzie równoznaczny z true lub false . Pozwala to na użycie dowolnej zmiennej w bloku warunkowym, np

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

Oto kilka podstawowych zasad dla różnych typów wartości zmiennych:

• Ciągi o niezerowej długości są równe true tym ciągi zawierające tylko białe znaki, takie jak ' ' .
• Puste łańcuchy '' oznaczają 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

• Liczby całkowite są równe true jeśli są niezerowe, a zero równa się 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 oznacza false

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

• Puste ciągi '' i ciąg zerowy '0' oznaczają 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

• Wartości zmiennoprzecinkowe są równe true jeśli są niezerowe, podczas gdy wartości zerowe są równe false .
  • NAN (PHP nie jest liczbą) odpowiada true , tzn. NAN == true jest true . Wynika to z faktu, że NAN jest niezerową wartością zmiennoprzecinkową.
  • Wartości zerowe obejmują zarówno +0, jak i -0 zgodnie z definicją IEEE 754. PHP nie rozróżnia +0 i -0 w zmiennoprzecinkowym podwójnej precyzji, tj. floatval('0') == floatval('-0') jest true .
    • W rzeczywistości floatval('0') === floatval('-0') .
    • Dodatkowo zarówno floatval('0') == false i 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

IDENTYCZNY OPERATOR

W dokumentacji PHP dla operatorów porównania jest identyczny operator === . Tego operatora można użyć do sprawdzenia, czy zmienna jest identyczna z wartością odniesienia:

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

Ma odpowiadający nie identyczny operator !== :

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

Identyczny operator może być użyty jako alternatywa dla funkcji językowych takich jak is_null() .

WYKORZYSTAJ strpos() Z strpos()

Funkcja strpos($haystack, $needle) służy do zlokalizowania indeksu, w którym $needle występuje w $haystack lub czy w ogóle występuje. W funkcji strpos() rozróżniana jest strpos() liter; jeśli szukanie bez rozróżniania wielkości liter jest tym, czego potrzebujesz, możesz użyć stripos($haystack, $needle)

Funkcja strpos i stripos zawiera również offset trzeciego parametru (int), które, jeśli zostanie określone, rozpocznie wyszukiwanie liczby znaków liczonych od początku łańcucha. W przeciwieństwie do strrpos i strripos, przesunięcie nie może być ujemne

Funkcja może zwrócić:

• 0 jeśli $needle zostanie znaleziona na początku $haystack ;
• niezerowa liczba całkowita określająca indeks, jeśli $needle zostanie znaleziona gdzieś indziej niż na początku w $haystack ;
• i wartość false jeśli $needle nie znaleziono nigdzie w $haystack .

Ponieważ zarówno 0 i false mają truthiness false w PHP, ale reprezentują różne sytuacje dla strpos() , ważne jest rozróżnienie między nimi i korzystać z identyczną operatora === patrzeć dokładnie na false , a nie tylko wartość, która przekłada się na false .

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

Alternatywnie, używając nie identycznego operatora:

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