Tablice

W tej części przyjrzymy się tablicom PHP. Tablice PHP są implementowane jako uporządkowana mapa, która wiąże wartości z kluczami. Istnieją trzy typy tablic w PHP: indeksowane, asocjacyjne i wielowymiarowe. PHP ma wiele funkcji tablicowych, które obejmują wiele typowych zastosowań funkcji. Zanim napiszesz funkcję do działania na tablicy, powinieneś najpierw sprawdzić, czy już nie istnieje. Są one zaimplementowane w C, a więc będą znacznie szybsze niż jakakolwiek funkcja, którą można napisać w PHP, aby osiągnąć ten sam wynik. Strona podręcznika tablicy zawiera je w jednym miejscu i powinieneś się upewnić, że przestudiowałeś tę stronę i stronę podręcznika każdej funkcji. Ta książka byłaby zbyt długa, aby wyczerpująco wymieniać wszystkie funkcje. Zamiast powielać te informacje, ten rozdział koncentruje się na grupowaniu i wyjaśnianiu niektórych z tych funkcji.

Deklarowanie i odwoływanie się do tablic

Nie będziemy rozwodzić się nad tym, jakie są tablice i raczej przejdziemy prosto do składni używanej do deklarowania tablic w PHP. Tablice są tworzone jako zestaw par wartości oddzielonych przecinkami.

< ? php
// indeks numeryczny, automatycznie przypisywany klucz
$arr = array(10, 'abc', 30);
// ndeks numeryczny, klucz jawnie ustawiony
$arr = array(0 => 10, 1 => 'abc', 2 => 30 );
// asocjacyjna
$arr = array('name' => 'foo', 'age' => 20);
// krótka składnia
$arr = ['name' => 'foo', 'age' => 20];

Jeśli nie określisz klucza, PHP przypisze klucz numeryczny z automatyczną inkrementacją. W tym przykładzie pierwsze dwa przypisania są identyczne, ponieważ PHP automatycznie przypisuje klucz. Klucz może być numeryczny lub ciąg znaków. Tablica może zawierać kombinację klawiszy numerycznych i ciągów znaków. Tablice z wpisami liczb są nazywane liczbowymi. Pierwsze dwa przykłady są liczbowe. Tablice zawierające ciągi kluczy nazywane są tablicami asocjacyjnymi. Dwa ostatnie przykłady to tablice asocjacyjne. Istnieją dwie formy składniowe do deklarowania tablicy; wybór jest kwestią stylu kodowania.

< ?php
$ shortForm = ['this', 'is', 'short'];
$ longForm = array ('this', 'is', 'short');
Tablice mogą być zagnieżdżone. Innymi słowy, wartością tablicy może być sama tablica. Są to tak zwane tablice wielowymiarowe. Do pojedynczego elementu tablicy można odwoływać się za pomocą operatora [] w następujący sposób:

< ?php
$arr = ['name' => 'foo', 'age' => 20];
echo $arr['age']; // 20

Jeśli nie podasz klucza w nawiasach, PHP zakłada, że próbujesz odwołać się do nowego elementu. Możesz użyć tego, aby dodać element na końcu tablicy:

< ?php
$arr = [0 => 'id', 'name' => 'foo', 'age' => 20];
$arr[] = 'example';
print_r($arr);
Spowoduje to wyświetlenie następujących danych:
Array
(
[0] => id
[name] => foo
[age] => 20
[1] => example
)

Zauważ, że PHP wybrał klucz, zwiększając najwyższy klucz numeryczny w tablicy.

Funkcje tworzące tablicę

Istnieje wiele funkcji PHP zwracających tablicę, ale przedstawię kilka, które są bezpośrednio związane z tablicami. Funkcja explode () służy do dzielenia łańcucha na tablicę. Najłatwiej jest to wyjaśnić przez przykład:

< ?php
// Separator to ciąg dowolnej długości
$delimiter = ',';
// ThisTen ciąg jest dzielony przez separator
$source = '1, abc, 2, def, 3, ghi';
// Limit określa, ile elementów eksplodujących powróci
$limit = -2;
//utwórz tablicę dzieląc źródło
$arr = explode($delimiter, $source, $limit);
print_r($arr);

Funkcja przyjmuje trzy parametry. Pierwszy to ciąg znaków, który ma być używany jako separator. Zazwyczaj jest to tylko jeden znak (jak przecinek podczas pracy z CSV), ale może mieć dowolną długość. Drugi parametr to ciąg zawierający listę elementów oddzielonych separatorem. Trzeci parametr ogranicza liczbę elementów zwracanych przez PHP. Domyślnie jest ustawiony na PHP_INT_MAX, więc PHP zwróci tyle elementów, ile może. Jeśli jest ujemny, PHP zwraca wszystkie elementy oprócz ostatniej kwoty $limit. Limit zerowy jest traktowany tak samo jak 1. W tym przykładzie określono -2 jako limit, więc PHP zwraca wszystkie elementy oprócz dwóch ostatnich. Dane wyjściowe tego przykładu to:

Array
(
[0] ⇒ 1
[1] ⇒ abc
[2] ⇒ 2
[3] ⇒ def
)

Funkcja implode() działa w odwrotny sposób. Łączy elementy tablicy razem w ciąg ograniczony przez dostarczony ciąg. preg_split() to kolejna funkcja, która dzieli ciąg znaków na tablicę. Jest podobny do explode(), ale używa wyrażenia regularnego do rozgraniczenia pola zamiast literału. Jest to udokumentowane w Podręczniku PHP. Możesz użyć funkcji str_split (), aby rozbić ciąg na tablicę porcji. Wymaga dwóch parametrów: ciągu, który chcesz podzielić, i długości porcji do użycia dla każdego elementu tablicy.

