Darmowy fragment publikacji:
PHP. Programowanie
w systemie Windows
Autor: Andrew Stopford
T³umaczenie: Aleksandra Kula
ISBN: 83-7197-915-0
Tytu³ orygina³u: PHP Programming for Windows
Format: B5, stron: 290
Ksi¹¿ka opisuje doskona³¹ platformê programistyczn¹ dla MS Windows. Opisuje ona
PHP na tyle szczegó³owo, ¿e osoby zainteresowane mog¹ potraktowaæ j¹ jako
podrêcznik tego jêzyka. Jej szczególn¹ zalet¹ jest wyczerpuj¹ce omówienie integracji
PHP z technologiami Windows. Dziêki ksi¹¿ce dowiesz siê, jak tworzyæ i wykorzystywaæ
obiekty COM w PHP, jak ³¹czyæ PHP z platform¹ .NET, jak korzystaæ z ActiveDirectory
oraz jak u¿ywaæ MSXML.
„PHP. Programowanie w systemie Windows” zawiera równie¿ opis:
• Instalacji PHP w systemie Windows
• Konfigurowania i optymalizacji serwerów WWW
• Jêzyka PHP i jego funkcji
• £¹czenia PHP z bazami danych (Microsoft SQL Server, Oracle i MySQL)
• U¿ycia XML i XSLT w PHP
• Integracji PHP z ASP przy u¿yciu WDDX
• Tworzenia us³ug WWW w PHP
Jeġli planujesz u¿ywaæ PHP w systemach Windows, ksi¹¿ka ta stanie siê dla Ciebie
nieocenion¹ pomoc¹. Gwarancjê dobrej jakoġci stanowi równie¿ nazwisko autora.
Andrew Stopford jest programist¹ z wieloletnim doġwiadczeniem, cz³onkiem wielu
zespo³ów pracuj¹cych nad projektami typu „open-source”, miêdzy innymi XML-RPC for
ASP i NMatrix.
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
5RKUVTGħEK
1#WVQT\G
9UVúR
9RTQYCF\GPKG
\úħè+
4Q\RQE\[PCO[RT\[IQFú\2*2
4Q\F\KCđ 9RTQYCF\GPKGFQ2*2
Co to jest PHP? ...................................................?...................................................?................18
Jak powstał PHP?...................................................?...................................................?.............18
Czym jest Open Source?...................................................?...................................................?..20
Projektowanie w PHP a projektowanie wykorzystujące technologie ASP i ColdFusion?....20
Kto odpowiada za dalszy rozwój PHP? ...................................................?..............................21
PHP dzisiaj...................................................?...................................................?.......................22
Przyszłość PHP ...................................................?...................................................?................22
Podsumowanie ...................................................?...................................................?.................23
+PUVCNCELCKQRV[OCNK\CELC
4Q\F\KCđ
Planowanie instalacji PHP ...................................................?..................................................25
Pobieranie PHP z witryny...................................................?...................................................?26
Instalowanie PHP...................................................?...................................................?.............28
Optymalizowanie instalacji...................................................?.................................................44
Rozwiązywanie problemów z instalacją...................................................?.............................51
Podsumowanie ...................................................?...................................................?.................51
\úħè++ 9RTQYCF\GPKGFQRTQITCOQYCPKCY2*2
4Q\F\KCđ 2TQITCOQYCPKGY2*2
Narzędzia do tworzenia aplikacji w PHP ...................................................?...........................55
Podstawy składni PHP ...................................................?...................................................?.....56
Zmienne ...................................................?...................................................?...........................57
Operatory logiczne i pętle...................................................?...................................................68
Tablice ...................................................?...................................................?.............................74
Kod strukturalny i kod wielokrotnego użytku ...................................................?....................80
Podsumowanie ...................................................?...................................................?.................86
4Q\F\KCđ 2*2KRNKMK
Funkcje PHP obsługi plików i katalogów...................................................?...........................87
PHP i pliki...................................................?...................................................?........................87
PHP i katalogi ...................................................?...................................................?..................97
Podsumowanie ...................................................?...................................................?...............104
4Q\F\KCđ 2*2KUGULG
Sesje PHP...................................................?...................................................?.......................105
PHP a sesje WDDX ...................................................?...................................................?.......110
Podsumowanie ...................................................?...................................................?...............120
2*22TQITCOQYCPKGYU[UVGOKG9KPFQYU
4Q\F\KCđ 2*2KDC\[FCP[EJ
Metody PHP tworzenia zapytań do bazy danych ...................................................?.............121
Współpraca z bazą danych...................................................?................................................123
Przekazywanie zapytania do bazy z wykorzystaniem ODBC i PHP...................................123
Przesyłanie zapytania bezpośrednio do bazy z wykorzystaniem PHP ................................128
Podsumowanie ...................................................?...................................................?...............151
CCYCPUQYCPGRTQITCOQYCPKGY2*2
\úħè+++
4Q\F\KCđ 2*2 1/K0 6
Wszystko na temat technologii COM ...................................................?...............................155
PHP i .NET ...................................................?...................................................?....................163
Podsumowanie ...................................................?...................................................?...............169
4Q\F\KCđ 2*2K:/.
Krótka historia XML-a ...................................................?...................................................?..171
Czym jest XML?...................................................?...................................................?............172
Wyświetlanie dokumentów w języku XML ...................................................?.....................173
Z czego składa się język XML?...................................................?........................................173
Struktura języka XML ...................................................?...................................................?...177
Korzystanie z PHP i XML ...................................................?................................................178
Formatowanie dokumentów XML za pomocą PHP i XSL .................................................186
Podsumowanie ...................................................?...................................................?...............190
4Q\F\KCđ 2*2KWUđWIK999
Z czego składają się usługi WWW? ...................................................?.................................191
Przyszłość usług WWW ...................................................?...................................................?199
Korzystanie z PHP do tworzenia usług WWW ...................................................?................199
Podsumowanie ...................................................?...................................................?...............208
4Q\F\KCđ 2*2K# 1
Historia ADO ...................................................?...................................................?.................209
Czym jest ADO dla programisty PHP? ...................................................?............................211
Instalowanie ADO ...................................................?...................................................?.........211
Współpraca pomiędzy PHP i ADO ...................................................?..................................211
ADODB i PHP...................................................?...................................................?...............232
Podsumowanie ...................................................?...................................................?...............234
4Q\F\KCđ 2*2K#EVKXG KTGEVQT[
Co to jest katalog X.500?...................................................?..................................................235
Czym jest LDAP? ...................................................?...................................................?..........236
Czym jest Active Directory?...................................................?.............................................236
Korzystanie z Active Directory ...................................................?........................................238
Korzystanie z PHP w połączeniu z Active Directory ...................................................?.......238
Podsumowanie ...................................................?...................................................?...............262
QFCVMKR
QFCVGM#
6YQT\GPKGRQđæE\GPKC1 $
QFCVGM$
+PUVCNQYCPKGUGTYGTC999
5MQTQYKF\
Rozdział 3.
2TQITCOQYCPKGY2*2
Teraz, kiedy już zainstalowałeś PHP, możesz zacząć projektować aplikacje z jego wykorzy-
staniem. W tym rozdziale dowiesz się, od czego zacząć, projektując aplikacje dla WWW,
oraz zapoznasz się z różnymi typami danych i strukturdami składającymi się na język.
0CT\úF\KCFQVYQT\GPKCCRNKMCELKY2*2
Zanim zaczniesz programować w PHP, potrzebny Ci będzie program do pisania, edy-
towania i zapisywania skryptów. Możesz korzystać z aplikacji Notatnik, jednak dostępne
są również inne programy oferujące takie funkcje jak podświetlanie składni kodu oraz
testowanie i uruchamianie. Omówimy to w kolejnych punkdtach.
2*2 FKV
Edytor typu open-source, PHP Edit, oferuje podświetlanie kodu w różnych kolorach, testo-
wanie go oraz dostęp do dokumentacji funkcji oraz obidektów i inne.
Więcej informacji, jak również samo narzędzie, znajdziesz na stronie http://www.
phpedit.com/.
/CETQOGFKC*QOG5KVG
Macromedia HomeSite to edytor HTML obsługujący technologię ASP, ColdFusion i PHP.
Obsługa kolorowego podświetlania poszczególnych elementów kodu jest wbudowaną
funkcją HomeSite, ale dostęp do innych funkcji, takich jak dokumentacja składni, jest
możliwy jedynie przy wykorzystaniu narzędzi innych fidrm.
Więcej informacji i testową wersję możesz pobrać z witryny http://www.macromedia.com/
software/homesite/.
Dodatki do programu Macromedia HomeSite przeznaczone do programowania w PHP
można pobrać ze strony http://www.wilk4.com/asp4hs/php4hs.htm.
\úħè++9RTQYCF\GPKGFQRTQITCOQYCPKCY2*2
#EVKXG5VCVG-QOQFQ
Narzędzie dostępne jest zarówno dla platformy Windows, jak i Linux. ActiveState Ko-
modo to popularny edytor. Obsługa PHP jest wbudowaną funkcją narzędzia umożliwia-
jącą podświetlanie w różnych kolorach składni oraz zddalne testowanie i uruchamianie kodu.
Więcej informacji i testową wersję ActiveState Komodo można pobrać z http://www.
activestate.com/Products/Komodo/.
GPF+
Zend IDE to narzędzie zbudowane w oparciu o język Java, które zawiera obsługę pod-
świetlania w różnych kolorach składni, jak również rozbudowane funkcje zdalnego testo-
wania i uruchamiania. Więcej informacji i testową wersję narzędzia znajdziesz na stronie
http://www.zend.com/store/products/zend-ide.php.
2QFUVCY[UMđCFPK2*2
Podobnie jak ASP, PHP wykorzystuje coś, co osobiście nazywam „otwierająco-zamy-
kającym nawiasem” (z ang. open-close bracket). W klasycznym ASP program rozpoczyna
się od znacznika początku programu (), a kończy się znacznikiem końca programu ( ):
4GURQPUGYTKVG
-NCU[E\P[RTQITCOY#52
Podobna sytuacja ma miejsce w przypadku PHP. Program rozpoczyna się od znacznika
!RJR, a kończy ! :
!RJR
RTKPV
2TQITCOY2*2
!
PHP dopuszcza również składnię dobrze znaną programistom tworzącym aplikacje urucha-
miane po stronie klienta. Składnia ta rozpoczyna się poleceniem 5 4+26.#0)7#) RJR ,
a kończy poleceniem 5 4+26 :
5 4+26.#0)7#) RJR
RTKPV
VGUV
5 4+26
Jeśli masz doświadczenie w projektowaniu w ASP, nie musisz się obawiać. PHP pozwala
wykorzystywać składnię ASP:
RTKPV
2TQITCOY2*2
Aby jednak taka składnia była poprawna, musisz zmienidć wpis w pliku php.ini:
CURAVCIU1P
Ta zmienna ma domyślnie przypisaną wartość 1HH.
4Q\F\KCđ2TQITCOQYCPKGY2*2
2TQITCO[YKGNQNKPKQYG
Wieloliniowe programy tworzone w PHP wymagają użycida dodatkowego znaku:
!RJR
RTKPV
6QLGUVVYÎLRKGTYU\[
RTKPV
RTQITCOY2*2
!
Zauważ, że PHP wymaga użycia operatora zamykającego linię ― znaku średnika ().
Jeśli uruchomisz program, w którym nie ma znacznika końca linii, jak w poniżej przedsta-
wionym przykładzie, pojawi się informacja o błędzie 2CTUGGTTQT
DđæFRT\GVYCT\CPKC:
!RJR
RTKPV
6QLGUVVYÎLRKGTYU\[
RTKPV
RTQITCOY2*2
!
Jeśli nigdy nie używałeś znaków końca linii, możesz czasami o nich zapominać. Jeśli
pojawi się wiadomość 2CTUGGTTQT podczas tworzenia aplikacji dla WWW, sprawdź, czy
nie brakuje znaku końca linii w wierszu o numerze podanym przez komunikat o błędzie,
jak pokazano na rysunku 3.1.
4[UWPGM
Wiadomość
o błędzie Parse error
OKGPPG
PHP jest określany jako język luźnych deklaracji. Oznacza to, że nie musisz deklarować
typu zmiennych przed ich użyciem. PHP przypisuje w Twoim imieniu typy zmiennych.
Aby to zrozumieć, przyjrzyj się następującemu przykładdowi:
!RJR
PCU\GV[R[FCP[EJ
KPVFCVC
FQWDNGFCVC
UVTKPIFCVC#PFT\GL
DQQNFCVC647
RQFCLV[R[FCP[EJ
+PV6[RGIGVV[RG
KPVFCVC
RTKPV
OKGPPCKPVFCVCLGUVV[RW+PV6[RG$4
QWDNG6[RGIGVV[RG
FQWDNGFCVC
RTKPV
OKGPPCFQWDNGFCVCLGUVV[RW QWDNG6[RG$4
\úħè++9RTQYCF\GPKGFQRTQITCOQYCPKCY2*2
5VTKPI6[RGIGVV[RG
UVTKPIFCVC
RTKPV
OKGPPCUVTKPIFCVCLGUVV[RWFCP[EJ5VTKPI6[RG$4
$QQN6[RGIGVV[RG
DQQNFCVC
RTKPV
OKGPPCDQQNFCVCLGUVV[RWFCP[EJ$QQN6[RG$4
!
Jeśli zapiszesz dane jako zmienną, PHP przypisuje typ zmiennej zgodnie z typem zapi-
sanych w niej danych. Najpierw podaj, jakie dane będą pdrzechowywane w zmiennej:
KPVFCVCXCT
FQWDNGFCVCXCT
UVTKPIXCT#PFT\GL
DQQNXCT647
PHP nadaje zmiennej typ odpowiadający danym zapisanym w zmiennej. Na przykład, po-
nieważ do zmiennej UVTKPIXCT przypisana jest wartość „Andrzej”, PHP nada tej zmiennej
typ UVTKPI. Możesz to sprawdzić, wyświetlając typ zmiennej za dpomocą funkcji )GV6[RG:
+PV6[RG)GV6[RG
KPVFCVCXCT
Teraz możesz wyświetlić wartość zmiennej i jej typ:d
RTKPV
OKGPPCKPVFCVCXCTLGUVV[RW+PV6[RG$4
Jeśli uruchomisz ten skrypt, zobaczysz takie wyniki, djakie pokazano na rysunku 3.2.
4[UWPGM
Typy danych w PHP
Zwróć uwagę, że zmienna typu DQQNGCP jest wyświetlana jako . PHP wyświetla zmienne
typu DQQNGCP jako , jeśli zmienna ma wartość 647 , i jako PWNN (wartość pusta), jeśli zmien-
na ma wartość (#.5 . Przyjrzymy się temu dokładniej w dalszej części tegdo rozdziału.
2T\[RKU[YCPKGV[RÎY\OKGPP[EJ
Chociaż luźne deklaracje mogą być przydatne w niektórych sytuacjach, czasem musisz
podać typ danych wprost, na przykład przy przetwarzaniu danych pobranych z bazy da-
nych. W tym celu musisz skorzystać z metody 5GV6[RG:
!RJR
PCU\GV[R[FCP[EJ
KPVFCVC
4Q\F\KCđ2TQITCOQYCPKGY2*2
FQWDNGFCVC
UVTKPI(CNUG
DQQN647
Y[RKU\V[R[FCP[EJ
+PV6[RGIGVV[RG
KPVFCVC
RTKPV
OKGPPCKPVFCVCLGUVV[RW+PV6[RG$4
QWDNG6[RGIGVV[RG
FQWDNGFCVC
RTKPV
OKGPPCFQWDNGFCVCLGUVV[RW QWDNG6[RG$4
5VTKPI6[RGIGVV[RG
UVTKPI
RTKPV
OKGPPCUVTKPILGUVV[RW5VTKPI6[RG$4
$QQN6[RGIGVV[RG
DQQN
RTKPV
OKGPPCDQQNLGUVV[RW$QQN6[RG$4
\OKGēV[R[FCP[EJ
5GV6[RG
FQWDNGFCVCKPVGIGT
5GV6[RG
KPVFCVCFQWDNG
5GV6[RG
DQQNUVTKPI
5GV6[RG
UVTKPIDQQNGCP
Y[ħYKGVNPQYGV[R[FCP[EJ
+PV6[RGIGVV[RG
KPVFCVC
RTKPV
OKGPPCKPVFCVCLGUVVGTC\V[RW+PV6[RG$4
QWDNG6[RGIGVV[RG
FQWDNGFCVC
RTKPV
OKGPPCFQWDNGFCVCLGUVVGTC\V[RW QWDNG6[RG$4
5VTKPI6[RGIGVV[RG
UVTKPI
RTKPV
OKGPPCUVTKPILGUVVGTC\V[RW5VTKPI6[RG$4 Y
$QQN6[RGIGVV[RG
DQQN
RTKPV
OKGPPCDQQNLGUVVGTC\V[RW$QQN6[RG$4
!
Podobnie jak w pierwszym przykładzie, przypisaliśmy zmiennym wartości i wyświetli-
liśmy zawartość tych zmiennych oraz ich typ:
KPVFCVC
FQWDNGFCVC
UVTKPI(CNUG
DQQN647
+PV6[RGIGVV[RG
KPVFCVC
RTKPV
OKGPPCKPVFCVCLGUVV[RW+PV6[RG$4
QWDNG6[RGIGVV[RG
FQWDNGFCVC
RTKPV
OKGPPCFQWDNGFCVCLGUVV[RW QWDNG6[RG$4
\úħè++9RTQYCF\GPKGFQRTQITCOQYCPKCY2*2
5VTKPI6[RGIGVV[RG
UVTKPI
RTKPV
OKGPPCUVTKPILGUVV[RW5VTKPI6[RG$4
$QQN6[RGIGVV[RG
DQQN
RTKPV
OKGPPCDQQNLGUVV[RW$QQN6[RG$4
Następnie możliwa jest zmiana typu każdej ze zmiennydch za pomocą funkcji 5GV6[RG:
5GV6[RG
FQWDNGFCVCKPVGIGT
5GV6[RG
KPVFCVCFQWDNG
5GV6[RG
DQQNUVTKPI
5GV6[RG
UVTKPIDQQNGCP
Jako argumenty funkcji 5GV6[RG podaj nazwę zmiennej, której typ chcesz zmienić (jak
na przykład FQWDNGFCVC), a następnie typ danych, na który typ zmiennej ma zostać zmie-
niony (na przykład KPVGIGT). Na końcu możesz wyświetlić wartości i nowe typy zmiennych:
+PV6[RGIGVV[RG
KPVFCVC
RTKPV
OKGPPCKPVFCVCLGUVV[RW+PV6[RG$4
QWDNG6[RGIGVV[RG
FQWDNGFCVC
RTKPV
OKGPPCFQWDNGFCVCLGUVV[RW QWDNG6[RG$4
5VTKPI6[RGIGVV[RG
UVTKPI
RTKPV
OKGPPCUVTKPILGUVV[RW5VTKPI6[RG$4
$QQN6[RGIGVV[RG
DQQN
RTKPV
OKGPPCDQQNLGUVV[RW$QQN6[RG$4
Jeśli uruchomisz ten skrypt, zobaczysz, że typy zmiennych zostały zmienione zgodnie
z wydanymi poleceniami, jak pokazano na rysunku 3.3.
4[UWPGM
Wykorzystanie funkcji
SetType do zmiany
typu zmiennej
O ile zamiana zmiennych typu KPVGIGTi FQWDNG nie stanowiła większego problemu, to
zamiana zmiennych typu DQQNGCP i UVTKPI była większym wyzwaniem. Wyświetlone wyniki
pokazują, że zmienna typu UVTKPI ma wartość . Jest to zgodne z zasadami wyświetlania
przez PHP zmiennych typu DQQNGCP, ponieważ PHP wyświetla wartość 647 jako , dlatego
po konwersji zmienna typu UVTKPI ma wartość .
4Q\F\KCđ2TQITCOQYCPKGY2*2
Jak widać, również zmienna DQQNGCP ma wartość . Zmienna typu UVTKPI miała wartość
(CNUG, lecz po konwersji na typ DQQNGCP zmienna nie była pusta i dlatego została uznana
za zmienną o wartości 647 czyli . Aby po konwersji zmienna typu $QQNGCP miała war-
tość (#.5 , czyli , zmienna typu UVTKPI musiałaby przed konwersją mieć wartość
bądź być pusta:
UVTKPI
Jeśli dokonamy takiej zmiany w naszym przykładzie, to widać (patrz rysunek 3.4), że
wartość zmiennej typu DQQNGCP jest widoczna jako pusta zmienna. Pamiętaj, że PHP traktuje
wartość jako wartość (#.5 dla zmiennej typu DQQNGCP. Dlatego po konwersji zmiennej
typu UVTKPI o wartości do typu DQQNGCP zawartość zmiennej jest traktowana jako (#.5 .
Należy również pamiętać, że PHP wyświetla zmienne typu DQQNGCP o wartości (CNUG jako
zmienne puste. Stąd w naszym przykładzie została wyśdwietlona pusta zmienna.
4[UWPGM
Dane zawierająca
zmienną typu boolean
o wartości False
4\WVQYCPKGV[RÎY
Rzutowanie typów to kolejny sposób przypisywania typówd zmiennych.
!RJR
UQOGFCVC
PGYV[RG)GV6[RG
UQOGFCVC
2TKPV
OKGPPCUQOGFCVCOCRT\[RKUCP[V[R\OKGPPGLPYGYV[RGQTC\YCTVQħè
åUQOGFCVC$4 $4
\OKGēPCV[RUVTKPI
\OKGPV[R
UVTKPIUQOGFCVC
PGYV[RG)GV6[RG
\OKGPV[R
2TKPV
OKGPPCUQOGFCVCOCRT\[RKUCP[V[R\OKGPPGLPYGYV[RGQTC\YCTVQħè
å\OKGPV[R$4
\OKGēPCV[RKPVGIGT
\OKGPV[R
KPVGIGTUQOGFCVC
\úħè++9RTQYCF\GPKGFQRTQITCOQYCPKCY2*2
PGYV[RG)GV6[RG
\OKGPV[R
2TKPV
OKGPPCUQOGFCVCOCRT\[RKUCP[V[R\OKGPPGLPYGYV[RGQTC\YCTVQħè
å\OKGPV[R$4
\OKGēPCV[RFQWDNG
\OKGPV[R
FQWDNGUQOGFCVC
PGYV[RG)GV6[RG
\OKGPV[R
2TKPV
OKGPPCUQOGFCVCOCRT\[RKUCP[V[R\OKGPPGLPYGYV[RGQTC\YCTVQħè
å\OKGPV[R$4
\OKGēV[RPCDQQNGCP
\OKGPV[R
DQQNGCPUQOGFCVC
PGYV[RG)GV6[RG
\OKGPV[R
2TKPV
OKGPPCUQOGFCVCOCRT\[RKUCP[V[R\OKGPPGLPYGYV[RGQTC\YCTVQħè
å\OKGPV[R$4
!
Najpierw przypisz wartość zmiennej:
UQOGFCVC
Wiadomo, że dla takiej wartości zmiennej, PHP ustawi typ zmiennej jako FQWDNG. Możesz
jednak zmienić ten typ. Jeśli chcesz zmienić typ zmiennej na UVTKPI, możesz to zrobić za
pomocą następującego polecenia:
\OKGPV[R
UVTKPIUQOGFCVC
Zmienna \OKGPV[R przyjmuje wartość zmiennej UQOGFCVC, ale przypisywany jest jej
typ UVTKPI. Takie rzutowanie typów jest możliwe dla wszystkich typów zmiennych, jak
widać na przedstawionym przykładzie. Po uruchomieniu skryptu przekonasz się, jak
działa rzutowanie skryptów (pokazano to na rysunku 3.5d).
4[UWPGM
Rzutowanie typów
4Q\F\KCđ2TQITCOQYCPKGY2*2
W przedstawionym przykładzie widać, że wartość została uznana przez PHP za typ
FQWDNG. Po wykonaniu rzutowania typów, widoczne są zmiany wartości zmiennej w za-
leżności od bieżącego typu zmiennej.
1RGTCVQT[CT[VOGV[E\PG
PHP pozwala używać operatorów arytmetycznych na zgodnych typach zmiennych. Jakie
to typy? Wszystkie przechowujące dane w formie numerycznej (oznacza to dowolny typ
zmiennych z wyjątkiem typu DQQNGCP). W kolejnym przykładzie przedstawiony zostanie
również operator konkatenacji (połączenia ciągów). Nie martw się, jeśli nie jesteś zazna-
jomiony z tą kwestią. Przyjrzymy się jej za moment:
!RJR
Wľ[YCPG\OKGPPG
PWO
PWO
FQFCYCPKG
UWOCPWO
PWO
2TKPV
PWO
PWOUWOC
2TKPV
$4
QFGLOQYCPKG
TQ\PKECPWOPWO
2TKPV
PWOPWOTQ\PKEC
2TKPV
$4
F\KGNGPKG
KNQTC\PWOPWO
2TKPV
PWOPWOKNQTC\
2TKPV
$4
OPQľGPKG
KNQE\[PPWOPWO
2TKPV
PWOPWOKNQE\[P
2TKPV
$4
OQFWNQ
OQFWNQPWOPWO
2TKPV
PWOPWOOQFWNQ
2TKPV
$4
!
\úħè++9RTQYCF\GPKGFQRTQITCOQYCPKCY2*2
Zaczynamy od przypisania wartości dwóch zmiennych, na których będziemy wykonywać
operacje arytmetyczne:
PWO
PWO
Następnie wykonujemy działanie arytmetyczne na tych zdmiennych:
UWOCPWO
PWO
W końcu wyświetlany jest wynik operacji:
2TKPV
PWO
PWOUWOC
Jeśli uruchomisz skrypt, wyświetlone zostaną wyniki operacji arytmetycznych pokazane
na rysunku 3.6.
4[UWPGM
Operacje arytmetyczne
Warto nadmienić, że następująca deklaracja jest równideż poprawna:
PWO
PWO
W ten sposób utworzone zmienne będą różnych typów. Zmienna PWO jest typu KPVGIGT,
a zmienna PWO jest typu UVTKPI. Jeśli zmienisz wartości zmiennych zgodnie z poniższym
przykładem, skrypt nadal będzie działał poprawnie:
PWO
PWOCC
Skrypt nadal będzie wykonany poprawnie, ale operatory arytmetyczne nie zadziałają.
Jeśli PHP napotka dane innego typu niż numeryczne, dzignoruje tę zmienną.
1RGTCVQT[đCēEWEJQYGKHWPMELG
PHP udostępnia kilka sposobów pracy na zmiennych łańcuchowych (UVTKPI). Często
korzystasz ze zmiennych łańcuchowych pobranych z takiego źródła jak formularze HTML,
pliki czy bazy danych, dlatego PHP umożliwia manipulowanie tymi danymi na różne
sposoby.
4Q\F\KCđ2TQITCOQYCPKGY2*2
Rozpoczniemy naszą pracę ze zmiennymi łańcuchowymi od dzdefiniowania kilku zmiennych:
KOKG(QZ
URCELC
PC\YKUMQ/WNFGT
ĐæE\GPKGEKæIÎY
Aby połączyć zdefiniowane wcześniej ciągi, użyj operadtora konkatenacji:
KOKGAPC\YKUMQKOKGURCELCPC\YKUMQ
Utworzyłeś nową zmienną łańcuchową przez połączenie trzech ciągów. Zauważ, że do
łączenia łańcuchów służy znak kropki ().
đWIQħèEKæIW
Aby poznać długość nowego ciągu, użyj funkcji UVTNGP:
FNWIQUEAEKCIWUVTNGP
KOKGAPC\YKUMQ
QFCVMQYCURCELC
PHP umożliwia usuwanie dodatkowego znaku spacji (często zwanego również „białą
spacją”) znajdującego się na końcu lub na początku łańcucha znaków. Ponieważ nasz
nowy łańcuch nie kończy się ani nie zaczyna „białą spacją”, musimy ją najpierw dodać,
aby następnie użyć tych funkcji:
KOKGAPC\YKUMQAKAURCELGKOKGAPC\YKUMQ
Teraz możesz usunąć początkową spację za pomocą funkdcji NVTKO:
NVTKOAKOKGAPC\YKUMQNVTKO
KOKGAPC\YKUMQAKAURCELG
„Białą spację” zarówno rozpoczynającą, jak i kończącą łańcuch znaków możesz usunąć
za pomocą funkcji VTKO:
VTKOAKOKGAPC\YKUMQVTKO
KOKGAPC\YKUMQAKAURCELG
9KGNMQħèNKVGT
PHP pozwala zmienić wielkość wszystkich liter w łańcuchu na wielkie lub na małe. Aby
zmienić wszystkie litery w łańcuch na wielkie, użyj dfunkcji UVTVQWRRGT:
KOKGAPC\YKUMQAYKGNMKGNKVGT[UVTVQWRRGT
KOKGAPC\YKUMQ
Funkcja UVTVQNQYGT służy do zamiany wszystkich liter w łańcuchu na małed:
KOKGAPC\YKUMQAOCNGNKVGT[UVTVQNQYGT
KOKGAPC\YKUMQ
2QFđCēEWEJ[\PCMÎY
PHP umożliwia wyszukanie lokalizacji, utworzenie oraz dodanie podłańcucha do łańcucha
znaków. Do utworzenia podłańcucha znaków służy funkcja UWDUVT:
RQFANCPEWEJUWDUVT
KOKGAPC\YKUMQ
\úħè++9RTQYCF\GPKGFQRTQITCOQYCPKCY2*2
Jako argument podawany jest łańcuch znaków, z którego utworzony ma być podłańcuch
(w naszym przypadku jest to łańcuch KOKGAPC\YKUMQ), i pozycja w łańcuchu, od której
podłańcuch ma się zaczynać (w naszym przykładzie podłańcuch ma się zaczynać od
trzeciego znaku w łańcuchu).
Możesz odszukać lokalizację podłańcucha wewnątrz łańcudcha za pomocą funkcji UVTRQU:
RQ\[ELCARQFNCPEWEJUVTRQU
KOKGAPC\YKUMQRQFANCPEWEJ
Argumentami tej funkcji jest łańcuch, wewnątrz którego podłańcuch ma być wyszukany
(u nas jest to łańcuch KOKGAPC\YKUMQ), oraz wyszukiwany podłańcuch (jest to wcześniej
utworzony podłańcuch RQFANCPEWEJ).
Możesz również zamienić wybrany podłańcuch na inny we dwskazanym łańcuchu za pomocą
funkcji UVTATGRNCEG:
RQFAKOKGAPC\YKUMQUVTATGRNCEG
(QZ5EWNN[KOKGAPC\YKYUMQ
Argumentem funkcji UVTATGRNCEG jest łańcuch, który ma być wyszukany (w naszym przy-
padku jest to (QZ), łańcuch, którym zostanie on zastąpiony (w naszym prdzykładzie jest
to łańcuch 5EWNN[), oraz łańcuch, wewnątrz którego zamiana zostanie dokonana (w na-
szym przykładzie jest toKOKGAPC\YKUMQ).
6GUVQYCPKGOGVQFQDUđWIKđCēEWEJÎY
Możesz sprawdzić wszystkie opisane wcześniej metodyd za pomocą następującego skryptu:
!RJR
đCēEWEJ[
KOKG(QZ
URCELC
PC\YKUMQ/WNFGT
đæE\GPKG
KOKGAPC\YKUMQKOKGURCELCPC\YKUMQ
RTKPV
KOKGAPC\YKUMQVQPCU\RQđæE\QP[đCēEWEJ
RTKPV
$4
FđWIQħè
FNWIQUEANCPEWEJCUVTNGP
KOKGAPC\YKUMQ
RTKPV
đWIQħèRQđæE\QPGIQđCēEWEJCVQFNWIQUEANCPEWEJC
RTKPV
$4
FQFCVMQYCURCELC
KOKGAPC\YKUMQAKAURCELCKOKGAPC\YKUMQ
RTKPV
ĐCēEWEJ\FQFCVMQY[OK\PCMCOKURCELKVQKOKGAPC\YKYUMQAKAURCELC
RTKPV
$4
4Q\F\KCđ2TQITCOQYCPKGY2*2
NVTKOAKOKGAPC\YKUMQNVTKO
KOKGAPC\YKUMQAKAURCELC
RTKPV
ĐCēEWEJRQWUWPKúEKWRQE\æVMQYGLURCELKVQNVTKOAKOKYGAPC\YKUMQ
RTKPV
$4
VTKOAKOKGAPC\YKUMQVTKO
KOKGAPC\YKUMQAKAURCELC
RTKPV
ĐCēEWEJRQWUWPKúEKWMQēE\æEGLURCELKVQVTKOAKOKGAPC\YYKUMQ
RTKPV
$4
YKGNMQħèNKVGT
KOKGAPC\YKUMQAYKGNMKGNKVGT[UVTVQWRRGT
KOKGAPC\YKUMQ
RTKPV
ĐCēEWEJRKUCP[YKGNMKOKNKVGTCOKVQKOKGAPC\YKUYMQAYKGNMKGNKVGT[
RTKPV
$4
KOKGAPC\YKUMQAOCNGNKVGT[UVTVQNQYGT
KOKGAPC\YKUMQ
RTKPV
ĐCēEWEJRKUCP[OCđ[OKNKVGTCOKVQKOKGAPC\YKUMQAOCNGNKVGT[
RTKPV
$4
RQFđCēEWEJ[
RQFđCēEWEJ
RQFANCPEWEJUWDUVT
KOKGAPC\YKUMQ
RTKPV
2QFđCēEWEJVQRQFANCPEWEJ
RTKPV
$4
RQ\[ELCRQFđCēEWEJC
RQFNCPEWEJARQ\[ELCUVTRQU
KOKGAPC\YKUMQRQFANCPEWEJ
RTKPV
2Q\[ELCRQFđCēEWEJCVQRQFNCPEWEJARQ\[ELC
RTKPV
$4
RQFOKGēRQFđCēEWEJ
RQFAKOKGAPC\YKUMQUVTATGRNCEG
(QZ5EWNN[KOKGAPC\YYKUMQ
RTKPV
2QFOKGPKQP[đCēEWEJVQRQFAKOKGAPC\YKUMQ
RTKPV
$4
!
Jeśli uruchomisz powyższy skrypt, zobaczysz, jak działają metody obsługi łańcuchów,
co pokazano na rysunku 3.7. Zauważ, że wyświetlając wyniki działania metody konka-
tenacji, po obu stronach łańcucha umieściłem znaki . Pozwala to pokazać znaki spacji
umieszczone pomiędzy tymi znakami a łańcuchem.
\úħè++9RTQYCF\GPKGFQRTQITCOQYCPKCY2*2
4[UWPGM
Metody obsługi
łańcuchów
1RGTCVQT[NQIKE\PGKRúVNG
Kontrolowanie działania programu jest niezwykle istotną kwestią. Być może musisz
sprawdzić określone warunki logiczne lub wykonać pętlę po sprawdzeniu warunku.
Takie elementy były zawsze obecne w językach programowania i w tym przypadku
PHP nie jest wyjątkiem.
1RGTCVQT[NQIKE\PG
W PHP istnieje kilka sposobów sprawdzania warunków logicznych. Sprawdzając waru-
nek logiczny, porównujesz jedną wartość z inną wartością i sprawdzasz, czy są sobie równe:
!RJR
JCUNQCD
KH
JCUNQCD]
RTKPV
1FPCNG\KQPQJCUđQ
_
!
Ten fragment kodu wykorzystuje instrukcję KH. Składnia tej instrukcji jest prosta. Jeśli
wartość jest równa innej wartości, PHP zwraca wartość wyrażenia jako „prawda”. W po-
wyższym fragmencie kodu sprawdzamy, czy wartość zmiennej JCUNQ jest równa CD.
Jeśli tak, to wyświetlany jest komunikat, jak pokazdano na rysunku 3.8.
Co by się stało, gdyby wartość zmiennej JCUNQ była różna od podanej w warunku wartości?
Poprzedni przykład nie wyświetliłby żadnej wartości. Jednak za pomocą PHP również
możesz wykonywać określone działania, jeśli warunekd nie zostanie spełniony.
4Q\F\KCđ2TQITCOQYCPKGY2*2
4[UWPGM
Testowanie
prawdziwości
wyrażenia za pomocą
instrukcji if
!RJR
JCUNQ
KH
JCUNQCD]
RTKPV
1FPCNG\KQPQJCUđQ
_GNUG]
RTKPV
0KGQFPCNG\KQPQJCUđC
_
!
Jeśli wartości, której szukasz, nie odnaleziono, wykonane zostanie działanie zdefinio-
wane po instrukcji GNUG. Jeśli wartość zmiennej JCUNQ jest równa podanej wartości, to
wyświetlony zostanie komunikat 1FPCNG\KQPQ JCUđQ. Jeśli jednak wartość zmiennej
jest różna od podanej wartości, to wyświetlony zostanie komunikat 0KG QFPCNG\KQPQ
JCUđC. Nadanie zmiennej JCUNQ wartości innej niż podana w warunku powoduje wy-
świetlenie komunikatu 0KGQFPCNG\KQPQJCUđC, jak pokazano na rysunku 3.9.
4[UWPGM
Sprawdzanie
nieprawdziwości
wyrażenia za pomocą
instrukcji if else
Jeśli masz wiele warunków do sprawdzenia za pomocą instrukcji KH, możesz to zrobić
w następujący sposób:
!RJR
JCUNQDD
KH
JCUNQCC]
RTKPV
1FPCNG\KQPQJCUđQFNCWľ[VMQYPKMC,CP
_
\úħè++9RTQYCF\GPKGFQRTQITCOQYCPKCY2*2
KH
JCUNQDD]
RTKPV
1FPCNG\KQPQJCUđQFNCWľ[VMQYPKMC#NHTGF
_
KH
JCUNQEE]
RTKPV
1FPCNG\KQPQJCUđQFNCWľ[VMQYPKMC,CEGM
_
!
Największym problemem sprawia tutaj fakt, że PHP wykona wszystkie instrukcje KH,
nawet jeśli pierwszy warunek zostanie spełniony. Aby tego uniknąć, możesz wykorzystać
zagnieżdżone instrukcje KH:
!RJR
JCUNQDD
+H
JCUNQCC]
2TKPV
1FPCNG\KQPQJCUđQFNCWľ[VMQYPKMC,CP
_GNUG+H
JCUNQDD]
2TKPV
1FPCNG\KQPQJCUđQFNCWľ[VMQYPKMC#NHTGF
_GNUG+H
JCUNQEE]
2TKPV
1FPCNG\KQPQJCUđQFNCWľ[VMQYPKMC,CEGM
_
!
Jednak, jeśli utworzyłeś wiele zagnieżdżonych instrukcji KH, pisany przez Ciebie kod szybko
stanie się nieczytelny. Lepszym sposobem będzie użycie dinstrukcji UYKVEJ i ECUG:
!
JCUNQDD
UYKVEJ
JCUNQ]
ECUGCC
2TKPV
1FPCNG\KQPQJCUđQFNCWľ[VMQYPKMC,CPY
DTGCM
ECUGDD
2TKPV
1FPCNG\KQPQJCUđQFNCWľ[VMQYPKMC#NHTYGF
DTGCM
ECUGEE
2TKPV
1FPCNG\KQPQJCUđQFNCWľ[VMQYPKMC,CEGM
DTGCM
_
!
W tym przykładzie sprawdzana jest każda wartość zmiennej JCUNQ w instrukcji ECUG.
Jeśli odnaleziona zostanie pasująca wartość, wyświetlany jest komunikat o odnalezieniu
hasła dla danego użytkownika.
4Q\F\KCđ2TQITCOQYCPKGY2*2
Zauważ, że użyto instrukcji DTGCM, aby po odszukaniu odpowiedniej wartości przerwane
zostało wykonywanie dalszych instrukcji wewnątrz instrukcji UYKVEJ. W przeciwnym
razie instrukcja UYKVEJ byłaby wykonywana analogicznie jak wcześniej przedstawiona
instrukcja KH, czyli sprawdzane zostałyby kolejno wszystkie warudnki.
+VGTCELG
PHP umożliwia wykonywanie w programie pętli na kilka sposobów. Wszystkie pętle
pozwalają wykonywać serie poleceń, aż do momentu, kiedy warunek wykonania pętli
zostanie spełniony, na przykład licznik osiągnie określoną wartość. Pierwszą metodą
jest pętla HQT:
!RJR
HQT
NKE\PKMNKE\PKMNKE\PKM
]
RTKPV
NKE\PKM
RTKPV
$4
_
!
Pętla HQT składa się z następujących elementów:
Wartości rozpoczynającej pętlę ― w naszym przypadku jedst to 1 (NKE\PKM).
Sposobu sprawdzania wartości. W tym przypadku, jeśli wdartość zmiennej
wyniesie 10, pętla przestanie być wykonywana (NKE\PKM).
Sposobu zmiany wartości wewnątrz pętli. W naszym przykdładzie wartość jest
zwiększana o jeden przy każdym przebiegu pętli (NKE\PKM
).
Dlatego pętla wyświetla liczby od 1 do 10 (rysunek 3.10).
4[UWPGM
Inkrementacja
licznika pętli for
od 1 do 10
Wewnątrz pętli HQT ma miejsce kilka ważnych zdarzeń. Pierwszym z nich jest testowa-
nie warunku logicznego. W naszym przykładzie sprawdzaliśmy, czy wartość zmiennej
jest równa lub mniejsza od 10. Możesz również sprawdzać inne warunki, jak pokazano
w tabeli 3.1.
\úħè++9RTQYCF\GPKGFQRTQITCOQYCPKCY2*2
6CDGNC Inne warunki
Warunki
Znaczenie
równy
różny
mniejszy niż
większy niż
większy lub równy
mniejszy lub równy
identyczny (równa wartość i taki sam typ)
Możesz używać tych warunków nie tylko w połączeniu z instrukcją HQT, ale z dowolną
instrukcją, która sprawdza wartość warunku logicznego, na przykład z instrukcją KH.
Przyjrzyj się, w jaki sposób w poprzednim przykładzie zmieniana jest wartość licznika
podczas wykonywania pętli. Wartość licznika może być inkrementowana lub dekremen-
towana. Dekrementowanie licznika będzie miało postać:
NKE\PKM
Możemy zmienić nasz przykład w następujący sposób:
!RJR
HQT
NKE\PKMNKE\PKM NKE\PKM]
RTKPV
NKE\PKM
RTKPV
$4
_
!
Po uruchomieniu tego skryptu pętla wykona odliczanie od 10 do 1, jak pokazano na
rysunku 3.11.
4[UWPGM
Dekrementacja
licznika w pętli for
od 10 do 1
Innym sposobem wykonania pętli jest instrukcja YJKNG:
4Q\F\KCđ2TQITCOQYCPKGY2*2
!RJR
NKE\PKM
YJKNG
NKE\PKM]
RTKPV
NKE\PKM
RTKPV
$4
NKE\PKM
_
!
Na początku przypisywana jest wartość początkowa zmiennej NKE\PKM ― w naszym
przykładzie jest to 1:
NKE\PKM
Następnie wykonywana jest pętla do chwili, gdy wartośdć licznika osiągnie 10:
YJKNG
NKE\PKM]
Podobnie jak w przypadku pętli HQT możesz użyć różnych operatorów porównania. We-
wnątrz pętli wartość zmiennej NKE\PKM jest inkrementowana:
NKE\PKM
Oczywiście możesz również zastosować podobną metodę jak w naszym drugim przy-
kładzie z pętlą HQT — dekrementować wartość licznika. Po uruchomieniu skryptu pętla
YJKNG odlicza od 1 do 10, jak pokazano na rysunku 3.12.
4[UWPGM
Inkrementowana
pętla while odliczająca
od 1 do 10
PHP umożliwia sterowanie wykonaniem pętli za pomocąd instrukcji FQYJKNG:
!RJR
NKE\PKM
FQ]
RTKPV
NKE\PKM
RTKPV
$4
NKE\PKM
\úħè++9RTQYCF\GPKGFQRTQITCOQYCPKCY2*2
_YJKNG
NKE\PKM
!
Przedstawiona pętla wygląda podobnie jak pętla YJKNG. Po uruchomieniu skryptu wykonane
zostanie liczenie od 1 do 10, a następnie pętla zostanie zakończona. Czym się w takim
razie różni od pętli YJKNG? Różnica pomiędzy tymi pętlami polega na lokalizacji instrukcji
YJKNG. W pętli FQYJKNG wartość zmiennej licznika jest modyfikowana (w naszym przy-
kładzie jest inkrementowana), a następnie wartość tej zmiennej jest sprawdzana. W pętli
YJKNG wartość zmiennej jest testowana, a następnie zmieniana. Istotny jest moment zmiany
licznika i moment jego sprawdzenia. Tutaj zmienna NKE\PKM przy wartości 1 nigdy nie
jest sprawdzana, ponieważ przed sprawdzeniem jest idnkrementowana do wartości 2.
6CDNKEG
Tablica zapewnia uporządkowany sposób przechowywania danych, do których można
się w prosty sposób odwoływać. Na rysunku 3.13 widać, że tablica wygląda jak talia
numerowanych kart, a na każdej karcie jest wydrukowana wartość. Na przykład karta 3
ma nadrukowaną wartość L.
4[UWPGM
Struktura tablicy
Każda karta w naszym przykładzie jest określana jako element tablicy. Wartość poszcze-
gólnych elementów tablicy to wartość tablicy, a do każdego elementu tablicy można się
odwołać poprzez klucz. W PHP dostępnych jest kilka sposobów obsługi tablicy.
!RJR
YKCFQOQUE=?*
YKCFQOQUE=?
YKCFQOQUE=?.
YKCFQOQUE=?.
YKCFQOQUE=?1
YJKNG
NKUV
MNWE\YCTVQUEGCEJ
YKCFQOQUE]
RTKPV
YCTVQUE
RTKPV
MNWE\VCDNKE[MNWE\TÎYPCUKúYCTVQħYEKYCTVQUE
RTKPV
$4
_
!
Rozpoczynamy od utworzenia tablicy:
YKCFQOQUE=?*
YKCFQOQUE=?
YKCFQOQUE=?.
YKCFQOQUE=?.
YKCFQOQUE=?1
4Q\F\KCđ2TQITCOQYCPKGY2*2
Wykorzystywana jest zmienna typu CTTC[. Mówi o tym nawias kwadratowy umieszczony
za nazwą zmiennej. Zauważ, że tablica zaczyna się od pozycji 0; w PHP wszystkie tablice
zaczynają się od tej pozycji. W naszym przykładzie wartość elementu YKCFQOQUE=? jest
równa E. Teraz, kiedy utworzona została tablica, musisz mieć możliwość dostępu do jej ele-
mentów. PHP umożliwia odwołanie do kolejnych elementówd tablicy w następujący sposób:
YJKNG
NKUV
MNWE\YCTVQUEGCEJ
YKCFQOQUE]
RTKPV
YCTVQUE
RTKPV
$4
_
Pętla YJKNG przechodzi przez kolejne elementy tablicy. Tablica jest dzielona na klucze
elementów i wartości elementów za pomocą instrukcji NKUV, a następnie instrukcja GCEJ
pobiera wartości kolejnych elementów tablicy. Wewnątrz pętli wyświetlane są kolejne
elementy tablicy:
RTKPV
MNWE\VCDNKE[MNWE\TÎYPCUKúYCTVQħEKYCTVQUE
Po uruchomieniu skryptu wyświetlone zostaną kolejned elementy tablicy.
Jako kluczy poszczególnych elementów tablicy nie musisz używać liczb. Możesz używać
dowolnych wartości. Możemy zmienić powyższy przykład, zastępując liczby literami:
!RJR
YKCFQOQUE=#?*
YKCFQOQUE=$?
YKCFQOQUE= ?.
YKCFQOQUE= ?.
YKCFQOQUE= ?1
YJKNG
NKUV
MNWE\YCTVQUEGCEJ
YKCFQOQUE]
RTKPV
YCTVQUE
RTKPV
$4
_
!
Możesz również wyszukiwać wartości w tablicy, posługudjąc się kluczem elementu:
!RJR
YKCFQOQUE=#?*
YKCFQOQUE=$?
YKCFQOQUE= ?.
YKCFQOQUE= ?.
YKCFQOQUE= ?1
YJKNG
NKUV
MNWE\YCTVQUEGCEJ
YKCFQOQUE]
KH
MNWE\$]
RTKPV
NGOGPVVCDNKE[QMNWE\WMNWE\OCYCYTVQħèYCTVQUE
_
_
!
Powyższy kod wyszukuje element tablicy o kluczu B i wyświetla jego wartość, jak poka-
zano na rysunku 3.14.
\úħè++9RTQYCF\GPKGFQRTQITCOQYCPKCY2*2
4[UWPGM
Wartość elementu
tablicy wyszukana
poprzez klucz tego
elementu
PHP umożliwia również tworzenie tablicy za pomocą indstrukcji CTTC[:
!
YKCFQOQUECTTC[
# *$ . Y. 1
YJKNG
NKUV
MNWE\YCTVQUEGCEJ
YKCFQOQUE]
RTKPV
MNWE\VCDNKE[MNWE\TÎYPCUKúYYCTVQħEKYCTVQUE
RTKPV
$4
_
!
Zmienna YKCFQOQUE zawiera tablicę utworzoną za pomocą instrukcji CTTC[. Instrukcja
CTTC[ pozwala tworzyć tablicę przez podanie kolejnych kluczy elementów i ich wartości.
Po uruchomieniu skryptu zobaczysz zawartość struktury utworzonej przez instrukcję
CTTC[, jak pokazano na rysunku 3.15.
4[UWPGM
Klucze i wartości
elementów tablicy
utworzonej przez
instrukcję array
Instrukcja CTTC[ samodzielnie nadaje klucze kolejnym elementom tablicy, jeśli nie zostaną
one osobno zdefiniowane:
!
YKCFQOQUECTTC[
* ..1
YJKNG
NKUV
MNWE\YCTVQUEGCEJ
YKCFQOQUE]
RTKPV
MNWE\VCDNKE[MNWE\TÎYPCUKúYCTVQYħEKYCTVQUE
RTKPV
$4
_
!
4Q\F\KCđ2TQITCOQYCPKGY2*2
W tym przykładzie podaliśmy jedynie wartości elementów tablicy tworzonej instrukcją
CTTC[. Po uruchomieniu skryptu widać, że instrukcja CTTC[ samodzielnie nadała klucze
kolejnym elementom tablicy (patrz rysunek 3.16).
4[UWPGM
Klucze kolejnych
elementów tablicy
są automatycznie
tworzone przy użyciu
instrukcji array
5QTVQYCPKGVCDNKE[
Zdarza się, że tablica zawiera nieuporządkowane elementy; wartości elementów i kluczy
nie są umieszczone na kolejnych pozycjach tablicy i należy je uporządkować. Tworzenie
fragmentów kodu, który wykonuje porządkowanie tablicy może być bardzo czasochłonne
(nawet, jeśli korzystamy z napisanych przez innych programistów fragmentów kodu).
Na szczęście PHP zawiera zestaw instrukcji, które słudżą do tego celu.
W kolejnych punktach omówimy cztery typy instrukcji UQTV przeznaczonej do sortowania
tablicy według wartości elementów tablicy lub ich klucdzy.
(WPMELCUQTV
Instrukcja UQTV pozwala posortować wartości elementów tablicy w pordządku rosnącym:
!RJR
UQTVQYCPKG\CYCTVQħEKVCDNKE[YRQT\æFMWTQUPæE[O
PWOGTMKCTTC[
PKGWRQT\æFMQYCPG
RTKPV
PKGWRQT\æFMQYCPCVCDNKEC$4
YJKNG
NKUV
MNWE\YCTVQUEGCEJ
PWOGTMK]
RTKPV
NGOGPVQMNWE\WMNWE\OCYCTVQħèYCTYVQUE
RTKPV
$4
_
RTKPV
$4
WRQT\æFMQYCPG
RTKPV
WRQT\æFMQYCPCVCDNKEC$4
UQTV
PWOGTMK
\úħè++9RTQYCF\GPKGFQRTQITCOQYCPKCY2*2
YJKNG
NKUV
MNWE\YCTVQUEGCEJ
PWOGTMK]
RTKPV
NGOGPVQMNWE\WMNWE\OCYCTVQħèYCTYVQUE
RTKPV
$4
_
!
Powyższy fragment kodu powoduje utworzenie tablicy za pomocą instrukcji CTTC[, która
samodzielnie nadaje klucze kolejnym elementom tablicy. Następnie skrypt wyświetla
zawartość nieuporządkowanej tablicy, porządkuje elementy tablicy i ponownie wyświetla
zawartość tablicy, tym razem już posortowaną.
(WPMELCCUQTV
Zauważ, że podczas sortowania tablicy przy użyciu instrukcji UQTV zmieniane są klucze
elementów tablicy. Przed sortowaniem klucz 0 wskazywał wartość 5, natomiast po sor-
towaniu ten sam klucz wskazywał wartość 1. Możesz zachować pary klucz-wskazywany
element, równocześnie porządkując rosnąco elementy dtablicy. Jak? Użyj funkcji CUQTV:
!RJR
UQTVQYCPKG\CYCTVQħEKVCDNKE[YRQT\æFMWTQUPæE[O\CEJQYYWLæERT\[RKUCPKCMNWE\[
YKCFQOQUECTTC[
# $ Y
PKGWRQT\æFMQYCPG
RTKPV
PKGWRQT\æFMQYCPCVCDNKEC$4
YJKNG
NKUV
MNWE\YCTVQUEGCEJ
YKCFQOQUE]
RTKPV
NGOGPVQMNWE\WMNWE\OCYCTVQħèYCTYVQUE
RTKPV
$4
_
RTKPV
$4
WRQT\æFMQYCPG
RTKPV
WRQT\æFMQYCPCVCDNKEC$4
CUQTV
YKCFQOQUE
YJKNG
NKUV
MNWE\YCTVQUEGCEJ
YKCFQOQUE]
RTKPV
NGOGPVQMNWE\WMNWE\OCYCTVQħèYCTYVQUE
RTKPV
$4
_
!
W naszym kodzie podczas definiowania tablicy podawane są zarówno wartości elemen-
tów, jak i ich klucze, jednak możesz również skorzystać z automatycznego nadawania
kluczy przez wykorzystanie instrukcji CTTC[, podobnie jak w poprzednim przykładzie
opisującym instrukcję UQTV. Następnie skrypt wyświetla zawartość nieuporządkowanej
tablicy, sortuje elementy tablicy za pomocą instrukcji CUQTV i ponownie wyświetla za-
wartość tablicy, jak pokazano na rysunku 3.17.
Elementy tablicy zostały uporządkowane, ale powiązania pomiędzy kluczami i elemen-
tami tablicy pozostały niezmienione. Na przykład klucz E wskazuje element tablicy o war-
tość 4 przed i po sortowaniu.
4Q\F\KCđ2TQITCOQYCPKGY2*2
4[UWPGM
Tablica posortowana
w porządku rosnącym
z wykorzystaniem
instrukcji asort,
która nie modyfikuje
powiązań kluczy
z elementami tablicy
(WPMELCTUQTV
Możliwe jest również posortowanie elementów tablicy w porządku malejącym za pomocą
funkcji TUQTV:
!RJR
UQTVQYCPKGVCDNKE[YRQT\æFMWOCNGLæE[O
YKCFQOQUECTTC[
PKGRQUQTVQYCPC
RTKPV
PKGRQUQTVQYCPCVCDNKEC$4
YJKNG
NKUV
MNWE\YCTVQUEGCEJ
YKCFQOQUE]
RTKPV
NGOGPVQMNWE\WMNWE\OCYCTVQħèYCTVYQUE
RTKPV
$4
_
RTKPV
$4
RQUQTVQYCPC
RTKPV
RQUQTVQYCPCVCDNKEC$4
TUQTV
YKCFQOQUE
YJKNG
NKUV
MNWE\YCTVQUEGCEJ
YKCFQOQUE]
RTKPV
NGOGPVQMNWE\WMNWE\OCYCTVQħèYCTVQUE
RTKPV
$4
_
!
Powyższy przykład działa analogiczne jak przykładowy skrypt opisujący funkcję UQTV.
Funkcja TUQTV sortuje tablicę w porządku malejącym.
\úħè++9RTQYCF\GPKGFQRTQITCOQYCPKCY2*2
(WPMELCMUQTV
PHP umożliwia sortowanie kluczy tablicy w porządku rosnącym za pomocą funkcji MUQTV:
!RJR
UQTVQYCPKGMNWE\[VCDNKE[YRQT\æFMWTQUPæE[O
YKCFQOQUECTTC[
$ # Y
PKGWRQT\æFMQYCPG
RTKPV
PKGWRQT\æFMQYCPCVCDNKEC$4
YJKNG
NKUV
MNWE\YCTVQUEGCEJ
YKCFQOQUE]
RTKPV
NGOGPVQMNWE\WMNWE\OCYCTVQħèYCTYVQUE
RTKPV
$4
_
RTKPV
$4
WRQT\æFMQYCPG
MUQTV
YKCFQOQUE
RTKPV
WRQT\æFMQYCPCVCDNKEC$4
YJKNG
NKUV
MNWE\YCTVQUEGCEJ
YKCFQOQUE]
RTKPV
NGOGPVQMNWE\WMNWE\OCYCTVQħèYCTYVQUE
RTKPV
$4
_
!
Powyższy skrypt wygląda analogiczne jak poprzednie przykłady, z tą różnicą, że wyko-
rzystuje instrukcję MUQTV do porządkowania tablicy.
W tym przykładzie kluczami elementów tablicy są litery. Po posortowaniu za pomocą
instrukcji MUQTV, klucze są sortowane w porządku alfabetycznym.
-QFUVTWMVWTCNP[KMQFYKGNQMTQVPGIQWľ[VMW
Moje pierwsze spotkanie z programowaniem miało miejsce na studiach. Moim nauczy-
cielem był Chris Pickford, a był on jednym z najbardziej cierpliwych ludzi, jakich spo-
tkałem w życiu. Chris dawał z siebie wszystko, próbując nauczyć grupę niedoświadczonych,
ale bardzo chętnych, programistów podstaw i zalet programowania strukturalnego i nada-
jącego się do wielokrotnego wykorzystania kodu. Dopiero kiedy zacząłem żyć z progra-
mowania zrozumiałem, jak ważne było to, czego nauczył mnie Chris. Ten punkt dedykuję
Tobie, Chris.
Kod strukturalny i kod wielokrotnego użytku pozwala rozbić program na uporządkowane
fragmenty, w celu efektywnego wykorzystania fragmentów kodu wewnątrz aplikacji.
Takie podejście jest korzystne, ponieważ aplikacja może wielokrotnie wykonywać te
same zadania, takie jak łączenie się z bazą danych, wystawianie zapytania do bazy danych
4Q\F\KCđ2TQITCOQYCPKGY2*2
i wyświetlanie danych otrzymanych z bazy danych. Podzielenie aplikacji na fragmenty
pozwala zmniejszyć możliwość wystąpienia błędów oraz skrócić czas tworzenia aplikacji
(oszczędzanie czasu to zawsze ważna rzecz). PHP pozwala dzielić kod na kilka sposobów
przy wykorzystaniu funkcji, klas i dołączanych bibliotdek.
-QT\[UVCPKG\HWPMELK
Korzystanie z funkcji to jeden z najprostszych sposobów dzielenia kodu na fragmenty,
które mogą być wielokrotnie wykorzystywane.
!RJR
HWPEVKQP9KCFQOQUE2QYKVCNPC
KOKG]
TGVWTP*GNNQKOKG
_
\YTQV9KCFQOQUE2QYKVCNPC
#PFT\GL
RTKPV
\YTQV
!
W powyższym przykładzie utworzona została funkcja wyświetlająca wiadomość. Do
funkcji jako argument przesyłane jest imię, które następnie jest umieszczane jako część
wyświetlanej wiadomości. Najpierw tworzona jest funkcdja:
HWPEVKQP9KCFQOQUE2QYKVCNPC
KOKG]
TGVWTP*GNNQKOKG
_
Zauważ, że wyniki wykonania funkcji są zwracane w nadstępujący sposób:
TGVWTP*GNNQKOKG
Innymi słowy, instrukcja TGVWTP zwraca wyniki wykonania funkcji po jej wywołaniu.
Dlatego, aby pobrać wyniki wykonania funkcji, należy zdapisać je jako zmienną:
\YTQV9KCFQOQUE2QYKVCNPC
#PFT\GL
W końcu wyświetlane są wyniki wykonania funkcji:
RTKPV
\YTQV
Po uruchomieniu skryptu wyświetlone zostaną wyniki dwywołania funkcji.
2T\GMC\[YCPKGFCP[EJRT\G\\OKGPPæNWDRT\G\YCTVQħèÎ
Za pomocą funkcji można również modyfikować zawartość przekazywanych do nich
zmiennych. Przekazując zmienną do funkcji, możesz zachować niezmienioną wartość
zmiennej po zakończeniu wykonywania funkcji (nazywane jest to przekazywaniem przez
wartość) lub zmienić dane (nazywamy to przekazywaniemd przez zmienną).
!RJR
HWPEVKQP9JQ+U QQN
CTIWOGPV]
CTIWOGPV UæEQQN
\úħè++9RTQYCF\GPKGFQRTQITCOQYCPKCY2*2
_
PC\YC2TQITCOKħEK2*2
RT\G\YCTVQħè
9JQ+U QQN
PC\YC
RTKPV
PC\YC
PQYCNKPKC
RTKPV
$4
RT\G\\OKGPPæ
9JQ+U QQN
PC\YC
RTKPV
PC\YC
!
Powyższy kod modyfikuje zmienną PC\YC. Najpierw zmiennej nadawana jest wartość:
PC\YC2TQITCOKħEK2*2
Funkcja łączy łańcuch danych ze zmienną łańcuchową przedkazywaną do funkcji:
HWPEVKQP9JQ+U QQN
CTIWOGPV]
CTIWOGPV UæEQQN
_
Następnie wywoływana jest funkcja, do której argument jest przekazywany przez wartość
i wyniki działania funkcji są wyświetlane. Zauważ, że w PHP argumenty do funkcji są
domyślnie przekazywane przez wartość:
9JQ+U QQN
PC\YC
RTKPV
PC\YC
Następnie ta sama funkcja jest wywoływana z przekazaniem argumentu przez zmienną,
a wynik działania funkcji jest wyświetlany.
9JQ+U QQN
PC\YC
RTKPV
PC\YC
Aby przekazać do funkcji argument przez zmienną, należy dodać znak przed zmienną
przekazywaną do funkcji (jak na przykład PCOG). Po uruchomieniu skryptu widać, że
przy wywołaniu funkcji z przekazaniem argumentu przez wartość, wartość zmiennej łańcu-
chowej pozostaje niezmieniona (patrz rysunek 3.18). Jednak przy przekazaniu argumentu
przez zmienną, jej wartość jest zmieniana.
4[UWPGM
Wyniki przekazania
argumentu
przez wartość
i przez zmienną
4Q\F\KCđ2TQITCOQYCPKGY2*2
-QT\[UVCPKG\QDKGMVÎY
PHP pozwala na rozbudowywanie i wielokrotne wykorzystanie napisanego fragmentu
kodu w postaci obiektów. Obiekty PHP umożliwiają dzielenie kodu na segmenty, które
w PHP są określane jako klasy. Jest to kolejny krok w kierunku strukturyzacji i wielo-
krotnego wykorzystania kodu, ponieważ umożliwia całkowite oddzielenie różnych części
aplikacji. Rozdzielając w ten sposób kod, programista ma pewność, że podczas testowania
i uruchamiania segmentu kodu wszystkie potrzebne instrukcje i definicje znajdują się
w jednej klasie. Jak, w takim razie, korzystać z obiektów w PHP?
!RJR
ENCUUOQLCMNCUC]
HWPEVKQP9KCFQOQUE2QYKVCNPC
CTIWOGPV]
TGVWTP9KVCLCTIWOGPV
_
_
VYQT\GPKGPQYGLMQRKKMNCU[
OQLQDKGMVPGYOQLCMNCUC
Y[YQđCPKGHWPMELK9KCFQOQUE2QYKVCNPCK\CRKUCPKGY[PKMWY[MQPCPKCHWPMELK
\YTQVOQLQDKGMV 9KCFQOQUE2QYKVCNPC
#PFT\GL
Y[ħYKGVNGPKGY[PKMÎY
RTKPV
\YTQV
!
Najpierw należy zdefiniować klasę dla naszego obiektud:
ENCUUOQLCMNCUC]
HWPEVKQP9KCFQOQUE2QYKVCNPC
CTIWOGPV]
TGVWTP9KVCLCTIWOGPV
_
_
Należy tutaj wspomnieć o kilku istotnych kwestiach. Po pierwsze, cały kod dotyczący
klasy jest umieszczony wewnątrz nawiasów funkcji klasy. Po drugie, zauważ, że funkcja
9KCFQOQUE2QYKVCNPC użyta w poprzednich przykładach tego rozdziału, ponownie się
pojawia. Nie ma obowiązku umieszczania definiowanych funkcji wewnątrz klasy, ale
jest to naturalny krok, jeśli dążysz do strukturyzacji kodu. Podobnie jak w poprzednich
przykładach, funkcja 9KCFQOQUE2QYKVCNPC pobiera dane poprzez argument, dokleja dane
do zmiennej i zwraca zmienną jako wynik działania.
OQLQDKGMVPGYOQLCMNCUC
W dalszej części tworzonego kodu możesz wykorzystywać zdefiniowaną wcześniej klasę.
W tym celu musisz najpierw stworzyć kopię obiektu i przypisać ją do zmiennej. W jakim
celu? Jest to kolejny krok w kierunku wielokrotnego wykorzystania fragmentu kodu.
Możesz korzystać z tego samego obiektu, nadając mu różne wartości i uzyskując różne
wyniki. Nie możesz jednak używać tego samego obiektu, równocześnie nadając mu różne
wartości, dlatego musisz utworzyć kilka kopii tego obiektu i używać tych kopii. W naszym
przykładzie obiekt jest wykorzystywany tylko jeden raz, ale zasady składni pozostają
niezmienione. Kopia obiektu jest przypisana do zmienndej OQLQDKGMV:
\YTQVOQLQDKGMV 9KCFQOQUE2QYKVCNPC
#PFT\GL
\úħè++9RTQYCF\GPKGFQRTQITCOQYCPKCY2*2
Teraz możesz korzystać z obiektu. W PHP obowiązuje nasdtępująca składnia:
-QRKC1DKGMVW 0C\YC(WPMELK
W tym przykładzie wywoływana jest funkcja 9KCFQOQUE2QYKVCNPC obiektu OQLCMNCUC.
Po uruchomieniu skryptu pojawią się wyniki wywołania funkcji wewnątrz obiektu. Ten
przykład jest raczej prosty. Aby przedstawić zalety wynikające z wykorzystania obiektów
w PHP, musimy go rozbudować:
!RJR
ENCUUOQLCMNCUC]
XCTY[UYKGVNCPCPC\YC9U\[UE[
HWPEVKQP QFCL0C\YG
CTIWOGPV]
VJKU Y[UYKGVNCPCPC\YCCTIWOGPV
_
HWPEVKQP9KCFQOQUE2QYKVCNPC
]
TGVWTP9KVCLVJKU Y[UYKGVNCPCPC\YC
_
_
VYQT\GPKGRKGTYU\GLMQRKKMNCU[
OQLQDKGMVPGYOQLCMNCUC
Y[YQđCPKGHWPMELK9KCFQOQUE2QYKVCNPCK\CRKUCPKGY[PKMWYY[MQPCPKCHWPMELK
\YTQVOQLQDKGMV 9KCFQOQUE2QYKVCNPC
Y[ħYKGVNGPKGY[PKMÎY
RTKPV
\YTQV
RTKPV
$4
VYQT\GPKGFTWIKGLMQRKKMNCU[
OQLQDKGMVPGYOQLCMNCUC
OQLQDKGMV QFCL0C\YG
#PFT\GL
\YTQVOQLQDKGMV 9KCFQOQUE2QYKVCNPC
Y[ħYKGVNGPKGY[PKMÎY
RTKPV
\YTQV
!
W tym przypadku klasa składa się z kilku elementów:
ENCUUOQLCMNCUC]
XCTY[UYKGVNCPCPC\YC9U\[UE[
HWPEVKQP QFCL0C\YG
CTIWOGPV]
VJKU Y[UYKGVNCPCPC\YCCTIWOGPV
_
HWPEVKQP9KCFQOQUE2QYKVCNPC
]
TGVWTP9KVCLVJKU Y[UYKGVNCPCPC\YC
_
_
4Q\F\KCđ2TQITCOQYCPKGY2*2
Najpierw zdefiniowano zmienną wewnątrz klasy. Na niej operuje kod znajdujący się
wewnątrz definicji klasy i dlatego jest określana jdako zmienna klasy.
XCTY[UYKGVNCPCPC\YC9U\[UE[
Musisz zadeklarować zmienną klasy przy użyciu instrukcji XCT. Dzięki temu PHP „wie”,
co jest zmienną, a co funkcją.
W naszym przykładzie obiekt zawiera dwie funkcje:
HWPEVKQP QFCL0C\YG
CTIWOGPV]
VJKU Y[UYKGVNCPCPC\YCCTIWOGPV
_
HWPEVKQP9KCFQOQUE2QYKVCNPC
]
TGVWTP9KVCLVJKU Y[UYKGVNCPCPC\YC
_
Pierwsza z nich pobiera argument i przypisuje zmienndej klasy wartość tego argumentu:
HWPEVKQP QFCL0C\YG
CTIWOGPV]
VJKU Y[UYKGVNCPCPC\YCCTIWOGPV
_
Zwróć uwagę na składnię przypisania zmiennej klasy:
VJKU Y[UYKGVNCPCPC\YCCTIWOGPV
Odwołanie dotyczy zmiennej Y[UYKGVNCPCPC\YC zdefiniowanej w bieżącej klasie. Użycie
następującej składni gwarantuje, że odwołanie dotyczy zmiennej klasy i PHP nie pomyli
jej z inną zmienną znajdującą się poza klasą.
HWPMELC9KCFQOQUE2QYKVCNPC
]
TGVWTP9KVCLVJKU Y[UYKGVNCPCPC\YC
_
Druga funkcja przekazuje wartość zmiennej klasy poza klasę. Kod wywołujący klasę
spełnia dwa zadania. Najpierw tworzy kopię klasy i wydświetla wartość zmiennej klasy:
OQLQDKGMVPGYOQLCMNCUC
\YTQVOQLQDKGMV 9KCFQOQUE2QYKVCNPC
RTKPV
\YTQV
Następnie tworzy kolejną kopię klasy i przekazuje wartość funkcji QFCL0C\YG w celu
przypisania wartości zmiennej klasy. Ostatnim krokiem jest wyświetlenie nowej wartości
zmiennej klasy:
OQLQDKGMVPGYOQLCMNCUC
OQLQDKGMV QFCL0C\YG
#PFT\GL
\YTQVOQLQDKGMV 9KCFQOQUE2QYKVCNPC
Y[ħYKGVNGPKGY[PKMÎY
RTKPV
\YTQV
Po uruchomieniu skryptu zobaczysz wyniki wykonania dwóch części skryptu; w pierwszej
części wartość zmiennej klasy pozostawała niezmieniona, w drugiej części widoczna jest
nowa wartość zmiennej klasy, jak pokazano na rysunkdu 3.19.
\úħè++9RTQYCF\GPKGFQRTQITCOQYCPKCY2*2
4[UWPGM
Zmiana wartości
zmiennej klasy
2QFUWOQYCPKG
W tym rozdziale pokrótce przyjrzeliśmy się różnym rodzajom edytorów w systemie
Windows, za pomocą których możesz tworzyć skrypty PHP. Omówiliśmy również pod-
stawy języka PHP, takie jak składnia, zmienne, tablice, operatory logiczne i pętle, funkcje
i obiekty. Rozdział 4., „PHP i pliki”, poświęcony jest współpracy PHP z plikami oraz
systemem plików Windows.
Pobierz darmowy fragment (pdf)