PHP
Rodzaje

Liczby całkowite

Liczby całkowite w PHP mogą być natywnie określone w bazie 2 (binarnej), bazie 8 (ósemkowej), bazie 10 (dziesiętnej) lub bazie 16 (szesnastkowej).

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

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

Liczby całkowite mają długość 32 lub 64 bitów, w zależności od platformy. Stała PHP_INT_SIZE przechowuje liczbę całkowitą w bajtach. PHP_INT_MAX i (od PHP 7.0) PHP_INT_MIN są również dostępne.

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

Wartości całkowite są tworzone automatycznie w razie potrzeby na podstawie liczb zmiennoprzecinkowych, boolean i ciągów. Jeśli potrzebny jest jawny typecast, można to zrobić za pomocą rzutowania (int) lub (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)

Przepełnienie liczb całkowitych będzie obsługiwane przez konwersję na liczbę zmiennoprzecinkową:

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

W PHP nie ma operatora dzielenia liczb całkowitych, ale można go symulować za pomocą niejawnego rzutowania, który zawsze „zaokrągla” po prostu odrzucając część zmiennoprzecinkową. Od wersji PHP 7 dodano funkcję dzielenia liczb całkowitych.

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

(Należy pamiętać, że dodatkowe nawiasy wokół (25 / 4) są potrzebne, ponieważ rzutowanie (int) ma wyższy priorytet niż podział)

Smyczki

Łańcuch w PHP to seria znaków jednobajtowych (tzn. Nie ma natywnej obsługi Unicode), którą można określić na cztery sposoby:

Pojedynczy cytat

Wyświetla rzeczy prawie całkowicie „takie, jakie są”. Zmienne i większość sekwencji specjalnych nie będą interpretowane. Wyjątkiem jest to, że aby wyświetlić dosłowny pojedynczy cudzysłów, można uciec z ukośnikiem odwrotnym, a aby wyświetlić ukośnik odwrotny, można go uciec innym ukośnikiem \

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

Dwukrotnie cytowany

W przeciwieństwie do ciągu pojedynczego cudzysłowu, oceniane będą proste nazwy zmiennych i sekwencje specjalne w ciągach. Nawiasy klamrowe (jak w ostatnim przykładzie) mogą być używane do izolowania złożonych nazw zmiennych.

$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

W łańcuchu heredoc nazwy zmiennych i sekwencje specjalne są analizowane w podobny sposób jak ciągi cudzysłowione, chociaż nawiasy klamrowe nie są dostępne dla złożonych nazw zmiennych. Początek ciągu jest ograniczony identifier <<< , a koniec identifier , gdzie identifier jest dowolną prawidłową nazwą PHP. Identyfikator końcowy musi sam pojawiać się w wierszu. Żadna spacja nie jest dozwolona przed ani po identyfikatorze, chociaż jak każda linia w PHP, musi być również zakończona średnikiem.

$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

Łańcuch nowdoc jest podobny do cytowanej wersji heredoc, chociaż nie są oceniane nawet najbardziej podstawowe sekwencje specjalne. Identyfikator na początku łańcucha jest zawinięty w pojedyncze cudzysłowy.

$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 to typ mający dwie wartości, oznaczone jako true lub false .

Ten kod ustawia wartość $foo jako true a $bar jako false :

$foo = true;
$bar = false;

true i false nie rozróżniają wielkości liter, więc TRUE i FALSE mogą być również użyte, nawet FaLsE jest możliwy. Używanie małych liter jest najbardziej powszechne i zalecane w większości przewodników po stylu kodu, np. PSR-2 .

Wartości logiczne mogą być użyte w następujących instrukcjach:

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

Z powodu tego, że PHP jest słabo wpisane, jeśli $foo powyżej jest inne niż true lub false , jest automatycznie wymuszane na wartość logiczną.
Następujące wartości powodują false :

• wartość zero: 0 (liczba całkowita), 0.0 (liczba zmiennoprzecinkowa) lub '0' (ciąg znaków)
• pusty ciąg '' lub tablica []
• null (zawartość zmiennej nieustawionej lub przypisanej do zmiennej)

Każda inna wartość daje wartość true .

Aby uniknąć tego luźnego porównania, możesz wymusić silne porównanie za pomocą === , który porównuje wartość i typ . Szczegółowe informacje zawiera porównanie typów .

Aby przekonwertować typ na wartość logiczną, możesz użyć rzutowania (bool) lub (boolean) przed typem.

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

lub wywołaj funkcję boolval :

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

Logiczna konwersja na ciąg znaków (zwróć uwagę, że false daje pusty ciąg znaków):

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

Konwersja logiczna na liczbę całkowitą:

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

Pamiętaj, że możliwe jest również odwrotnie:

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

Również wszystkie niezerowe wartości zwrócą wartość 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)

Pływak

$float = 0.123;

Z powodów historycznych „double” jest zwracane przez gettype() w przypadku liczby zmiennoprzecinkowej, a nie po prostu „zmiennoprzecinkowe”