< ?php
$input = '12345678';
$arr = str_split($input, 3);
print_r($arr);
Ten przykład dzieli ciąg na tablicę zawierającą elementy o długości 3, jak tu:

Array
(
[0] ⇒ 123
[1] ⇒ 456
[2] ⇒ 78
)

Zauważ, że ciąg nie jest równomiernie podzielny przez wielkość porcji, a zatem ostatni element ma tylko dwa znaki. Jeśli wielkość porcji jest większa niż długość łańcucha, cały łańcuch jest zwracany jako jedyny element tablicy. Funkcja zwraca FAŁSZ, jeśli spróbujesz użyć ujemnej długości porcji.

Operatory macierzy

Tablice PHP można przetestować pod kątem równoważności i tożsamości. W sekcji dotyczącej operatorów porównania widzieliśmy, że tablice są równoważne, jeśli mają te same pary klucz i wartość. Są identyczne, jeśli mają te same pary klucz i wartość, są w tej samej kolejności, a klucz-wartość są tego samego typu. Operator + utworzy połączenie dwóch tablic. Podczas korzystania z operatora + unii PHP dołącza tablicę po prawej stronie operatora po lewej stronie. Jeśli klucz istnieje w obu tablicach, wówczas dla klucza używana jest wartość lewej tablicy.

< ?php
$a = ['a' => 'hello', 'b' => 'world'];
$b = ['a' => 'goodbye', 'c' => 'cruel'];
echo implode(' ', $a + $b); // hello world cruel

W poprzednim przykładzie obie tablice mają klucz a. Zjednoczenie tablic będzie zatem miało wartość od $a dla tego klucza, ponieważ $a było po lewej stronie operatora związku.

Przykład : Nazwa : Wynik

$a + $b : Unia : $b jest dołączana do $a. Jeśli klucz istnieje w obu tablicach, następnie wartość z $a jest umieszczana w unii.
$ a == $b : Równość : PRAWDA, jeśli $a i $b mają te same pary klucz-wartość
$a === $b : Tożsamość : PRAWDA, jeśli $a i $b mają te same pary klucz-wartość, te same typy i w tej samej kolejności.
$a != $b : Nierówność : PRAWDA, jeśli $a nie jest równe $b.
$a <> $b : Nierówność : PRAWDA, jeśli $a nie jest równe $b.
$a !== $b : Brak tożsamości : PRAWDA, jeśli $a nie jest identyczne z $b.

< ?php
$a = ['a', 'b', '1'];
$b = ['a', 'b', 1];
$c = ['1', 'b', 'a'];
$d = [2 => 1, 0 => 'a', 1 => 'b'];
var_dump($a == $b); // true
var_dump($a === $b); // false
var_dump($a == $c); // false
var_dump($a == $d); // true
var_dump($a === $d); // false

Widzimy, że $a jest równe $b, ponieważ pary klucz-wartość są takie same. Nie są one jednak równoważne, ponieważ typ trzeciego elementu to ciąg znaków w $a i liczba całkowita w $b. $a i $c nie są równe, mimo że mają te same wartości. Tablice są uważane za równe, jeśli mają te same pary klucz-wartość. W tym przypadku nie określiliśmy klucza, więc PHP przypisał klucz automatycznej inkrementacji dla każdej wartości. Dlatego pary klucz-wartość nie pasują, nawet jeśli wartości są takie same. $a i $d są równe, ponieważ pary klucz-wartość są takie same, ale nie są identyczne, ponieważ nie są w tej samej kolejności.

Właściwości kluczy tablicy PHP

Tablice PHP są zerowane. W kluczach tablicy PHP rozróżniana jest wielkość liter: $arr ['A'] i $arr ['a'] to różne elementy. Klucze mogą być tylko ciągiem lub liczbą całkowitą. Inne typy zmiennych są rzutowane na jeden z tych typów przed zapisaniem. Ciągi zawierające dziesiętne prawidłowe liczby całkowite zostaną rzutowane na typ całkowity.

< ?php
$a = [
"2" ⇒"hello",
0x03 ⇒"world",
0b100 ⇒ ' this is ',
"04" ⇒"PHP",
8.7 ⇒"!!!!"
];
var_dump($a);
/*
array(5) {
[2] ⇒
string(5) "hello"
[3] ⇒
string(5) "world"
[4] ⇒
string(9) " this is "
["04"]⇒
string(3) "PHP"
[8] ⇒
string(4) "!!!!"
}
*/

W poprzednim przykładzie widzimy, że ciąg "2" jest konwertowany na liczbę całkowitą 2. Formaty szesnastkowe i binarne są konwertowane na dziesiętne. Ciąg "04" nie jest konwertowany na liczbę całkowitą, ponieważ zawiera reprezentację ósemkową, a nie dziesiętną. PHP zaokrągla liczbę zerową, gdy rzutuje liczbę całkowitą. Innym sposobem na określenie tego jest stwierdzenie, że ułamkowa część liczby jest obcięta. Na przykład liczba zmiennoprzecinkowa 133,7 będzie rzutowana na wartość całkowitą 133 (i nie będzie zaokrąglana w górę do 134). Wartości logiczne można również rzutować na liczby całkowite. Wartość logiczna true ma wartość całkowitą 1, a false staje się liczbą całkowitą 0. Null jest traktowany jako pusty ciąg. Tak więc klucz zerowy będzie przechowywany pod kluczem "". Zmienne złożone (obiekty i tablice) i zasoby nie mogą być używane jako klucz. Jeśli spróbujesz to zrobić, PHP wyświetli ostrzeżenie "nielegalny typ offsetu". Klucze są unikalne; jeśli wiele elementów w tablicy używa tego samego klucza (po przekonwertowaniu jak wyżej), PHP użyje ostatniego z nich dla wartości i zastąpi wszystkie poprzednie wartości.

Wskazówka : To dobry moment na sprawdzenie żonglowania typem!

Wypełnianie tablic

Za pomocą funkcji range() można dodawać wartości do tablicy na podstawie określonego zakresu wartości. Określ zakres początkowy, końcowy i krokowy dla zakresu. Podręcznik PHP zawiera wiele przydatnych przykładów, ale tutaj jest jeden oparty na jednym z komentarzy:

< ?php
print_r(array_combine(range(1, 10, 2),range(1,5)));
Spowoduje to wyświetlenie następujących danych:
/*
Array
(
[1] => 1
[3] => 2
[5] => 3
[7] => 4
[9] => 5
)
*/

Kolejne polecenie o nazwie array_fill() pozwoli ci wypełnić tablicę jedną wartością. Pobiera parametry indeksu początkowego, liczbę wartości do wypełnienia i wartość do wstawienia.

< ?php
print_r(array_fill(10, 5, 'five'));
Ten skrypt generuje:
Array
(
[10] ⇒ five
[11] ⇒ five
[12] ⇒ five
[13] ⇒ five
[14] ⇒ five
)

Powiązana z tym jest funkcja array_fill_keys(). Ta funkcja wypełni tablicę określoną wartością i pozwoli ci określić, jakich kluczy użyć

< ?php
$keys = range(1, 10, 2);
$value = "PHP";
print_r(array_fill_keys($keys, $value));
/*
Array
(
[1] ⇒> PHP
[3] ⇒ PHP
[5] ⇒ PHP
[7] ⇒ PHP
[9] ⇒ PHP
)
*/

Push, Pop, Shift i Unshift

Te cztery polecenia służą do dodawania lub usuwania elementów z tablic.

Funkcja : Efekt

array_shift() : Przesuwa element poza początek tablicy
array_unshift() : Przenosi jeden lub więcej elementów na początek tablicy
array_pop() : Zdejmuje element z końca tablicy
array_push() : Pcha jeden lub więcej elementów na koniec tablicy

Prawdopodobnie zauważysz, że za pomocą tych funkcji możesz łatwo implementować kolejki i stosy. Polecenia usuwające element z tablicy zwracają go tobie i przesuwają wszystkie elementy w dół. Klawisze numeryczne są zmniejszane, dopóki nie zaczynają odliczać od 0, a klawisze dosłowne pozostają nietknięte

< ?php
$stack = array("one", "two", "three", "four");
$fruit = array_shift($stack);
print_r($stack);
Na wyjściu zauważysz, że "dwa" ma teraz klucz 0, gdzie wcześniej było 1:

/*
Array
(
[0] ⇒ two
[1] ⇒ three
[2] ⇒ four
)
*/

Porównywanie tablic

Widziałeś wcześniej, że do porównywania tablic można używać operatorów równości == i tożsamości ===. Po zastosowaniu do tablic operator równości zwraca wartość true, jeśli tablice mają te same klucze i wartości, niezależnie od ich typu. Operator tożsamości zwróci wartość true tylko wtedy, gdy tablice mają te same klucze i wartości, są w tej samej kolejności i mają te same typy zmiennych.

$ arr = ["1", "2", "3"];
$ brr = [1, 2, 3];
var_dump ($ arr === $ brr); // fałszywy
var_dump ($ arr == $ brr); // prawdziwe

Istnieją funkcje PHP poświęcone porównaniom tablic, które umożliwiają bardziej wyrafinowane porównania.

array_diff()

Funkcja array_diff() przyjmuje listę tablic jako argumenty. Zwróci tablicę zawierającą wartości z pierwszej tablicy, które nie były obecne w żadnej innej tablicy. W tym przykładzie użyto array_diff() do porównania parametrów wejściowych podanych w superglobale $_POST ze wstępnie zdefiniowaną listą wymaganych parametrów.

< ?php
$requiredKeys = ['username', 'password', 'csrf_token'];
$missingKeys = array_diff($requiredKeys, array_keys($_POST));
if (count($missingKeys)) {
throw new UnexpectedValueException('You need to provide
[' . print_r($missingKeys, true) . ']');
}

Ten kod znajduje wszystkie klucze, które znajdują się na wymaganej liście, ale nie w tablicy pocztowej, i tworzy tablicę o nazwie $missingKeys, która je zawiera. Pozwala to sprawdzić, czy formularz został całkowicie wypełniony. Array_diff_assoc() jest skojarzoną wersją array_diff() i bierze pod uwagę klucze tablicy oraz ich wartości. Aby zobaczyć różnicę, możemy użyć bardzo prostego przykładu:

< ?php
$a = ['a' => 'apple', 'b' => 'banana'];
$b = ['a' => 'apple', 'd' => 'banana'];
print_r(array_diff($a, $b));
print_r(array_diff_assoc($a, $b));
/*
Array
(
)
Array
(
[b] ⇒ banana
)
*/

Wynikiem array_diff () jest pusta tablica, ale array_diff_assoc () zwraca tablicę składającą się z [b] ⇒ banana, ponieważ kluczem wartości banana jest b w pierwszej tablicy id w drugiej.

array_intersect()

Funkcja array_intersect() przyjmuje również listę tablic jako parametry. Oblicza, które wartości z pierwszej tablicy są również obecne we wszystkich innych tablicach.

< ?php
$birds = ['duck', 'chicken', 'goose'];
$net = ['dog', 'cat', 'chicken', 'goose', 'hamster'];
print_r(array_intersect($net, $birds));

Spowoduje to wyświetlenie elementów, które są w $net, a także w $birds:

Array
(
[2] ⇒ chicken
[3] ⇒ goose
)

Pamiętaj, że klucze są zachowane. array_intersect_assoc() obejmuje sprawdzenie indeksu podczas dopasowywania elementów. Jeśli zastosujesz go do tablic w przykładzie, zwróci pustą tablicę. Zwracana wartość jest pusta, ponieważ chociaż wartości w tablicach są zgodne, ich indeksy nie.

Funkcje dopasowywania zdefiniowane przez użytkownika

PHP zapewnia funkcje, które pozwalają określić własną funkcję porównania. Rozważ jako przykład array_udiff(). Pobiera listę parametrów tablicy, po której następuje wywołanie jako ostatni parametr. Rozważmy trywialny przykład, w którym chcemy porównać wartości małych tablic ze sobą. Bardziej realistyczne przypadki użycia mogą wymagać bardziej skomplikowanych operacji, na przykład na obiektach.

< ?php
$birds = ['duck', 'chicken', 'goose'];
$net = ['Dog', 'Cat', 'Chicken', 'Goose', 'Hamster'];
$diff = array_udiff($net, $birds, function($a, $b){
$a = strtolower($a);
$b = strtolower($b);
if ($a < $b) {
return -1;
} elseif ($a > $b) {
return 1;
} else {
return 0;
}
}); print_r($diff);

Ten kod wyświetla elementy w $net, które nie mają pasującego zwierzęcia na liście $birds. Do porównania używamy funkcji niestandardowej, która najpierw konwertuje oba ciągi znaków na małe litery.

Array
(
[0] ⇒ Dog
[1] ⇒ Cat
[4] ⇒ Hamster
)

Uwaga:

•  Z instrukcji: "Funkcja porównania musi zwracać liczbę całkowitą mniejszą, równą lub większą od zera, jeśli pierwszy argument jest uważany za odpowiednio mniejszy, równy lub większy niż drugi."
•  Możesz używać zamknięć jako wywołań dla dowolnej funkcji, która przyjmuje wywołanie jako parametr.
•  Możesz używać lambda jako wywoływalnych, także dla każdej funkcji, która przyjmuje wywoływalny parametr. W tym przykładzie używamy lambda.
•  Funkcja porównania przyjmuje dwa argumenty, które będą wartościami do porównania.

Istnieją funkcje PHP, które pozwalają określić własną możliwość wywołania w celu porównania kluczy, wartości lub obu.

Szybka lista funkcji porównawczych

Ta tabela pokazuje tablice do wykonywania różnicy między funkcjami. Istnieją podobne funkcje do wykonania skrzyżowania. Mają tę samą konwencję nazewnictwa i parametry, więc nie wymienię ich tutaj.

Funkcja : Użycie

array_diff : Oblicza różnicę tablic
array_diff_assoc : Oblicza różnicę tablic z dodatkowym sprawdzaniem indeksu
array_udiff : Oblicza różnicę tablic za pomocą funkcji zwrotnej do porównania danych
array_udiff_assoc : Oblicza różnicę tablic z dodatkowym sprawdzaniem indeksu i porównuje dane za pomocą funkcji zwrotnej
array_udiff_uassoc : Oblicza różnicę tablic z dodatkowym sprawdzaniem indeksu oraz porównuje dane i indeksy według funkcji wywołania zwrotnego

Zauważ, że array_udiff_uassoc () przyjmuje jako parametry dwie wywoływalne funkcje, jedną dla wartości i ostatni parametr dla indeksów. Spójrz na stronę podręcznika i upewnij się, że przestudiowałeś wszystkie powiązane funkcje.

Łączenie tablic

PHP oferuje kilka przydatnych funkcji, które pomagają łączyć tablice. Funkcja Combine_array($keys, $values) tworzy tablicę, używając jednej tablicy dla kluczy, a drugiej dla jej wartości. Zwróci FAŁSZ, jeśli liczba elementów w tablicach nie będzie zgodna, w przeciwnym razie zwróci tablicę asocjacyjną. Możesz użyć array_replace($array1, $array2, …), aby sekwencyjnie zamieniać wartości w tablicy wartościami z innych tablic. Pobiera dwa lub więcej tablic jako parametry i przetwarza je od lewej do prawej. Aby ustalić końcowy wynik, postępuj zgodnie z tymi zasadami:

•  Jeśli pierwsza tablica ma klucz, którego nie ma w drugiej tablicy, wówczas para klucz-wartość pozostaje nietknięta.
•  Jeśli druga tablica ma klucz, którego nie ma w pierwszej tablicy, wówczas para klucz-wartość z drugiej tablicy jest wstawiana do pierwszej tablicy.
•  Jeśli druga wartość ma klucz, który znajduje się również w pierwszej tablicy, to wartość z drugiej tablicy zastępuje wartość z pierwszej tablicy.

< ?php
$input = ['a', 'b', 'c'];
$replace = [3 ⇒ 'd', '1' ⇒ 'q'];
$replaceTwo = [2 ⇒ 1, 1.3 ⇒ 'Z'];
$output = array_replace($input, $replace, $replaceTwo);
echo implode(", ", $output); // a, Z, 1, d

Umieściłem te informacje w tabeli, abyś mógł zobaczyć, jak reguły są stosowane. Funkcja działa od lewej do prawej, zastępując każdy kolejny parametr poprzednią tablicą.

Klucz : $input : $replace : $replace : $replaceTwo : $output

0 : a : : : a
1 : b : q : Z : Z
2 : c : : 1 : 1
3 : : d : : d

Uwaga Klucz ciąg 1 jest rzutowany na liczbę całkowitą, a klucz pływakowy 1.3 jest również rzutowany na liczbę całkowitą.

Oba oceniają na 1 i dlatego zastąpią wartość w tej pozycji. Funkcja array_merge() scali jedną lub więcej tablic. Można się spodziewać, że podczas łączenia zachowuje się tak samo jak operator +, ale w niektórych sytuacjach zachowuje się zupełnie inaczej. Rozważ ten przykład:

< ?php
$arrOne = [
// liczba całkowita
0 ⇒ 'One 0',
// string
'a' ⇒ 'One a',
// nie=puste w One, ale puste w Two
'Overwrite' ⇒ 'Nie puste',
];
$arrTwo = [
0 ⇛ 'Two 0',
1 ⇛ 'Two 1',
'b' ⇛ 'Two b',
'Overwrite' => '',
];
print_r($arrOne + $arrTwo);
print_r(array_merge($arrOne, $arrTwo));

Pokażę ci wynik tego kodu za chwilę. W danych wyjściowych kodu należy zwrócić uwagę na dwie rzeczy:

•  Funkcja array_merge() ponownie indeksuje klawisze numeryczne, ale operator tego nie robi.
•  Funkcja array_merge() nie zastąpi niepustej wartości pustą wartością, ale operator to zrobi. Zgodnie z obietnicą, oto wynik pokazujący różnice:

Array
(
[0] ⇒ One 0
[a] ⇒ One a
[1] ⇒ Two 1
[b] ⇒ Two b
)
Array
(
[0] ⇒ One 0
[a] ⇒ One a
[1] ⇒ Two 0
[2] ⇒ Two 1
[b] ⇒ Two b
)

Podział tablic

Istnieje kilka funkcji, których można użyć do podzielenia tablicy. Poniższa tabela zawiera ich listę. Przyjrzymy się niektórym szczegółom w książce, ale powinieneś również przeczytać instrukcję.

Funkcja : Użycie

array_chunk : Podziel tablicę na części
array_column : Zwraca pojedynczą kolumnę z tablicy wejściowej, na przykład tablicę wyniki zapytania do bazy danych.
array_slice : Wyodrębnij tablicę tablicy

array_splice : Zwraca kawałek tablicy i zamienia ją na coś innego w oryginalnej tablicy (argument jest wywoływany przez odwołanie).
extract : Utwórz zmienne nazwane dla kluczy tablicy, które zawierają wartości z tablicy. Korzystanie z tej funkcji może prowadzić do mętnego kodu ponieważ nie jest od razu jasne, gdzie zdefiniowano zmienną.
array_rand : Wybierz losowe klucze z tablicy.

Spośród tych funkcji jedyną potencjalnie trudną funkcją jest array_splice(). Nie tylko zwraca wartość (wycięty fragment), ale ponieważ tablica wejściowa jest przekazywana przez odwołanie, wpływa również na tablicę, do której ją wywołujesz. Aby dodać dodatkową komplikację, opcjonalnie możesz zastąpić wycinek wyodrębniony z tablicy wejściowej tablicą zastępczą. Spójrzmy na przykład:

< ?php
$input = [1,2,3];
$replacement = ['hello', 'world'];
// $slice zawiera fragment, który wyodrębniamy
$slice = array_splice($input, 1, 1, $replacement);
// $inputsą przekazywane przez odniesienie, a zatem są zmieniane
print_r($input);

Ten skrypt szuka wycinka tablicy wejściowej, która zaczyna się od pozycji 1 i ma długość 1. Wiemy, że tablice są oparte na zerach, więc pozycja 1 ma wartość 2. Funkcja array_splice() zwraca tablicę fragmentu, który był znaleziony. Dlatego $ slice będzie tablicą z pojedynczym elementem zawierającym wartość 2. Argument tablicy wejściowej do array_splice() jest przekazywany przez odwołanie, a więc zostanie zmodyfikowany przez funkcję. Zastępujemy wycięty fragment wycinkiem zastępczą tablicą. Dane wyjściowe skryptu to:

Array
(
[0] ⇒ 1
[1] ⇒ hello
[2] ⇒ world
[3] ⇒ 3
)

Tablice destrukcyjne

Konstrukcja języka list() służy do przypisywania zmiennych z tablicy na podstawie ich indeksów. Oto podstawowy przykład jego użycia:

< ?php
$array = ["one", "two", "three"];
list ($ a, $ b, $ c) = $ tablica;
echo $a; // jeden
echo $b; // dwa
echo $c; //trzy

PHP 7 wprowadził zmianę składni dla list(), która sprawia, że zachowuje się bardziej spójnie podczas tworzenia tablicy indeksowanej. W PHP 7 zmienne są przypisywane w kolejności, w której je zapisujesz, podczas gdy w PHP 5 są one przypisywane w odwrotnej kolejności. Będzie to miało większy sens, jeśli zobaczysz przykład:

< ?php
$array = ['one', 'two', 'three'];
list($indexedArray[0], $indexedArray[1], $indexedArray[2]) = $array;
var_dump($indexedArray);

W PHP 7mamy dane wyjściowe:

array(3) {
[0] ⇒
string(3) "one" [1] ⇒
string(3) "two"
[2] ⇒
string(5) "three"
}

W PHP 5 kolejność jest odwrócona, co powoduje:

array(3) {
[2] ⇒
string(5) "three"
[1] ⇒
string(3) "two"
[0] ⇒
string(3) "one"
}

Obliczanie za pomocą tablic

PHP oferuje kilka wygodnych funkcji, które pozwalają wykonywać obliczenia matematyczne na tablicach bez konieczności iterowania ich ręcznie.

Funkcja : Wartość zwracana

array_count_values : Ile razy pojawia się każda unikalna wartość w tablicy
array_product : Iloczyn wszystkich wartości w tablicy
array_sum : Suma wszystkich wartości w tablicy
count : Ile elementów jest w tablicy
sizeof : To jest alias count ()

Uwaga : Iloczyn pustej tablicy wynosi 1, a nie 0

Iteracja przez tablice

Istnieją dwa sposoby iteracji w tablicy - za pomocą kursora i pętli w tablicy.

Pętla przez tablice

Wyliczeniowa tablica PHP może być zapętlona poprzez zwiększenie licznika indeksów, ale to nie zadziała dla tablic asocjacyjnych. Lepszym i bardziej niezawodnym podejściem jest użycie konstrukcji foreach(). Pozwala szybko spojrzeć na dwie możliwe składnie, których używa foreach(), a następnie przejść dalej. Powinieneś być już zaznajomiony z jego użyciem, jeśli rozważasz możliwość przystąpienia do egzaminu, więc jest to korzystne dla programistów z innych języków.

< ?php
$arr = [
'a' ⇒ 'apple',
'b' ⇒ 'banana',
'c' ⇒ 'cherry'
];
foreach($arr as $value) {
echo $value . PHP_EOL;
}
foreach($arr as $key ⇒ $value) {
echo $key . ' = ' . $value . PHP_EOL;
}

Pierwsza pętla foreach() przejdzie przez tablicę i przekaże wartości tablicy do bloku kodu. Druga pętla foreach() przechodzi przez nią i przekazuje klucz i wartość. Domyślnie PHP wartość przekazywana do bloku kodu pętli foreach() jest przekazywana przez wartość. Jeśli zmienisz wartość w bloku kodu, nie będzie to miało wpływu poza blok kodu. Możesz jednak oznaczyć wartość, która ma być przekazana przez odwołanie, poprzedzając ją znakiem "i".

Uwaga : Generalnie ludzie będą się na ciebie krzywo patrzeć za użycie odwołania w pętli foreach().

Przyjrzymy się temu w poniższym przykładzie kodu, który pokazuje również, że zmienna zadeklarowana w bloku foreach zostaje zdefiniowana w zakresie zawierającym. Po zakończeniu pętli zachowa ostatnią wartość, którą miał w pętli. Jednak poleganie na tej funkcji sprawia, że kod jest trudniejszy do odczytania

< ?php
$arr = [1,2,3];
foreach ($arr as $value) {
$value += 1;
}
echo implode(', ', $arr) . PHP_EOL; // 1, 2, 3
echo $value . PHP_EOL; // 4
foreach ($arr as &$value) {
$value += 1;
}
echo implode(', ', $arr) . PHP_EOL; // 2, 3, 4
echo $value;

Od wersji PHP 5.5 konstrukcja list() może być używana w pętlach foreach() do rozpakowywania zagnieżdżonych tablic. Jest to szczególnie przydatne, gdy mamy do czynienia z wynikami bazy danych. Oto przykład użycia listy:

< ?php
// przypisywanie do skalarów
list($animal, $food, $mood) = ['cat', 'cheeseburgers', 'grumpy'];
echo "{$animal}s eat $food except when they're $mood." . PHP_EOL;
// przypisanie do tablicy
$info = [];
list($info[0], $info[1], $info[2]) = ['cat', 'cheeseburgers', 'grumpy'];
var_dump($info);
/*
koty jedzą cheeseburgery, chyba że są zrzędliwe.
array(3) {
[0]⇒
string(3) "cat"
[1] ⇒
string(13) "cheeseburgers"
[2] ⇒
string(6) "grumpy"
}
*/

Uwaga : Każde słowo kluczowe, które może być również używane do przechodzenia przez tablicę, jest przestarzałe w PHP 7.2.0 (więc nie używaj go również w PHP 7.1)

Korzystanie z kursorów tablicowych

Każda tablica ma kursor lub wskaźnik, który wskazuje na bieżący element. Wiele funkcji PHP używa kursora do określania, na którym elemencie ma działać. Oto podstawowe funkcje kursora:

Funkcje : Działanie

reset : Przenosi kursor na początek tablicy
end : Przesuwa kursor na koniec tablicy
next : Przesuwa kursor
prev : Przesuwa kursor
current : Zwraca wartość elementu wskazywanego przez kursor
key : Zwraca klucz elementu, na który wskazuje kursor

Obiekty mogą być iterowane przy użyciu tej samej składni, ale ważne jest, aby wiedzieć, że implementują iterator interfejsu. Rzadziej spotykane użycie kursora to takie:

< ?php
$arr = [
'a' ⇒ 'apple',
'b' ⇒ 'banana',
'c' ⇒ 'cherry'
];
while (list($var, $val) = each($arr)) {
echo "$var is $val" . PHP_EOL;
}

list() to konstrukcja języka, która przypisuje zmienne z dostarczonej tablicy. Funkcja each() zwraca bieżącą parę klucz i wartość z tablicy i przesuwa kursor tablicy.

Spacerując po tablicach

Funkcja array_walk() stosuje wywołanie przez użytkownika do każdego elementu w tablicy. Wymaga dwóch parametrów - odniesienia do tablicy i wywołania. Do wywołania funkcji zostaną przekazane dwa parametry. Pierwszy to wartość elementu z tablicy, a drugi to jego indeks. Niektóre funkcje wewnętrzne, takie jak na przykład strtolower(), rzutują ostrzeżenie, jeśli otrzymają zbyt wiele parametrów, a zatem nie są odpowiednie jako wywołanie zwrotne dla array_walk().

Uwaga : Jeśli potrzebujesz funkcji zwrotnej, aby zmienić wartość tablicy, upewnij się, że przekazałeś pierwszy parametr przez odniesienie.

Oto przykład, który przekonwertuje wszystkie elementy tablicy na wielkie litery:

< ?php
$arr = [
'a' ⇒ 'apple',
'b'⇒ 'banana',
'c' ⇒ 'cherry'
];
array_walk($arr, function(&$value, $key) {
$value = strtoupper($value);
});
print_r($arr);

Zauważ, że przekazuję wartość przez referencję do mojej funkcji lambda, więc zmiana jej w lambda wpłynie na zmienną $arr. Gdybyśmy użyli strtoupper() jako wywołania zwrotnego, PHP wygenerowałoby ostrzeżenia. W ramach ćwiczenia spróbuj ustalić, dlaczego tak jest.

Sortowanie tablic

PHP oferuje kilka funkcji sortowania. Postępują zgodnie z konwencją nazewnictwa, w której podstawowa funkcja sortowania jest poprzedzona r dla odwrotnego i as dla asocjacyjnego. Wszystkie funkcje sortowania odwołują się do tablicy jako parametru i zwracają wartość logiczną wskazującą powodzenie lub niepowodzenie

Funkcja : Użycie

sort : Sortuj tablice alfabetycznie
rsort : Odwróć sortowanie alfabetyczne
asort : Sortowanie asocjacyjne
arsort : Odwrócony sortowanie asocjacyjne
ksort : Sortowanie kluczy
krsort : Odwróć sortowanie kluczy
usort : Zdefiniowana przez użytkownika funkcja porównania do sortowania
shuffle : Sortowanie pseudolosowe

Sortowanie asocjacyjne będzie sortować według wartości i utrzymywać powiązanie indeksu. Na przykład spójrz na jedną z ich stron podręcznika. Wszystkie funkcje (oprócz usort()) akceptują opcjonalny parametr wskazujący flagę sortowania. Te flagi są predefiniowanymi stałymi:

Flaga : Znaczenie

SORT_REGULAR : Porównaj produkty normalnie; nie zmieniaj typów.
SORT_NUMERIC : Rzutuj elementy na wartości liczbowe, a następnie porównaj.
SORT_STRING : Rzuć elementy na łańcuchy, a następnie porównaj.
SORT_LOCALE_STRING : Użyj ustawień regionalnych, aby rzutować elementy na łańcuchy.
SORT NATURAL : Użyj naturalnego sortowania porządku, na przykład funkcji natsort().
SORT_FLAG_CASE : Można połączyć z SORT_STRING i SORT_NATURAL do sortuj ciągi bez rozróżniania wielkości liter.

Naturalne sortowanie porządku

Porządek naturalny jest porządkiem sortującym, który ma sens dla ludzi. Jest to kolejność sortowania alfabetycznego, ale wiele cyfr jest traktowanych jako pojedynczy znak. Funkcja natsort() nie przyjmuje flag i jest taka sama jak sort () z ustawioną flagą SORT_NATURAL. Na przykład zacznijmy od sznurka, który wygląda na nasze ludzkie oczy, potasuj go, a następnie użyj obu form sortowania, aby zobaczyć, jak to wygląda:

< ?php
$a = $b = explode(' ', 'a1 a2 a10 a11 a12 a20 a21');
shuffle($a);
shuffle($b);
natsort($a);
sort($b);
print_r($a);
print_r($b);

Zauważ, że użyłem funkcji explode do rozbicia łańcucha na tablicę. To daje:

Array
(
[5] ⇒ a1
[2] ⇒ a2
[0] ⇒ a10
[4] ⇒ a11
[6] ⇒ a12
[3] ⇒> a20
[1]⇒ a21
)
Array
(
[0] ⇒ a1
[1] ⇒ a10
[2] ⇒ a11
[3] ⇒ a12
[4] ⇒ a2
[5] ⇒ a20
[6] ⇒> a21
)

Standardowa biblioteka PHP (SPL): klasa ArrayObject

Biblioteka SPL zawiera klasę ArrayObject, która umożliwia tworzenie obiektów z tablic. Te obiekty mogą korzystać z metod klasy ArrayObject, które są wymienione na stronie podręcznika. Pozwala to na pracę z tablicami jako obiektami, jak w tym przykładzie z podręcznika PHP:

< ?php
$fruits = array("d" ⇒"lemon", "a" ⇒"orange", "b" ⇒"banana", "c" ⇒"apple");
$fruitArrayObject = new ArrayObject($fruits);
$fruitArrayObject->ksort();
foreach ($fruitArrayObject as $key => $val) {
echo "$key = $val\n";
}

Podczas konstruowania obiektu ArrayObject przekazujesz dane wejściowe, które mogą być tablicą lub obiektem. Możesz także opcjonalnie określić flagi:

Flaga : Efekt

ArrayObject :: STD_PROP_LIST : Właściwości obiektu mają swoją normalną wartość funkcjonalność przy dostępie jako lista (var_dump, foreach itp.).
ArrayObject :: ARRAY_AS_PROPS : Dostęp do wpisów można uzyskać jako właściwości (odczyt i zapis)

Te flagi można ustawić za pomocą metody setFlags (), jak w tym przykładzie z instrukcji:

< ?php
// Tablica dostępnych owoców
$fruits = array("lemons" ⇒ 1, "oranges" ⇒ 4, "bananas" ⇒ 5, "apples" ⇒ 10);
$fruitsArrayObject = new ArrayObject($fruits);
// Spróbuj użyć klucza tablicy jako właściwości
var_dump($fruitsArrayObject->lemons);
// Ustaw flagę, aby klucze tablicy mogły być używane jako właściwości ArrayObject
$fruitsArrayObject->setFlags(ArrayObject::ARRAY_AS_PROPS);
// Spróbuj ponownie
var_dump($fruitsArrayObject->lemons);

Dane wyjściowe:
NULL
int(1)

QUIZ

P1: Czy w kluczach PHP rozróżniana jest wielkość liter? Jakie będą wyniki tego skryptu?

< ?php
$ arr1 = ["A" ⇒ "apple", "B" ⇒ "banana"];
$ arr2 = ["a" ⇒ "aardvark", "b"⇒ "pawian"];
echo count ($ arr1 + $ arr2);
--------------------------------

To powoduje błąd
2
4
Żadne z powyższych

P2: Co wygeneruje ten skrypt?

< ?php
$arr = [
"a" ⇒ "jabłko",
"b" ⇒ "banan",
"c" ⇒ "wiśnia"
];
$ keys = array_keys ($ arr);
if (in_array ($ keys, 'a'))) {
echo "Znaleziono";
}
--------------------------------

