From 16bc8e8a2aee74cf1b10ac0c4361bb48447f0038 Mon Sep 17 00:00:00 2001 From: Maciej Sobaczewski Date: Tue, 31 Dec 2024 05:16:27 +0100 Subject: [PATCH] Translate the /language/types/ section --- README.md | 54 +- language/types.xml | 158 +++ language/types/array.xml | 1509 +++++++++++++++++++++++ language/types/boolean.xml | 171 +++ language/types/callable.xml | 184 +++ language/types/declarations.xml | 797 ++++++++++++ language/types/enumerations.xml | 77 ++ language/types/float.xml | 190 +++ language/types/integer.xml | 301 +++++ language/types/iterable.xml | 65 + language/types/mixed.xml | 44 + language/types/never.xml | 40 + language/types/null.xml | 80 ++ language/types/numeric-strings.xml | 156 +++ language/types/object.xml | 103 ++ language/types/relative-class-types.xml | 56 + language/types/resource.xml | 68 + language/types/singleton.xml | 48 + language/types/string.xml | 1382 +++++++++++++++++++++ language/types/type-juggling.xml | 469 +++++++ language/types/type-system.xml | 227 ++++ language/types/void.xml | 41 + 22 files changed, 6195 insertions(+), 25 deletions(-) create mode 100644 language/types.xml create mode 100644 language/types/array.xml create mode 100644 language/types/boolean.xml create mode 100644 language/types/callable.xml create mode 100644 language/types/declarations.xml create mode 100644 language/types/enumerations.xml create mode 100644 language/types/float.xml create mode 100644 language/types/integer.xml create mode 100644 language/types/iterable.xml create mode 100644 language/types/mixed.xml create mode 100644 language/types/never.xml create mode 100644 language/types/null.xml create mode 100644 language/types/numeric-strings.xml create mode 100644 language/types/object.xml create mode 100644 language/types/relative-class-types.xml create mode 100644 language/types/resource.xml create mode 100644 language/types/singleton.xml create mode 100644 language/types/string.xml create mode 100644 language/types/type-juggling.xml create mode 100644 language/types/type-system.xml create mode 100644 language/types/void.xml diff --git a/README.md b/README.md index f842cf84..9f4f5b52 100644 --- a/README.md +++ b/README.md @@ -144,31 +144,35 @@ w dokumentacji PHP. > więc do momentu osiągnięcia ewentualnego konsensusu w sprawie nowego tłumaczenia, stosujmy się do tych, które już są > używane w polskiej wersji i zostały wymienione poniżej. -| Angielski wyraz lub wyrażenie | Polskie tłumaczenie | Komentarz | -|-----------------------------------------------|-------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| constructor property promotion | automatyczne tworzenie właściwości | Pomimo wielu poszukiwań nie znalazłem żadnego tłumaczenia w polskim internecie. To tylko moja radosna twórczość, jestem otwarty na lepsze propozycje | -| handler | funkcja obsługi | | -| Locale settings | Ustawienia regionalne (locale) | Jako iż nie ma powszechnie używanego tłumaczenia na j. polski to zawieramy też oryginalne słówko, aby ułatwić np. Googlowanie | -| locale-dependent / locale-specific | z uwzględnieniem ustawień regionalnych (locale) | | -| locale-independent | bez uwzględnienia ustawień regionalnych (locale) | | -| null-coalescing operator | - | Nie jest mi znane żadne tłumaczenie, tym bardziej żadne powszechnie zrozumiałe | -| property | właściwość | W kontekście właściwości klas | -| scope | zasięg | W kontekście zmiennych | -| string | ciąg znaków | Ewentualnie _łańcuch znaków_, jeśli gdzieś chcemy uniknąć powtórzeń | -| trait, traits | trait, traity | Brak tłumaczenia, jedynie polska odmiana | -| variable variables | zmienne zmiennych | | -| will generate deprecation notice | wygeneruje komunikat `E_DEPRECATED` | | -| `E_WARNING` is raised | generowane jest ostrzeżenie (`E_WARNING`) | | -| `foo` | Parametr `foo` | Poprzedzić słowem "parametr" przynajmniej przy pierwszym opisywaniu danego parametru na danej stronie. W przeciwnym razie dostajemy mieszkankę polskiego i angielskiego, która nie zawsze jest zrozumiała | -| `foo` is nullable now | Parametr `foo dopuszcza teraz &null; | | -| `bar` example | Przykład użycia `bar` | W tytułach większości przykładów | -| `&array;` | `Tablica` | Nie zawsze warto tłumaczyć, patrz pkt. 4 poniżej | -| `&bool;` | `Wartość logiczna` | Nie zawsze warto tłumaczyć, patrz pkt. 4 poniżej | -| `&float;` | `Liczba zmiennoprzecinkowa` | Nie zawsze warto tłumaczyć, patrz pkt. 4 poniżej | -| `&integer;` | `Liczba` | Czasami też "liczba całkowita". Nie zawsze warto tłumaczyć, patrz pkt. 4 poniżej | -| `&object;` | `Obiekt` | Nie zawsze warto tłumaczyć, patrz pkt. 4 poniżej | -| `&resource;` | `Zasób` | Nie zawsze warto tłumaczyć, patrz pkt. 4 poniżej | -| `&string;` | `Ciąg znaków` | Nie zawsze warto tłumaczyć, patrz pkt. 4 poniżej | +| Angielski wyraz lub wyrażenie | Polskie tłumaczenie | Komentarz | +|----------------------------------------------|-------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| coercive typing | luźne typowanie | Odnosi się do trybu, w którym działa system typów PHP (strict types vs. coercive typing); prawdopodobnie jest to dalekie od poprawnego tłumaczenia | +| constructor property promotion | automatyczne tworzenie właściwości | Pomimo wielu poszukiwań nie znalazłem żadnego tłumaczenia w polskim internecie. To tylko moja radosna twórczość, jestem otwarty na lepsze propozycje | +| first class callable syntax | Obsługa callable przy użyciu dedykowanej składni (first-class) | Podałem najbardziej rozbudowane tłumaczenie, używane np. jako pełen nagłówek opisujący tę funkcjonalność. Oczywiście w wielu kontekstach wystarczy krótsza forma, np. "dedykowana składnia" | +| handler | funkcja obsługi | | +| intersection types | typy przecinające się? | Bardzo możliwe, że lepiej po prostu tego nie tłumaczyć. Na razie dorzucam zawsze oryginalny termin w nawiasie | +| Locale settings | Ustawienia regionalne (locale) | Jako iż nie ma powszechnie używanego tłumaczenia na j. polski to zawieramy też oryginalne słówko, aby ułatwić np. Googlowanie | +| locale-dependent / locale-specific | z uwzględnieniem ustawień regionalnych (locale) | | +| locale-independent | bez uwzględnienia ustawień regionalnych (locale) | | +| null-coalescing operator | - | Nie jest mi znane żadne tłumaczenie, tym bardziej żadne powszechnie zrozumiałe | +| property | właściwość | W kontekście właściwości klas | +| scope | zasięg | W kontekście zmiennych | +| string | ciąg znaków | Ewentualnie _łańcuch znaków_, jeśli gdzieś chcemy uniknąć powtórzeń | +| trait, traits | trait, traity | Brak tłumaczenia, jedynie polska odmiana | +| type juggling | dopasowywanie typów | Dosłowne tłumaczenie "żonglowanie typami" nie istnieje nigdzie w wynikach Google, więc "dopasowywanie typów" przynajmniej daje okazję zrozumieć o czym mowa | +| variable variables | zmienne zmiennych | | +| will generate deprecation notice | wygeneruje komunikat `E_DEPRECATED` | | +| `E_WARNING` is raised | generowane jest ostrzeżenie (`E_WARNING`) | | +| `foo` | Parametr `foo` | Poprzedzić słowem "parametr" przynajmniej przy pierwszym opisywaniu danego parametru na danej stronie. W przeciwnym razie dostajemy mieszkankę polskiego i angielskiego, która nie zawsze jest zrozumiała | +| `foo` is nullable now | Parametr `foo dopuszcza teraz &null; | | +| `bar` example | Przykład użycia `bar` | W tytułach większości przykładów | +| `&array;` | `Tablica` | Nie zawsze warto tłumaczyć, patrz pkt. 4 poniżej | +| `&bool;` | `Wartość logiczna` | Nie zawsze warto tłumaczyć, patrz pkt. 4 poniżej | +| `&float;` | `Liczba zmiennoprzecinkowa` | Nie zawsze warto tłumaczyć, patrz pkt. 4 poniżej | +| `&integer;` | `Liczba` | Czasami też "liczba całkowita". Nie zawsze warto tłumaczyć, patrz pkt. 4 poniżej | +| `&object;` | `Obiekt` | Nie zawsze warto tłumaczyć, patrz pkt. 4 poniżej | +| `&resource;` | `Zasób` | Nie zawsze warto tłumaczyć, patrz pkt. 4 poniżej | +| `&string;` | `Ciąg znaków` | Nie zawsze warto tłumaczyć, patrz pkt. 4 poniżej | ### Inne porady dot. tłumaczenia diff --git a/language/types.xml b/language/types.xml new file mode 100644 index 00000000..0905df15 --- /dev/null +++ b/language/types.xml @@ -0,0 +1,158 @@ + + + + Typy + + + Wprowadzenie + + + Każde jedno wyrażenie w PHP ma jeden z następujących + wbudowanych typów, zależnie od jego wartości: + + null + bool + int + float (liczba zmiennoprzecinkowa) + string + array + object + callable + resource + + + + + PHP jest językiem typowanym dynamicznie, co oznacza, że domyślnie nie ma + potrzeby określania typu zmiennej, bo będzie on określony w + trakcie wykonywania kodu. Jednakże jest możliwe statyczne otypowanie niektórych elementów + języka używając + deklaracji typu. + Różne typy wspierane przez system typowania PHP można znaleźć na + stronie o systemie typowania. + + + + Typy określają rodzaj operacji, który można na nich wykonać. + Jednak jeśli wyrażenie lub zmienna są użyte w operacji, która + nie jest wspierana przez ich typ, PHP spróbuje wykonać + dopasowanie typów + wartości tak, aby uzyskać obsługujący daną operację. + Ten proces zależy od kontekstu, w którym użyta jest wartość. + Aby dowiedzieć się więcej na ten temat, możesz przeczytać sekcję + o Żonglowaniu typami. + + + + + Przydatne mogą być też tablice porównań typów, + które zawierają najróżniejsze przykłady porównań między wartościami + różnych typów. + + + + + + Można wymusić aby wyrażenie było skonwertowane na określony typ używając + rzutowania typu. + Zmienna może być też zrzutowana poprzez użycie na niej + funkcji settype. + + + + + Aby sprawdzić wartość i typ + wyrażenia + użyj funkcji var_dump. + Aby pobrać tylko typ + wyrażenia + użyj funkcji get_debug_type. + Jednak jeśli chcesz sprawdzić, czy wyrażenie ma określony typ, to skorzystaj + z jednej z funkcji is_typ. + + + + +]]> + + &example.outputs.8; + + + + + + + + Przez PHP 8.0.0, gdzie funkcja get_debug_type nie jest + dostępna, można skorzystać z funkcji gettype. + Nie używa ona jednak podstawowych nazw typów. + + + + + &language.types.type-system; + &language.types.null; + &language.types.boolean; + &language.types.integer; + &language.types.float; + &language.types.string; + &language.types.numeric-strings; + &language.types.array; + &language.types.object; + &language.types.enumerations; + &language.types.resource; + &language.types.callable; + &language.types.mixed; + &language.types.void; + &language.types.never; + &language.types.relative-class-types; + &language.types.singleton; + &language.types.iterable; + &language.types.declarations; + &language.types.type-juggling; + + + diff --git a/language/types/array.xml b/language/types/array.xml new file mode 100644 index 00000000..de7383d9 --- /dev/null +++ b/language/types/array.xml @@ -0,0 +1,1509 @@ + + + + Tablice + + + Tablica (array) w PHP to tak naprawdę posortowana mapa. Mapa to typ, który + przepisuje wartość do kluczy (klucze są też nazywane indeksami). Ten typ + jest zoptymalizowany dla kilku różnych przypadków; może być traktowany jako tablica, + lista (wektor), hash table (implementację mapy), słownik, + kolekcja, stos kolejka i prawdopodobnie więcej. Jako że wartościami tablicy + mogą być inne tablice, możliwe jest tworzenie drzew i wielowymiarowych + tablic. + + + + Wyjaśnienie tych typów danych wykracza poza zakres tego podręcznika, ale + dla każdego z nich podano przynajmniej jeden przykład. Aby dowiedzieć się więcej, + szukaj uznanej literatury dotyczącej tego rozbudowanego tematu. + + + + Składnia + + + Określanie przy użyciu <function>array</function> + + + Tablica może być stworzona używając konstrukcji języka array. + Przyjmuje ona dowolną liczbę par + klucz => wartość + oddzielonych przecinkami jako argumenty. + + + +array( + klucz => wartość, + klucz2 => wartość2, + klucz3 => wartość3, + ... +) + + + + Przecinek po ostatnim elemencie tablicy jest opcjonalny i można go pominąć. Pomija się go zwykle + dla tablic definiowanych w jednej linii, np. array(1, 2) zamiast + array(1, 2, ). Dla tablic deklarowanych w wielu liniach użycie końcowego przecinka + jest powszechne, bo pozwala na łatwiejsze dodawanie nowych elementów na końcu tablicy. + + + + + Istnieje skrócona składnia tablic, która zamienia + array() na []. + + + + + Prosta tablica + + "bar", + "bar" => "foo", +); + +// Używając skróconej składni +$tablica = [ + "foo" => "bar", + "bar" => "foo", +]; +?> +]]> + + + + + Klucz może być liczbą całkowitą (int) + lub ciągiem znaków (string). Wartość może być + dowolnego typu. + + + + Ponadto wystąpią następujące rzutowania typu klucza: + + + + Ciągi znaków (string) zawierające poprawną liczbę w systemie dziesiętnym będą zrzutowane na + liczbę całkowitą (int), chyba, że liczba jest poprzedzona znakiem +. Na przykład klucz "8" będzie + tak naprawdę zachowany jako 8. Z drugiej strony "08" nie będzie + zrzutowany, ponieważ nie jest poprawną liczbą w systemie dziesiętnym. + + + + + Liczby zmiennoprzecinkowe (float) także są rzutowane na liczby całkowite, co oznacza, że + część ułamkowa jest ucinana. Na przykład klucz 8.7 zostanie tak naprawdę + zachowany jako 8. + + + + + Wartości logiczne (bool) też są rzutowane na liczby całkowite, tj. klucz + &true; zostanie tak naprawdę zapisany jako 1 + a klucz &false; jako 0. + + + + + Null zostanie zrzutowany na pusty ciąg znaków, a więc klucz + null zostanie tak naprawdę zapisany jako "". + + + + + Tablice i obiekty nie mogą być używane jako klucze. + W takim razie zostanie pokazanie ostrzeżenie: Illegal offset type. + + + + + + + Jeżeli wiele elementów tablicy używa tego samego klucza, to tylko ostatni z nich + zostanie użyty, bo wszystkie wcześniejsze zostaną nadpisane. + + + + Przykład rzutowania typów i nadpisywania + + "a", + "1" => "b", + 1.5 => "c", + true => "d", +); +var_dump($tablica); +?> +]]> + + &example.outputs; + + + string(1) "d" +} +]]> + + + Jako że wszystkie klucze w powyższym przykładzie są rzutowane do 1 wartość będzie nadpisywana + przy każdym nowym elemencie, a ostatnia przypisana wartość "d" będzie jedną użytą. + + + + + Tablice PHP mogą zawierać klucze o typach int oraz string jednocześnie, + jako że PHP nie ma rozróżnienia między tablicami indeksowanymi i asocjacyjnymi. + + + + Wymieszane klucze <type>int</type> i <type>string</type> + + "bar", + "bar" => "foo", + 100 => -100, + -100 => 100, +); +var_dump($tablica); +?> +]]> + + &example.outputs; + + + string(3) "bar" + ["bar"]=> + string(3) "foo" + [100]=> + int(-100) + [-100]=> + int(100) +} +]]> + + + + + Klucz jest opcjonalny. Jeśli nie jest określony, PHP zwiększy + o jeden największy ostatnio użyty klucz numeryczny. + + + + Indeksowane tablice bez klucza + + +]]> + + &example.outputs; + + + string(3) "foo" + [1]=> + string(3) "bar" + [2]=> + string(5) "hello" + [3]=> + string(5) "world" +} +]]> + + + + + Można określić klucz tylko dla niektórych elementów i pominąć go dla innych: + + + + Klucz nie dla wszystkich elementów + + "c", + "d", +); +var_dump($tablica); +?> +]]> + + &example.outputs; + + + string(1) "a" + [1]=> + string(1) "b" + [6]=> + string(1) "c" + [7]=> + string(1) "d" +} +]]> + + + Jak widać ostatnia wartość "d" została przypisana do klucza + 7. Stało się tak, ponieważ największym kluczem liczbowym użytym wcześniej + był 6. + + + + + Złożony przykład rzutowania typów i nadpisywania + + Ten przykład zawiera wszystkie odmiany rzutowania typów kluczy i nadpisywania + elementów. + + + 'a', + '1' => 'b', // wartość "a" będzie nadpisana przez "b" + 1.5 => 'c', // wartość "b" będzie nadpisana przez "c" + -1 => 'd', + '01' => 'e', // jako że nie jest to numeryczny ciąg znaków, to NIE nadpisze on klucza 1 + '1.5' => 'f', // jako że nie jest to numeryczny ciąg znaków, to NIE nadpisze on klucza 1 + true => 'g', // wartość "c" zostanie nadpisana przez "g" + false => 'h', + '' => 'i', + null => 'j', // wartość "i" zostanie nadpisana przez "j" + 'k', // wartość "k" ma przypisany klucz 2. Dzieje się tak, bo największy klucz numeryczny użyty wcześniej to 1 + 2 => 'l', // wartość "k" zostanie nadpisana przez "l" +); + +var_dump($tablica); +?> +]]> + + &example.outputs; + + + string(1) "g" + [-1]=> + string(1) "d" + ["01"]=> + string(1) "e" + ["1.5"]=> + string(1) "f" + [0]=> + string(1) "h" + [""]=> + string(1) "j" + [2]=> + string(1) "l" +} +]]> + + + + + Przykład indeksów ujemnych + + Jeśli przypisany zostanie ujemny klucz n PHP przypisze następny + klucz jako n+1. + + + +]]> + + &example.outputs; + + + int(1) + [-4]=> + int(2) +} +]]> + + + + + Przed PHP 8.3.0 przypisanie ujemnego klucza n przypisałoby + następnie klucz 0, więc poprzedni przykład + wyświetliłby:: + + + + + int(1) + [0]=> + int(2) +} +]]> + + + + + + + + Dostęp do elementów tablicy przy użyciu nawiasów kwadratowych + + + Dostęp do elementów tablicy można uzyskać używając składni tablica[klucz]>. + + + + Dostęp do elementów tablicy + + "bar", + 42 => 24, + "wielo" => array( + "wymiarowa" => array( + "tablica" => "foo" + ) + ) +); + +var_dump($tablica["foo"]); +var_dump($tablica[42]); +var_dump($tablica["wielo"]["wymiarowa"]["tablica"]); +?> +]]> + + &example.outputs; + + + + + + + + Przed PHP 8.0.0 można było wymiennie używać nawiasów kwadratowych i klamrowych + dla uzyskania dostępu do elementów tablicy (np. $tablica[42] i $tablica{42} + działałyby tak samo). + Składnia z nawiasami klamrowymi została uznana za przestarzałą od PHP 7.4.0 a od PHP 8.0.0 nie jest już obsługiwana. + + + + + Dereferencja tablic + + +]]> + + + + + + Próba dostępu do klucza tablicy, który nie został zdefiniowany działa + tak samo jak dostęp do dowolnej innej niezdefiniowanej zmiennej: + zostanie pokazane ostrzeżenie E_WARNING + (lub E_NOTICE przed PHP 8.0.0), + a wynikiem będzie &null;. + + + + + Dereferencja wartości skalarnej z tablicy, która nie jest ciągiem znaków, + skutkuje typem &null;. Przed PHP 7.4.0 nie powodowało to wiadomości błędu. + Od PHP 7.4.0 powoduje to komunikat E_NOTICE, + a od PHP 8.0.0 ostrzeżenie E_WARNING. + + + + + + Tworzenie lub modyfikacja wartości używając nawiasów kwadratowych + + + Istniejące tablice mogą być modyfikowane, jeśli wprost ustawimy wartości + w nich zawarte. + + + + Można to uzyskać przez przypisanie wartości do tablicy, określając + klucz w nawiasach kwadratowych. Klucz można też pominąć, czyli użyć pustej pary + nawiasów kwadratowych ([]). + + + +$tablica[klucz] = wartość; +$tablica[] = wartość; +// klucz może być typu int lub string +// wartość może być dowolnego typu + + + Jeżeli zmienna tablica nie istnieje lub jest ustawiona na &null; lub &false; to zostanie utworzona, więc + jest to też alternatywny sposób tworzenia tablicy. Ta praktyka + nie jest jednak zalecana, ponieważ jeśli $tablica zawiera już + jakąś wartość (np. string) to ta wartość w niej pozostanie a [] może zostać zinterpretowane + jako operator dostępu do + ciągu znaków. Zawsze lepiej jest utworzyć zmienną używając bezpośredniego + przypisania. + + + + Od PHP 7.1.0 użycie pustego operatora klucza ([]) na ciągu znaków powoduje błąd + krytyczny. Wcześniej ciąg znaków był po cichu konwertowany na tablicę bez zgłoszenia żadnego błędu. + + + + + Od PHP 8.1.0 tworzenie nowej tablicy z wartości &false; jest przestarzałe. + Tworzenie nowej tablicy z &null; i niezdefiniowanych wartości wciąż jest dozwolone. + + + + + Aby zmienić określoną + wartość przypisz wartość temu elementowi używając jej klucza. Aby usunąć + parę klucz/wartość, użyj na niej funkcji unset. + + + + + 1, 12 => 2); + +$tablica[] = 56; // Równoznaczne z użyciem $tablica[13] = 56; + // w tym miejscu skryptu + +$tablica["x"] = 42; // Dodaje nowy element do + // tablicy z kluczem "x" + +unset($tablica[5]); // Usuwa element z tablicy + +unset($tablica); // Usuwa całą tablicę +?> +]]> + + + + + + Jak wspomniano wyżej, jeśli klucz nie jest określony, to używany jest największy z istniejących + kluczy numerycznych, a nowym kluczem będzie ta maksymalna wartość + plus 1 (ale nie mniej niż 0). Jeśli nie istnieje jeszcze żaden indeks numeryczny, to kluczem + będzie 0 (zero). + + + + Zwróć uwagę, że maksymalny klucz używany do tego nie musi + obecnie istnieć w tablicy. Musiał on tylko istnieć + w tablicy w chwili kiedy tablica była + ostatnio przeindeksowana. Pokazuje to poniższy przykład: + + + + + $wartosc) { + unset($tablica[$i]); +} +print_r($tablica); + +// Przypisz element (zauważ, że nowym kluczem jest 5 a nie 0). +$tablica[] = 6; +print_r($tablica); + +// Przeindeksuj tablicę: +$tablica = array_values($tablica); +$tablica[] = 7; +print_r($tablica); +?> +]]> + + &example.outputs; + + 1 + [1] => 2 + [2] => 3 + [3] => 4 + [4] => 5 +) +Array +( +) +Array +( + [5] => 6 +) +Array +( + [0] => 6 + [1] => 7 +) +]]> + + + + + + + + + Destrukturyzacja tablicy + + + Tablice można destrukturyzować używając [] (od PHP 7.1.0) lub + konstrukcji językowej list. Te + konstrukcje mogą być użyte do destrukturyzacji tablicy do zmiennych. + + + + + +]]> + + + + + Destrukturyzacja tablicy może być użyta w &foreach; aby zdestrukturyzować + wielowymiarową tablicę w trakcie iterowania po niej. + + + + + +]]> + + + + + Elementy tablicy będą zignorowane jeśli nie została podana zmienna. Destrukturyzacja + tablicy zawsze zaczyna się od indeksu 0. + + + + + +]]> + + + + + Od PHP 7.1.0 tablice asocjacyjne też mogą być destrukturyzowane. Pozwala + to też na prostszy wybór właściwego elementu z tablic indeksowanych numerycznie, + ponieważ indeks można podać wprost. + + + + + 1, 'bar' => 2, 'baz' => 3]; + +// Przypisz element z kluczem "bar" do zmiennej $three +['baz' => $three] = $tablica_zrodlowa; + +echo $three; // wyświetla 3 + +$tablica_zrodlowa = ['foo', 'bar', 'baz']; + +// Przypisz element z kluczem 2 do zmiennej $baz +[2 => $baz] = $tablica_zrodlowa; + +echo $baz; // wyświetla "baz" +?> +]]> + + + + + Destrukturyzacji tablicy można użyć też dla łatwej zamiany dwóch zmiennych. + + + + + +]]> + + + + + + Operator spread (...) nie jest obsługiwany przy przypisywaniu. + + + + + + Próba dostępu do klucza tablicy, który nie został zdefiniowany działa + tak samo jak dostęp do dowolnej innej niezdefiniowanej zmiennej: + zostanie pokazane ostrzeżenie E_WARNING + (lub E_NOTICE przed PHP 8.0.0), + a wynikiem będzie &null;. + + + + + + + + Przydatne funkcje + + + Istnieje sporo funkcji przydatnych przy pracy z tablicami. Zobacz + sekcję funkcje tablicowe. + + + + + Funkcja unset pozwala na usuwanie kluczy z + tablicy. Pamiętaj, że tablica nie zostanie + przeindeksowana. Jeśli chcesz usunąć wartość i przeindeksować tablicę, + możesz po usunięciu użyć funkcji + array_values. + + + + + 'raz', 2 => 'dwa', 3 => 'trzy'); +unset($a[2]); +/* stworzy tablicę, którą zdefiniowalibyśmy następująco + $a = array(1 => 'raz', 3 => 'trzy'); + a NIE + $a = array(1 => 'raz', 2 =>'trzy'); +*/ + +$b = array_values($a); +// Teraz tablica $b to array(0 => 'raz', 1 =>'trzy') +?> +]]> + + + + + + Struktura kontrolna &foreach; + została stworzona specjalnie dla tablic. Pozwala na + przechodzenie po tablicy w łatwy sposób. + + + + + Co robić i czego nie robić z tablicami + + + Czemu <literal>$foo[bar]</literal> jest złe? + + + Zawsze używaj cudzysłowów lub apostrofów wokół ciągu znaków reprezentującego dosłowny klucz tablicy. Na przyklad + $foo['bar'] jest poprawne, a + $foo[bar] nie jest. Dlaczego? W starszych skryptach wciąż + można znaleźć tego typu składnię: + + + + + +]]> + + + + + To działa, ale jest niepoprawne. Ten kod ma niezdefiniowaną + stałą (bar) a nie ciąg znaków ('bar' - zwróć uwagę na + apostrofy). Działa to tylko dlatego, że PHP automatycznie konwertuje + nieosłonięty ciąg znaków (ciąg znaków bez cudzysłowów/apostrofów, który + nie odnosi się do żadnego znanego symbolu) na string, który + zawiera ten nieosłonięty ciąg znaków. Na przykład, jeśli w skrypcie + nie została zdefiniowana stała nazywająca się bar, to PHP podstawi + w jej miejsce ciąg znaków 'bar'. + + + + Ten awaryjny sposób traktowania niezdefiniowanych stałych jako nieosłoniętych ciągów znaków powoduje błąd + poziomu E_NOTICE. + Jest to przestarzałe od PHP 7.2.0 i powoduje błąd + poziomu E_WARNING. + Od PHP ta funkcjonalność została usunięta i rzuca + wyjątek typu Error. + + + + + + Nie oznacza to, że musisz zawsze używać apostrofów/cudzysłowów wokół klucza. Nie + używaj ich jeśli klucze są stałymi lub + zmiennymi, ponieważ w ten sposób + uniemożliwisz PHP zinterpretowanie ich. + + + + + +]]> + + + &example.outputs; + + + + + + + Więcej przykładów pokazujących to zachowanie: + + + + + 'jabłko', 'warzywo' => 'marchewka'); + +// Poprawnie +print $tablica['owoc']; // jabłko +print $tablica['warzywo']; // marchewka + +// Niepoprawnie. Działa, ale PHP pokazuje błąd o poziomie E_NOTICE, ze względu +// na niezdefiniowaną stałą nazwaną owoc +// +// Notice: Use of undefined constant owoc - assumed 'owoc' in... +print $tablica[owoc]; // jabłko + +// Zdefiniujmy stała aby pokazać co się dzieje. Od teraz do stałej +// nazywającej się owoc przypisujemy wartość 'warzywo'. +define('owoc', 'warzywo'); + +// Zwróć uwagę na różnicę +print $tablica['owoc']; // jabłko +print $tablica[owoc]; // marchewka + +// Poniższe jest poprawne ponieważ występuje w ciągu znaków. Wyszukiwanie stałych +// nie odbywa się wewnątrz ciągu znaków, więc tu nie wystąpi E_NOTICE +print "To jest $tablica[owoc]"; // To jest jabłko + +// Z jednym wyjątkiem: nawiasy okalające tablice wewnątrz ciągów znaków pozwalają +// na interpretowanie stałych +print "To jest {$tablica[owoc]}"; // To jest marchewka +print "To jest {$tablica['owoc']}"; // To jest jabłko + +// Poniższe nie zadziała i będzie skutkowało błędem parsowania tego typu: +// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING' +// Odnosi się to oczywiście także do używania superglobalnych wewnątrz ciągów znaków +print "To jest $tablica['owoc']"; +print "To jest $_GET['foo']"; + +// Konkatenacja też jest możliwa +print "To jest " . $tablica['owoc']; // To jest jabłko +?> +]]> + + + + + Jeśli dyrektywa error_reporting jest ustawiona tak, + by pokazywać błędy o poziomie E_NOTICE (czyli na przykład + na E_ALL), to takie przypadki będą natychmiast + widoczne. Domyślnie + error_reporting nie pokazuje + takich komunikatów. + + + + Jak wspomniano w sekcji o składni, + zawartością nawiasów kwadratowych ('[' i + ']') musi być wyrażenie. Oznacza to, że kod taki jak + ten działa: + + + + + +]]> + + + + + Jest to przykład użycia wartości zwracanej przez funkcję jako klucza tablicy. PHP + będzie także rozumieć stałe: + + + + + +]]> + + + + + Zauważ, że E_ERROR jest też poprawnym identyfikatorem, tak jak + bar w pierwszym przykładzie. Lecz ostatni przykład jest tak naprawdę + równoważny z napisaniem: + + + + + +]]> + + + + + ponieważ wartością stałej E_ERROR jest 1 itd. + + + + Więc dlaczego jest to złe? + + + W jakimś momencie w przyszłości zespół PHP może dodać nową + stałą lub słowo kluczowe lub stała w innym kodzie może kolidować. Na + przykład błędem jest już użycie słów empty i + default, bo są to + zastrzeżone słowa kluczowe. + + + + + Podsumowując, wewnątrz ciągów znaków otoczonych cudzysłowami poprawne jest + nieotaczanie kluczy tablicy apostrofami lub cudzysłowami, więc zapis "$foo[bar]" + jest poprawny. Zobacz powyższe przykłady, aby zrozumieć, dlaczego tak jest oraz zapoznaj się z sekcją + o parsowaniu zmiennych w + ciągach znaków. + + + + + + + + + Konwersja na tablicę + + + Dla typów int, float, + string, bool and resource + konwersja wartości na tablicę stworzy tablicę z jednym + elementem z indeksem zero i wartością skalarną, która została skonwertowana. Innymi + słowy kod (array) $wartośćSkalarna działa tak samo jak + array($wartośćSkalarna). + + + + Gdy obiekt jest konwertowany na tablicę, wynikiem + jest tablica, której elementami są właściwości + obiektu. Klucze to nazwy tych właściwości z kilkoma istotnymi + wyjątkami: właściwości, których nazwy to liczby są niedostępne, + prywatne właściwości mają swoje klucze poprzedzone nazwą klasy, + właściwości protected mają swoje klucze poprzedzone znakiem "*". Te + właściwości poprzedzone innymi znakami mają też bajty NUL po obu stronach. + Niezainicjalizowane otypowane właściwości + są po cichu odrzucane podczas konwersji. + + + + + {1} = null; + } +} + +var_export((array) new A()); +?> +]]> + + &example.outputs; + + NULL, + '' . "\0" . '*' . "\0" . 'C' => NULL, + 'D' => NULL, + 1 => NULL, +) +]]> + + + + + Te bajty NUL mogą powodować nieodczekiwane zachowanie: + + + + + +]]> + + &example.outputs; + + + NULL + ["AA"]=> + NULL + ["AA"]=> + NULL +} +]]> + + + + + Będzie wydawać się, że istnieją dwa klucze o nazwie "AA", choć jeden z nich tak + naprawdę nazywa się '\0A\0A'. + + + + Konwersja &null; na tablicę skutkuje pustą + tablicą. + + + + + Porównywanie + + + Porównywanie tablic jest możliwe przy użyciu funkcji + array_diff i + operatorów tablicowych. + + + + + Odpakowywanie tablic + + + Tablica poprzedzona znakami ... zostanie rozpakowana w miejscu podczas definiowania tablicy. + Tylko tablice i obiekty, które implementują Traversable mogą być rozpakowane. + Rozpakowywanie tablic przy użyciu ... jest dostępne od PHP 7.4.0. + + + + Możliwe jest wielokrotne odpakowywanie i dodawanie zwykłych elementów przed i po operatorze ...: + + + Proste odpakowywanie tablicy + + 'd']; //['a', 'b', 'c' => 'd'] +?> +]]> + + + + + + Odpakowywanie tablicy operatorem ... używa semantyki funkcji array_merge. + To znaczy, że późniejsze klucze tekstowe nadpisują te wcześniejsze, a klucze numeryczne są przenumerowywane: + + + Odpakowywanie tablicy a zduplikowane klucze + + 1]; +$tablica2 = ["a" => 2]; +$tablica3 = ["a" => 0, ...$tablica1, ...$tablica2]; +var_dump($tablica3); // ["a" => 2] + +// klucz numeryczny +$tablica4 = [1, 2, 3]; +$tablica5 = [4, 5, 6]; +$tablica6 = [...$tablica4, ...$tablica5]; +var_dump($tablica6); // [1, 2, 3, 4, 5, 6] +// Odpowiada to [0 => 1, 1 => 2, 2 => 3, 3 => 4, 4 => 5, 5 => 6] +// gdzie oryginalne klucze numeryczne nie zostały zachowane. +?> +]]> + + + + + + + Klucze, które nie są liczbami ani ciągami znaków rzucają wyjątek TypeError. + Takie klucze mogą być wygenerowane tylko przez obiekt implementujący Traversable. + + + + + Przed PHP 8.1 odpakowywanie tablicy z kluczami tekstowymi nie było wspierane. + + + + 4]; +$tablica3 = [...$tablica1, ...$tablica2]; +// Fatal error: Uncaught Error: Cannot unpack array with string keys in example.php:5 + +$tablica4 = [1, 2, 3]; +$tablica5 = [4, 5]; +$tablica6 = [...$tablica4, ...$tablica5]; // działa. [1, 2, 3, 4, 5] +?> +]]> + + + + + + + + Przykłady + + + Typ tablicowy w PHP jest bardzo wszechstronny. Oto niektóre przykłady: + + + + + 'czerwony', + 'smak' => 'słodki', + 'kształt' => 'okrągły', + 'nazwa' => 'jabłko', + 4 // kluczem będzie 0 + ); + +$b = array('a', 'b', 'c'); + +// ...jest dokładnym odpowiednikiem tego: +$a = array(); +$a['kolor'] = 'czerwony'; +$a['smak'] = 'słodki'; +$a['kształt'] = 'okrągły'; +$a['nazwa'] = 'jabłko'; +$a[] = 4; // kluczem będzie 0 + +$b = array(); +$b[] = 'a'; +$b[] = 'b'; +$b[] = 'c'; + +// Po wykonaniu powyższego kodu $a będzie tablicą +// array('kolor' => 'czerwony', 'smak' => 'słodki', 'kształt' => 'okrągły', +// 'nazwa' => 'jabłko', 0 => 4) a $b będzie tablicą +// array(0 => 'a', 1 => 'b', 2 => 'c'), lub po prostu array('a', 'b', 'c'). +?> +]]> + + + + + Użycie array() + + 4, + 'OS' => 'Linux', + 'lang' => 'english', + 'short_tags' => true + ); + +// tylko klucze numeryczne +$tablica = array( 7, + 8, + 0, + 156, + -10 + ); +// to samo co: array(0 => 7, 1 => 8, ...) + +$switching = array( 10, // klucz = 0 + 5 => 6, + 3 => 7, + 'a' => 4, + 11, // klucz = 6 (największym z kluczy numerycznych był 5) + '8' => 2, // klucz = 8 (liczba!) + '02' => 77, // klucz = '02' + 0 => 12 // wartość 10 będzie nadpisana przez 12 + ); + +// pusta tablica +$empty = array(); +?> +]]> + + + + + + Kolekcja + + +]]> + + &example.outputs; + + + + + + + Bezpośrednia zmiana wartości tablicy jest możliwa + jeśli przekazano je jako referencję. + + + + Zmiana elementu w pętli + + +]]> + + &example.outputs; + + CZERWONY + [1] => NIEBIESKI + [2] => ZIELONY + [3] => ŻÓŁTY +) +]]> + + + + + Ten przykład tworzy tablicę indeksowaną od 1. + + + + Tablica indeksowana od 1 + + 'styczeń', 'luty', 'marzec'); +print_r($pierwszyKwartal); +?> +]]> + + &example.outputs; + + 'styczeń' + [2] => 'luty' + [3] => 'marzec' +) +]]> + + + + + Wypełnianie tablicy + + +]]> + + + + + Tablice są sortowane. Kolejność może być zmieniona przy użyciu różnych + funkcji sortujących. Zobacz sekcję o funkcjach tablicowych, + aby dowiedzieć się więcej. Funkcja count może być + użyta, aby policzyć liczbę elementów w tablicy. + + + + Sortowanie tablicy + + +]]> + + + + + Ponieważ wartość tablicy może być dowolna, może nią być też + inna tablica. Pozwala to na tworzenie rekurencyjnych + i wielowymiarowych tablic. + + + + Tablice rekurencyjne i wielowymiarowe + + array ( "a" => "pomarańcza", + "b" => "banan", + "c" => "jabłko" + ), + "liczby" => array ( 1, + 2, + 3, + 4, + 5, + 6 + ), + "dołki" => array ( "pierwszy", + 5 => "drugi", + "trzeci" + ) + ); + +// Kilka przykładów odniesienia się do wartości tablicy powyżej +echo $owoce["dołki"][5]; // wyświetla "drugi" +echo $owoce["owoce"]["a"]; // wyświetla "pomarańcza" +unset($owoce["dołki"][0]); // usuń "pierwszy" + +// Stwórz nową tablicę wielowymiarową +$juices["jabłko"]["zielone"] = "dobre"; +?> +]]> + + + + + Przypisanie tablicy zawsze powoduje kopiowanie wartości. Użyj + operatora referencji, aby skopiować + tablicę przez referencję. + + + + + +]]> + + + + + + + diff --git a/language/types/boolean.xml b/language/types/boolean.xml new file mode 100644 index 00000000..df4b3f2d --- /dev/null +++ b/language/types/boolean.xml @@ -0,0 +1,171 @@ + + + + Wartości logiczne + + + Typ bool ma tylko dwie wartości i jest używany, aby wyrazić, + czy coś jest prawdą. Może mieć wartość tylko &true; albo &false;. + + + + Składnia + + Aby określić wartość typu bool użyj stałych &true; lub + &false;. Obie nie rozróżniają wielkości liter. + + + + + +]]> + + + + + Zazwyczaj wynik operatora, + który zwraca wartość logiczną jest przekazywany do + struktur kontrolnych. + + + + +\n"; +} + +// ...ponieważ można zapisać to w ten sposób: +if ($show_separators) { + echo "
\n"; +} +?> +]]> + + + + + + Konwersja na wartość logiczną + + + Aby jawnie skonwertować wartość na typ bool użyj + rzutowania (bool). Zazwyczaj nie jest to niezbędne, ponieważ gdy + wartość będzie użyta w kontekście logicznym, to zostanie automatycznie zinterpretowana + jako wartość o typie bool. Aby dowiedzieć się więcej + zobacz stronę poświęconą żonglowaniu typami. + + + + Podczas konwersji na wartość logiczną następujące wartości są traktowane jak + &false;: + + + + + + typ boolean &false; sam w sobie + + + + + liczba + 0 (zero) + + + + + liczby zmiennoprzecinkowe + 0.0 i -0.0 (zero) + + + + + pusty ciąg znaków "", + i ciąg znaków "0" + + + + + tablica z zerową liczbą elementów + + + + + typ NULL (w tym + usunięte zmienne) + + + + + Wbudowane obiekty, które przeciążają ich zachowanie przy rzutowaniu na wartość logiczną. + Na przykład obiekty SimpleXML + stworzone z pustych elementów bez atrybutów. + + + + + + Każda inna wartość jest traktowana jako &true; + (w tym zasoby + oraz NAN). + + + + + -1 jest traktowane jak &true;, tak jak każda inna liczba + różna od zera (ujemna czy dodatnia)! + + + + + + +]]> + + + + + + diff --git a/language/types/callable.xml b/language/types/callable.xml new file mode 100644 index 00000000..df529229 --- /dev/null +++ b/language/types/callable.xml @@ -0,0 +1,184 @@ + + + + Funkcje zwrotne / Callable + + + Funkcje zwrotne mogą być oznaczone deklaracją typu callable. + + + + Niektóre funkcje, takie jak call_user_func lub + usort przyjmują funkcje zwrotne zdefiniowane przez użytkownika jako + swój parametr. Funkcje zwrotne mogą być nie tylko prostymi funkcjami, ale też + metodami obiektów, w tym statycznymi metodami klas. + + + + Przekazywanie + + + Funkcje PHP są przekazywane jako ciąg znaków z ich nazwą. Może byc użyta + każda wbudowana lub zdefiniowana przez użytkownika funkcja, poza konstrukcjami języka takimi jak: + array, echo, + empty, eval, + exit, isset, + list, print i + unset. + + + + Metoda zainstancjonowanego obiektu jest przekazywana jako + tablica zawierająca obiekt jako indeks 0 oraz + nazwę metody pod indeksem 1. Można tak uzyskać dostęp do metod prywatnych i protected + z tej samej klasy. + + + + Statyczne metody klas mogą być też przekazane bez tworzenia + obiektu tej klasy, przekazując nazwę klasy zamiast jej + obiektu pod indeksem 0 lu przekazując ciąg znaków w formacie + 'NazwaKlasy::nazwaMetody'. + + + + Poza zwykłymi funkcjami zdefiniowanymi przez użytkownika, + jako parametr typu callback mogą być też przekazane + funkcje anonimowe i + funkcje strzałkowe. + + + + + Od PHP 8.1.0 funkcje anonimowe mogą być też stworzone przy użyciu specjalnej składni. + + + + + Ogólnie rzecz biorąc, każdy obiekt implementujący __invoke() może również + zostać przekazany do parametru, który oczekuje callbacku. + + + + + + Przykłady funkcji zwrotnych + + + +]]> + + + + + + + Przykład funkcji zwrotnej przy użyciu domknięcia (closure) + Callback example using a Closure + + + +]]> + + &example.outputs; + + + + + + + ¬e.func-callback-exceptions; + + + + + diff --git a/language/types/declarations.xml b/language/types/declarations.xml new file mode 100644 index 00000000..d031cdc0 --- /dev/null +++ b/language/types/declarations.xml @@ -0,0 +1,797 @@ + + + + Deklaracje typów + + + Deklaracje typów mogą być dodane do argumentów funkcji, zwracanych wartości, + właściwości klas (od PHP 7.4.0), a od PHP 8.3.0 do stałych w klasach. + Pozwalają się upewnić, że w trakcie wykonywania kodu wartość jest określonego typu, + a jeśli nie, to zostanie rzucony TypeError. + + + + Każdy typ obsługiwany przez PHP, z wyjątkiem + resource może być użyty dla deklaracji stworzonych przez użytkownika. + Ta strona zawiera wykaz zmian dostępności różnych typów + i dokumentację ich użycia w deklaracjach typów. + + + + + Kiedy klasa implementuje metodę interfejsu lub reimplementuje metodę, która + została zdefiniowana w klasie rodzica, to ta metoda musi być kompatybilna ze + wspomnianą wcześniej definicją. + Metoda jest uznawana za kompatybilną, jeżeli przestrzega + zasad wariancji. + + + + + &reftitle.changelog; + + + + + &Version; + &Description; + + + + + 8.3.0 + + Dodano wsparcie dla typowania stałych w klasach, interfejsach, traitach i enumach. + + + + 8.2.0 + + Dodano wsparcie dla typów DNF. + + + + 8.2.0 + + Dodano wsparcie dla typu true. + + + + 8.2.0 + + Można używać null i falsse jako samodzielnych typów. + + + + 8.1.0 + + Dodano obsługę typów krzyżujących się (intersection types). + + + + 8.1.0 + + Zwracanie przez referencję z funkcji otypowanej jako void jest teraz przestarzałe. + + + + 8.1.0 + + Dodano wsparcie dla typu never, który może być użyty tylko jako typ zwracany. + + + + 8.0.0 + + Dodano wsparcie dla typu mixed. + + + + 8.0.0 + + Dodano wsparcie dla typu static, który może być użyty tylko jako typ zwracany. + + + + 8.0.0 + + Dodano wsparcie dla unii typów. + + + + 7.4.0 + + Dodano wsparcie dla typowania właściwości klas. + + + + 7.2.0 + + Dodano wsparcie dla typu object. + + + + 7.1.0 + + Dodano wsparcie dla typu iterable. + + + + 7.1.0 + + Dodano wsparcie dla typu void. + + + + 7.1.0 + + Dodano wsparcie dla typów dopuszczających &null;. + + + + + + + + + Uwagi na temat używania typów atomowych + + + Zachowanie typów atomowych (a więc takie, których nie możemy podzielić bardziej, w przeciwieństwie + do np. unii typów) jest proste, z kilkoma drobnymi zastrzeżeniami opisanymi w tej sekcji. + + + + Typy skalarne + + + Aliasy nazw dla typów skalarnych (bool, int, + float, string) nie są obsługiwane. + Zostaną one potraktowane jak nazwa klasy lub interfejsu. + Na przykład użycie boolean jako deklaracji typu + będzie wymagało, aby wartość była instancją (&instanceof;) klasy lub interfejsu + o nazwie boolean, a nie wartością logiczną; + + + + +]]> + + &example.outputs.8; + + + + + + + + + void + + + Zwracanie przez referencję z funkcji opisanej typem void jest przestarzałe od PHP 8.1.0, + ponieważ taka funkcja zaprzecza sama sobie. + Wcześniej i tak powodowało to błąd poziomu + E_NOTICE przy wywołaniu: + Only variable references should be returned by reference. + + + +]]> + + + + + + + + Typy callable + + Typ callable (opisujący funkcje zwrotne) nie może być użyty jako typ właściwości klasy. + + + + + Nie jest możliwe określenie spodziewanej sygnatury funkcji zwrotnej. + + + + + + Deklaracje typów dla parametrów przekazywanych przez referencję + + + Jeżeli parametr przekazywany przez referencję ma deklarację typu, to typ + zmiennej jest sprawdzany tylko przy wejściu do funkcji, na + początku wywołania, ale nie kiedy funkcja zwraca. + Oznacza to, że funkcja może zmienić typ zmiennej przekazanej przez referencję. + + + Otypowane parametry przekazywane przez referencję + + +]]> + + &example.outputs.similar; + + + + + + + + + Uwagi na temat używania typów złożonych + + Deklaracje typów złożonych ("kompozytowych") podlegają kilku ograniczeniom, a + w trakcie kompilacji zostanie wykonane sprawdzenie redundancji, aby zapobiec prostym błędom. + + + + + Przed PHP 8.2.0 i wprowadzeniem typów DNF + nie było możliwe połączenie typów przecinających się (intersection types) z unią typów. + + + + + Unia typów + + + Nie jest możliwe połączenie typów false + i true przez unię typów. + Zamiast tego skorzystaj z typu bool. + + + + + + Przed PHP 8.2.0, jako że false ani null + nie mogły być używane jako samodzielne typy, unia typów składająca się tylko + z tych typów nie była dozwolona. Tyczyło się to następujących typów: + false, false|null, + and ?false. + + + + + Typ dopuszczający null i cukier składniowy + + + Podstawowa deklaracja pojedynczego typu może być oznaczona jako dopuszczająca wartości null poprzez poprzedzenie + typu znakiem zapytania (?). + Tak więc ?T i T|null działają identycznie. + + + + + Ta składnia jest wspierana od PHP 7.1.0 i była wprowadzona przed ogólnym wsparciem + dla unii typów. + + + + + + Stworzenie argumentów pozwalających na null jest możliwe też przez użycie + null jako ich domyślnej wartości. + Nie jest to zalecane, jako że gdy wartość domyślna jest zmieniana w klasie + potomnej, to zostanie zgłoszone naruszenie kompatybilności typów, gdyż + null będzie musiał być dodany do deklaracji typu. + + + Stary sposób aby pozwolić na wartości null dla argumentu + + +]]> + + &example.outputs; + + + + + + + + + + Zduplikowane i nadmiarowe typy + + Aby wyłapać proste błędy w złożonych deklaracjach typów, nadmiarowe typy, które + mogą być wykryte bez ładowania klas, będą skutkowały + błędem kompilacji. Zaliczają się do tego: + + + + + Każdy typ o rozwiązanej nazwie może wystąpić tylko raz. Typy takie jak + int|string|INT lub + Countable&Traversable&COUNTABLE + będą skutkowały błędem. + + + + + Użycie mixed skutkuje błędem. + + + + Dla unii typów: + + + + Jeżeli użyty jest bool, to false ani true + nie mogą zostać użyte dodatkowo razem z nim. + + + + + Jeżeli użyty jest object, to nie można dodatkowo użyć typu konkretnej klasy. + + + + + Jeżeli użyty jest iterable, to array + ani Traversable nie mogą być użyte dodatkowo. + + + + + + Dla typów przecinających się (intersection types) + + + + Użycie typu, który nie jest typem klasy, skutkuje błędem. + + + + + Użycie self, parent lub + static skutkuje błędem. + + + + + + Dla typów DNF: + + + + Jeżeli użyty jest bardziej ogólny typ, to bardziej ścisły jest nadmiarowy. + + + + + Użycie dwóch identycznych typów przecinających się (intersection types). + + + + + + + + + + Nie gwarantuje to, że typ jest "minimalny", bo wymagałoby to + załadowania wszystkich użytych typów klas. + + + + + Na przykład jeśli A i B są + aliasami klasy, to A|B jest wciąż dozwoloną unią typów, + nawet, mimo iż można by ją zredukować do A lub + B. + Podobnie, jeśli klasa B extends A {}, to A|B + też jest dozwoloną un→ą typów, mimo iż można ją zredukować po prostu do + A. + + + + +]]> + + + + + + + + &reftitle.examples; + + Podstawowa deklaracja typu klasy + + +]]> + + &example.outputs.8; + + + + + + + Podstawowa deklaracja typu interfejsu + + +]]> + + &example.outputs.8; + + + + + + + Podstawowe deklaracje typu zwracanego + + +]]> + + &example.outputs; + + + + + + + Zwracanie obiektu + + +]]> + + &example.outputs; + + + + + + + Deklaracja argumentu dopuszczającego wartość null + + +]]> + + &example.outputs; + + + + + + + Deklaracja zwracanego typu dopuszczającego null + + +]]> + + + + + Deklaracja typu właściwości klasy + +id = $id; + $this->username = $username; + } +} +?> +]]> + + + + + + + Ścisłe typowanie + + + Domyślnie PHP będzie wymuszać konwersję wartości niewłaściwego typu do oczekiwanej + deklaracji typu skalarnego, jeśli to możliwe. Na przykład, funkcja, która otrzymuje + int dla parametru, który oczekuje string + otrzyma zmienną typu string. + + + + Możliwe jest włączenie trybu ścisłego na poziomie pliku. W trybie + ścisłym tylko wartość, której typ dokładnie odpowiada deklaracji typu, będzie + zaakceptowana, w przeciwnym wypadku zostanie rzucony TypeError. + Jedynym wyjątkiem od tej reguły jest to, że wartość int będzie + akceptowalna dla deklaracji typu float. + + + + + Funkcje wywoływane przez wbudowane funkcje PHP nie będą podlegały pod + deklarację strict_types. + + + + + Do włączenia trybu ścisłego używane jest wyrażenie &declare; z + deklaracją strict_types: + + + + + Ścisłe typowanie tyczy się wywołań funkcji wykonanych z + wewnątrz pliku, który ma włączone ścisłe typowanie, a nie + do funkcji zdefiniowanych w tym pliku. Jeżeli plik bez włączonego + ścisłego typowania wywołuje funkcję, która była zdefiniowana w pliku + z włączonym ścisłym typowaniem, to honorowana będzie preferencja strony + wywołującej kod (typowanie nieścisłe), a wartość zostanie skonwertowana. + + + + + + Ścisłe typowanie tyczy się tylko wartości skalarnych. + + + + + Ścisłe typowanie wartości argumentów + + +]]> + + &example.outputs.8; + + + + + + + Nieścisłe (konwertujące) typowanie wartości argumentów + + +]]> + + &example.outputs; + + + + + + + Ścisłe typowanie zwracanych wartości + + +]]> + + &example.outputs; + + + + + + + + diff --git a/language/types/enumerations.xml b/language/types/enumerations.xml new file mode 100644 index 00000000..f4dbb35b --- /dev/null +++ b/language/types/enumerations.xml @@ -0,0 +1,77 @@ + + + + Wyliczenia (enumy) + + + + Podstawowe wyliczenia + + + Wyliczenia są warstwą zacieśniającą ponad klasami i stałymi w klasach, + których przeznaczeniem jest dostarczenie sposobu na zdefiniowanie zamkniętego zbioru dozwolonych wartości dla typu. + + + + + +]]> + + + + + Dla pełnego opisu zapoznaj się z + rozdziałem Wyliczenia. + + + + + + Rzutowanie + + + Jeżeli typ enum jest konwertowany na object, to nie + jest modyfikowany. Jeżeli enum jest konwertowany na tablicę (array), + to tworzona jest tablica z pojedynczym kluczem name (dla czystych enumów) + lub tablica z kluczami name i values + (dla backed enums, enumeracji z wartościami). Wszystkie inne rzutowania skutkują błędem. + + + + + diff --git a/language/types/float.xml b/language/types/float.xml new file mode 100644 index 00000000..5b94bade --- /dev/null +++ b/language/types/float.xml @@ -0,0 +1,190 @@ + + + + Liczby zmiennoprzecinkowe + + + Liczby zmiennoprzecinkowe (znane też jako "floaty", "double" lub liczby rzeczywiste) + mogą być określone używając następujących składni: + + + + + +]]> + + + + + Formalna definicja od PHP 7.4.0 (wcześniej znaki podkreślenia nie były dozwolone): + + + + + + + + + + Rozmiar liczby zmiennoprzecinkowej zależy od platformy, choć maksymalna wartość około 1.8e308 + z precyzją około 14 miejsc po przecinku jest najbardziej powszechna (format IEEE dla + 64 bitów). + + + + Precyzja zmiennoprzecinkowa + + + Liczby zmiennoprzecinkowe mają ograniczoną precyzję. Mimo iż zależy to od + systemu, PHP zazwyczaj używa formatu podwójnej precyzji IEEE 754, który + daje maksymalny błąd względny wynikający z zaokrąglenia rzędu 1,11e-16. + Nieelementarne operacje arytmetyczne mogą skutkować większymi błędami i oczywiście, + propagacja błędów musi być brana pod uwagę, gdy kilka operacji jest + złożonych. + + + + Dodatkowo, liczby wymierne, które są dokładnie reprezentowalne jako liczby + zmiennoprzecinkowe o podstawie 10, takie jak 0.1 lub + 0.7, nie mają dokładnej reprezentacji jako liczby + zmiennoprzecinkowe o podstawie 2, która jest używana wewnętrznie, bez względu na rozmiar + mantysy. W związku z tym nie można ich przekonwertować na ich wewnętrzne binarne + odpowiedniki bez niewielkiej utraty precyzji. Może to prowadzić do mylących + wyników: na przykład floor((0.1+0.7)*10) zazwyczaj + zwróci 7 zamiast oczekiwanego 8, + ponieważ wewnętrzna reprezentacja będzie wyglądać mniej więcej tak + 7.9999999999999991118.... + + + + Tak więc nigdy nie ufaj wynikom liczb zmiennoprzecinkowych do ostatniej cyfry i nie porównuj + liczb zmiennoprzecinkowych bezpośrednio pod kątem równości. Jeśli konieczna jest wyższa + precyzja, dostępne są funkcje matematyczne dowolnej precyzji + i funkcje gmp. + + + + Dla "prostego" wyjaśnienia zobacz poradnik o liczbach zmiennoprzecinkowych + (w języku angielskim), który jest też zatytułowany "Dlaczego moje liczby się nie dodają?". + + + + + Konwersja na liczbę zmiennoprzecinkową + + + Z łańcuchów znaków + + + Jeżeli łańcuch znaków jest + numeryczny + lub jego początek jest numeryczny, to zostanie rozwiązany do + odpowiadającej wartości zmiennoprzecinkowej, w przeciwnym razie zostanie skonwertowany na zero + (0). + + + + + Z innych typów + + + Dla wartości innych typów konwersja jest wykonywana przez skonwertowanie + wartości najpierw na int, a potem na float. Zobacz + rozdział Konwersja na liczbę całkowitą, + aby dowiedzieć się więcej. + + + + + Jako że pewne typy mają niezdefiniowane zachowanie podczas konwersji na + int, występuje to także podczas konwersji na + float. + + + + + + + Porównywanie liczb zmiennoprzecinkowych + + + Jak zaznaczono w ostrzeżeniu powyżej, sprawdzanie liczb zmiennoprzecinkowych pod kątem równości jest + problematyczne, ze względu na ich wewnętrzną reprezentację. Jednakże + istnieją sposoby porównywania liczb zmiennoprzecinkowych, które obchodzą + te ograniczenia. + + + + Aby przetestować wartości zmiennoprzecinkowe pod kątem równości, używana jest + górna granica względnego błędu z powodu zaokrąglenia. Wartość ta znana jest jako epsilon maszynowy + lub zaokrąglenie jednostkowe i jest najmniejszą dopuszczalną różnicą w obliczeniach. + + + + + $a i $b są identyczne do precyzji + 5 cyfr po przecinku. + + + +]]> + + + + + + NaN + + Niektóre operacje numeryczne mogą skutkować wartością reprezentowaną przez stałą + NAN. Ten wynik oznacza niezdefniowaną lub + niereprezentowalną wartość w obliczeniach zmiennoprzecinkowych. Dowolne luźne lub ścisłe + porównanie tej wartości z dowolną inną wartością (nawet z samą sobą), poza &true;, będzie + miało wynik &false;. + + + Jako że NAN reprezentuje dowolną ilość różnych wartości, + NAN nie powinien być porównywany do innych wartości, w tym + do siebie samego, a w zamian powinien być sprawdzony funkcją is_nan. + + + + + diff --git a/language/types/integer.xml b/language/types/integer.xml new file mode 100644 index 00000000..98ed8b22 --- /dev/null +++ b/language/types/integer.xml @@ -0,0 +1,301 @@ + + + + Liczby całkowite + + + Typ int to liczba z zakresu + ℤ = {..., -2, -1, 0, 1, 2, ...}. + + + + &reftitle.seealso; + + + Liczby zmiennoprzecinkowe + Liczby o dowolnej precyzji / BCMath + Liczby o dowolnej długości / GMP + + + + + + Składnia + + + Liczby całkowite int mogą być określone w notacji dziesiętnej (podstawa 10), szesnastkowej + (podstawa 16), ósemkowej (podstawa 8) lub binarnej (podstawa 2). + Można użyć operatora negacji, + aby oznaczyć liczbę ujemną. + + + + Aby skorzystać z notacji ósemkowej, poprzedź liczbę używając 0 (zero). + Od PHP 8.1.0 notacja ósemkowa może być też poprzedzona 0o lub 0O. + Aby użyć notacji szesnastkowej, poprzedź liczbę 0x. + Aby użyć notacji binarnej, poprzedź liczbę 0b. + + + + Od PHP 7.4.0 wyrażenia liczbowe mogą zawierać podkreślenia (_) pomiędzy cyframi, + aby poprawić czytelność liczb. Te podkreślenia są usuwane przez parser PHP. + + + + Wyrażenia liczbowe + + +]]> + + + + + Formalnie strukturą dla wyrażeń int od PHP 8.1.0 jest + (wcześniej 0o ani 0O nie były + dozwolone jako prefiksy liczb ósemkowych, a przed PHP 7.4.0 nie były dozwolone + znaki podkreślenia): + + + + + + + + + + Rozmiar typu int zależy od platformy, choć zazwyczaj maksymalna + wartość to około dwóch miliardów (32 bity ze znakiem). + Platformy 64-bitowe zazwyczaj mają maksymalną wartość około 9E18. + PHP nie wspiera liczb bez znaków (ang. unsigned). + Rozmiar int może być określony + używając stałej PHP_INT_SIZE, maksymalna wartość przy użyciu + stałej PHP_INT_MAX, a najmniejsza wartość przy użyciu + stałej PHP_INT_MIN. + + + + + Przepełnienie integera + + + Jeżeli PHP napotka liczbę spoza zakresu typu int, + to zostanie ona zinterpretowana jako float. Ponadto + operacja, która skutkuje otrzymaniem liczby poza zakresem + typu int zwróci typ float. + + + + Integer overflow + + +]]> + + + + + + Dzielenie liczb całkowitych + + + Nie istnieje operator dla dzielenia typu int w PHP, skorzystaj + z funkcji intdiv, aby osiągnąć taki efekt. + 1/2 zwraca wynik 0.5 jako float. + Wartość może być zrzutowana do typu int aby zaokrąglić ją w kierunku zera lub + można użyć funkcji round dla dokładniejszej kontroli zaokrąglania. + + + + + +]]> + + + + + + Konwertowanie na liczby całkowite + + + Aby jawnie przekonwertować wartość na typ int, użyj + rzutowania (int) lub (integer). Jednak + w większości wypadków rzutowanie nie jest potrzebne, jako że wartość będzie konwertowana + automatycznie, jeśli operator funkcja lub struktura kontrolna wymaga argumentu o + typie int. Wartość może być też przekonwertowana na int + przy użyciu funkcji intval. + + + + Jeśli typ resource zostanie przekonwertowany na int, to + wynikiem będzie unikalny numer zasobu przypisany do typu + resource przez PHP w trakcie wykonywania programu. + + + + Zobacz też Dopasowywanie typów. + + + + Z <link linkend="language.types.boolean">wartości logicznych</link> + + + &false; zwróci 0 (zero), a &true; zwróci + 1 (jeden). + + + + + + Z <link linkend="language.types.float">liczb zmiennoprzecinkowych</link> + + + + Gdy float jest konwertowany na int, liczba + jest zaokrąglana w kierunku zera. + Od PHP 8.1.0 przy niejawnym konwertowaniu niecałkowitej wartości &float; na &integer;, która traci precyzję, emitowany jest komunikat o przestarzałym zachowaniu. + + + + +]]> + + + + Jeżeli liczba zmiennoprzecinkowa jest poza zakresem int (zazwyczaj + +/- 2.15e+9 = 2^31 na platformach 32-bitowych i + +/- 9.22e+18 = 2^63 na platformach 64-bitowych), + wynik jest nieokreślony, jako że float nie ma + wystarczającej precyzji aby podać dokładny wynik int. + W takiej sytuacji nie jest generowane żadne ostrzeżenie ani nawet komunikat. + + + + + NaN, Inf i -Inf zawsze mają wartość zero przy rzutowaniu na int. + + + + + + Nigdy nie rzutuj nieznanego ułamka do int, jako że może + to czasami prowadzić do nieoczekiwanych wyników. + + + + + +]]> + + + + + Zobacz też ostrzeżenie o precyzji + liczb zmiennoprzecinkowych. + + + + + + Z ciągów znaków + + + Jeżeli ciąg znaków jest + numeryczny + lub jego początek jest numeryczny, to rozwiąże się on do + odpowiadającej wartości liczby całkowitej, w przeciwnym wypadku będzie skonwertowany jako zero + (0). + + + + + Z <type>NULL</type> + + + &null; jest zawsze konwertowany na zero (0). + + + + + Z innych typów + + + + Zachowanie przy konwersji na int jest niezdefiniowane dla + innych typów. Nie polegaj na żadnym zaobserwowanym zachowaniu, jako + że może się ono zmienić bez ostrzeżenia. + + + + + + + + diff --git a/language/types/iterable.xml b/language/types/iterable.xml new file mode 100644 index 00000000..344a7e25 --- /dev/null +++ b/language/types/iterable.xml @@ -0,0 +1,65 @@ + + + + Iterable + + + Iterable to wbudowany, dostępny w czasie kompilacji, alias typu dla + + array|Traversable. + Od jego wprowadzenia w PHP 7.1.0 i przed PHP 8.2.0, + iterable był wbudowanym pseudo-typem, który zachowywał się jak + wcześniej wspominany alias typu i może być użyty jako deklaracja typu. + Typ iterable może być użyty w &foreach; oraz w + yield from wewnątrz + generatorów. + + + + + Funkcje deklarujące iterable jako typ zwracanej wartości mogą być też generatorami. + + + + Przykład zwracanego typu iterable + + + +]]> + + + + + + diff --git a/language/types/mixed.xml b/language/types/mixed.xml new file mode 100644 index 00000000..1e23069f --- /dev/null +++ b/language/types/mixed.xml @@ -0,0 +1,44 @@ + + + + Mixed + + + Typ mixed akceptuje każdą wartość. Jest odpowiednikiem + unii typów + + object|resource|array|string|float|int|bool|null. + Dostępny od PHP 8.0.0. + + + + mixed jest, w języku teorii typów, typem nadrzędnym. + Oznacza to, że każdy inny typ jest jego podtypem. + + + + diff --git a/language/types/never.xml b/language/types/never.xml new file mode 100644 index 00000000..57594819 --- /dev/null +++ b/language/types/never.xml @@ -0,0 +1,40 @@ + + + + Never + + + never jest tylko typem zwracanym, wskazującym, że funkcja + nie jest zakańczana. Oznacza to, że albo wywołuje exit, + rzuca wyjątek lub jest nieskończoną pętlą. + W związku z tym ten typ nie może być częścią deklaracji + unii typów + Dostępny od PHP 8.1.0. + + + never jest, w języku teorii typów, typem dolnym. + Oznacza to, że jest podtypem każdego innego typu i może zastąpić każdy inny + typ zwracany podczas dziedziczenia. + + + + diff --git a/language/types/null.xml b/language/types/null.xml new file mode 100644 index 00000000..85ed4a54 --- /dev/null +++ b/language/types/null.xml @@ -0,0 +1,80 @@ + + + + NULL + + + Typ null jest typem jednostkowym PHP, tzn ma tylko jedną wartość: + &null;. + + + + Zmienne niezdefiniowane lub potraktowane unset będą rozwiązywane + do wartości &null;. + + + + Składnia + + + Jest tylko jedna wartość typu null i jest to + nierozróżniająca wielkości znaków stała &null;. + + + + + +]]> + + + + + + Rzutowanie na &null; + + + &warn.deprecated.feature-7-2-0.removed-8-0-0; + + + + Rzutowanie zmiennej na null używając (unset) $zmienna + nie usunie zmiennej ani nie jej wartości. + Po prostu zwróci wartość &null;. + + + + + + &reftitle.seealso; + + + is_null + unset + + + + + + diff --git a/language/types/numeric-strings.xml b/language/types/numeric-strings.xml new file mode 100644 index 00000000..8e4af33e --- /dev/null +++ b/language/types/numeric-strings.xml @@ -0,0 +1,156 @@ + + + + Numeryczne ciągi znaków + + Typ string w PHP jest uznawany za numeryczny, jeśli może być zinterpretowany jako + int lub float. + + + + Formalnie od PHP 8.0.0: + + + + + + + + + + PHP ma też koncept początkowych ciągów numerycznych. + Jest to po prostu string, który zaczyna się jak numeryczny ciąg znaków, po którym następują + inne znaki. + + + + + Dowolny ciąg znaków zawierający literę E (bez względu na jej wielkość) + ograniczony liczbami będzie postrzegany jako liczba wyrażona w notacji naukowej. + Może to przynieść nieoczekiwane rezultaty. + + +]]> + + + + + + Ciągi znaków używane w kontekstach numerycznych + + Gdy string musi być obliczony jako liczba (np. operacje + arytmetyczne, deklaracja typu int itp.) podejmowane są następujące + w celu określenia wyniku: + + + + + Jeśli string jest numeryczny, rozwiąż go do typu int o + ile ciąg znaków jest numeryczną liczbą całkowitą i mieści się w + limitach typu int (określonych przez stałą + PHP_INT_MAX), w przeciwnym razie rozwiąż jako + float. + + + + + Jeśli kontekst pozwala na początkowo numeryczne ciągi znaków i string + jest takim, rozwiąż go do typu int, jeśli początkowa część + ciągu znaków jest numerycznym ciągiem znaków liczby całkowitej i mieści się w + limitach typu int (określonych przez stałą + PHP_INT_MAX), w przeciwnym razie rozwiąż jako + float. + Dodatkowo zgłaszany jest błąd o poziomie E_WARNING. + + + + + Ciąg znaków string nie jest numeryczny, rzuć + TypeError. + + + + + + + + Zachowanie przed PHP 8.0.0 + + Przed PHP 8.0.0 string był uznawany za numeryczny tylko, jeśli + miał początkowe białe znaki. Jeśli miał + po sobie białe znaki, to był uznawany za + początkowo numeryczny. + + + + Przed PHP 8.0.0 jeśli ciąg znaków był używany w kontekście numerycznym, to byłyby + wykonane kroki wymienione wyżej z następującymi różnicami: + + + + Użycie początkowo numerycznego ciągu znaków spowodowałoby błąd o poziomie + E_NOTICE zamiast E_WARNING. + + + + + Jeżeli ciąg znaków nie jest numeryczny, to zgłaszany był błąd E_WARNING + i zwracana była wartość 0. + + + + Przed PHP 7.1.0 nie byl zgłaszany E_NOTICE + ani E_WARNING. + + + + + +]]> + + + + + diff --git a/language/types/object.xml b/language/types/object.xml new file mode 100644 index 00000000..fb2f343e --- /dev/null +++ b/language/types/object.xml @@ -0,0 +1,103 @@ + + + + Obiekty + + + Inicjalizacja obiektów + + + Aby stworzyć nowy obiekt użyj wyrażenia new + do zainstancjonowania klasy: + + + + +do_foo(); +?> +]]> + + + + + Dla pełnego opisu zapoznaj się z + rozdziałem Klasy i obiekty. + + + + + + Konwersja na obiekt + + + Jeżeli typ object jest konwertowany na object, to nie jest + on modyfikowany. Jeśli wartość dowolnego innego typu jest konwertowana na + object, tworzona jest nowa instancja wbudowanej klasy + stdClass. Jeśli wartością było &null;, to nowa instancja + będzie pusta. Tablica (array) jest konwertowana na obiekt z właściwościami + nazwanymi kluczami tablicy i ich odpowiadającymi wartościami. Zwróć uwagę, że w takim wypadku przed PHP 7.2.0 klucze + numeryczne były niedostępne, chyba że po nich iterowano. + + + + + 'foo'); +var_dump(isset($obj->{'1'})); // wyświetla 'bool(true)' od PHP 7.2.0; wcześniej 'bool(false)' +var_dump(key($obj)); // wyświetla 'string(1) "1"' od PHP 7.2.0; wcześniej 'int(1)' +?> +]]> + + + + + Dla każdej innej wartości właściwość o nazwie scalar będize zawierała + tę wartość. + + + + +scalar; // wyświetla 'ciao' +?> +]]> + + + + + + + diff --git a/language/types/relative-class-types.xml b/language/types/relative-class-types.xml new file mode 100644 index 00000000..65aab0ba --- /dev/null +++ b/language/types/relative-class-types.xml @@ -0,0 +1,56 @@ + + + + Typy względne klas + + + Te deklaracje typów mogą być używane tylko wewnątrz klas. + + + + <type>self</type> + + Wartość musi być instancją (&instanceof;) tej samej klasy, + w której deklaracja została użyta. + + + + + <type>parent</type> + + Wartość musi być instancją (&instanceof;) rodzica klasy, + w której deklaracja została użyta. + + + + + static + + static jest tylko typem zwracanym, który wymaga aby + zwracana wartość była instancją (&instanceof;) tej samej klasy, + w której została wywołana metoda. + Dostępne od PHP 8.0.0. + + + + + diff --git a/language/types/resource.xml b/language/types/resource.xml new file mode 100644 index 00000000..72010bc7 --- /dev/null +++ b/language/types/resource.xml @@ -0,0 +1,68 @@ + + + + Zasoby + + + Zasób (resource) to specjalna zmienna, która przechowuje odniesienie + do zewnętrznego zasobu. Zasoby są tworzone i wykorzystywane przez specjalne funkcje. Zobacz + dodatek, który zawiera listę wszystkich tych + funkcji i odpowiadających im typów zasobów. + + + + Zapoznaj się też z funkcją get_resource_type. + + + + Konwersja na zasób + + + Zmienne o typie resource przechowują specjalne uchwyty do otwartych plikó,w + połączenia do bazy danych, obszary zdjęć i podobne. Konwersja na typ + resource nie ma sensu. + + + + + Zwalnianie zasobów + + + Dzięki mechanizmowi zliczania referencji będącemu częścią Zend Engine, + zasoby, do których nie ma już odwołań, są wykrywane + automatycznie i są zwalniane przez garbage collector. Z tego powodu rzadko + istnieje konieczność ręcznego zwalniania pamięci. + + + + + Trwałe połączenia do bazy danych są wyjątkiem od tej reguły. + Nie są one niszczone przez garbage collector. Przeczytaj + sekcję o trwałych + połączeniach, aby dowiedzieć się więcej. + + + + + + + diff --git a/language/types/singleton.xml b/language/types/singleton.xml new file mode 100644 index 00000000..5abf1113 --- /dev/null +++ b/language/types/singleton.xml @@ -0,0 +1,48 @@ + + + + Typy singletonowe + + + Typy singletonowe to takie, które dopuszczają tylko jedną wartość. + PHP obsługuje dwa typy singletonowe: + false od PHP 8.0.0 i true + od PHP 8.2.0. + + + + + Przed PHP 8.2.0 typ false + mógł być użyty tylko jako część + unii typów. + + + + + + Nie jest możliwe definiowanie własnych typów singletonowych. Rozważ użycie + wyliczeń zamiast tego. + + + + + diff --git a/language/types/string.xml b/language/types/string.xml new file mode 100644 index 00000000..670b8636 --- /dev/null +++ b/language/types/string.xml @@ -0,0 +1,1382 @@ + + + + Ciągi znaków + + + Ciąg znaków (string) to lista znaków, gdzie znak to + to samo co bajt. Oznacza to, że PHP obsługuje tylko zestaw 256 znaków, + a więc nie oferuje natywnej obsługi Unikodu. Zapoznaj się ze + szczegółami typu + string. + + + + + W kompilacjach 32-bitowych string może mieć rozmiar to 2GB + (maksymalnie 2147483647 bajtów). + + + + + Składnia + + + Literał string może być określony na cztery różne sposoby: + + + + + + używając apostrofów + + + + + używając cudzysłowów + + + + + składnią heredoc + + + + + składnią nowdoc + + + + + + Używając apostrofów + + + Najprostszym sposobem określenia ciągu znaków jest otoczenie go pojedynczymi + cudzysłowami (znak '). + + + + Aby określić dosłowny znak apostrofu, poprzedź go znakiem odwrotnego ukośnika + (\). Aby określić dosłowny znak odwrotnego ukośnika, podwój go + (\\). Wszystkie inne wystąpienia odwrotnych ukośników będą traktowane + jak dosłowny odwrotny ukośnik: oznacza to, że inne sekwencje ucieczkowe, do których + możesz być przyzwyczajony, takie jak \r czy \n, + będą wyświetlone dosłownie i nie mają żadnego specjalnego + znaczenia. + + + + + W przeciwieństwie do składni cudzysłowów + i heredoc, + zmienne oraz sekwencje ucieczkowe + dla znaków specjalnych nie są rozwiązywane, jeśli występują + w ciągu znaków otoczonym apostrofami. + + + + + + +]]> + + + + + + + Używając cudzysłowów + + + Jeśli string jest otoczony cudzysłowem ("), to PHP + zinterpretuje następujące sekwencje ucieczkowe dla znaków specjalnych: + + + + Rozszerzane znaki + + + + + Sekwencja + Znaczenie + + + + + + \n + nowa linia (LF lub 0x0A (10) w ASCII) + + + \r + znak powrotu karetki (CR lub 0x0D (13) w ASCII) + + + \t + tabulator poziomy (HT lub 0x09 (9) w ASCII) + + + \v + tabulator pionowy (VT lub 0x0B (11) w ASCII) + + + \e + escape (ESC lub 0x1B (27) w ASCII) + + + \f + znak formularza (FF lub 0x0C (12) w ASCII) + + + \\ + odwrotny ukośnik + + + \$ + znak dolara + + + \" + cudzysłów + + + \[0-7]{1,3} + + Wartość ósemkowa: sekwencja znaków pasująca do wyrażenia regularnego [0-7]{1,3} + jest znakiem w notacji ósemkowej (np. "\101" === "A"), + która po cichu przepełnia się aby zmieścić się w bajcie (np. "\400" === "\000") + + + + \x[0-9A-Fa-f]{1,2} + + Wartość szesnastkowa: sekwencja znaków pasująca do wyrażenia regularnego + [0-9A-Fa-f]{1,2} jest znakiem w notacji szesnastkowej + (np. "\x41" === "A") + + + + \u{[0-9A-Fa-f]+} + + Unicode: sekwencja znaków pasująca do wyrażenia regularnego [0-9A-Fa-f]+ + jest codepointem Unicode, który będzie wyświetlony w ciągu znaków jako reprezentacja tego codepointa w UTF-8. + Nawiasy klamrowe są wymagane dla sekwencji. Np. "\u{41}" === "A" + + + + +
+ + + Tak jak w ciągach znaków w apostrofach, poprzedzenie każdego innego znaku odwrotnym ukośnikiem, + też wyświetli ten odwrotny ukośnik. + + + + Najważniejszą funkcjonalnością ciągów znaków w cudzysłowach jest fakt, + że nazwy zmiennych są rozwiązywane. Zobacz sekcję o + interpolacji stringów, aby + dowiedzieć się więcej. + + + + + Heredoc + + + Trzecim sposobem ograniczenia ciągów znaków jest składnia heredoc: + <<<. Po tym operatorze umieszcza się identyfikator, + a potem nową linię. Potem sam ciąg znaków, a potem ponownie ten + sam identyfikator, aby zamknąć ciąg znaków. + + + + Zamykający identyfikator może być wcięty spacją lub tabulatorem, w tym wypadku + wcięcia zostaną wycięte ze wszystkich linii w ciągu heredoc. + Przed PHP 7.3.0 końcowy identyfikator musiał + zaczynać się w pierwszej kolumnie linii. + + + + Ponadto, zamykający identyfikator musi stosować się do tych samych reguł nazewnictwa co każda + inna etykieta w PHP: musi zawierać tylko znaki alfanumeryczne i + podkreślenia i musi zaczynać się od znaku niebędącego liczbą ani podkreśleniem. + + + + Podstawowy przykład Heredoc od PHP 7.3.0 + + + + &example.outputs.73; + + + + + + + Jeżeli zamykający identyfikator jest wcięty bardziej niż dowolna z linii ciała, to rzucony zostanie ParseError: + + + + Zamykający identyfikator nie może być wcięty bardziej niż żadna z linii ciała + + + + &example.outputs.73; + + + + + + + Jeżeli zamykający identyfikator jest wcięty, to mogą byc też użyte tabulatory, + ale tabulatory i spacje nie mogą być wymieszane przy tworzeniu + wcięcia identyfikatora końcowego. W każdym z tych wypadków zostanie rzucony ParseError. + + Te ograniczenia białych znaków zostały dodane ponieważ mieszanie tabulatorów + i spacji we wcięciach jest szkodliwe dla czytelności. + + + + Inne wcięcia dla ciała (spacje) i zamykającego identyfikatora + + + + &example.outputs.73; + + + + + + + Po zamykającym identyfikatorze dla ciała stringu heredoc nie musi + występować średnik lub nowa linia. Na przykład następujący kod + jest dozwolony od PHP 7.3.0: + + + + Kontynuacja wyrażenia po zamykającym identyfikatorze + + + + &example.outputs.73; + + + string(11) "a + b + c" + [1] => + string(5) "d e f" +} +]]> + + + + + + Jeżeli identyfikator zamykający został znaleziony na początku linii, to + niezależnie czy był on częścią innego słowa, może być on być uznany jako + identyfikator zamykający i może spowodować błąd parsowania (ParseError). + + + + Zamykający identyfikator w ciele ciągu znaków może powodować błąd parsowania + + + + &example.outputs.73; + + + + + + + Aby uniknąć tego problemu, bezpiecznie jest przestrzegać prostej zasady: + nie wybieraj identyfikatora zamykającego, który może pojawić się + w ciele tekstu. + + + + + + + Przed PHP 7.3.0 należy koniecznie zauważyć, że pierwsza linia z + identyfikatorem zamykającym nie może zawierać innych znaków, poza średnikiem + (;). + Oznacza to zasadniczo, że identyfikator + nie może być wcięty i zarówno przed, jak i po identyfikatorze, + nie mogą znajdować się żadne spacje ani taby. Trzeba też sobie zdać sprawę, że + pierwszym znakiem po identyfikatorze zamykającym musi być nowa linia, + określona przez używany system operacyjny. Będzie to \n w + systemach UNIX, w tym macOS. Po końcowym identyfikatorze zamykającym także musi + znaleźć się nowa linia. + + + + Jeżeli ta zasada nie jest przestrzegana i identyfikator zamykający nie jest "czysty", nie + będzie on uznany za identyfikator zamykający i PHP będzie szukał go dalej. + Jeżeli przed końcem obecnego pliku nie zostanie znaleziony prawidłowy identyfikator + zamykający, zostanie zgłoszony bład parsowania w ostatniej linii pliku. + + + + Niepoprawny przykład, przed PHP 7.3.0 + + + +]]> + + + + Poprawny przykład, nawet przed PHP 7.3.0 + + + +]]> + + + + + Ciągi heredoc zawierające zmienne nie mogą być używane do inicjalizowania właściwości klas. + + + + + + Ciągi heredoc zachowują się tak jak zwykłe ciągi umieszczone w cudzysłowie, ale + bez użycia cudzysłowu. Oznacza to, że cudzysłowy w ciągach heredoc nie potrzebują + znaków ucieczki, ale kody ucieczki wymienione powyżej wciąż mogą być używane. Zmienne + są rozszerzane, ale przy złożonych wyrażeniach zmiennych należy zachować tę samą uwagę + co dla zwykłych stringów. + + + + Przykład obsługi cudzysłowów w ciągach heredoc + +foo = 'Foo'; + $this->bar = array('Bar1', 'Bar2', 'Bar3'); + } +} + +$foo = new foo(); +$name = 'MyName'; + +echo <<foo. +Now, I am printing some {$foo->bar[1]}. +This should print a capital 'A': \x41 +EOT; +?> +]]> + + &example.outputs; + + + + + + + Możliwe jest też użycie składni Heredoc do przekazania danych do argumentów + funkcji: + + + + Przykład użycia Heredoc dla argumentów + + +]]> + + + + + Możliwe jest inicjalizowanie zmiennych statycznych i właściwości/stałych + w klasach przy użyciu składni Heredoc: + + + + Użycie Heredoc do zainicjalizowania wartości statycznych + + +]]> + + + + + Otwierający identyfikator Heredoc może być opcjonalnie + ujęty w cudzysłów: + + + + Użycie cudzysłowu w Heredoc + + +]]> + + + + + + + Nowdoc + + + Ciągi Nowdoc są tym dla ciągów w apostrofach czym ciągi heredoc są dla ciągów + w cudzysłowie. Nowdoc jest określany podobnie do heredoc, ale wewnątrz ciągu nowdoc nie + jest wykonywana interpolacja. Ta konstrukcja jest idealna + do umieszczania kodu PHP lub innych dużych bloków tekstu bez potrzeby + dodawania znaków ucieczki. Niektóre z jej cech są podobne do konstrukcji + <![CDATA[ ]]> w SGML, jako że definiuje ona + blok tekstu, który nie powinien być parsowany. + + + + Nowdoc używa identycznej sekwencji <<< + jak ciągi heredoc, ale identyfikator następuje po niej musi być otoczony + apostrofami, np. <<<'EOT'. Wszystkie reguły odnośnie + identyfikatorów heredoc stosują się też do identyfikatorów nowdoc, szczególnie te + odnoszące się do występowania identyfikatora zamykającego. + + + + Przykład cudzysłowów w ciągach nowdoc + + + + &example.outputs; + + + + + + + Przykład cudzysłowów w ciągach nowdoc zawierających zmienne + +foo = 'Foo'; + $this->bar = array('Bar1', 'Bar2', 'Bar3'); + } +} + +$foo = new foo(); +$name = 'MyName'; + +echo <<<'EOT' +My name is "$name". I am printing some $foo->foo. +Now, I am printing some {$foo->bar[1]}. +This should not print a capital 'A': \x41 +EOT; +?> +]]> + + &example.outputs; + +foo. +Now, I am printing some {$foo->bar[1]}. +This should not print a capital 'A': \x41]]> + + + + + Przykład danych statycznych + + +]]> + + + + + + + Interpolacja ciągów + + + Kiedy string jest zawarty w cudzysłowie lub wewnątrz heredoc, + zmienne wewnątrz niego są zamieniane. + + + + Istnieją dwa typy składni: + podstawowa i + zaawansowana. + Podstawowa składnia jest najbardziej powszechna i najwygodniejsza. Pozwala + na umieszczenie zmiennej, wartości tablicy lub właściwości obiektu + wewnątrz ciągu znaków w prosty sposób. + + + + Składnia podstawowa + + Jeżeli napotkany zostanie znak dolara ($), to znaki + następujące po nim, które mogą być użyte w nazwie zmiennej, będą interpretowane + jako takie i nastąpi próba ich podmiany na wartość zmiennej. + + + + +]]> + + &example.outputs; + + + + + + + Formalnie struktura składni dla podstawowej podmiany zmiennych jest + następująca: + + + + name + +variable-name:: + $ name + +name:: + [a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]* + +]]> + + + + + + Składnia ${ wyrażenie } jest przestarzała od + PHP 8.2.0, jako że może być ona zinterpretowana jako + zmienne zmiennych: + + + +]]> + + &example.outputs.82; + + + + &example.outputs; + + + + + Zamiast tego powinna być użyta + zaawansowana składnia interpolacji ciągów znaków. + + + + + + Jeżeli stworzenie poprawnej nazwy zmiennej, to znak dolara pozostaje + nienaruszony w ciągu znaków: + + + + +]]> + + &example.outputs; + + + + + + + + Interpolacja wartości pierwszego wymiaru tablicy lub właściwości + + "purple"); + +echo "He drank some $juices[0] juice."; +echo PHP_EOL; +echo "He drank some $juices[1] juice."; +echo PHP_EOL; +echo "He drank some $juices[string_key] juice."; +echo PHP_EOL; + +class A { + public $s = "string"; +} + +$o = new A(); + +echo "Object value: $o->s."; +?> +]]> + + &example.outputs; + + + + + + + + Klucz tablicy nie może używać cudzysłowu ani apostrofów, a więc przy użyciu + składni podstawowej niemożliwe jest odwołanie się do stałej jako klucza. Zamiast + tego użyj składni + zaawansowanej. + + + + + Od PHP 7.1.0 wspierane są też ujemne indeksy + numeryczne. + + + Negatywne indeksy numeryczne + + +]]> + + &example.outputs; + + + + + + + Dla bardziej złożonych przypadków + musi zostać użyta składnia + zaawansowana. + + + + + Składnia zaawansowana (z klamerkami) + + + Zaawansowana składnia pozwala na interpolację + zmiennych z dowolnym sposobem dostępu. + + + + Przy użyciu tej składni można dołączyć dowolną zmienną + skalarną, element tablicy lub właściwość obiektu + (używającą static lub też nie), + która ma reprezentację jako ciąg znaków. + Wyrażenie jest zapisywany w taki sam sposób, w jaki występowałoby poza + ciągiem znaków, a następnie opakowuje się je znakami { i + }. Jako, że { nie może być wyescape'owane, ta + składnia będzie rozpoznana tylko, gdy $ następujace bezpośrednio + po {. Użyj {\$ jeśli chcesz + wyświetlić dosłownie {$. Oto kilka przykładów dla rozjaśnienia: + + + + + 'Wartość indeksowana', + 'const-key' => 'Klucz ze znakiem minus', + 'foo' => ['foo1', 'foo2', 'foo3'] +]; + +// Nie zadziała, wyświetli: To jest { fantastic} +echo "To jest { $great}"; + +// Działa, wyświetli: To jest super +echo "To jest {$great}"; + +class Square { + public $width; + + public function __construct(int $width) { $this->width = $width; } +} + +$square = new Square(5); + +// Działa +echo "Bok tego kwadratu ma {$square->width}00 centymetrów."; + + +// Działa, klucze w apostrofach lub cudzysłowie działają tylko przy składni w klamerkach +echo "To działa: {$arr['key']}"; + + +// Działa +echo "To działa: {$arr[3][2]}"; + +echo "To działa: {$arr[DATA_KEY]}"; + +// Przy użyciu tablic wielowymiarowych w ciągach znaków, zawsze używaj +// nawiasów klamrowych +echo "To działa: {$arr['foo'][2]}"; + +echo "To działa: {$obj->values[3]->name}"; + +echo "To działa: {$obj->$staticProp}"; + +// Nie zadziała, wyświetli: C:\directory\{super}.txt +echo "C:\directory\{$great}.txt"; + +// Działa, wyświetli: C:\directory\super.txt +echo "C:\\directory\\{$great}.txt"; +?> +]]> + + + + + + Jako że ta składnia pozwala na dowolne wyrażenia, możliwe jest użycie + zmiennych zmiennych + w składni zaawansowanej. + + + + + + + Dostęp do ciągów znaków i modyfikacja po znaku + + + Do znaków wewnątrz ciągów znaków można uzyskać dostęp i modyfikować je + określając przesunięcie liczone od zera dla oczekiwanego znaku, + używając nawiasów klamrowych jak przy tablicach, np. + $str[42]. Pomyśl o ciągu znaków jak + o tablicy znaków pod tym kątem. Funkcje + substr i substr_replace + mogą być użyte jeśli chcesz wydobyć lub zmienić więcej niż jeden znak. + + + + + Od PHP 7.1.0 wspierane są też ujemne przesunięcia dla ciągów znaków. Określają one + offset liczony od końca ciągu znaków. + Wcześniej negatywne przesunięcia emitowały E_NOTICE przy odczycie + (zwracając pusty ciąg znaków) i E_WARNING dla zapisu + (ciąg znaków nie był zmieniany). + + + + + + Przed PHP 8.0.0 do ciągów znaków można było uzyskać dostęp, używając nawiasów klamrowych, np. + $str{42}, aby osiągnąć ten sam efekt. + Składnia używająca nawiasów klamrowych była przestarzała od PHP 7.4.0 i niewspierana od PHP 8.0.0. + + + + + + Zapis do przesunięcia (offsetu) poza zasięgiem powoduje dodanie spacji do ciągu znaków. + Typy niebędące liczbami całkowitymi są konwertowane dla liczb całkowitych. + Niepoprawny offset powoduje wygenerowanie ostrzeżenia E_WARNING. + Używany jest tylko pierwszy znak przypisanego ciągu znaków. + Od PHP 7.1.0 przypisanie pustego ciągu znaków powoduje rzucenie błędu krytycznego. Wcześniej + przypisało to bajt NULL. + + + + + + Wewnętrznie ciągi znaków w PHP są tablicami bajtów. W wyniku tego dostęp + i modyfikacja stringów używając nawiasów tablicowych, nie są bezpieczne dla ciągów wielobajtowych + i powinny być używane tylko dla stringów, które są w kodowaniu jednobajtowym, jak + np. ISO-8859-1. + + + + + + Od PHP 7.1.0 zastosowanie pustego operatora indeksu ciągu znaków do pustego ciągu znaków powoduje błąd + krytyczny. Wcześniej pusty ciąg znaków był po cichu konwertowany na tablicę. + + + + + Trochę przykładów dla ciągów znaków + + +]]> + + + + + Przesunięcia (offsety) ciągów znaków muszą być liczbami lub numerycznymi ciągami znaków, + w przeciwnym razie zostanie zgłoszone ostrzeżenie. + + + + + Przykłady niepoprawnych offsetów ciągów znaków + + +]]> + + &example.outputs; + + + + + + + + Dostęp do zmiennych innych typów (innych niż tablice czy obiekty + implementujące odpowiednie interfejsy) przy użyciu [] lub + {} zwraca &null; bez zgłaszania błędów. + + + + + + Dostęp do znaków wewnątrz ciągów znaków można uzyskać + używając [] lub {}. + + + + + + Dostęp do znaków wewnątrz ciągów znaków przy użyciu + składni {} jest przestarzały od PHP 7.4. + Ta możliwość została usunięta w PHP 8.0. + + + + + + + Przydatne funkcje i operatory + + + Stringi mogą być konkatenowane, czyli łączone, za pomocą operatora "." (kropki). Zauważ, + że operator "+" (dodawania) nie zadziała w ten sposób. + Zapoznaj się z rozdziałem Operatory ciągów znaków, aby + dowiedzieć się więcej. + + + + Istnieje wiele przydatnych funkcji do manipulacji ciągami znaków. + + + + Zobacz sekcję o funkcjach ciągów znaków, aby + zobaczyć ogólne funkcje oraz Funkcje wyrażeń regularnych + kompatybilnych z Perl dla zaawansowanych operacji typu znajdź & zamień. + + + + Istnieją też funkcje dla stringów URL oraz + funkcje do szyfrowania/odszyfrowywania ciągów znaków + (Sodium i + Hash). + + + + W końcu, zobacz też funkcje typu + znaku. + + + + + Konwersja na ciąg znaków + + + Wartość może być skonwertowana na typ string przy użyciu + rzutowania (string) lub funkcji strval. + Konwersja na ciąg znaków jest wykonywana automatycznie w zakresie + wyrażenia, które potrzebuje typu string. Dzieje się to gdy używane są + funkcje echo czy print, lub gdy + zmienna jest porównywana do ciągu znaków. Sekcje poświęcone + Typom i + Żonglowaniu typami powinny + to rozjaśnić. Zapoznaj się też z funkcją settype. + + + + Wartość logiczna (typu bool) &true; jest konwertowana na string + "1". bool &false; jest konwertowana na + "" (pusty string). Pozwala to na konwersję w tę + i z powrotem między wartościami o typach bool i string. + + + + Wartość typu int lub float jest konwertowana na + string reprezentujący daną liczbę tekstowo (zawierającą też + część wykładniczą dla liczb zmiennoprzecinkowych). Liczby zmiennoprzecinkowe mogą + być skonwertowane używając notacji wykładniczej (4.1E+6). + + + + + Od PHP 8.0.0 separatorem dziesiętnym jest zawsze + kropka ("."). Przed PHP 8.0.0 + znak separatora dziesiętnego był zdefiniowany zgodnie z ustawieniami regionalnymi skryptu (kategoria + LC_NUMERIC). Patrz funkcja setlocale. + + + + + Tablice są zawsze konwertowane na ciąg znaków + "Array"; z tego powodu echo ani + print nie mogą same w sobie pokazać zawartości + tablicy. Aby wyświetlić pojedynczy element tablicy, użyj konstrukcji jak np. + echo $arr['foo']. Spójrz poniżej, aby zobaczyć porady dla wyświetlania całej + zawartości. + + + + Aby móc skonwertować obiekty na string, musi być + użyta magiczna metoda __toString. + + + + Zasoby (typ resource) są zawsze konwertowane na string o + strukturze "Resource id #1", gdzie 1 + to numer zasobu przypisany do niego przez PHP w + trakcie wykonywania. Mimo iż nie powinno się polegać na dokładnej strukturze + tego ciągu znaków i może się ona zmienić, to będzie on zawsze unikalny dla danego zasobu + w trakcie życia wykonywanego skryptu (np. zapytania HTTP lub procesu + konsolowego) i nie będzie on użyty ponownie dla innych zasobów. Aby pobrać typ zasobu, użyj + funkcji get_resource_type. + + + + &null; jest zawsze konwertowane na pusty ciąg znaków. + + + + Jak powiedziano wyżej bezpośrednia konwersja tablic, + obiektów ani zasobów nie + dostarcza żadnych przydatnych informacji o wartości stojącej za tym typem. Zobacz + funkcje print_r i var_dump, aby + poznać bardziej skuteczne sposoby inspekcji zawartości tych typów. + + + + Większość wartości w PHP może być skonwertowana na string w celu permanentnego + ich zachowania. Ten proces nazywany jest serializacją i wykonuje go + funkcja serialize. + + + + + + + Szczegóły typu string + + + Typ string w PHP jest zaimplementowany jako tablica bajtów oraz + liczba oznaczająca długość buforu. Nie przechowuje on informacji o tym, jak + te bajty są tłumaczone na znaki, pozostawiając to zadanie programiście. + Nie ma ograniczeń wartości, z których może być złożony ciąg znaków, w + szczególności bajty z wartością 0 ("bajty NUL") są dozwolone + w dowolnym miejscu ciągu znaków (choć kilka funkcji opisanych jest w tym podręczniku jako + takie, które są "bezpieczne binarnie" mogą przekazać obsługę ciągów do bibliotek, które + ignorują dane po bajcie NUL). + + + Ta natura typu string wyjaśnia dlaczego w PHP nie istnieje osobny typ "bajt" - tę + rolę pełnią ciągi znaków. Funkcje, które nie zwracają danych tekstowych, na + przykład dowolne dane odczytane z gniazda sieciowego, wciąż zwrócą + typ string. + + + Biorąc pod uwagę, że PHP nie wymusza określonego kodowania dla stringów, ktoś + może zastanawiać się, jak kodowane są niektóre znaki. Na przykład, czy string + "á" to będzie "\xE1" (ISO-8859-1), + "\xC3\xA1" (UTF-8, wariant C), + "\x61\xCC\x81" (UTF-8, wariant D), czy któraś z innych możliwych + reprezentacji? Odpowiedź brzmi: ciąg znaków będzie zakodowany w taki sposób, w + jaki jest zakodowany w pliku skryptu. Tak więc jeśli skrypt jest napisany w + ISO-8859-1, to ciąg znaków będzie zakodowany w ISO-8859-1 i tak dalej. Nie + jest to jednak prawdą, jeśli włączona jest obsługa Zend Multibyte; w tym wypadku skrypt + może być zapisany w dowolnym kodowaniu (które jest wprost określone lub + wykryte), a potem będzie przekonwertowany do określonego kodowania wewnętrznego, które jest potem + kodowaniem używanym dla stringów. + Zwróć uwagę, że istnieją pewne ograniczenia kodowania skryptu (bądź też + kodowania wewnętrznego, jeśli włączone jest Zend Multibyte) - oznacza to prawie + zawsze, że kodowanie powinno być kompatybilnym nadzbiorem ASCII, takim jak + UTF-8 lub ISO-8859-1. Zauważ jednak, że te kodowania zależne od stanu, gdzie + te same wartości bajtów mogą być użyte w przesunięciach wyjściowych i nie-wyjściowych, + mogą być problematyczne. + + + Oczywiście aby były użyteczne, funkcje które operują na tekście muszą + czynić pewne założenia na temat kodowania ciągów znaków. Niestety, w tej + kwestii istnieje wiele różnic pomiędzy funkcjami PHP: + + + + + Niektóre funkcje zakładają, że ciąg znaków jest zakodowany w jakimś (dowolnym) kodowaniu + jedno-bajtowym, ale nie muszą one interpretować tych bajtów jako konkretne + znaki. Tak jest w wypadku na przykład substr, + strpos, strlen czy + strcmp. O tych funkcjach można też myśleć tak, + że operują one na buforach pamięci, to znaczy działają na bajtach i przesunięciach + bajtów. + + + + + Do innych funkcji przekazuje się kodowanie ciągu znaków, prawdopodobnie przyjmują + one też domyślne kodowanie, jeśli ta informacja nie została podana. Tak działa np. + htmlentities i większość + funkcji z rozszerzenia mbstring. + + + + + Inne wykorzystają obecne ustawienia regionalne (patrz setlocale), ale + działają bajt po bajcie. + + + + + W końcu, niektóre mogą też zakładać, że ciąg znaków używa konkretnego kodowania, + najczęściej UTF-8. Tak dzieje się w wypadku większości funkcji z + rozszerzeń intl oraz + PCRE + (w tym ostatnim przypadku, tylko gdy użyty został modyfikator u). + + + + + + Ostatecznie oznacza to, że pisanie poprawnych programów używających Unikodu zależy + od ostrożnego unikania funkcji, które nie będą działać i które prawdopodobnie + uszkodzą dane, a zamiast tego używainu funkcji, które będą się zachowywały poprawnie, + zazwyczaj z rozszerzeń intl oraz + mbstring. + Jednakże użycie funkcji obsługujących kodowanie Unikodu to dopiero + początek. Niezależnie od tego, jakie funkcje dostarcza język, kluczowe jest + rozumienie specyfikacji Unikodu. Przykładowo program, który zakłada, że istnieją + tylko duże i małe litery, czyni złe założenie. + + + + + diff --git a/language/types/type-juggling.xml b/language/types/type-juggling.xml new file mode 100644 index 00000000..a965523a --- /dev/null +++ b/language/types/type-juggling.xml @@ -0,0 +1,469 @@ + + + + Dopasowywanie typów + + + PHP nie wymusza jawnej deklaracji typu przy deklarowaniu zmiennej. + W tym wypadku typ zmiennej jest określany przez wartość, którą ona przechowuje. + Oznacza to, że jeśli przypisujemy string do zmiennej + $var, to $var jest typu + string. Jeśli później przypiszemy do niej wartość typu int, + to $var stanie się zmienną typu int. + + + + PHP może spróbować skonwertować typ wartości na inny automatycznie + w niektórych kontekstach. Różne istniejące konteksty to: + + + Numeryczny + + + Ciąg znaków + + + Logiczny + + + Całkowity i ciągów znaków + + + Porównawczy + + + Funkcji + + + + + + + Kiedy wartość musi być zinterpretowana jako inny typ, sama wartość + nie zmienia typu. + + + + + Aby wymusić traktowanie zmiennej jako określony typ, zapoznaj się z sekcją poświęconą + rzutowaniu typów. Aby zmienić + typ zmiennej, zapoznaj się z funkcją settype. + + + + Konteksty numeryczne + + + Ten kontekst stosowany jest, gdy używany jest + operator arytmetyczny. + + + + W tym kontekście, jeśli któryś z operandów jest typu float (lub nie + jest interpretowalny jako int), to oba operandy są interpretowane jako + float (liczby zmiennoprzecinkowe) i wynik będzie typu float. + W przeciwnym razie operandy będą interpretowane jako int (liczby całkowite) + i wynik też będzie typu int. + Od PHP 8.0.0 jeśli jeden z operandów nie może być zinterpretowany, + zostanie rzucony TypeError. + + + + + Konteksty ciągów znaków + + + Ten kontekst stosowany jest, gdy używane są echo, + print, + interpolacja ciągów znaków, + lub + operator łączenia (konkatenacji) ciągów znaków. + + + + W tym kontekście wartość będzie interpretowana jako string. + Jeśli wartość nie może zostać zinterpretowana, zostanie rzucony TypeError. + Przed PHP 7.4.0 zgłaszany był błąd o poziomie E_RECOVERABLE_ERROR. + + + + + Konteksty logiczne + + + Ten kontekst stosowany jest gdy używane są wyrażenia logiczne, + operator trójkowy + lub operator logiczny. + + + + W tym kontekście wartość będzie interpretowana jako bool. + + + + + Konteksty całkowite i ciągów znaków + + + Ten kontekst stosowany jest, gdy używane są + operatory przesunięć bitowych. + + + + W tym kontekście, jeśli wszystkie operandy są typu string, to wynik + także będzie typu string. + W przeciwnym wypadku operandy będą interpretowane jako liczby całkowite (int) + i wynik też będzie typu int. + Od PHP 8.0.0 jeśli jeden z operandów nie może być zinterpretowany, to + rzucany jest TypeError. + + + + + Konteksty porównawcze + + + Ten kontekst ma zastosowanie, gdy używany jest + operator porównania. + + + + Konwersje typów zachodzące w tym kontekście są wyjaśnione w + tabeli + porównań z różnymi typami. + + + + + Konteksty funkcji + + + Ten kontekst ma zastosowanie, gdy wartość jest przekazywana do otypowanego parametru, właściwości + lub zwracana z funkcji, która określa typ zwracanej wartości. + + + + W tym kontekście wartość musi być określonego typu. + Istnieją dwa wyjątki, pierwszy z nich to: jeśli wartość jest typu + int a zadeklarowanym typem jest float, to + liczba całkowita jest konwertowana na zmiennoprzecinkową. + Drugi wyjątek to: jeśli deklarowana wartość jest typu skalarnego, + wartość jest konwertowalna na typ skalarny i włączony jest luźny tryb typowania + (ustawienie domyślne), to wartość może być skonwertowana na akceptowalny typ skalarny. + Czytaj dalej, aby zobaczyć opis tego zachowania. + + + + + Funkcje wewnętrzne + domyślnie konwertują &null; na wartości skalarne, + choć to zachowanie jest PRZESTARZAŁE od PHP 8.1.0. + + + + + Luźne typowanie z prostymi deklaracjami typów + + + + deklaracja typu bool: wartość jest interpretowana jako bool. + + + + + deklaracja typu int: wartość jest interpretowana jako int, + jeżeli konwersja jest jasno określona. Na przykład ciąg znaków jest + numeryczny. + + + + + deklaracja typu float: wartość jest interpretowana jako float, + jeżeli konwersja jest jasno określona. Na przykład ciąg znaków jest + numeryczny. + + + + + deklaracja typu string: wartość jest interpretowana jako string. + + + + + + + Luźne typowanie z uniami typów + + Kiedy ścisłe typowanie (strict_types) nie jest włączone, to deklaracje typów skalarnych + podlegają ograniczonemu niejawnemu dopasowywaniu typów. + Jeżeli dokładny typ wartości nie jest częścią unii typów, to docelowy typ + jest wybierany w następującej kolejności: + + + + + int + + + + + float + + + + + string + + + + + bool + + + + + Jeżeli typ istnieje w uni i wartość może być dopasowana do + typu w ramach istniejącej semantyki sprawdzania typów w PHP, to wybierany jest ten typ. + W przeciwnym razie podejmowana jest próba dopasowania dla kolejnego typu. + + + + + Wyjątkiem jest gdy wartość jest ciągiem znaków, a częścią unii jest zarówno int oraz float. + Preferowany typ jest określany zgodnie z istniejącą semantyką + numerycznych ciągów znaków. + Na przykład dla "42" wybierany jest typ int, + a dla "42.0" typ float. + + + + + + Typy które nie są częścią powyższej listy, nie podlegają + niejawnemu dopasowaniu. W szczególności nie występuje niejawne dopasowanie do + typów null, false ani true. + + + + + Przykład typów dopasowywanych do typu będącego częścią unii + + 42 // dokładny typ +"42" --> "42" // dokładny typ +new ObjectWithToString --> "Wynik __toString()" + // obiekt nigdy nie jest kompatybilny z typem, obsłuż jako string +42.0 --> 42 // float kompatybilny z int +42.1 --> 42 // float kompatybilny z int +1e100 --> "1.0E+100" // float zbyt duży na typ int, obsłuż jako string +INF --> "INF" // float zbyt duży na typ int, obsłuż jako string +true --> 1 // wartość logiczna (bool) kompatybilna z typem int +[] --> TypeError // tablica nie jest kompatybilna z typem int ani string + +// int|float|bool +"45" --> 45 // ciąg numeryczny typu dla liczby całkowitej +"45.0" --> 45.0 // ciąg numeryczny dla wartości zmiennoprzecinkowej + +"45X" --> true // nie jest ciągiem numerycznym, obsłuż jako bool +"" --> false // nie jest ciągiem numerycznym, obsłuż jako bool +"X" --> true // nie jest ciągiem numerycznym, obsłuż jako bool +[] --> TypeError // tablica nie jest kompatybilna z typami int, float ani bool +?> +]]> + + + + + + + + Rzutowanie typów + + + Rzutowanie typów konwertuje wartość na podany typ przy pomocy zapisania typu w + nawiasach przed wartością do skonwertowania. + + + + + +]]> + + + + + Dozwolone rzutowania to: + + + + (int) - rzutowanie na int + (bool) - rzutowanie na bool + (float) - rzutowanie na float + (string) - rzutowanie na string + (array) - rzutowanie na array + (object) - rzutowanie na object + (unset) - rzutowanie na NULL + + + + + (integer) jest aliasem rzutowania (int). + (boolean) jest aliasem rzutowania (bool). + (binary) jest aliasem rzutowania (string). + (double) i (real) są aliasami + rzutowania (float). + Te rzutowania nie używają głównej nazwy typu i nie są rekomendowane. + + + + + + Alias rzutowania (real) jest przestarzały od PHP 8.0.0. + + + + + + Rzutowanie (unset) jest przestarzałe od PHP 7.2.0. + Zauważ, że rzutowanie (unset) działa tak samo jak przypisanie + wartości NULL do zmiennej lub wywołania. + Rzutowanie (unset) zostało usunięte w PHP 8.0.0. + + + + + + Rzutowanie (binary) oraz prefiks b istnieją, + aby zapewnić obsługę w przyszłości Obecnie (binary) i + (string) działają identycznie, ale może się to zmienić + i nie powinno się na tym polegać. + + + + + + Białe znaki są ignorowane w nawiasach określających rzutowanie typu. + W związku z tym następujące dwa rzutowania działają identycznie: + + + +]]> + + + + + + + + Rzutowanie wartości string i zmiennych na ciągi + binarne: + + + + +]]> + + + + + + + Zamiast rzutowania zmiennej na typ string możliwe jest też + otoczenie jej cudzysłowami. + + + + + +]]> + + + + + + Może nie być oczywiste co dokładnie stanie się, gdy nastąpi rzutowanie między pewnymi + typami. Aby dowiedzieć się więcej, zobacz te sekcje: + + Konwertowanie na wartość logiczną + Konwertowanie na liczbę całkowitą + Konwertowanie na liczbę zmiennoprzecinkową + Konwertowanie na ciąg znaków + Konwertowanie do tablicy + Konwertowanie do obiektu + Konwertowanie do zasobów + Konwertowanie do NULL + Tabele porównania typów + + + + + + Ponieważ PHP obsługuje indeksy na typie string jako przesunięcia, + używając tej samej składni jak indeksy tablic, poniższy przykład + jest prawdziwy we wszystkich wersjach PHP: + + + + + +]]> + + + + + Przeczytaj rozdział dostęp + do pojedynczego znaku ciągu, aby dowiedzieć się więcej. + + + + + + diff --git a/language/types/type-system.xml b/language/types/type-system.xml new file mode 100644 index 00000000..08bfba63 --- /dev/null +++ b/language/types/type-system.xml @@ -0,0 +1,227 @@ + + + + System typów + + + PHP używa nominalnego systemu typów z silną behawioralną relacją podtypowania. + Relacja podtypowania jest sprawdzana w czasie kompilacji, podczas gdy weryfikacja + typów jest sprawdzana dynamicznie w czasie wykonywania. + + + + System typów PHP wspiera różne typy atomowe, które można łączyć, + aby stworzyć bardziej złożone typy. Niektóre z tych typów mogą być zapisane jako + deklaracje typów. + + + + Typy atomowe + + Niektóre typy atomowe to wbudowane typy, które są ściśle zintegrowane z + językiem i nie da się ich odtworzyć typami zdefiniowanymi przez użytkownika. + + + + Lista podstawowych typów jest następująca: + + + Typy wbudowane + + + + Typy skalarne: + + + + typ bool + + + typ int + + + typ float + + + typ string + + + + + typ array + + + typ object + + + typ resource + + + typ never + + + typ void + + + + Względne typy klas: + self, parent i static + + + + + Typy singetonowe + + + + false + + + true + + + + + + Typy jednostkowe + + + + null + + + + + + + + Typy zdefiniowane przez użytkownika (określane też jako typy klasowe) + + + + Interfejsy + + + Klasy + + + Wyliczenia + + + + + typ callable + + + + + + Typy skalarne + + Wartość jest uznawana za skalarną, jeśli jest typu int, + float, string lub bool. + + + + + Typy zdefiniowane przez użytkownika + + Możliwe jest definiowanie własnych typów przy użyciu + interfejsów, + klas i + wyliczeń. + Są one uznawane za typy zdefiniowane przez użytkownika typy klasowe. + Na przykład może zostać zdefiniowana klasa nazwana Kot, + potem mogą zostać utworzone obiekty typu Kot, + a funkcja może oczekiwać parametru o typie Kot. + + + + + + Typy złożone + + Możliwe jest połączenie wielu atomowych typów w typy złożone (kompozytowe). + PHP pozwala na połączenie typów w następujące sposoby: + + + + + + Przecięcie typów klasowych (interfejsów i nazw klas). + + + + + Unia typów. + + + + + + Przecięcie typów + + Przecięcie typów akceptuje wartości, które spełniają wiele + deklaracji typów klasowych, a nie tylko jedną. + Typy, które tworzą typ będący przecięciem są łączone + znakiem &. W związku z tym przecięcie typów składające + się z typów T, U, and + V będzie zapisywane jako T&U&V. + + + + + Unie typów + + Unia typów dopuszcza wartości wielu różnych typów, + a nie tylko jednego. + Typy, które tworzą unię są łączone + znakiem |. W związku z tym unia typów składająca + się z typów T, U, and + V będzie zapisywana jako T|U|V. + Jeżeli jeden z typów w unii jest typem przecinającym się, to musi być otoczony + nawisami, aby mógł być zapisany jako DNF: + T|(X&Y). + + + + + + Aliasy typów + + + PHP obsługuje dwa aliasy: mixed oraz + iterable, które odpowiadają kolejno + uniom typów + object|resource|array|string|float|int|bool|null + oraz Traversable|array. + + + + + PHP nie obsługuje aliasów typów zdefiniowanych przez użytkownika. + + + + + + diff --git a/language/types/void.xml b/language/types/void.xml new file mode 100644 index 00000000..fc67ae2c --- /dev/null +++ b/language/types/void.xml @@ -0,0 +1,41 @@ + + + + Void + + + void jest dostępny wyłącznie jako deklaracja zwracanego typu i oznacza, + że funkcja nie zwraca żadnej wartości, ale wciąż może zakończyć wykonywanie skryptu. + W związku z tym nie może być częścią deklaracji + unii typów. + Dostępne od PHP 7.1.0. + + + + + Nawet jeśli funkcja używa zwracanego typu void, to wciąż + zwróci wartość. Tą wartością jest zawsze &null;. + + + + +