AJAX_i_JavaScript_Tworzenie_i_optymalizacja_aplikacji_sieciowych_ajjsto.pdf

(564 KB) Pobierz
AJAX i JavaScript. Tworzenie i optymalizacja aplikacji sieciowych
Tworzenie i optymalizacja
aplikacji sieciowych
Autor: Joshua Eichorn
TĀumaczenie: Tomasz Walczak
ISBN: 978-83-246-1098-3
to Create Rich Internet Applications
Format: B5, stron: 336
PrzykĀady na ftp: 691 kB
Wydawnictwo Helion
ul. Koľciuszki 1c
44-100 Gliwice
tel. 032 230 98 63
e-mail: helion@helion.pl
Wykorzystaj w projektach najnowsze technologie
¤ Poznaj zasady funkcjonowania technologii AJAX
¤ Zastosuj narzķdzia i biblioteki uĀatwiajĴce budowanie aplikacji internetowych
¤ Zaprojektuj aplikacje, posĀugujĴc siķ przypadkami uŃycia
RosnĴca popularnoľě internetu sprawiĀa, Ńe jego uŃytkownicy stawiajĴ witrynom WWW
i aplikacjom sieciowym coraz wyŃsze wymagania. Nie wystarczy juŃ przygotowaě efektowny
projekt graficzny i atrakcyjnĴ treľě. Dziľ liczy siķ szybkoľě dziaĀania, bezpieczeĺstwo
i wygoda obsĀugi. Ratunkiem dla programistw poszukujĴcych kolejnych metod
usprawnienia dziaĀania swoich aplikacji jest technologia AJAX. To niesamowite poĀĴczenie
jķzyka JavaScript i XML pozwoliĀo wyeliminowaě najwiķkszĴ wadķ aplikacji i witryn WWW,
czyli koniecznoľě przeĀadowywania strony po kaŃdej zmianie zawartoľci. AJAX realizuje
proces przeĀadowania danych w tle, w sposb niezauwaŃalny dla uŃytkownika. Oczywiľcie,
to nie jedyna zaleta technologii AJAX -- jest ich znacznie wiķcej.
CzytajĴc ksiĴŃkķ â AJAX i JavaScript. Tworzenie i optymalizacja aplikacji sieciowych Ò ,
odkryjesz wszystkie zalety tej technologii i dowiesz siķ, jak projektowaě i pisaě wydajne,
bezpieczne oraz ergonomiczne aplikacje WWW. Nauczysz siķ korzystaě z ŃĴdaĺ
asynchronicznych, przetwarzaě pobrane dane i rozbudowywaě istniejĴce aplikacje tak,
aby zastosowaě AJAX. Poznasz proces projektowania i tworzenia aplikacji sieciowych
z wykorzystaniem przypadkw uŃycia, zadbasz o wygodķ obsĀugi i zdiagnozujesz
oraz rozwiĴŃesz problemy z kodem AJAKSA. W ksiĴŃce znajdziesz takŃe omwienie bibliotek
i narzķdzi, dziķki ktrym proces budowania aplikacji przyspieszysz i usprawnisz.
¤ Obiekty XMLHttpRequest
¤ İĴdania asynchroniczne
¤ Modyfikowanie aplikacji pod kĴtem AJAKSA
¤ Zwiķkszanie uŃytecznoľci witryn internetowych
¤ Przetwarzanie danych zwracanych do aplikacji ajaksowych
¤ Korzystanie z bibliotek Sarissa i Scriptaculous
¤ Przyspieszanie wyľwietlania danych
¤ Formularze logowania oparte na AJAKSIE
¤ Biblioteki AJAKSA dla PHP, Javy, C# i DHTML
Powiķksz swj arsenaĀ narzķdzi o technologiķ AJAX
i popraw komfort swojej pracy oraz jakoľě aplikacji!
AJAX i JavaScript.
692074676.001.png 692074676.002.png 692074676.003.png 692074676.004.png
Spis treści
Podziękowania ................................................................................. 7
O autorze ......................................................................................... 9
Wprowadzenie ................................................................................ 11
Część I ........................................................................................ 17
Rozdział 1. Czym jest AJAX? ............................................................................ 19
1.1. Bogate aplikacje internetowe ................................................................................ 19
1.2. Definicja AJAX-a ................................................................................................. 20
1.3. Technologie AJAX-a ............................................................................................ 21
1.4. Zdalne wykonywanie skryptów ............................................................................ 24
1.5. Gmail popularyzuje obiekty XMLHttpRequest .................................................... 24
1.6. Nowa nazwa — AJAX .......................................................................................... 26
1.7. Podsumowanie ...................................................................................................... 27
Rozdział 2. Zaczynamy .................................................................................... 29
2.1. Wprowadzenie do obiektów XMLHttpRequest .................................................... 29
2.1.1. XMLHttpRequest::Open() .......................................................................... 30
2.1.2. XMLHttpRequest::Send() ........................................................................... 31
2.1.3. XMLHttpRequest::setRequestHeader() ...................................................... 31
2.1.4. XMLHttpRequest::getResponseHeader() i getAllResponseHeaders() ....... 32
2.1.5. Inne metody obiektu XMLHttpRequest ...................................................... 32
2.1.6. Właściwości obiektów XMLHttpRequest ................................................... 33
2.1.7. Informacje o zmiennej readyState ............................................................... 33
2.2. Obiekty XMLHttpRequest działające w różnych przeglądarkach ........................ 34
2.3. Przesyłanie żądań asynchronicznych .................................................................... 36
2.4. AJAX bez obiektów XMLHttpRequest ................................................................ 40
2.5. Pierwsze rozwiązanie rezerwowe — przesyłanie żądań
za pomocą ramek IFrame ...................................................................................... 41
2.5.1. Tworzenie ukrytych ramek IFrame ............................................................. 43
2.5.2. Tworzenie formularza ................................................................................. 43
2.5.3. Przesyłanie pobranych danych do oryginalnego dokumentu ...................... 44
2.5.4. Kompletny przykład komunikacji w AJAX-ie przy użyciu ramek IFrame .... 44
2.6. Drugie rozwiązanie rezerwowe — przesyłanie żądań za pomocą ciasteczek ....... 47
2.7. Podsumowanie ...................................................................................................... 50
 