Liczby zmiennoprzecinkowe to liczby zmiennoprzecinkowe, które umożliwiają większą precyzję wyjściową niż zwykłe liczby całkowite.

Liczby zmiennoprzecinkowe i liczby całkowite mogą być używane razem, ponieważ PHP odlewa zmienne typy:

$sum = 3 + 0.14;

echo $sum; // 3.14

php nie pokazuje liczby zmiennoprzecinkowej jako liczby zmiennoprzecinkowej, jak inne języki, na przykład:

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

Ostrzeżenie

Dokładność zmiennoprzecinkowa

(Ze strony podręcznika PHP )

Liczby zmiennoprzecinkowe mają ograniczoną precyzję. Chociaż zależy to od systemu, PHP zwykle podaje maksymalny błąd względny z powodu zaokrąglenia w kolejności od 1,11e-16. Nie elementarne operacje arytmetyczne mogą dawać większe błędy i należy uwzględnić propagację błędów, gdy kilka operacji jest złożonych.

Ponadto liczby wymierne, które są dokładnie reprezentowalne jako liczby zmiennoprzecinkowe w bazie 10, takie jak 0,1 lub 0,7, nie mają dokładnej reprezentacji jako liczby zmiennoprzecinkowe w bazie 2 (binarne), która jest używana wewnętrznie, bez względu na wielkość mantysy . Dlatego nie można ich przekształcić w ich wewnętrzne odpowiedniki binarne bez niewielkiej utraty precyzji. Może to prowadzić do mylących wyników: na przykład floor ((0,1 + 0,7) * 10) zwykle zwraca 7 zamiast oczekiwanych 8, ponieważ wewnętrzna reprezentacja będzie wyglądała jak 7.9999999999999991118 ....

Dlatego nigdy nie ufaj wynikom liczb zmiennoprzecinkowych do ostatniej cyfry i nie porównuj liczb zmiennoprzecinkowych bezpośrednio dla równości. Jeśli konieczna jest większa precyzja, dostępne są funkcje matematyczne o dowolnej precyzji i funkcje gmp.

Do wywołania

Odwołania to wszystko, co można nazwać oddzwonieniem. Rzeczy, które można nazwać „oddzwanianiem”, są następujące:

• Funkcje anonimowe

• Standardowe funkcje PHP (uwaga: nie konstrukcje językowe )

• Klasy statyczne

• Klasy niestatyczne ( przy użyciu alternatywnej składni )

• Określone metody obiektów / klas

• Same obiekty, o ile obiekt znajduje się w kluczu 0 tablicy

  Przykład odwołania się do obiektu jako elementu tablicy:

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

Oddzwanianie może być oznaczone podpowiedzi typu callable od PHP 5.4.

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

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

call_something($callable);

Zero

PHP oznacza „brak wartości” za pomocą słowa kluczowego null . Jest nieco podobny do wskaźnika zerowego w języku C i do wartości NULL w SQL.

Ustawienie zmiennej na null:

$nullvar = null; // directly

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

Sprawdzanie, czy zmienna została ustawiona na null:

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

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

Zmienna zerowa a niezdefiniowana

Jeśli zmienna nie została zdefiniowana lub została rozbrojona, wszelkie testy na wartości null zakończą się powodzeniem, ale wygenerują również komunikat 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 */ }

Dlatego niezdefiniowane wartości należy sprawdzić za pomocą isset :

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

Porównanie typów

Istnieją dwa typy porównania : luźne porównanie z == i ścisłe porównanie z === . Ścisłe porównanie zapewnia, że zarówno typ, jak i wartość obu stron operatora są takie same.

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

Możesz również użyć silnego porównania, aby sprawdzić, czy typ i wartość nie pasują do siebie za pomocą !== .

Typowym przykładem, w którym operator == jest niewystarczający, są funkcje, które mogą zwracać różne typy, takie jak strpos , który zwraca false jeśli searchword nie zostanie znalezione, a w przeciwnym razie pozycja dopasowania ( 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.

Typ Casting

PHP na ogół poprawnie zgadnie typ danych, którego zamierzasz użyć, z kontekstu, w którym jest używany, jednak czasem przydatne jest ręczne wymuszenie typu. Można tego dokonać, poprzedzając deklarację nazwą wymaganego typu w nawiasie:

$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

Ale bądź ostrożny: nie wszystkie typy rzutów działają tak, jak można się spodziewać:

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

Zasoby

Zasób jest specjalnym typem zmiennej, która odwołuje się do zasobu zewnętrznego, takiego jak plik, gniazdo, strumień, dokument lub połączenie.

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

echo gettype($file);
# Out: resource

echo $file;
# Out: Resource id #2

Istnieją różne (pod-) typy zasobów. Możesz sprawdzić typ zasobu za pomocą 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

Pełną listę wbudowanych typów zasobów można znaleźć tutaj .

Wpisz żonglerka

PHP jest słabo napisanym językiem. Nie wymaga wyraźnej deklaracji typów danych. Kontekst, w którym używana jest zmienna, określa jej typ danych; konwersja odbywa się automatycznie:

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