Znaleziony
Nic
Warning: in_array() expects parameter 2 to be array
Żadne z powyższych

P3: Co wygeneruje ten skrypt?

< ?php
$birds = ['duck', 'chicken', 'goose'];
$net = ['dog', 'cat', 'chicken', 'goose', 'hamster'];
echo count(array_intersect_assoc($net, $birds));
--------------------------------

0
1
2
3
Żadne z powyższych

P4: Co wygeneruje ten skrypt?

< ?php
// Tablica dostępnych owoców
$fruits = array("lemons" ⇒ 1, "oranges" ⇒ 4, "bananas" ⇒ 5, "apples" ⇒ 10);
$fruitsArrayObject = new ArrayObject($fruits);
$fruitsArrayObject->setFlags(ArrayObject::ARRAY_AS_PROPS);
// Spróbuj użyć klucza tablicy jako właściwości
var_dump($fruitsArrayObject->lemons);
--------------------------------

To powoduje błąd
int(1)
string(6) "lemons"
Żadne z powyższych

P5: Co wygeneruje ten skrypt?

< ?php
$a = array('one','two');
$b = array('three','four','five');
echo count($a + $b);
--------------------------------

To powoduje błąd
2
3
5

P6: Co wygeneruje ten skrypt?

< ?php
$a = array('three','four','five');
$b = array('one','two');
echo count($a - $b);
--------------------------------