4
Spis treści
Rozdział 3. Używanie pobranych danych ........................................................... 51
3.1. Podejścia bazujące na dokumentach ..................................................................... 51
3.1.1. Używanie AJAX-a do dodawania nowych danych HTML do strony ........ 52
3.1.2. Używanie XML-a w modelu DOM ............................................................ 54
3.1.3. Używanie XML-a za pomocą XSLT .......................................................... 57
3.2. Zdalne wykonywanie skryptów ............................................................................ 61
3.2.1. Podstawowe techniki RPC .......................................................................... 62
3.2.2. SOAP i XML-RPC ...................................................................................... 70
3.2.3. Niestandardowe formaty XML ................................................................... 71
3.2.4. JavaScript i JSON ....................................................................................... 77
3.3. Jak wybrać typ żądania? ....................................................................................... 78
3.4. Podsumowanie ...................................................................................................... 79
Rozdział 4. Dodawanie AJAX-a do procesu tworzenia stron ................................ 81
4.1. Zmiany w cyklu tworzenia stron ........................................................................... 81
4.1.1. Zmiany wynikające z rozszerzania ............................................................. 82
4.1.2. AJAX w akcji — zastępowanie wyszukiwania użytkowników
w oknie wyskakującym ............................................................................... 83
4.1.3. Zmiany przy tworzeniu aplikacji sterowanych AJAX-em .......................... 85
4.2. Integrowanie AJAX-a w ramach platformy .......................................................... 88
4.3. Język JavaScript jako podstawowy język programowania ..................................... 89
4.4. Problemy wynikające ze stosowania nowego paradygmatu programowania ....... 91
4.5. Zalety stosowania bibliotek .................................................................................. 92
4.6. Przyczyny tworzenia własnych bibliotek .............................................................. 93
4.7. Jak oprogramowanie o otwartym dostępie do kodu źródłowego wpasowuje się
w zestaw narzędzi? ................................................................................................ 94
4.7.1. Ocena bibliotek o otwartym dostępie do kodu źródłowego ........................ 94
4.7.2. Biblioteki o otwartym dostępie do kodu źródłowego
a biblioteki komercyjne ............................................................................... 95
4.8. Przypadek użycia w dziedzinie tworzenia — licznik pobrań przeglądarki Firefox ..... 97
4.9. Przypadek użycia w dziedzinie pobierania — witryna intranetowa ..................... 99
4.10. Podsumowanie .................................................................................................... 100
Rozdział 5. Optymalne wykorzystywanie możliwości AJAX-a ............................ 101
5.1. Cele stosowania AJAX-a .................................................................................... 101
5.1.1. Zwiększanie interaktywności .................................................................... 102
5.1.2. Zmniejszanie czasu potrzebnego na wykonywanie operacji .................... 104
5.1.3. Zmniejszanie obciążenia łączy .................................................................. 106
5.1.4. Tworzenie bogatych aplikacji ................................................................... 107
5.2. Pomiar usprawnień .............................................................................................. 108
5.3. Wady i zalety łączenia AJAX-a z innymi nowymi technologiami ..................... 114
5.3.1. Łączenie AJAX-a z technologią Flash ...................................................... 115
5.3.2. Skalowalna grafika wektorowa (SVG) ..................................................... 115
5.3.3. Języki interfejsu użytkownika bazujące na XML-u .................................. 116
5.4. Podsumowanie .................................................................................................... 116
Rozdział 6. Porady dotyczące użyteczności ..................................................... 119
6.1. Definiowanie użyteczności ................................................................................. 119
6.2. Porady dotyczące użyteczności ........................................................................... 121
6.2.1. Pamiętaj o oczekiwaniach użytkowników ................................................ 121
6.2.2. Udostępnianie informacji o zachodzących operacjach ............................. 122
6.2.3. Pamiętanie o użytkownikach w trakcie dodawania zawartości strony ..... 122
6.2.4. Zachowanie możliwości cofnięcia operacji .............................................. 123
6.2.5. Określenie, czy programista tworzy aplikację czy witrynę internetową ...... 123
Spis treści
5
6.2.6. Stosowanie AJAX-a tylko wtedy, kiedy przynosi to optymalne efekty ... 123
6.2.7. Plan dla użytkowników, których przeglądarki
nie obsługują obiektów XMLHttpRequest ................................................ 124
6.3. Często spotykane problemy z użytecznością ...................................................... 124
6.3.1. Odciąganie uwagi przez komunikaty o sprawdzaniu poprawności .......... 124
6.3.2. Uniemożliwienie cofania operacji
w wyniku automatycznego zapisywania ................................................... 127
6.3.3. Aktualizowanie fragmentów strony bez zwracania na to uwagi
użytkownika .............................................................................................. 128
6.3.4. Problemy z tworzeniem zakładek przy używaniu AJAX-a
do wczytywania całych stron ..................................................................... 130
6.3.5. Wymaganie obsługi AJAX-a na witrynie sklepu internetowego .............. 131
6.4. Podsumowanie .................................................................................................... 132
Rozdział 7. Wskazówki dotyczące diagnozowania ........................................... 133
7.1. Dwie strony diagnozowania ................................................................................ 133
7.2. Spojrzenie na komunikację w AJAX-ie .............................................................. 134
7.2.1. Tworzenie AJAX-owego rejestratora ....................................................... 134
7.2.2. Używanie rejestratora ................................................................................ 138
7.2.3. Firebug — rozszerzenie do diagnozowania dla przeglądarki Firefox ...... 139
7.2.4. Fiddler ....................................................................................................... 143
7.2.5. Ogólne scenariusze diagnostyczne ............................................................ 147
7.3. Narzędzia do diagnozowania kodu JavaScript .................................................... 148
7.4. Wyjątki w języku JavaScript ............................................................................... 150
7.5. Zrzuty zmiennych ............................................................................................... 152
7.6. Podsumowanie .................................................................................................... 153
Część II ..................................................................................... 155
Rozdział 8. Biblioteki używane w części II — Sarissa i scriptaculous ............... 157
8.1. Przegląd przypadków użycia .............................................................................. 157
8.2. Biblioteki używane w części II ........................................................................... 158
8.3. Sarissa ................................................................................................................. 158
8.3.1. Instalacja ................................................................................................... 159
8.3.2. Zgłaszanie żądań AJAX-a ......................................................................... 159
8.3.3. Podstawowe funkcje do obsługi XML-a ................................................... 160
8.3.4. Obsługa dokumentów DOM ..................................................................... 160
8.3.5. Używanie XPath do wyszukiwania węzłów w dokumencie ..................... 163
8.3.6. Przekształcanie danych XML za pomocą XSLT ...................................... 166
8.3.7. Porady dla programistów używających Sarissy ........................................ 169
8.4. Scriptaculous ....................................................................................................... 170
8.4.1. Instalacja ................................................................................................... 170
8.4.2. Efekty wizualne ......................................................................................... 170
8.4.3. Pary „wyświetl-ukryj” ............................................................................... 171
8.4.4. Przeciąganie .............................................................................................. 173
8.4.5. Obiekty sortowalne ................................................................................... 174
8.4.6. Suwak ........................................................................................................ 177
8.4.7. Wskazówki dla użytkowników biblioteki scriptaculous ........................... 179
8.5. Podsumowanie .................................................................................................... 180
Rozdział 9. Biblioteki używane w części II — HTML_AJAX ............................... 181
9.1. HTML_AJAX ..................................................................................................... 181
9.1.1. Instalacja ................................................................................................... 182
9.1.2. Interfejs API biblioteki HTML_AJAX dla języka JavaScript .................. 183
9.1.3. Zdalny pośrednik AJAX-a ........................................................................ 189
6
Spis treści
9.1.4. Korzystanie z klasy HTML_AJAX_Action .............................................. 192
9.1.5. Działania języka JavaScript ...................................................................... 193
9.1.6. Metody narzędziowe dla języka JavaScript .............................................. 195
9.1.7. Metody narzędziowe dla języka PHP ....................................................... 196
9.1.8. Wskazówki dotyczące korzystania z HTML_AJAX ................................ 197
9.2. Podsumowanie .................................................................................................... 197
Rozdział 10. Przyspieszanie wyświetlania danych .............................................. 199
10.1. Wprowadzenie do przeglądarki wschodów i zachodów słońca .......................... 199
10.2. Tworzenie przeglądarki wschodów i zachodów słońca bez AJAX-a ................. 200
10.2.1. Klasa SunRiseSet .................................................................................... 203
10.2.2. Plik Graph.php ........................................................................................ 208
10.2.3. Plik Standard.php .................................................................................... 208
10.3. Problemy z przeglądarką bez AJAX-a ................................................................ 212
10.4. Usprawnianie przeglądania za pomocą AJAX-a ................................................ 212
10.4.1. Przeglądarka w wersji HTML usprawniona pod kątem AJAX-a ........... 214
10.4.2. Skrypt PHP przeglądarki zmodyfikowany po kątem AJAX-a ................ 218
10.5. Podsumowanie .................................................................................................... 225
Rozdział 11. Logowanie do blogu przy użyciu AJAX-a ......................................... 227
11.1. Dlaczego AJAX dobrze nadaje się do obsługi logowania? ................................ 227
11.2. Tworzenie systemu logowania bazującego na AJAX-ie ..................................... 228
11.3. Rozbudowywanie formularza logowania ............................................................ 233
11.4. Używanie formatu XML do tworzenia AJAX-owego logowania
do systemu komentarzy ....................................................................................... 238
11.5. Podsumowanie .................................................................................................... 245
Rozdział 12. Budowanie systemu sygnalizowania błędów .................................. 247
12.1. System sygnalizowania błędów .......................................................................... 247
12.2. Skala zależności od AJAX-a ............................................................................... 249
12.3. Tworzenie zaplecza ............................................................................................. 250
12.4. Eksportowanie zaplecza ...................................................................................... 256
12.5. Tworzenie aplikacji bazującej na języku JavaScript ........................................... 261
12.6. Komponent do logowania ................................................................................... 271
12.7. Komponent do rejestracji użytkowników ........................................................... 276
12.8. Komponent do edycji kont .................................................................................. 279
12.9. Komponent do tworzenia zgłoszeń ..................................................................... 281
12.10. Komponent do edycji zgłoszeń ........................................................................... 283
12.11. Komponent „moje zgłoszenia” ........................................................................... 288
12.12. Komponent do przypisywania zgłoszeń ............................................................. 293
12.13. Zagadnienia związane z bezpieczeństwem w aplikacjach AJAX-owych ........... 297
12.14. Porównywanie aplikacji sterowanych AJAX-em ze standardowym
modelem MVC .................................................................................................... 298
12.15. Podsumowanie .................................................................................................... 299
Dodatki ..................................................................................... 301
Dodatek A Biblioteki AJAX-a dla języka JavaScript ......................................... 303
Dodatek B Biblioteki AJAX-a z warstwami serwera ......................................... 309
Dodatek C Biblioteki dla DHTML JavaScript ................................................... 317
Skorowidz ....................................................................................................... 323

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin