Darmowy fragment publikacji:
IDZ DO
IDZ DO
PRZYK£ADOWY ROZDZIA£
PRZYK£ADOWY ROZDZIA£
SPIS TREŒCI
SPIS TREŒCI
KATALOG KSI¥¯EK
KATALOG KSI¥¯EK
KATALOG ONLINE
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
TWÓJ KOSZYK
DODAJ DO KOSZYKA
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
ZAMÓW INFORMACJE
O NOWOŒCIACH
O NOWOŒCIACH
ZAMÓW CENNIK
ZAMÓW CENNIK
CZYTELNIA
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
PHP i MySQL.
Dla ka¿dego
Autor: Marcin Lis
ISBN: 83-7361-694-2
Format: B5, stron: 592
Szybki rozwój technologii informatycznych wywar³ wyj¹tkowo silny wp³yw na Internet.
Zmieni³a siê nie tylko szybkoœæ transmisji danych i sposoby ich zabezpieczania,
ale równie¿ metody tworzenia witryn WWW. Statyczne strony WWW s¹ stopniowo
wypierane przez dynamiczne witryny, pe³ne elementów interaktywnych i artyku³ów
generowanych w oparciu o bazy danych. Wœród narzêdzi i technologii stosowanych
do tworzenia tego typu witryn najwiêksz¹ popularnoœci¹ ciesz¹ siê jêzyk
programowania PHP oraz baza danych MySQL. Skrypty stworzone za pomoc¹ PHP
i korzystaj¹ce z danych zapisanych w tabelach MySQL-a „napêdzaj¹” zdecydowan¹
wiêkszoœæ dynamicznych witryn WWW.
„PHP i MySQL dla ka¿dego” to podrêcznik opisuj¹cy zasady wykorzystywania tych
dostêpnych bezp³atnie technologii do tworzenia stron i serwisów WWW. Czytaj¹c go,
nauczysz siê instalowaæ interpreter PHP i bazê danych MySQL w ró¿nych systemach
operacyjnych, tworzyæ skrypty w PHP i ³¹czyæ je z baz¹ danych. Poznasz zasady
programowania w jêzyku PHP i sposoby osadzania skryptów w kodzie strony WWW.
Dowiesz siê, jak projektowaæ bazy danych i w jaki sposób wykorzystywaæ jêzyk SQL
do manipulowania zawartymi w nich informacjami. W oparciu o te wiadomoœci
stworzysz elementy dynamicznej witryny WWW — licznik, mechanizmy autoryzacji
u¿ytkowników i generowania statystyk, wiadomoœci, ankiety, koszyk na zakupy i wiele
innych, w oparciu o które bêdziesz móg³ zbudowaæ w³asny serwis WWW oparty na
bazie danych i skryptach PHP.
(cid:129) Instalacja PHP w Windows i Linuksie
(cid:129) Podstawowe wiadomoœci o PHP
(cid:129) Instrukcje jêzyka PHP
(cid:129) Przetwarzanie danych z przegl¹darki WWW
(cid:129) Operacje na systemie plików
(cid:129) Obs³uga sesji i plików cookies
(cid:129) Instalacja i uruchomienie MySQL-a
(cid:129) Tworzenie tabel
(cid:129) Operacje na danych
(cid:129) £¹czenie skryptów z baz¹ danych
(cid:129) Uwierzytelnianie u¿ytkowników
(cid:129) Tworzenie modu³u statystyk
(cid:129) Komponenty dynamicznych witryn WWW
Do³¹cz do grona twórców witryn WWW korzystaj¹cych z PHP i MySQL-a
Spis treści
Wstęp .............................................................................................. 9
Rozdział 1. Podstawy ....................................................................................... 11
Czym jest PHP? .............................................................................................................. 11
Krótka historia PHP ........................................................................................................ 11
Instalacja ........................................................................................................................ 12
Linux ........................................................................................................................ 13
Windows .................................................................................................................. 15
Konfiguracja ................................................................................................................... 18
Pierwszy skrypt .............................................................................................................. 19
Jak to działa? .................................................................................................................. 20
Rozdział 2. Znaczniki, zmienne i typy danych .................................................... 23
Umieszczanie skryptów w kodzie HTML ...................................................................... 23
Znaczniki kanoniczne (klasyczne) ........................................................................... 23
Znaczniki typu SGML .............................................................................................. 24
Znaczniki typu ASP ................................................................................................. 24
Znaczniki skryptów HTML ...................................................................................... 24
Skrypty zewnętrzne ........................................................................................................ 25
Instrukcja include ..................................................................................................... 25
Instrukcja require ..................................................................................................... 26
Więcej o dołączaniu plików ..................................................................................... 27
Komentarze w skryptach ................................................................................................ 28
Komentarz blokowy ................................................................................................. 29
Komentarz jednowierszowy ..................................................................................... 30
Komentarz jednowierszowy uniksowy ..................................................................... 30
Typy danych ................................................................................................................... 30
Typy skalarne ........................................................................................................... 31
Typy złożone ............................................................................................................ 35
Typy specjalne ......................................................................................................... 35
Zmienne ......................................................................................................................... 36
Zmienne w PHP ....................................................................................................... 36
Tworzenie zmiennych .............................................................................................. 36
Jak wykryć typ zmiennej? ........................................................................................ 38
Zmienne globalne (superglobalne) ........................................................................... 40
Stałe ................................................................................................................................ 42
Stałe w PHP ............................................................................................................. 42
Stałe predefiniowane ................................................................................................ 42
4
PHP i MySQL dla każdego
Operatory ....................................................................................................................... 42
Operatory arytmetyczne ........................................................................................... 43
Operatory inkrementacji i dekrementacji ................................................................. 44
Operatory bitowe ...................................................................................................... 47
Operatory logiczne ................................................................................................... 49
Operatory relacyjne .................................................................................................. 51
Operator łańcuchowy ............................................................................................... 51
Operatory przypisania .............................................................................................. 52
Operatory tablicowe ................................................................................................. 53
Pozostałe operatory .................................................................................................. 55
Priorytet operatorów ................................................................................................ 57
Konwersje typów ............................................................................................................ 58
Zmiana typu zmiennej .............................................................................................. 58
Rzutowanie typów .................................................................................................... 59
Funkcje konwersji .................................................................................................... 60
Zasady konwersji ..................................................................................................... 62
Rozdział 3. Instrukcje sterujące i funkcje .......................................................... 65
Instrukcje warunkowe .................................................................................................... 65
Instrukcja if...else ..................................................................................................... 65
Instrukcja if...else if .................................................................................................. 66
Zagnieżdżanie instrukcji warunkowych ................................................................... 67
Operator warunkowy ...................................................................................................... 71
Instrukcja wyboru switch ............................................................................................... 72
Pętle ................................................................................................................................ 76
Pętla typu for ............................................................................................................ 76
Pętla typu while ........................................................................................................ 80
Pętla typu do...while ................................................................................................. 81
Pętla typu foreach ..................................................................................................... 82
Składnia alternatywna .................................................................................................... 84
Instrukcje warunkowe .............................................................................................. 84
Instrukcja switch ...................................................................................................... 86
Pętle ......................................................................................................................... 86
Instrukcje break i continue ............................................................................................. 87
Instrukcja break ........................................................................................................ 87
Instrukcja continue ................................................................................................... 89
Funkcje ........................................................................................................................... 91
Budowa funkcji ........................................................................................................ 91
Argumenty funkcji ................................................................................................... 91
Zwracanie wartości .................................................................................................. 93
Zasięg zmiennych .................................................................................................... 94
Argumenty funkcji raz jeszcze ................................................................................. 98
Rozdział 4. Tablice i obiekty ............................................................................. 103
Tablice .......................................................................................................................... 103
Tablice zwykłe ....................................................................................................... 103
Tablice asocjacyjne ................................................................................................ 106
Tablice wielowymiarowe ....................................................................................... 110
Operacje na tablicach ............................................................................................. 116
Obiekty ......................................................................................................................... 126
Odwołania do składowych ..................................................................................... 127
Odwołanie this ....................................................................................................... 128
Konstruktory .......................................................................................................... 129
Dziedziczenie ......................................................................................................... 130
Przesłanianie składowych ...................................................................................... 132
Spis treści
5
Rozdział 5. Przetwarzanie danych z przeglądarki .............................................. 135
Metoda GET ................................................................................................................. 136
Metoda POST ............................................................................................................... 140
Wysyłanie plików (upload) .......................................................................................... 141
Odbieranie plików (download) ..................................................................................... 145
Wysłanie pojedynczego pliku ................................................................................ 145
Wysyłanie pliku wybieranego z listy ..................................................................... 147
Automatyczne generowanie listy plików ............................................................... 150
Lista plików przechowywana w pliku tekstowym .................................................. 152
Rozdział 6. Ciągi znaków, data i czas ............................................................. 157
Ciągi znaków ................................................................................................................ 157
Formatowanie ciągów ............................................................................................ 159
Porównywanie ciągów ........................................................................................... 167
Przeszukiwanie ciągów .......................................................................................... 169
Przetwarzanie ciągów ............................................................................................. 170
Data i czas .................................................................................................................... 175
Funkcja checkdate .................................................................................................. 175
Funkcja date ........................................................................................................... 175
Funkcja getdate ...................................................................................................... 177
Funkcja gmdate ...................................................................................................... 178
Funkcja localtime ................................................................................................... 179
Funkcja microtime ................................................................................................. 180
Funkcja mktime ...................................................................................................... 180
Funkcja strftime ..................................................................................................... 181
Funkcja strtotime .................................................................................................... 183
Funkcja time ........................................................................................................... 183
Rozdział 7. System plików .............................................................................. 185
Obsługa struktury plików i katalogów .......................................................................... 185
Odczyt zawartości katalogu ................................................................................... 185
Tworzenie i usuwanie katalogów ........................................................................... 189
Zmiana katalogu bieżącego .................................................................................... 189
Odczytywanie informacji o plikach ....................................................................... 190
Miejsce na dysku .................................................................................................... 191
Usuwanie zawartości katalogu ............................................................................... 193
Nawigacja po katalogach ....................................................................................... 193
Obsługa plików ............................................................................................................ 195
Otwieranie i zamykanie plików .............................................................................. 195
Odczyt danych ....................................................................................................... 197
Zapis danych .......................................................................................................... 203
Poruszanie się po danych w pliku .......................................................................... 205
Synchronizacja dostępu .......................................................................................... 206
Wykorzystanie plików do przechowywania danych ..................................................... 208
Licznik zwykły ....................................................................................................... 208
Licznik graficzny ................................................................................................... 209
Ankieta ................................................................................................................... 211
Logowanie .............................................................................................................. 217
Generowanie listy odnośników .............................................................................. 219
Rozdział 8. Cookies i sesje ............................................................................. 223
Cookies ......................................................................................................................... 223
Czym są cookies? ................................................................................................... 223
Jak zapisać cookie? ................................................................................................ 223
Jak odczytać cookie? .............................................................................................. 225
Wykorzystanie cookies .......................................................................................... 226
6
PHP i MySQL dla każdego
Obsługa sesji ................................................................................................................ 228
Mechanizm sesji ..................................................................................................... 228
Obsługa sesji .......................................................................................................... 229
Uwierzytelnianie z wykorzystaniem mechanizmu sesji ........................................... 236
Śledzenie użytkownika ........................................................................................... 241
Rozdział 9. Podstawy MySQL .......................................................................... 243
Czym jest MySQL? ...................................................................................................... 243
Instalacja i konfiguracja ............................................................................................... 244
Instalacja w systemie Windows ............................................................................. 244
Konfiguracja w systemie Windows ........................................................................ 247
Instalacja w systemie Linux ................................................................................... 250
Zarządzanie serwerem .................................................................................................. 251
Uruchamianie serwera ............................................................................................ 251
Kończenie pracy serwera ....................................................................................... 253
Narzędzia dodatkowe ................................................................................................... 254
Koncepcja relacyjnych baz danych .............................................................................. 256
Tabele ..................................................................................................................... 256
Klucze .................................................................................................................... 257
Relacje ................................................................................................................... 258
Jak projektować tabele bazy? ................................................................................. 261
Tworzenie i obsługa baz ............................................................................................... 265
Łączenie z serwerem .............................................................................................. 265
Tworzenie i usuwanie baz ...................................................................................... 266
Zarządzanie kontami użytkowników ...................................................................... 267
Praca z wieloma bazami ......................................................................................... 273
Pobieranie listy baz i tabel ..................................................................................... 273
Kodowanie znaków ................................................................................................ 274
Wczytywanie poleceń z plików zewnętrznych ....................................................... 277
Rozdział 10. Podstawy SQL .............................................................................. 279
Czym jest SQL? ........................................................................................................... 279
Tabele ........................................................................................................................... 280
Tworzenie tabel ...................................................................................................... 280
Typy danych w kolumnach .................................................................................... 282
Pobranie struktury tabeli ........................................................................................ 289
Modyfikacja tabel .................................................................................................. 290
Usuwanie tabel ....................................................................................................... 292
Zapytania wprowadzające dane .................................................................................... 293
Pierwsza postać instrukcji INSERT ....................................................................... 293
Druga postać instrukcji INSERT ............................................................................ 295
Wstawianie wielu wierszy ...................................................................................... 295
Zapytania pobierające dane .......................................................................................... 296
Pobieranie zawartości całej tabeli .......................................................................... 297
Sortowanie wyników .............................................................................................. 297
Pobieranie zawartości wybranych kolumn ............................................................. 299
Zmiana nazw kolumn w wynikach zapytania ......................................................... 299
Selektywne pobieranie danych ............................................................................... 300
Ograniczanie liczby wierszy w wynikach zapytania .............................................. 304
Zapytania modyfikujące dane ....................................................................................... 305
Zapytania usuwające dane ............................................................................................ 306
Wstawianie specjalne ................................................................................................... 307
Spis treści
7
Rozdział 11. Więcej o SQL ................................................................................ 309
Pobieranie danych z wielu tabel ................................................................................... 309
Złączenia ................................................................................................................ 309
Typy złączeń .......................................................................................................... 311
Agregacja (grupowanie) danych ................................................................................... 314
Funkcje statystyczne .............................................................................................. 314
Grupowanie wyników zapytań ............................................................................... 318
Warunki grupowania .............................................................................................. 320
Funkcje agregujące w złączeniach ......................................................................... 320
Typy tabel ..................................................................................................................... 323
Indeksy ......................................................................................................................... 325
Więzy integralności — klucze obce ............................................................................. 327
Tworzenie ograniczeń ............................................................................................ 327
Dodawanie i usuwanie ograniczeń w istniejących tabelach ................................... 329
Podzapytania ................................................................................................................ 330
Podzapytania proste ............................................................................................... 330
Podzapytania skorelowane ..................................................................................... 332
Podzapytania w klauzuli FROM ............................................................................ 333
Podzapytania w instrukcjach INSERT, UPDATE, DELETE ................................. 334
Rozdział 12. Tworzenie bazy w praktyce ............................................................ 337
Założenia ...................................................................................................................... 337
Diagramy tabel ............................................................................................................. 338
Tworzenie tabel ............................................................................................................ 341
Indeksy i więzy integralności ....................................................................................... 348
Baza w praktyce ........................................................................................................... 353
Rozdział 13. Współpraca PHP i MySQL ............................................................. 359
Konfiguracja PHP ........................................................................................................ 360
Łączenie z bazą danych ................................................................................................ 361
Kończenie połączenia z bazą danych ........................................................................... 362
Wybór bazy .................................................................................................................. 362
Problem polskich liter .................................................................................................. 364
Obsługa zapytań ........................................................................................................... 365
Zapytania typu SELECT ........................................................................................ 366
Zapytania typu INSERT, UPDATE, DELETE ...................................................... 372
Rozdział 14. Autoryzacje .................................................................................. 377
Proste uwierzytelnianie ................................................................................................ 377
Uwierzytelnianie z wykorzystaniem sesji ..................................................................... 381
Rejestracja nowych użytkowników .............................................................................. 386
Rozdział 15. Generowanie statystyk ................................................................. 397
Wstępne założenia i struktura danych .......................................................................... 397
Funkcje pomocnicze ..................................................................................................... 399
Część główna ............................................................................................................... 407
Generowanie statystyk ................................................................................................. 413
Rozdział 16. Zarządzanie kontami użytkowników ............................................... 427
Rozdział 17. System news ................................................................................ 447
Rozdział 18. System zbierania opinii ................................................................. 473
Rozdział 19. Subskrypcje .................................................................................. 487
8
PHP i MySQL dla każdego
Rozdział 20. Forum .......................................................................................... 505
Rozdział 21. Tworzenie sklepu internetowego ................................................... 527
Główna część serwisu .................................................................................................. 527
Logowanie i rejestracja użytkowników ........................................................................ 535
Funkcje obsługi sklepu ................................................................................................. 544
Wyszukiwanie danych ........................................................................................... 545
Prezentacja szczegółowych danych książki ........................................................... 550
Obsługa koszyka .................................................................................................... 552
Obsługa zamówień ................................................................................................. 558
Skorowidz ..................................................................................... 565
Rozdział 4.
Tablice i obiekty
Tablice
Tablice to występujące w większości języków programowania struktury, pozwalające
na przechowywanie zbioru danych określonego typu. Tablicę można sobie wyobrazić
jako wektor elementów, taki jak zaprezentowany na rysunku 4.1. Zawartością pojedyn-
czej komórki tablicy może być wartość dowolnego typu danych. W PHP dostępne są
dwa rodzaje tablic: klasyczne (indeksowane numerycznie) oraz asocjacyjne. Dostęp do
poszczególnych danych zawartych w tablicy uzyskuje się poprzez podanie indeksu (in-
aczej klucza), pod którym dana wartość została zapisana.
Rysunek 4.1.
Struktura typowej
tablicy
Tablice zwykłe
Aby utworzyć prostą tablicę indeksowaną numerycznie, należy użyć słowa kluczowego
array w schematycznej postaci:
$tablica = array( wartość1 , wartość2 ,..., wartośćn );
gdzie: tablica to nazwa zmiennej tablicowej, dzięki której będziemy mogli się do tej
tablicy odwoływać, natomiast wart1, wart2 itd. to wartości kolejnych komórek. W przy-
padku dużej liczby wartości w celu zwiększania czytelności można również zastoso-
wać zapis w postaci:
$tablica = array(
wartość1 ,
wartość2 ,
...,
wartośćn );
104
PHP i MySQL dla każdego
Zobaczmy, jak to będzie wyglądać w praktyce. Obrazuje to skrypt widoczny na li-
stingu 4.1.
Listing 4.1. Deklaracja prostej tablicy
?php
$kolory = array( czerwony , zielony , niebieski );
echo( kolory[0] = $kolory[0] br );
echo( kolory[1] = $kolory[1] br );
echo( kolory[2] = $kolory[2] br );
?
Powstała tutaj tablica o nazwie kolory, której kolejnym komórkom zostały przypisane
ciągi znaków określające kolory: czerwony, zielony i niebieski. Aby uzyskać dostęp do
wartości zapisanej w danej komórce, należy podać jej numer (indeks) w nawiasach kwa-
dratowych występujących za nazwą tablicy. Należy przy tym pamiętać, że indekso-
wanie tablicy zaczyna się od zera, co oznacza że indeksem pierwszej komórki jest 0,
a NIE 1. Aby zatem odczytać zawartość pierwszej komórki, piszemy $kolory[0], dru-
giej komórki — $kolory[1], a trzeciej komórki — $kolory[2]. Dzięki temu po urucho-
mieniu skryptu na ekranie ukaże się widok przedstawiony na rysunku 4.2.
Rysunek 4.2.
Wyświetlenie
zawartości
tablicy kolory
Do odczytu zawartości tablicy można wykorzystać również pętle. Są one przydatne
w szczególności wtedy, gdy tablica ma duże rozmiary. Na listingu 4.2 został przed-
stawiony skrypt realizujący takie samo zadanie, jak skrypt z listingu 4.1 (czyli utworze-
nie tablicy i wyświetlenie jej zawartości), wykorzystujący jednak pętlę typu for.
Listing 4.2. Wykorzystanie pętli for do wyświetlenia zawartości tablicy
?php
$kolory = array( czerwony , zielony , niebieski );
for($i = 0; $i 3; $i++){
echo( kolory[$i] = $kolory[$i] br );
}
?
Tablica może zostać również utworzona poprzez bezpośrednie przypisywanie warto-
ści jej komórkom. Przykładowo zamiast pisać:
$kolory = array( czerwony , zielony , niebieski );
Rozdział 4. ♦ Tablice i obiekty
105
można wykorzystać serię instrukcji w postaci:
$kolory[0] = czerwony ;
$kolory[1] = zielony ;
$kolory[2] = niebieski ;
W ten sam sposób można również zmieniać zawartość poszczególnych komórek. Taką
technikę obrazuje skrypt przedstawiony na listingu 4.3.
Listing 4.3. Modyfikacja komórek tablicy
?php
$kolory[0] = czerwony ;
$kolory[1] = zielony ;
$kolory[2] = niebieski ;
echo( Pierwotna zawartość tablicy: br );
for($i = 0; $i 3; $i++){
$kolor = $kolory[$i];
echo( kolory[$i] = $kolor br );
}
$kolory[0] = żółty ;
$kolory[1] = fioletowy ;
$kolory[2] = czarny ;
echo( br Zawartość tablicy po zmianach: br );
for($i = 0; $i 3; $i++){
$kolor = $kolory[$i];
echo( kolory[$i] = $kolor br );
}
?
W pierwszej części skryptu powstała tablica kolory, której kolejnym indeksom zostały
przypisane wartości czerwony, zielony i niebieski. Ściślej rzecz ujmując tablica po-
wstała po wykonaniu instrukcji $kolory[0] = czerwony ;. PHP po napotkaniu tej in-
strukcji i stwierdzeniu, że w skrypcie nie ma tablicy o nazwie kolory, tworzy ją i przy-
pisuje komórce o indeksie 0 wartość występującą między cudzysłowami. Kolejne dwie
instrukcje to nic innego jak utworzenie kolejnych dwóch komórek w tablicy kolory
i przypisanie im wskazanych wartości. Po przeprowadzeniu wymienionych operacji jest
wykonywana pętla for, która wyświetla zawartość całej tablicy w przeglądarce.
Za pętlą znajduje się instrukcja $kolory[0] = żółty ;. Ponieważ istnieje już tablica
o nazwie kolory, powoduje ona przypisanie komórce o indeksie 0 ciągu znaków żółty.
W tym momencie zostaje również utracona poprzednia zawartość tej komórki, czyli ciąg
czerwony. Podobnie działają dwie kolejne instrukcje. Zamieniają występujące w tablicy
wartości z komórek 1 i 2 na ciągi znaków fioletowy i czarny. Po przeprowadzeniu tych
operacji jest wykonywana druga pętla for, która wysyła do przeglądarki aktualną za-
wartość tablicy. Tym samym po wykonaniu skryptu na ekranie zobaczymy widok za-
prezentowany na rysunku 4.3.
D:PDFPHP i MySQL dla każdego 4.doc
(05-09-12) 105
106
Rysunek 4.3.
Ilustracja działania
skryptu z listingu 4.3
PHP i MySQL dla każdego
Tablice asocjacyjne
Oprócz tablic indeksowanych numerycznie w PHP istnieją również tablice asocjacyjne.
W tablicach tego typu każdemu indeksowi można nadać unikalną nazwę, czyli zamiast
indeksów 0, 1, 2 itd. mogą występować indeksy: kolor, autor, procesor itp. Najczę-
ściej też zamiast terminu indeks stosuje się inny termin — klucz. Mówimy zatem, że
w tablicy asocjacyjnej występują pary klucz-wartość, w których każdy klucz jedno-
znacznie identyfikuje przypisaną mu wartość. Tablicę tego typu tworzy się — podobnie
jak w przypadku tablic klasycznych indeksowanych numerycznie — za pomocą słowa
kluczowego array; konstrukcja ta ma jednak nieco inną postać. Schematycznie wygląda
to następująco:
array(
klucz1 = wartość1,
klucz2 = wartość2,
...
kluczn = wartośćn
);
Na listingu 4.4 został przedstawiony krótki skrypt, który pokazuje, w jaki sposób utwo-
rzyć tablicę asocjacyjną i odczytać zapisane w niej wartości.
Listing 4.4. Utworzenie tablicy asocjacyjnej
?php
$kolory = array(
kolor1 = czerwony ,
kolor2 = zielony ,
kolor3 = niebieski
);
echo( Zawartość tablicy: br );
echo( kolory[ kolor1 ] = );
echo($kolory[ kolor1 ]);
Rozdział 4. ♦ Tablice i obiekty
107
echo( br kolory[ kolor2 ] = );
echo($kolory[ kolor2 ]);
echo( br kolory[ kolor3 ] = );
echo($kolory[ kolor3 ]);
?
W skrypcie została utworzona tablica kolory, zawierająca trzy klucze o nazwach: kolor1,
kolor2 i kolor3. Kluczowi kolor1 został przypisany ciąg znaków czerwony, kluczowi
kolor2 — ciąg znaków zielony, a kluczowi kolor3 — ciąg znaków niebieski. Dzięki
temu po zastosowaniu konstrukcji w schematycznej postaci:
nazwa_tablicy[ nazwa_klucza ]
otrzymamy wartość odpowiadającą danemu kluczowi. Ten fakt został wykorzystany do
wyświetlenia zawartości poszczególnych kluczy tablicy w przeglądarce. Instrukcja echo
($kolory[ kolor1 ]); wyświetla zawartość klucza kolor1, instrukcja echo($kolory
[ kolor3 ]) — klucza kolor2, a instrukcja echo($kolory[ kolor3 ]) — klucza kolor3.
Tym samym na ekranie zobaczymy widok zaprezentowany na rysunku 4.4.
Rysunek 4.4.
Efekt działania
skryptu z listingu 4.4
Drugim ze sposobów tworzenia tablicy asocjacyjnej jest użycie składni z nawiasami
kwadratowymi, podobnie jak miało to miejsce w przypadku tablic indeksowanych nu-
merycznie. Schematycznie taka konstrukcja ma postać:
nazwa_tablicy[ nazwa_klucza ] = wartość_klucza;
Na listingu 4.5 został przedstawiony skrypt, który realizuje takie samo zadanie jak
skrypt 4.4, czyli utworzenie tablicy asocjacyjnej i wyświetlenie jej zawartości, ale wy-
korzystujący zaprezentowaną powyżej składnię.
Listing 4.5. Drugi sposób tworzenia tablic asocjacyjnych
?php
$kolory[ kolor1 ] = czerwony ;
$kolory[ kolor2 ] = zielony ;
$kolory[ kolor3 ] = niebieski ;
echo( Zawartość tablicy: br );
echo( kolory[ kolor1 ] = );
echo($kolory[ kolor1 ]);
D:PDFPHP i MySQL dla każdego 4.doc
(05-09-12) 107
108
PHP i MySQL dla każdego
echo( br kolory[ kolor2 ] = );
echo($kolory[ kolor2 ]);
echo( br kolory[ kolor3 ] = );
echo($kolory[ kolor3 ]);
?
Pierwsza instrukcja tego skryptu powoduje utworzenie tablicy asocjacyjnej o nazwie
kolory oraz umieszczenie w niej klucza o nazwie kolor1, powiązanego z ciągiem zna-
ków czerwony. Kolejne dwie instrukcje powodują umieszczenie w istniejącej już tablicy
dwóch kolejnych kluczy: kolor2 i kolor3 oraz przypisanie do nich odpowiadającym im
wartości. Zawartość poszczególnych kluczy tak utworzonej tablicy jest następnie wy-
syłana do przeglądarki za pomocą serii instrukcji echo.
Do odczytu tablic asocjacyjnych można, podobnie jak w przypadku tablic klasycznych,
użyć pętli. Nie może być to jednak pętla typu for, gdyż nie zdoła ona stwierdzić, jakie
są wartości kluczy. Dlatego też tablice asocjacyjne są obsługiwane przez pętle typu
foreach (por. rozdział 3., sekcja „Pętla typu foreach”). Taka pętla potrafi pobrać kolejne
wartości kluczy; jak to zrobić, obrazuje skrypt z listingu 4.6.
Listing 4.6. Wykorzystanie pętli typu foreach
?php
$kolory[ kolor1 ] = czerwony ;
$kolory[ kolor2 ] = zielony ;
$kolory[ kolor3 ] = niebieski ;
echo( Zawartość tablicy: br );
foreach($kolory as $kolor){
echo($kolor);
echo( br );
}
?
Konstrukcja tego typu pętli oznacza, że w każdym jej przebiegu pod zmienną kolor
będzie podstawiana wartość kolejnego klucza. A zatem zmienna kolor w pierwszym
przebiegu pętli będzie zawierała ciąg znaków czerwony, w drugim przebiegu — ciąg
znaków zielony, a w trzecim przebiegu — ciąg znaków niebieski. W momencie kiedy
zostaną odczytane wartości wszystkich kluczy, pętla zakończy działanie. W ten sposób
uzyskamy jednak jedynie wartości kluczy, nie zaś nazwy kluczy. Jeśli również ta infor-
macja jest nam potrzebna, trzeba zastosować drugą wersję pętli foreach. Przykład tej
konstrukcji został zaprezentowany na listingu 4.7.
Listing 4.7. Inna wersja pętli foreach
?php
$kolory[ kolor1 ] = czerwony ;
$kolory[ kolor2 ] = zielony ;
$kolory[ kolor3 ] = niebieski ;
echo( Zawartość tablicy: br );
Rozdział 4. ♦ Tablice i obiekty
109
foreach($kolory as $klucz = $kolor){
echo( kolory[ $klucz ] = $kolor );
echo( br );
}
?
Tym razem, w każdym przebiegu pętli, pod zmienną klucz podstawiana jest nazwa ko-
lejnego klucza, a pod zmienną kolor — wartość przypisana temu kluczowi. Dzięki
temu, za pomocą instrukcji echo, możemy wysłać do przeglądarki wszystkie istotne in-
formacje o zawartości tablicy. Efekt działania kodu będzie taki sam jak skryptu z listin-
gu 4.4 (rysunek 4.4).
Modyfikacji zawartości tablic asocjacyjnych dokonuje się analogicznie do zmian w przy-
padku tablic klasycznych. Oczywiście zamiast indeksów numerycznych trzeba zastoso-
wać wartości kluczy. Aby zatem przypisać nową wartość już istniejącemu kluczowi,
trzeba skorzystać z konstrukcji, której schematyczna postać jest następująca:
nazwa_tablicy[ nazwa_klucza ] = wartość;
Na listingu 4.8 pokazany został przykładowy skrypt, który wykonuje modyfikację za-
wartości tablicy asocjacyjnej kolory.
Listing 4.8. Modyfikacja zawartości tablicy asocjacyjnej
?php
$kolory[ kolor1 ] = czerwony ;
$kolory[ kolor2 ] = zielony ;
$kolory[ kolor3 ] = niebieski ;
echo( Zawartość tablicy po utworzeniu: br );
foreach($kolory as $klucz = $kolor){
echo( kolory[ $klucz ] = $kolor );
echo( br );
}
$kolory[ kolor1 ] = żółty ;
$kolory[ kolor2 ] = fioletowy ;
$kolory[ kolor3 ] = czarny ;
echo( br Zawartość tablicy po modyfikacji: br );
foreach($kolory as $klucz = $kolor){
echo( kolory[ $klucz ] = $kolor );
echo( br );
}
Tablica kolory jest tu tworzona w sposób analogiczny do przedstawionego w poprzed-
nim przykładzie. Tak samo jest również wyświetlana jej pierwotna zawartość. Klu-
czowi kolor1 został przypisany ciąg znaków czerwony, kluczowi kolor2 — ciąg zna-
ków zielony, a kluczowi kolor3 — ciąg znaków niebieski. Po wykonaniu pętli for
wyświetlającej te dane na ekranie wykonywana jest instrukcja $kolory[ kolor1 ] =
żółty ;. Ponieważ tablica kolory już istnieje i jest w niej zawarty klucz kolor1, na-
stępuje modyfikacja przypisanej do niego wartości, z czerwony na żółty. Analogiczne
D:PDFPHP i MySQL dla każdego 4.doc
(05-09-12) 109
110
PHP i MySQL dla każdego
operacje wykonywane są z wartościami kluczy kolor2 i kolor3. Po wykonaniu tych
modyfikacji zawartość tablicy jest ponownie wysyłana do przeglądarki. Tym samym po
uruchomieniu skryptu na ekranie zobaczymy widok zaprezentowany na rysunku 4.5.
Rysunek 4.5.
Zawartość tablicy
została zmodyfikowana
Tablice wielowymiarowe
Do tej pory omawialiśmy tablice jednowymiarowe, czyli takie, które są wektorami ele-
mentów, o strukturze przedstawionej na rysunku 4.1. Aby odczytać dane z pojedyn-
czej komórki, wystarczyło podać jej indeks lub, w przypadku tablic asocjacyjnych,
nazwę klucza. PHP umożliwia jednak budowanie bardziej skomplikowanych struktur
— tablic wielowymiarowych. Przykładowa struktura prostej tablicy dwuwymiarowej
została przedstawiona na rysunku 4.6. Jak widać, aby otrzymać wartość danej komórki,
trzeba znać dwie liczby określające jej położenie: numer rzędu i numer kolumny. Na
przykład komórka zawierająca wartość 8 znajduje się w rzędzie o indeksie 1 i kolum-
nie o indeksie 2.
Rysunek 4.6.
Struktura przykładowej
tablicy dwuwymiarowej
Tworzenie tablic wielowymiarowych
Do tworzenia tablic wielowymiarowych w PHP wykorzystuje się fakt, że pojedyncza
komórka zwykłej tablicy jednowymiarowej może zawierać dane dowolnego typu, a zatem
również inną tablicę. Wynika z tego, że tablica dwuwymiarowa to nic innego jak tablica
jednowymiarowa, w której komórkach zawarte zostały inne tablice jednowymiarowe.
Rozdział 4. ♦ Tablice i obiekty
111
Spróbujmy wykonać prosty przykład. Na listingu 4.9 został zaprezentowany kod two-
rzący tablicę dwuwymiarową, w której komórkach zostały zawarte kolejne liczby od
1 do 6, i wyświetlający jej zawartość na ekranie.
Listing 4.9. Tworzenie tablicy dwuwymiarowej
?php
$tablica = array(
array(1, 2, 3),
array(4, 5, 6)
);
echo( tablica[0][0] = . $tablica[0][0] . br );
echo( tablica[0][1] = . $tablica[0][1] . br );
echo( tablica[0][2] = . $tablica[0][2] . br );
echo( tablica[1][0] = . $tablica[1][0] . br );
echo( tablica[1][1] = . $tablica[1][1] . br );
echo( tablica[1][2] = . $tablica[1][2] . br );
?
Konstrukcja tworząca tablicę tablica dosyć dokładnie odzwierciedla sposób, w jaki ona
powstaje. W pierwszej komórce (o indeksie 0) została umieszczona tablica trójelemen-
towa zawierająca liczby 1, 2, 3, natomiast w komórce drugiej (o indeksie 1) została
umieszczona, również trójelementowa, tablica zawierająca liczby 4, 5, 6. Utworzyliśmy
więc w ten sposób strukturę o dwóch rzędach i trzech kolumnach. Dostęp do poszcze-
gólnych komórek wymaga zatem podania numeru wiersza i kolumny, schematycznie:
$tablica[wiersz][kolumna]
Ten sposób odwoływania się do komórek tablicy jest wykorzystywany w instrukcjach
echo do wyświetlenia wszystkich zawartych w niej wartości w przeglądarce (rysunek 4.7).
Rysunek 4.7.
Wyświetlenie zwartości
tablicy dwuwymiarowej
Do odczytu zawartości takiej tablicy można również wykorzystać dwie zagnieżdżone
pętle for. Taki sposób jest szczególnie przydatny wówczas, gdy tablica ma dużą licz-
bę wierszy i kolumn. Kod z listingu 4.10 obrazuje, jak wykonać takie zadanie dla tablicy
powstałej w poprzednim przykładzie.
D:PDFPHP i MySQL dla każdego 4.doc
(05-09-12) 111
112
PHP i MySQL dla każdego
Listing 4.10. Wykorzystanie pętli for do odczytu tablicy
?php
$tablica = array(
array(1, 2, 3),
array(4, 5, 6)
);
for($i = 0; $i 2; $i++){
for($j = 0; $j 3; $j++){
$wart = $tablica[$i][$j];
echo( tablica[$i][$j] = $wart );
echo( br );
}
echo( br );
}
?
Zewnętrzna pętla for, ze zmienną iteracyjną i, kontroluje numer aktualnie odczytywa-
nego wiersza tablicy, natomiast wewnętrzna pętla for, ze zmienną iteracyjną j, kon-
troluje numer aktualnie odczytywanej kolumny tablicy. Wartości kolejnych komórek
są po odczytaniu zapisywane w zmiennej pomocniczej wart, która jest następnie wy-
korzystywana jako parametr instrukcji echo.
Tablice wielowymiarowe nie muszą być indeksowane numerycznie; mogą być również
strukturami asocjacyjnymi. Każdemu indeksowi można przypisać jego własną nazwę.
Spróbujmy więc utworzyć i taką tablicę. Załóżmy, że mają być w niej przechowywa-
ne dane dotyczące książek w bibliotece. Pojedynczy wiersz przechowywał będzie dane
dotyczące tytułu, autora i numeru katalogowego. Podstawowa tablica będzie mogła prze-
chowywać wiele takich wierszy, a więc opisywać wiele książek. Jej struktura będzie
zatem następująca:
$tablica = array(
array( Autor = Autor1 ,
Tytuł = Tytuł1 ,
Numer = Numer1 ),
array( Autor = Autor2 ,
Tytuł = Tytuł2 ,
Numer = Numer2 ),
array( Autor = Autor3 ,
Tytuł = Tytuł3 ,
Numer = Numer3 )
);
W ten sposób otrzymalibyśmy sam zbiór książek. Książki w bibliotece zazwyczaj stoją
jednak na regałach. Moglibyśmy wprowadzić więc dodatkową tablicę opisującą regały.
Jej zawartością byłyby tablice opisujące książki. Powstałaby w ten sposób struktura
trójwymiarowa, schematycznie przedstawiona na rysunku 4.8. Spróbujmy zbudować ta-
ką tablicę, wprowadzając do niej przykładowe dane, i wyświetlić jej zawartość na
ekranie. To zadanie realizuje skrypt widoczny na listingu 4.11.
Rozdział 4. ♦ Tablice i obiekty
113
Rysunek 4.8.
Schematyczna struktura
tablicy trójwymiarowej
Listing 4.11. Skrypt obsługujący tablicę trójwymiarową
?php
$biblioteka = array(
regał1 = array
(
array( Autor = Autor1 ,
Tytuł = Tytuł1 ,
Numer = Numer1 ),
array( Autor = Autor2 ,
Tytuł = Tytuł2 ,
Numer = Numer2 ),
array( Autor = Autor3 ,
Tytuł = Tytuł3 ,
Numer = Numer3 )
),
regał2 = array
(
array( Autor = Autor4 ,
Tytuł = Tytuł4 ,
Numer = Numer4 ),
array( Autor = Autor5 ,
Tytuł = Tytuł5 ,
Numer = Numer6 ),
array( Autor = Autor6 ,
Tytuł = Tytuł6 ,
Numer = Numer6 )
),
regał3 = array
(
array( Autor = Autor7 ,
Tytuł = Tytuł7 ,
Numer = Numer7 ),
array( Autor = Autor8 ,
Tytuł = Tytuł8 ,
Numer = Numer8 ),
array( Autor = Autor9 ,
Tytuł = Tytuł9 ,
Numer = Numer9 )
)
);
foreach($biblioteka as $regal_nazwa = $regal){
echo( Regał: $regal_nazwa br );
foreach($regal as $ksiazka){
$autor = $ksiazka[ Autor ];
$tytuł = $ksiazka[ Tytuł ];
$numer = $ksiazka[ Numer ];
D:PDFPHP i MySQL dla każdego 4.doc
(05-09-12) 113
114
PHP i MySQL dla każdego
echo $autor | $tytuł | $numer ;
echo( br );
}
echo( br );
}
Mamy tu zatem tablicę główną o nazwie biblioteka. Zawiera ona trzy klucze o na-
zwach regał1, regał2 i regał3. Pod każdym kluczem znajdują się kolejne tablice, za-
wierające dane opisujące książki w danym regale. Każda taka tablica składa się z serii
tablic jednowymiarowych o kluczach Autor, Tytuł i Numer. Razem tworzy to pełny opis
książek w bibliotece. Ponieważ ręczne pobieranie danych w celu wyświetlenia całej za-
wartości tablicy biblioteka byłoby bardzo niewygodne i czasochłonne, do ich prezen-
tacji zostały wykorzystane dwie zagnieżdżone pętle foreach.
Pętla zewnętrzna odczytuje zawartość kluczy tablicy głównej biblioteka. Pod zmien-
ną regal_nazwa podstawiane są nazwy odczytanych kluczy, natomiast pod zmienną
regal — ich zawartość. Zawartością każdego klucza jest tablica zawierająca spis ksią-
żek z danego regału, a zatem do jej odczytania wykorzystywana jest wewnętrzna pętla
foreach. Pętla ta odczytuje zawartość kolejnych komórek tablicy regal, podstawiając je
pod zmienną ksiazka. Zawartość tej zmiennej będzie niczym innym, jak tablicą jed-
nowymiarową opisującą pojedynczą książkę. Indeksami tej tablicy są więc: Autor, Tytuł
i Numer. Dane te są odczytywane, zapisywane w zmiennych pomocniczych i wysyłane do
przeglądarki za pomocą instrukcji echo. Ostatecznie na ekranie zobaczymy zawartość
całej biblioteki z podziałem na regały, tak jak zostało to przedstawione na rysunku 4.9.
Rysunek 4.9.
Efekt działania
skryptu
z listingu 4.11
Tablice nieregularne
Tablice wielowymiarowe wcale nie muszą mieć regularnie prostokątnych kształtów, tak
jak prezentowane w poprzednich akapitach. Prostokątnych to znaczy takich, gdzie
w każdym wierszu znajduje się taka sama liczba komórek (czyli struktur podobnych do
Rozdział 4. ♦ Tablice i obiekty
115
prezentowanej na rysunku 4.6). Nic nie stoi na przeszkodzie, aby stworzyć strukturę
trójkątną (rysunek 4.10a) lub też całkiem nieregularną (rysunek 4.10b). Przy tworze-
niu takich struktur czeka nas jednak więcej pracy niż w przypadku tablic regularnych,
gdyż przeważnie każdy wiersz trzeba będzie tworzyć oddzielnie.
Rysunek 4.10.
Przykłady
nieregularnych tablic
wielowymiarowych
Jak tworzyć tego typu struktury? Wiemy już, że tablice wielowymiarowe to tak na-
prawdę tablice tablic jednowymiarowych. A zatem tablica dwuwymiarowa to tablica
jednowymiarowa zawierająca szereg tablic jednowymiarowych, tablica trójwymiarowa
to tablica jednowymiarowa zawierająca w sobie tablice dwuwymiarowe itd. Spróbuj-
my zatem stworzyć strukturę widoczną na rysunku 4.10b, wypełnioną wartościami od 1
do 10, i wyświetlić jej zawartość w przeglądarce. To zadanie realizuje kod widoczny na
listingu 4.12.
Listing 4.12. Tworzenie tablicy nieregularnej
?php
$tablica = array
(
array(1, 2, 3, 4),
array(5, 6),
array(7),
array(8, 9, 10)
);
foreach($tablica as $tab){
foreach($tab as $val){
echo( $val );
}
echo( br );
}
?
Postać skryptu nie powinna być żadnym zaskoczeniem. Sposób tworzenia tablicy jest
analogiczny do przedstawionego w poprzednich przykładach, z tą różnicą, że tym ra-
zem tablice składowe mają różne wielkości. Pierwsza zawiera cztery komórki, druga
dwie, trzecia jedną, a czwarta trzy. Sposób odczytywania zawartości jest również po-
dobny do przykładu z listingu 4.12, a nawet nieco prostszy. Pętla zewnętrzna odczytuje
kolejne komórki tablicy tablica. Każda z tych komórek zawiera kolejną tablicę o pew-
nej liczbie elementów, które odczytywane są za pomocą wewnętrznej pętli foreach. Tym
samym po uruchomieniu skryptu zobaczymy widok jak na rysunku 4.11.
D:PDFPHP i MySQL dla każdego 4.doc
(05-09-12) 115
116
Rysunek 4.11.
Zawartość tablicy
nieregularnej
z przykładu 4.12
PHP i MySQL dla każdego
Operacje na tablicach
Sortowanie tablic klasycznych
Jedną z operacji często wykonywanych na tablicach jest sortowanie, czyli ustawienie
elementów w danym porządku. PHP oferuje kilka wbudowanych funkcji sortujących.
Zobaczmy, w jaki sposób można z nich korzystać. Funkcją podstawową jest sort.
Działa ona zarówno na wartościach liczbowych, jak i na ciągach znaków. Jako argument
jej wywołania należy podać nazwę tablicy. Spójrzmy na listing 4.13. Zawiera on kod
sortujący dwie różne tablice.
Listing 4.13. Sortowanie za pomocą funkcji sort
?php
$tab1 = array(5, 7, 3, 1, 8, 2, 0, 4, 9, 6);
$tab2 = array( jeden , dwa , trzy , cztery , pięć );
echo( Zawartość tablic przed sortowaniem: br );
foreach($tab1 as $val)
echo( $val );
echo( br );
foreach($tab2 as $val)
echo( $val );
sort($tab1);
sort($tab2);
echo( br br Zawartość tablic po sortowaniu: br );
foreach($tab1 as $val)
echo( $val );
echo( br );
foreach($tab2 as $val)
echo( $val );
?
Efekt wykonania skryptu został przedstawiony na rysunku 4.12. Jak widać, obie tablice
zostały poprawnie posortowane. Oczywiście w przypadku tablicy tab1 mieliśmy do czy-
nienia z sortowaniem liczb i wartości zostały ustawione od najmniejszej do największej,
Rozdział 4. ♦ Tablice i obiekty
117
Rysunek 4.12.
Efekt sortowania
tablic
natomiast w przypadku tablicy tab2 nastąpiło sortowanie ciągów znaków, a zatem sło-
wa zostały ustawione w porządku alfabetycznym. Co jednak zrobić w sytuacji, gdyby-
śmy chcieli wykonać sortowanie odwrotne, czyli np. ustawić wartości z tablicy tab1 od
największej do najmniejszej? Nie ma z tym najmniejszego problemu. Wystarczy użyć
funkcji rsort (z ang. reverse sort), która wykona to zadanie.
Więcej problemów przysporzy nam sytuacja, w której będziemy chcieli ustawić ele-
menty tablicy w specyficznej kolejności, odmiennej od standardowego porządku. Mamy
wtedy do wyboru dwie drogi. Albo sami napiszemy całą funkcję wykonującą sorto-
wanie, albo też wykorzystamy specjalną wersję funkcji sortującej — usort — i napi-
saną przez nas funkcję porównującą dwa elementy. Schematyczne wywołanie takiej
funkcji ma postać:
usort($tablica, nazwa_funkcji )
gdzie tablica to nazwa tablicy, której elementy będą sortowane, a nazwa_funkcji to
nazwa funkcji dokonującej porównania dwóch elementów. Ta ostatnia funkcja będzie
otrzymywała w postaci argumentów dwa elementy sortowanej tablicy, musi natomiast
zwracać:
(cid:141) wartość mniejszą od zera, jeśli pierwszy argument jest mniejszy od drugiego;
(cid:141) wartość większą od zera, jeśli pierwszy argument jest większy od drugiego;
(cid:141) wartość równą zero, jeśli pierwszy argument jest równy drugiemu;
Zobaczmy, jak to działa na konkretnym przykładzie. Napiszemy skrypt, który będzie
sortował zawartość tablicy przechowującej liczby całkowite w taki sposób, że najpierw
umieszczone będą wartości podzielne przez dwa, od najmniejszej do największej, a do-
piero po nich wartości niepodzielne przez dwa, również od najmniejszej do największej.
To zadanie realizuje kod z listingu 4.14.
Listing 4.14. Realizacja niestandardowego sortowania
?php
function sortuj($e1, $e2)
{
if($e1 2 == 0){
if($e2 2 == 0){
return $e1 - $e2;
D:PDFPHP i MySQL dla każdego 4.doc
(05-09-12) 117
118
PHP i MySQL dla każdego
}
else{
return -1;
}
}
else{
if($e2 2 == 0){
return 1;
}
else{
return $e1 - $e2;
}
}
}
$tab1 = array(5, 7, 3, 1, 8, 2, 0, 4, 9, 6);
echo( Zawartość tablicy przed sortowaniem: br );
foreach($tab1 as $val)
echo( $val );
echo( br );
usort($tab1, sortuj );
echo( Zawartość tablicy po sortowaniu: br );
foreach($tab1 as $val)
echo( $val );
?
Tablica jest tworzona w standardowy sposób i jej początkowa zawartość jest wyświe-
tlana na ekranie. Następnie wywoływana jest funkcja usort, wykonująca operację sor-
towania, i zawartość posortowanej tablicy jest ponownie wyświetlana na ekranie. Tym
samym w przeglądarce ukaże się obraz widoczny na rysunku 4.13. Jak widać, układ liczb
jest zgodny z naszymi założeniami; najpierw umieszczone są liczby podzielne przez
dwa, od najmniejszej do największej, a za nimi liczby niepodzielne przez dwa, również
od najmniejszej do największej. Za takie uporządkowanie elementów tablicy odpowiada
kombinacja funkcji usort i sortuj.
Rysunek 4.13.
Efekt
niestandardowego
sortowania
Funkcja usort realizuje algorytm sortowania typu QuickSort. Ponieważ chcemy, aby
sortowanie odbywało się według niestandardowych zasad, musimy jej dostarczyć do-
datkową funkcję, która będzie porównywała dwa dowolne elementy tablicy tab1. Tą
funkcją jest sortuj. Przy porównywaniu dwóch dowolnych elementów tablicy tab1
możliwe są cztery różne sytuacje:
Rozdział 4. ♦ Tablice i obiekty
119
1. Pierwszy argument jest podzielny przez dwa (e1 2 równe 0) i drugi argument
jest również podzielny przez dwa (e2 2 równe 0). W takiej sytuacji należy
zwrócić wartość mniejszą od zera, jeśli pierwszy argument jest mniejszy;
wartość większą od zera, jeśli drugi argument jest mniejszy; lub wartość 0,
jeśli argumenty są równe. Zapewnia to instrukcja return $e1 - $e2;.
2. Pierwszy argument jest podzielny przez dwa (e1 2 równe 0), natomiast drugi
argument nie jest podzielny przez dwa (e2 2 różne od 0). W takiej sytuacji
argument pierwszy zawsze powinien znaleźć się przed argumentem drugim,
a zatem należy zwrócić wartość mniejszą od zera. Zapewnia to instrukcja
return -1;.
3. Pierwszy argument nie jest podzielny przez dwa (e1 2 różne od 0), a drugi
argument jest podzielny przez dwa (e2 2 równe 0). W takiej sytuacji argument
pierwszy zawsze powinien znaleźć się za argumentem drugim, a zatem należy
zwrócić wartość większą od zera. Zapewnia to instrukcja return 1;.
4. Pierwszy argument nie jest podzielny przez dwa (e1 2 różne od 0) i drugi
argument również nie jest podzielny przez dwa (e2 2 różne od 0). W takiej
sytuacji należy zwrócić wartość mniejszą od zera, jeśli pierwszy argument jest
mniejszy; wartość większą od zera, jeśli drugi argument jest mniejszy; oraz
wartość 0, jeśli argumenty są równe. Zapewnia to instrukcja return $e1 - $e2;.
Sortowanie tablic asocjacyjnych
W przypadku tablic asocjacyjnych nie można użyć zwykłej funkcji sort, gdyż spo-
woduje ona utratę kluczy. Możemy się o tym przekonać uruchamiając skrypt widoczny
na listingu 4.15. Została w nim utworzona tablica tab zawierająca cztery klucze z przy-
pisanymi wartościami całkowitymi. Tablica ta została następnie posortowana przez
użycie funkcji sort. Zawartość przed sortowaniem i po nim została wyświetlona za
pomocą pętli foreach i instrukcji echo. Jak widać na rysunku 4.14, efekt takiego działa-
nia nie jest zadowalający. Co prawda wartości zostały posortowane, ale jednocześnie
zostały utracone nazwy indeksów.
Listing 4.15. Użycie funkcji sort do sortowania tablicy asocjacyjnej
?php
$tab = array
(
indeks1 = 5,
indeks9 = 1,
indeks3 = 8,
indeks5 = 2
);
echo( Zawartość tablicy przed sortowaniem: br );
foreach($tab as $key = $val){
echo( tab[$key] = $val );
echo( br );
}
sort($tab);
echo( br Zawartość tablicy po sortowaniu: br );
D:PDFPHP i MySQL dla każdego 4.doc
(05-09-12) 119
120
PHP i MySQL dla każdego
foreach($tab as $key = $val){
echo( tab[$key] = $val );
echo( br );
}
?
Rysunek 4.14.
Utrata nazw indeksów
po nieprawidłowym
sortowaniu tablicy
asocjacyjnej
Aby zatem posortować tablicę asocjacyjną, musimy użyć innych funkcji: asort i ksort.
Pierwsza z nich sortuje tablicę względem wartości poszczególnych kluczy, natomiast
druga względem samych kluczy. Oznacza to, że jeśli w skrypcie z listingu 4.15 zamie-
nimy funkcję sort na asort, po sortowaniu uzyskamy kolejność:
tab[indeks9] = 1
tab[indeks5] = 2
tab[indeks1] = 5
tab[indeks3] = 8
Jeśli natomiast zamienimy sort na ksort, uzyskamy wynik:
tab[indeks1] = 5
tab[indeks3] = 8
tab[indeks5] = 2
tab[indeks9] = 1
Sortowanie może się odbywać również w porządku odwrotnym, czyli od wartości naj-
większej do najmniejszej. Służą do tego celu funkcje arsort (sortowanie względem
wartości) i krsort (sortowanie względem kluczy).
Operacje na elementach
Zmiana kolejności elementów
Jeśli chcemy odwrócić kolejność elementów w tablicy, czyli spowodować, aby pierw-
szy stał się ostatnim, drugim przedostatnim itd., możemy zastosować funkcję array_
reverse. Jako argument tej funkcji należy przekazać nazwę tablicy. Tablica ze zmienioną
Rozdział 4. ♦ Tablice i obiekty
121
kolejnością elementów zostanie
Pobierz darmowy fragment (pdf)