To powoduje błąd
3
2
1

P7: Jakie są wyniki następującego kodu?

< ?php
$ source = '12, 23,34 ';
$ arr = str_split ($ source, 2);
echo count ($ arr);
--------------------------------

To powoduje błąd
2
3
4

P8: Co wygeneruje ten kod?

< ?php
$keys = range(1, 6, 2);
$arr = array_fill_keys($keys, 'PHP');
krsort($arr);
$arr = array_flip($arr);
echo $arr['PHP'];
--------------------------------

Wystąpił błąd podczas wywoływania krsort ()
Wystąpił błąd podczas wywoływania array_flip ()
Nie można odwoływać się do klucza "PHP", ponieważ w tablicy jest więcej niż jeden z nich
1
5
6

P9: Co wygeneruje ten kod?

< ?php
$array = [
[1, 2],
[3, 4],
];
foreach ($array as list($a, $b)) {
echo "A: $a; B: $b" . PHP_EOL;
}
--------------------------------

A : 1; B: 2
A : 3; B: 4
Uwaga: Nieokreślone przesunięcie: 1
Niezdefiniowana zmienna $a
Żadne z powyższych

P10: Co wygeneruje ten kod?

< ?php
$arr = [1,2,3,4,5];
$spliced = array_splice ($ arr, 2, 1);
$number = array_shift($ arr);
echo $number;
--------------------------------

To powoduje błąd
1
3
5

ODPOWIEDZI

•  4

•  Warning: in_array() expects parameter 2 to be array

•  0

•  int(1)

•  3

• To powoduje błąd

•  4

•  1

• A : 1; B: 2 ; A : 3; B: 4

•  1