Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00522 007486 11067215 na godz. na dobę w sumie
Ajax. Od podstaw - książka
Ajax. Od podstaw - książka
Autor: , Liczba stron: 544
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-1287-1 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> webmasterstwo >> ajax
Porównaj ceny (książka, ebook, audiobook).

Wprowadzenie do technologii Ajax dla webmasterów

Choć technologia znana jest od końca ubiegłego wieku, uznanie zdobyła dopiero parę lat temu, kiedy firma Google zaczęła używać jej na większą skalę w swoich projektach. Wtedy webmasterzy odkryli, jaka siła tkwi w połączonych technologiach, kryjących się pod nazwą Ajax. Dołącz do nich i wzbogać swoje strony WWW, co sprawi, że staną się interaktywne bardziej niż kiedykolwiek.

'Ajax. Od podstaw' to książka dla twórców witryn internetowych, którzy chcą poszerzyć swoje umiejętności o niesamowitą technologię Ajax. Chris Ullmann i Lucinda Dykes, autorzy i współautorzy wielu książek o technikach programowania, przekazują tu swoje wieloletnie doświadczenie. Ułatwiają czytelnikowi opanowanie języka, przechodząc od podstawowych do coraz bardziej złożonych przypadków opartych na rzeczywistych przykładach. Narracyjny styl książki sprawia, że jest przyjazna czytelnikowi, a usystematyzowany układ czyni ją przejrzystą.

Poznaj nowe sposoby programowania webowego
i wzbogać swoje witryny WWW o technologię Ajax!

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Ajax. Od podstaw Autor: Chris Ullman, Lucinda Dykes T‡umaczenie: Anna Trojan ISBN: 978-83-246-1287-1 Tytu‡ orygina‡u: Beginning Ajax (Programmer to Programmer) Format: B5, stron: oko‡o 540 oprawa twarda Wprowadzenie do technologii Ajax dla webmaster(cid:243)w (cid:149) Jak tworzy(cid:230) interaktywne aplikacje webowe w technologii Ajax? (cid:149) Jak pisa(cid:230) i wykorzystywa(cid:230) wzorce projektowe w Ajax? (cid:149) Dlaczego warto skorzysta(cid:230) z mo¿liwo(cid:156)ci Ajaksa? Cho(cid:230) technologia znana jest od koæca ubieg‡ego wieku, uznanie zdoby‡a dopiero parŒ lat temu, kiedy Google zaczŒ‡o u¿ywa(cid:230) jej na wiŒksz„ skalŒ w swoich projektach. Wtedy webmasterzy odkryli, jaka si‡a tkwi w po‡„czonych technologiach, kryj„cych siŒ pod nazw„ Ajax. Do‡„cz do nich i wzboga(cid:230) swoje strony WWW, co sprawi, ¿e stan„ siŒ interaktywne bardziej ni¿ kiedykolwiek. (cid:132)Ajax. Od podstaw(cid:148) to ksi„¿ka dla tw(cid:243)rc(cid:243)w witryn internetowych, kt(cid:243)rzy chc„ poszerzy(cid:230) swoje umiejŒtno(cid:156)ci o niesamowit„ technologiŒ Ajax. Chris Ullmann i Lucinda Dykes, autorzy i wsp(cid:243)‡autorzy wielu ksi„¿ek o technikach programowania, przekazuj„ tu swoje wieloletnie do(cid:156)wiadczenie. U‡atwiaj„ czytelnikowi opanowanie jŒzyka, przechodz„c od podstawowych do coraz bardziej z‡o¿onych przypadk(cid:243)w opartych na rzeczywistych przyk‡adach. Narracyjny styl ksi„¿ki sprawia, ¿e jest przyjazna czytelnikowi, a usystematyzowany uk‡ad czyni j„ przejrzyst„. (cid:149) Model i sk‡adnia aplikacji opartej na technologii Ajax (cid:149) Komunikacja z serwerami (cid:149) Synchroniczne i asynchroniczne przesy‡anie danych (cid:149) Us‡ugi sieciowe (cid:149) API oraz aplikacje mushup (cid:149) Praca z XML, XSLT oraz XPath (cid:149) Integracja z formatem wymiany danych JSON (cid:149) Praca z serwerem MySQL (cid:149) Usuwanie oraz obs‡uga b‡Œd(cid:243)w (cid:149) Wzorce projektowe (cid:149) Wykorzystanie danych zewnŒtrznych (cid:149) Platformy oraz biblioteki dostŒpne dla technologii Ajax (cid:149) Przewodnik po jŒzyku JavaScript Poznaj nowe sposoby programowania webowego i wzboga(cid:230) swoje witryny WWW o technologiŒ Ajax! Wydawnictwo Helion ul. Ko(cid:156)ciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl Spis treści O autorach ................................................................................................................................................13 Wprowadzenie .........................................................................................................................................15 Rozdział 1. Wprowadzenie do Ajaksa .....................................................................................................23 Czym jest Ajax? ............................................................................................................ 24 Ajax w praktyce ....................................................................................................... 25 flickr ................................................................................................................. 25 Basecamp ......................................................................................................... 27 Amazon (A9.com) ............................................................................................... 28 Google Suggest oraz Google Maps ...................................................................... 29 Inne strony internetowe ...................................................................................... 30 Złe przykłady ..................................................................................................... 31 Ajax — akronim ...................................................................................................... 32 XHTML oraz CSS ................................................................................................ 33 DOM (Document Object Model) ........................................................................... 34 JavaScript ......................................................................................................... 35 XML, XSLT oraz XPath ........................................................................................ 36 Obiekt XMLHttpRequest ..................................................................................... 37 Technologie po stronie serwera .......................................................................... 39 Model aplikacji opartej na Ajaksie .................................................................................. 39 Dlaczego powinno się używać Ajaksa? ...................................................................... 41 Częściowe uaktualnianie strony .......................................................................... 41 Niewidoczne pobieranie danych .......................................................................... 42 Ciągłe uaktualnianie .......................................................................................... 42 Jednolite interfejsy ............................................................................................. 42 Prostota i bogactwo możliwości ........................................................................... 42 Przeciąganie i upuszczanie ................................................................................. 42 Kiedy nie należy używać Ajaksa ................................................................................ 43 Spowolnienie strony ........................................................................................... 43 Zakłócenie działania przycisku Wstecz w przeglądarce .......................................... 43 Zakłócanie działania zakładek oraz blokowanie indeksów wyszukiwarek ................. 44 Obciążenie dla przeglądarki ................................................................................ 44 Kto może bądź nie może używać Ajaksa? .................................................................. 44 Stwórz swój własny przykład .......................................................................................... 45 Podsumowanie ............................................................................................................ 55 Ćwiczenia .................................................................................................................... 55 6 Ajax. Od podstaw Rozdział 2. Powtórka z JavaScriptu .....................................................................................................57 Jądro JavaScriptu ......................................................................................................... 58 Składnia ................................................................................................................. 58 Zmienne ................................................................................................................. 58 Podstawowe typy danych .................................................................................... 59 Referencyjne typy danych ................................................................................... 60 Operatory ............................................................................................................... 60 Operator przypisania .......................................................................................... 61 Operatory arytmetyczne ...................................................................................... 61 Operatory porównania ........................................................................................ 61 Operatory logiczne ............................................................................................. 62 Operatory inkrementacji oraz dekrementacji ......................................................... 63 Instrukcje ............................................................................................................... 63 Instrukcje warunkowe ......................................................................................... 64 Pętle ................................................................................................................. 65 Funkcje .................................................................................................................. 66 JavaScript zorientowany obiektowo ................................................................................ 67 Obiekty wbudowane ................................................................................................ 68 Obiekty przeglądarki ................................................................................................ 68 Obiekty zdefiniowane przez użytkownika .................................................................... 69 Konstruktory ...................................................................................................... 70 Prototypy ................................................................................................................ 71 Niszczenie obiektów ........................................................................................... 72 DOM (Document Object Model) ..................................................................................... 74 Dokument jako drzewo potomków ............................................................................ 75 Dokument jako drzewo węzłów ................................................................................. 75 Metody dostępu do obiektów w DOM ........................................................................ 76 Metoda getElementById ..................................................................................... 76 Metoda getElementsByTagName ......................................................................... 77 Tworzenie węzłów .................................................................................................... 78 Alternatywne rozwiązanie — innerHTML .................................................................... 80 JavaScript oraz zdarzenia .............................................................................................. 81 Modele zdarzeń ...................................................................................................... 82 Rejestracja zdarzeń ................................................................................................. 82 Model rejestracji zdarzeń w przeglądarce Internet Explorer .................................... 83 Model rejestracji zdarzeń w DOM z W3C .............................................................. 84 Obiekty zdarzeń ...................................................................................................... 84 Podsumowanie ............................................................................................................ 88 Ćwiczenia .................................................................................................................... 89 Rozdział 3. Ajax oraz technologie po stronie serwera ..........................................................................91 Ajax oraz technologie po stronie serwera ........................................................................ 92 Formularze oraz kontrolki HTML ............................................................................... 92 Model przesyłania formularzy ................................................................................... 92 Model przesyłania formularzy w Ajaksie oraz JavaScripcie ........................................... 94 Od strony serwera ........................................................................................................ 94 Przesyłanie danych do serwera ................................................................................. 95 Serwer otrzymuje żądanie ........................................................................................ 95 Pisanie odpowiedzi HTTP .............................................................................................. 96 Obiekt XMLHttpRequest .......................................................................................... 97 Funkcja zwrotna ................................................................................................. 98 Właściwość responseText ................................................................................... 98 Spis treści 7 Właściwość responseXML .................................................................................. 99 Usuwanie błędów z responseXML ..................................................................... 100 Wykorzystywanie danych ................................................................................... 101 Technologie po stronie serwera ................................................................................... 102 ASP.NET ............................................................................................................... 102 Przykład wykorzystujący Ajaksa oraz ASP.NET ..................................................... 104 PHP ..................................................................................................................... 114 Przykład wykorzystujący Ajaksa oraz PHP ........................................................... 115 Serwlety Javy ........................................................................................................ 120 Przykład wykorzystujący Ajaksa oraz serwlety Javy .............................................. 121 Którą technologię powinno się wykorzystywać? ............................................................. 125 Podsumowanie .......................................................................................................... 126 Ćwiczenia .................................................................................................................. 126 Rozdział 4. Techniki Ajaksa ...................................................................................................................127 Obiekt XMLHttpRequest .............................................................................................. 128 Tworzenie obiektu XMLHttpRequest ............................................................................. 129 Użycie synchroniczne ............................................................................................. 129 Użycie asynchroniczne ........................................................................................... 130 Właściwość readyState .......................................................................................... 130 Właściwości oraz metody obiektu XMLHttpRequest .................................................. 131 Często popełniane błędy ........................................................................................ 137 Bardziej skomplikowane problemy .......................................................................... 138 Problem z tym samym pochodzeniem ................................................................ 138 Kontrola pamięci podręcznej — agresywna polityka przeglądarki Internet Explorer .... 139 Implikacje działania we wszystkich przeglądarkach ............................................. 143 Metoda POST ............................................................................................................. 144 Zalety i wady używania metod POST oraz GET ............................................................... 147 Inne techniki Ajaksa ................................................................................................... 147 Ukryte ramki ......................................................................................................... 147 Pomysł ............................................................................................................ 148 Zalety oraz wady .............................................................................................. 154 Ukryte ramki typu iframe ........................................................................................ 154 Pomysł ............................................................................................................ 155 Zalety oraz wady .............................................................................................. 158 Dynamiczne ładowanie skryptu ............................................................................... 158 Pomysł ............................................................................................................ 158 Zalety oraz wady .............................................................................................. 161 Obrazki oraz cookies ............................................................................................. 161 Pomysł ............................................................................................................ 162 Zalety oraz wady .............................................................................................. 166 Podsumowanie .......................................................................................................... 166 Ćwiczenie .................................................................................................................. 167 Rozdział 5. Praca z XML ........................................................................................................................169 Podstawy XML ............................................................................................................ 170 Tworzenie znaczników ............................................................................................ 170 Składnia XML ....................................................................................................... 170 Dokumenty XML poprawne składniowo oraz strukturalnie ......................................... 172 Ekstrakcja danych za pomocą JavaScriptu .................................................................... 177 Wykorzystywanie węzłów ........................................................................................ 177 Dostęp do elementów XML po ich nazwie ................................................................ 179 Dostęp do wartości atrybutów ................................................................................ 179 8 Ajax. Od podstaw Wykorzystywanie CSS z danymi XML ............................................................................ 183 Wykorzystywanie CSS z dokumentami XML .............................................................. 185 Wykorzystywanie CSS z Ajaksem ............................................................................ 185 Właściwość style ............................................................................................. 185 Właściwość className .................................................................................... 186 Podsumowanie .......................................................................................................... 186 Ćwiczenia .................................................................................................................. 187 Rozdział 6. Usuwanie oraz obsługa błędów ..........................................................................................189 Obsługa błędów w JavaScripcie ................................................................................... 190 Obsługa wyjątków ................................................................................................. 190 Program obsługi zdarzeń onerror ............................................................................ 192 Konsola błędów w przeglądarkach Mozilla ............................................................... 194 Microsoft Script Debugger ..................................................................................... 196 Firebug ................................................................................................................. 199 Inspektory DOM ......................................................................................................... 202 Inspektor DOM z przeglądarki Firefox ...................................................................... 202 Inspektor DOM w przeglądarce Internet Explorer ...................................................... 204 MODI (Mouseover DOM Inspector) ......................................................................... 204 Rozwiązywanie problemów związanych z Ajaksem .......................................................... 205 Wykorzystywanie dodatku Firebug z XMLHttpRequest ............................................... 206 Dodatek Live HTTP Headers ................................................................................... 206 Podsumowanie .......................................................................................................... 208 Ćwiczenia .................................................................................................................. 209 Rozdział 7. Usługi sieciowe, API oraz aplikacje typu mashup ..............................................................211 Czym jest usługa sieciowa? ......................................................................................... 212 Publiczne usługi sieciowe ...................................................................................... 213 Wykorzystywanie usług sieciowych należących do innych podmiotów ............................... 214 Struktura usługi sieciowej ........................................................................................... 216 Podejście oparte na REST ...................................................................................... 217 Podejście oparte na SOAP ..................................................................................... 218 Integrowanie usługi sieciowej z własną aplikacją opartą na Ajaksie ................................ 219 Wykorzystywanie usługi z obiektem XMLHttpRequest ............................................... 220 Polityka tego samego pochodzenia .................................................................... 220 Tworzenie proxy dla aplikacji .................................................................................. 221 Sztuczka ze znacznikiem script .............................................................................. 228 Przyszłe alternatywy .............................................................................................. 231 Wykorzystywanie API ................................................................................................... 232 Różnica między usługami sieciowymi a API .............................................................. 233 Google Maps API .................................................................................................. 234 Klucz Google Maps API ..................................................................................... 234 Obiekt mapy .................................................................................................... 234 Obiekt Geocode ............................................................................................... 235 Metoda fabrykująca XMLHttpRequest ................................................................ 236 Aplikacje typu mashup ................................................................................................ 244 W jaki sposób Ajax ułatwia wykorzystywanie aplikacji typu mashup ................................. 245 Wykorzystywanie Flickr API ..................................................................................... 246 Etykietki (lista ważona) .......................................................................................... 246 Wykorzystywanie klucza Flickr API ........................................................................... 247 Spis treści 9 Tworzenie przykładowej aplikacji ............................................................................. 247 Dodawanie informacji o miejscu zrobienia zdjęcia w serwisie Flickr ...................... 248 Wyświetlanie zdjęć z Flickr ..................................................................................... 257 Podsumowanie .......................................................................................................... 261 Ćwiczenia .................................................................................................................. 262 Rozdział 8. XSLT oraz XPath .................................................................................................................263 XSLT oraz jego cel ...................................................................................................... 264 Elementy XSLT ........................................................................................................... 266 Element xsl:stylesheet .......................................................................................... 266 Element xsl:output ................................................................................................ 267 Element xsl:include ............................................................................................... 268 Elementy xsl:template, xsl:apply-templates oraz xsl:call-template ............................. 268 Atrybut match .................................................................................................. 268 Atrybut name ................................................................................................... 269 Parametry XSLT ............................................................................................... 270 Element xsl:if ....................................................................................................... 270 Elementy xsl:choose, xsl:when oraz xsl:otherwise .................................................... 270 Znoszenie znaczenia specjalnego znaków w XSLT ............................................... 271 Element xsl:for-each .............................................................................................. 272 Element xsl:value-of .............................................................................................. 272 Element xsl:sort .................................................................................................... 273 Element xsl:variable .............................................................................................. 273 Obsługa XSLT w najważniejszych przeglądarkach ........................................................... 274 Wykonywanie transformacji ......................................................................................... 274 Wykonywanie transformacji w przeglądarce Internet Explorer .................................... 274 Wykonywanie transformacji w przeglądarce Firefox ................................................... 279 Wykonywanie transformacji po stronie serwera ........................................................ 281 Tworzenie arkusza stylów XSLT dla koszyka z zakupami ................................................. 284 XPath oraz jego cel ..................................................................................................... 294 Podstawowe możliwości XPath .................................................................................... 294 Wyrażenia XPath ................................................................................................... 295 Kontekst bieżący ............................................................................................. 295 Węzeł główny dokumentu ................................................................................. 296 Element główny dokumentu .............................................................................. 296 Rekurencyjne schodzenie w dół drzewa .............................................................. 296 Określone elementy ......................................................................................... 297 Funkcje XPath ....................................................................................................... 297 Funkcja number ............................................................................................... 297 Funkcja position .............................................................................................. 298 Funkcja count .................................................................................................. 298 Formatowanie łańcuchów znaków ...................................................................... 298 Funkcje arytmetyczne ....................................................................................... 299 Funkcje logiczne .............................................................................................. 299 Wykonywanie zapytań w dokumentach XML za pomocą XPath ........................................ 300 Ulepszenie przykładu z koszykiem z zakupami, tak by używał on XSLT oraz Ajaksa ........... 305 Podsumowanie .......................................................................................................... 313 Ćwiczenia .................................................................................................................. 314 10 Ajax. Od podstaw Rozdział 9. Wzorce .................................................................................................................................315 Podstawy wzorców projektowych .................................................................................. 316 Sprawdzanie poprawności formularzy ........................................................................... 317 Problem ............................................................................................................... 317 Wzorzec ............................................................................................................... 317 Dodatkowe informacje we wzorcach związanych z najeżdżaniem myszą na element ......... 325 Problem ............................................................................................................... 325 Wzorzec ............................................................................................................... 326 Wzorzec odpytywania serwera ..................................................................................... 333 Problem ............................................................................................................... 333 Wzorzec ............................................................................................................... 333 Wzorzec służący do tworzenia list opartych na przeciąganiu oraz upuszczaniu ................. 343 Problem ............................................................................................................... 343 Wzorzec ............................................................................................................... 343 Wzorzec obsługi błędów .............................................................................................. 357 Problem ............................................................................................................... 358 Wzorzec ............................................................................................................... 358 Podsumowanie .......................................................................................................... 364 Ćwiczenia .................................................................................................................. 365 Rozdział 10. Praca z danymi zewnętrznymi ........................................................................................367 Praca z kanałami informacyjnymi XML .......................................................................... 368 RSS 0.9x ............................................................................................................. 370 RSS 2.0 ............................................................................................................... 371 RSS 1.0 ............................................................................................................... 373 Atom .................................................................................................................... 374 Ekstrakcja danych z kanału informacyjnego XML ........................................................... 376 Ekstrakcja danych w postaci XML ........................................................................... 376 Ekstrakcja danych w postaci łańcucha znaków ........................................................ 383 Budowanie czytnika kanałów online opartego na Ajaksie ................................................ 385 Podsumowanie .......................................................................................................... 396 Ćwiczenia .................................................................................................................. 396 Rozdział 11. JSON ...................................................................................................................................397 Składnia JSON ........................................................................................................... 398 Typy danych JSON ................................................................................................. 398 Literały obiektów ................................................................................................... 399 Literały tablic ........................................................................................................ 400 Wykorzystywanie analizatora składniowego JSON ..................................................... 400 Formaty transmisji danych .......................................................................................... 401 Ajax oraz JSON ........................................................................................................... 403 Tworzenie żądania ................................................................................................. 403 Analiza składniowa odpowiedzi ............................................................................... 405 Wykorzystywanie metody eval() ......................................................................... 405 Wykorzystywanie parseJSON() ........................................................................... 406 Dodawanie danych JSON do strony internetowej ...................................................... 406 Wykorzystywanie JSON z PHP ...................................................................................... 410 Podsumowanie .......................................................................................................... 412 Ćwiczenia .................................................................................................................. 412 Spis treści 11 Rozdział 12. Zaawansowany przykład — lista sortowana .................................................................413 Wykorzystywanie MySQL ............................................................................................. 414 Tworzenie tabeli MySQL ......................................................................................... 414 Dodawanie danych do tabeli .................................................................................. 416 Tworzenie połączenia z bazą danych ....................................................................... 417 Tworzenie zapytań do bazy danych ............................................................................... 418 Uzyskanie aktualnych wartości pól .......................................................................... 419 Porządkowanie listy w kolejności ............................................................................ 419 Edycja rekordów bazy danych ...................................................................................... 421 Wstawianie rekordu ............................................................................................... 421 Usuwanie rekordu ................................................................................................. 423 Wykorzystywanie biblioteki Scriptaculous w przeciąganiu oraz upuszczaniu ..................... 424 Tworzenie elementu typu Droppable ....................................................................... 424 Tworzenie elementu typu Sortable .......................................................................... 426 Interakcja z użytkownikiem — strona główna ................................................................ 427 Wykorzystywanie Ajaksa do uaktualniania listy .............................................................. 431 Tworzenie żądań POST .......................................................................................... 432 Tworzenie żądań GET ............................................................................................ 434 Przetwarzanie wyników .......................................................................................... 435 Dodawanie stylu ................................................................................................... 437 Pliki .......................................................................................................................... 437 Podsumowanie .......................................................................................................... 438 Dodatek A Rozwiązania ćwiczeń ..........................................................................................................439 Dodatek B Istniejące zasoby Ajaksa — platformy oraz biblioteki ......................................................461 Dodatek C Istniejące zasoby JavaScriptu ............................................................................................471 Dodatek D Przewodnik po języku JavaScript .....................................................................................475 Skorowidz .............................................................................................................................................523 3 Ajax oraz technologie po stronie serwera Po lekturze wcześniejszych rozdziałów można odnieść wrażenie, że Ajax to tylko to, co dzieje się po stronie klienta. W początkowej definicji Ajaksa określenie, że współpracuje on „z danymi wejściowymi ze strony serwera” było istotnym ograniczeniem. Tak naprawdę wielu programistów Ajaksa uważało, że aplikacja używająca XMLHttpRequest do uaktual- nienia strony bez danych wejściowych z serwera nie jest prawdziwą aplikacją ajaksową. W omówionych dotychczas kwestiach unikano problemu drugiej strony komunikacji klient-serwer — strony serwera. W rzeczywistości cała ta sytuacja przypomina rozmowę telefoniczną, w której mówi się, jednak nie jest się w stanie słyszeć, co odpowiada rozmówca. W dwóch pierwszych rozdziałach niniejszej książki w ogóle nie używano żadnego kodu po stronie serwera. Musi się to zatem zmienić. Jednym z początkowych założeń tej książki było pozostanie niezależnym i niejednoznacz- nym w kwestii wyboru technologii po stronie serwera. Tak naprawdę w niniejszym roz- dziale założono, że Czytelnik dokonał już wyboru, dlatego pisanie o tym, jakie technologie preferują autorzy, mogłoby tylko prowadzić do antagonizmów. Jedną z istotniejszych zalet Ajaksa jest to, że w aplikacjach opartych na tej technologii można z łatwością użyć dowol- nej technologii po stronie serwera. Zostanie to zademonstrowane w niniejszym rozdziale. Sposób, w jaki Ajax (czyli obiekt XMLHttpRequest) komunikuje się z serwerem, jest w każ- dej technologii w zasadzie taki sam. Różnice polegają jednak na sposobie obsługi danych, które dotrą do serwera. Oczywiste jest, że niemożliwe byłoby omówienie wszystkich tech- nologii po stronie serwera w jednym rozdziale, dlatego autorzy książki wybrali trzy z nich, uważane za najbardziej popularne w kontekście Ajaksa: ASP.NET, PHP oraz Javę. Jeśli Czytelnik pracuje w innej technologii, może się przyjrzeć zaprezentowanym tutaj wzorcom i pomyśleć, w jaki sposób można je zastosować w innych warunkach. W omówieniu tym nie zamieszczono zbyt wielu szczegółów na temat tego, w jaki sposób działają te technologie; nie omówiono także detali składni czy jej zastosowania. W roz- dziale tym przechodzi się od razu do sedna sprawy i pokazuje przykład tego, w jaki sposób 92 Ajax. Od podstaw aplikacje oparte na Ajaksie współpracują z każdą z trzech przedstawionych technologii, a także jak dana technologia po stronie serwera może przekazywać z powrotem do klienta informacje oraz dane, które mogą być użyte w aplikacji. W niniejszym rozdziale omówiono następujące zagadnienia: (cid:81) Ajax oraz technologie po stronie serwera, (cid:81) ASP.NET, (cid:81) PHP, (cid:81) serwlety Javy. Ajax oraz technologie po stronie serwera W niniejszej książce zarysowano już najważniejszą różnicę pomiędzy sposobem działania tradycyjnych technologii po stronie serwera (model „dodaj dane-wyślij-czekaj”) a sposobem działania aplikacji opartych na Ajaksie (asynchroniczne wywoływanie serwera), która polega na zmianie tradycyjnych wzorców użycia stron internetowych w aplikacjach ajaksowych. Ajax nie jest ograniczony tylko do jednego wzorca użycia, a w rozdziale 9. zaprezentowane zostaną różne wzorce, w których Ajax może zmienić przepływ danych od klienta do serwera. Jedynym podobieństwem pomiędzy tymi wzorcami jest to, że nie jest się już przywiązanym do jawnego wysyłania formularza, a następnie zmuszonym do czekania na jego odpowiedź. Warto zatem skupić się chwilę na wykorzystywaniu formularzy oraz kontrolek HTML na stronie. Formularze oraz kontrolki HTML Ajax nie zmienia zasadniczego sposobu działania kontrolek HTML oraz sposobu pobiera- nia z nich danych. Nadal ma się do dyspozycji zbiór kontrolek HTML (takich, jak listy rozwijane, przyciski opcji, pola wyboru czy pola tekstowe), które w dalszym ciągu są prze- syłane do serwera. Serwer pobiera je w ten sam sposób. Istnieją jednak dwie zasadnicze zmiany. Pierwszą z nich jest sposób wywoływania strony po stronie serwera, a drugą fakt, iż formularz HTML może być całkowicie usunięty ze strony bądź przerobiony tak, że nie działa w oczekiwany sposób. Zostanie to wyjaśnione po bliż- szym przyjrzeniu się temu, jak działa istniejący model przesyłania formularza do serwera. Model przesyłania formularzy W przypadku dowolnej technologii po stronie serwera normalny sposób przesyłania for- mularza polega na dodaniu do niego przycisku, po kliknięciu którego formularz przesyłany jest do serwera. Rozdział 3. (cid:81) Ajax oraz technologie po stronie serwera 93 Normalnie ASP czy PHP korzystają z atrybutu action formularza, by przekierować użyt- kownika ze strony początkowej na stronę odpowiedzi. Przetwarzanie wykonywane jest na serwerze, zanim użytkownik zostanie przekierowany do nowej strony, natomiast nowa strona używana jest do wyświetlenia danych (rysunek 3.1). Rysunek 3.1. Klasyczny model przesyłania formularzy w PHP oraz ASP W ASP.NET model ten nieco zmieniono, usuwając atrybut action i dodając atrybut RUNAT= SERVER . Zamiast przechodzić do innej strony, strona ta prześle dane z powrotem do samej siebie. Ponownie jednak strona działa w momencie interwencji użytkownika (rysunek 3.2). Rysunek 3.2. Model przesyłania formularzy w ASP.NET W modelu ASP.NET nawigacja pomiędzy stronami wykonywana jest częściej za pomocą metod Response.Redirect bądź Server.Transfer. Jedną z największych przeszkód stoją- cych przed początkującymi programistami przechodzącymi z ASP na ASP.NET było zro- zumienie tej różnicy konceptualnej. Pozostało to popularnym zastosowaniem aż do czasów Ajaksa, który przywrócił pomysł wymuszenia na skrypcie przesyłania strony. 94 Ajax. Od podstaw Model przesyłania formularzy w Ajaksie oraz JavaScripcie W modelu przesyłania formularzy w JavaScripcie, który wykorzystywany jest w Ajaksie, znowu wprowadzono zmianę. Formularz może (choć nie musi) zostać całkowicie usunięty z tego modelu. Model ten wykorzystuje JavaScript do przechwycenia wywołania zdarzenia, a kiedy takie zdarzenie następuje (na przykład gdy użytkownik kliknie przycisk bądź dokona wyboru w kontrolce HTML), wywołanie przekazywane jest do skryptu. To skrypt ma następnie zaini- cjować wywołanie serwera (rysunek 3.3). Rysunek 3.3. Model przesyłania formularzy w JavaScripcie oraz Ajaksie Skrypt nie musi oczywiście przesyłać danych natychmiast. Może poczekać na spełnienie innych warunków oraz kryteriów przed przesłaniem danych. W tym modelu — ponieważ skrypt może odpowiedzieć na zdarzenie natychmiast i nie musi czekać na jawne przesłanie — zwracanie danych z serwera nie musi również być natychmiast widoczne dla użytkownika. Skrypt nie jest ograniczony czekaniem na odpowiedź. Od strony serwera JavaScript wykorzystywany jest do rozpoczęcia interakcji pomiędzy klientem a serwerem. Zostawmy na razie ten podział i skupmy się na tym, co dzieje się z danymi, kiedy docierają one do serwera. Ponieważ każdy etap tego procesu odbywa się osobno, można podzielić go na części i każdą z nich omówić niezależnie od pozostałych. Części te można sobie wyobrazić jako czarne skrzynki. Wymagają one dostarczenia określonych danych wejściowych i do- starczają pewne dane wyjściowe, choć to, co dzieje się w środku, może być bardzo różne. Rozważmy na przykład bankomat. Wkłada się do niego kartę, wpisuje numer identyfika- cyjny (PIN) i oczekuje się, że pieniądze (oraz być może potwierdzenie) zostaną wydane przez maszynę. W całym kraju istnieją tysiące bankomatów należących do wielu różnych banków. Rozdział 3. (cid:81) Ajax oraz technologie po stronie serwera 95 Niektóre pobierają opłaty, inne pozwalają sprawdzić szczegóły związane z kontem, a inne umożliwiają tylko dostęp do gotówki. Bankomaty działają różnie, jednak mają ten sam in- terfejs, za pomocą którego można się z nimi komunikować. Część transakcji pomiędzy klientem a serwerem — odbywająca się po stronie serwera — przebiega dość podobnie jak w przypadku tej hipotetycznej czarnej skrzynki czy banko- matu. Otrzymuje ona dane z żądania HTTP i w końcu, po przetworzeniu owych danych, musi zwrócić je jako odpowiedź serwera. Przesyłanie danych do serwera Choć istnieje kilka metod przesyłania danych do serwera, skupimy się tylko na obiekcie XMLHttpRequest. By przesłać dane do serwera za pomocą tego obiektu, należy wykonać trzy kroki: 1. Ustawić zdarzenie, które zostanie wywołane po otrzymaniu danych. 2. Wywołać metodę open wraz z żądaniem. 3. Przesłać żądanie. Metoda open jest jedyną, jaką trzeba będzie omówić. XMLHttpRequestObject.open(metoda, URL do wywołania, asynchroniczna bądź synchroniczna); Metoda ta przesyła żądanie w jeden z dwóch możliwych sposobów. Pierwszy odbywa się za pośrednictwem metody HTTP GET, gdzie wiadomość przesyłana jest tak, jak w poniższym kodzie: XMLHttpRequestObject.open( GET , response.aspx?value=1 , true ); Drugi sposób to wykorzystanie metody HTTP POST. W poniższym fragmencie kodu dane ze zmiennej są kodowane w URI, opakowane w ciało żądania i przesyłane: var argument = value= ; argument += encodeURIComponent(dane); XMLHttpRequestObject.open( POST , response.aspx , true ); xHRObject.send(ciało_żądania) Kod ten pozwala na przesłanie wartości kontrolek HTML oraz danych z formularzy do serwera w dokładnie taki sam sposób i w tym samym formacie, w jakim przesyłano by stronę za pomocą PHP czy ASP.NET. Serwer otrzymuje żądanie Co dzieje się, kiedy serwer otrzymuje dane? Kod w JavaScripcie określił już metodę GET lub POST, która przesyła dane albo jako część adresu URL, albo jako część ciała żądania Request. W klasycznym ASP bądź w ASP.NET można wykorzystać zbiory QueryString, Form lub Params do pobrania tych elementów. W PHP używa się do tego zbiorów $_GET, $_POST bądź $_REQUEST. 96 Ajax. Od podstaw Nie ma zauważalnej różnicy w otrzymywaniu danych za pomocą formularza HTML bądź z żądania pochodzącego ze skryptu w JavaScripcie. Można na przykład dołączyć do strony pole tekstowe o nazwie MyTextbox1 dzięki następującemu kodowi na stronie HTML: input type= text id= MyTextbox1 name= MyTextbox1 / Kiedy wyśle się dane z pola za pomocą metody GET i z użyciem języka C#, dane pojawią się w zbiorze QueryString w ASP.NET: string TextBox = Request.QueryString[ MyTextbox1 ].ToString(); Dane mogą też pojawić się w zbiorze Form, kiedy wysyłane są za pomocą metody POST. string TextBox = Request.Form[ MyTextbox1 ].ToString(); Aby pobrać element o tej nazwie albo ze zbioru QueryString, albo z Form, można wykorzy- stać następujący kod: string TextBox = Request.Params[ MyTextbox1 ].ToString(); W PHP odpowiednikiem tego będzie zbiór $_REQUEST. Można na przykład użyć następują- cego kodu: $TextBox = $_REQUEST[ MyTextbox1 ]; W PHP można również pobrać wartości tych zbiorów osobno za pomocą zbiorów $_GET oraz $_POST, które są analogiczne do zbiorów QueryString oraz Form z ASP.NET. $TextBox = $_GET[ MyTextbox1 ]; $TextBox = $_POST[ MyTextbox1 ]; Po pobraniu danych serwer może je przetworzyć i zwrócić do klienta. Pisanie odpowiedzi HTTP W normalnej sekwencji wydarzeń występującej przy użyciu technologii po stronie serwera informacje, które chce się wyświetlić, nie mogą być natychmiast wypisane na stronie. Zamiast tego trzeba spakować je w odpowiedź HTTP Response. Jest to o wiele łatwiejsze, niż może się wydawać na pierwszy rzut oka. W ASP oraz ASP.NET wypisuje się dane za pomocą metody Response.Write. string data = To są nasze dane. ; Response.Write(data); W PHP używa się polecenia echo. $data = To są nasze dane. ; echo $data Rozdział 3. (cid:81) Ajax oraz technologie po stronie serwera 97 Można tworzyć bardziej skomplikowane struktury (takie jak dokumenty XML), pod warun- kiem że będą analizowane składniowo jako tekst. Można to zaimplementować w ASP.NET w następujący sposób: XmlDocument XmlDoc = new XmlDocument(); XmlNode versionNode = XmlDoc.CreateXmlDeclaration( 1.0 , UTF-8 , yes ); XmlNode mainNode = XmlDoc.CreateElement( root ); XmlDoc.AppendChild(mainNode); XmlNode childNode = XmlDoc.CreateElement( child ); childNode.AppendChild(XmlDoc.CreateTextNode( Dane )); mainNode.AppendChild(versionNode); mainNode.AppendChild(childNode); string strXml = XmlDoc.InnerXml; Response.Write(strXml); W PHP to samo można zrobić w następujący sposób: $doc = new DomDocument( 1.0 ); $root = $doc- createElement( root ); $root = $doc- appendChild( root ); $child = $doc- createElement( child ); $child = $root- appendChild($child); $value = $doc- createTextNode( Dane ); $value = $child- appendChild($value); $strXml = $doc- saveXML(); echo $strXml; W ten sposób powstanie następujący dokument XML: ?xml version= 1.0 ? root child Dane /child /root Łańcuch znaków dołączany jest do odpowiedzi HTTP i odsyłany z powrotem do klienta jako gotowy do pobrania. Choć ta część procesu jest prosta, kiedy odpowiedź wraca do klienta, pobranie danych jest nieco bardziej skomplikowane. Obiekt XMLHttpRequest Jak zostanie to zaprezentowane w rozdziale 4., obiekt XMLHttpRequest nie jest jedyną metodą, którą ma się do dyspozycji w wykonywaniu interakcji pomiędzy klientem a serwerem w apli- kacjach opartych na Ajaksie. Jest jednak metodą najczęściej używaną. W niniejszym rozdziale nie omówiono szczegółów działania tego obiektu, dlatego najlepiej będzie go sobie wyobrazić jako kolejną czarną skrzynkę, która oczekuje na dane wejściowe z odpowiedzi HTTP. 98 Ajax. Od podstaw Funkcja zwrotna Pierwszy krok otrzymywania danych znany jest pod nazwą funkcji zwrotnej (ang. callback function). Jest to po prostu funkcja JavaScriptu, która wykonywana jest, kiedy dane zostaną w całości pobrane z serwera. Można jej nadać dość ogólną nazwę, taką jak na przykład getData(), a funkcja ta będzie w większości aplikacji opartych na Ajaksie wyglądała dość podobnie. Wewnątrz funkcji zwrotnej pierwszym zadaniem do wykonania jest sprawdzenie, czy dane są gotowe do pobrania. Wykonuje się to za pomocą sprawdzenia, czy właściwość readyState obiektu XMLHttpRequest równa jest 4 (wartość ta oznacza ukończenie). Na razie typowa funkcja zwrotna będzie wyglądała następująco: function getData() { if (xHRObject.readystate == 4) { // Tu następuje przetwarzanie } } Po upewnieniu się, że dane są gotowe, można je pobrać za pomocą jednej z dwóch właści- wości obiektu XMLHttpRequest: (cid:81) responseText, (cid:81) responseXML. Właściwość responseText Wykorzystywanie właściwości responseText jest najczęściej stosowanym podejściem do pobierania danych z odpowiedzi HTTP; jest również najłatwiejszym rozwiązaniem. Można utworzyć nową zmienną JavaScriptu, która przechowa zawartość odpowiedzi i zwróci ją jako łańcuch znaków: var text = xHRObject.responseText; Jeśli na stronie w ASP.NET utworzy się poniższy kod, wtedy właściwość responseText dla data będzie zawierała tekst To są nasze dane.: string data = To są nasze dane. ; Response.Write(data); W PHP należy zrobić to w następujący sposób: $data = To są nasze dane. ; echo $data I to wszystko. Można również pobrać w ten sposób kod HTML bądź XHTML. Co się jednak stanie, gdy chce się pobrać dane XML? Nadal można użyć metody responseText, zwróci ona jednak dane XML w postaci łańcucha znaków. Można zastanowić się nad poniższym kodem w ASP.NET: string data = ?xml version= 1.0 encoding= UTF-8 standalone= yes ? root child Dane /child /root ; Response.Write(data); Rozdział 3. (cid:81) Ajax oraz technologie po stronie serwera 99 W PHP będzie to wyglądało następująco: $data = ?xml version= 1.0 encoding= UTF-8 standalone= yes ? root child Dane /child /root ; echo $data Powyższe fragmenty kodu zwrócą następujące dane: ?xml version= 1.0 encoding= UTF-8 standalone= yes ? root child Dane /child /root Zwracanie dokumentów XML w postaci łańcuchów znaków może jednak zniwelować wiele zalet korzystania z XML. Dlatego też istnieje właściwość responseXML. Właściwość responseXML Właściwość responseXML na pierwszy rzut oka wygląda, jakby lepiej nadawała się do sytuacji, w których chce się przekazywać z powrotem do klienta dokumenty XML. Pozwala ona traktować odpowiedź jako obiekt dokumentu XML i wykonywać iteracje po różnych ele- mentach, atrybutach oraz węzłach tekstowych za pomocą DOM. Jak to jednak zwykle bywa w przypadku Ajaksa, trzeba sobie zdawać sprawę z istnienia kilku problemów związanych z korzystaniem z tej właściwości. Powiedzmy, że mamy następujący kod po stronie serwera, który wczytuje dokument XML: string data = ?xml version= 1.0 encoding= UTF-8 standalone= yes ? root child Dane /child /root ; Response.Write(data); A kod w JavaScripcie zmieni się na następujący: var text = xHRObject.responseXML; Jeśli oczekuje się, że z powrotem otrzyma się w pełni działający dokument XML, to można się srogo zawieść. Z powrotem otrzyma się obiekt, jednak będzie on pusty, bez śladu po kodzie XML, jaki się przesyłało. Dzieje się tak, ponieważ ContentType odpowiedzi Response musi być ustawiony na text/xml przed wypisaniem odpowiedzi. string data = ?xml version= 1.0 encoding= UTF-8 standalone= yes ? root child Dane /child /root ; Response.ContentType = text/xml ; Response.Write(data); Niestety, Internet Explorer szczególnie źle to toleruje. Jeśli nie ustawi się tego dobrze na serwerze, nie będzie można wykorzystywać responseXML w tej przeglądarce. W przeglądarce Firefox możliwe jest użycie w JavaScripcie metody overrideMimeType przed wywołaniem kodu, dzięki czemu można nadpisać i ustawić typ zawartości na text/xml po stronie klienta, jak w poniższym kodzie: xHRObject.overrideMimeType( text/xml ); xHRObject.send(null); var document = xHRObject.responseXML; 100 Ajax. Od podstaw Metody tej nie ma jednak w przeglądarce Internet Explorer. Problemy nie kończą się jed- nak na tym. Jeśli popełni się błąd w dokumencie XML, tak że nie jest on poprawny skła- dniowo, w IE otrzyma się ponownie pusty obiekt bez oczywistego komunikatu o błędzie. Usuwanie błędów z responseXML Przy ustalaniu przyczyny otrzymywania pustego obiektu z responseXML można użyć czterech metod. Pierwsza polega na sprawdzeniu, czy dane są zwracane w responseText. Można na przykład wykorzystać do tego okno dialogowe z ostrzeżeniem typu alert, jak poniżej: var text = xHRObject.responseText; alert(text); Można oczekiwać, że zobaczy się coś takiego, jak poniżej: ?xml version= 1.0 encoding= UTF-8 standalone= yes ? root child Dane /child /root Jeśli tak nie jest, oznacza to, że odpowiedź nie została poprawnie przesłana przez serwer i należy sprawdzić kod po stronie serwera. Wysoce prawdopodobne jest jednak, że dane te są poprawne. Jeśli dane nie są poprawne, kolejnym krokiem będzie sprawdzenie kodu błędu. Usuwanie błędów z responseXML w przeglądarce Internet Explorer By odnaleźć więcej informacji na temat błędu w przeglądarce Internet Explorer, należy skorzystać z poniższego kodu, by móc uzyskać nieco bardziej szczegółowy komunikat o błędzie oraz radę na temat tego, co należy poprawić w dokumencie XML: var errorcode = xHRObject.responseXML.parseError.errorCode; W normalnej sytuacji kod zwracany z przeglądarki Internet Explorer powinien być równy zero. Jednak, co bardziej prawdopodobne, jeśli ContentType na pewno jest ustawiony na text/xml, a responseXML.xml jest pusty, wtedy kod ten będzie inny niż zero. Dalsze informacje na temat znaczenia kodu zwracanego z właściwości responseXML można uzyskać w następujący sposób: var errormessage = xHRObject.responseXML.parseError.reason; Usuwanie błędów z responseXML w przeglądarce Firefox Choć w przeglądarce Firefox nie ma odpowiednika obiektu parseError, w menu Narzędzia można znaleźć opcję Konsola błędów, która pozwala na przejrzenie znaczących komuni- katów o błędzie obejmujących typ obiektu powodujący wystąpienie błędu. Jeśli w odpo- wiedzi istnieje problem z formatowaniem XML, konsola udostępni informacje takie, jak poniższe, i nie wymaga to żadnych zmian w kodzie w JavaScripcie ani też dodawania do niego czegokolwiek: Rozdział 3. (cid:81) Ajax oraz technologie po stronie serwera 101 Błąd: niepasujący znacznik. Oczekiwano: /error . Plik źródłowy: http://localhost:8080/Company/WebPages/framed.jsf?com.asparity.AJAX_CLIENT_ID= _idJsp0 3AmasterTree com.company.AJAX_REQUEST=true oracle.adf.faces.STATE_TOKEN=3 nodeString= 3A 3AdomainModel 3A1 clientNodeId= 3A 3AdomainModel 3A1 3Aawaiting AjaxData Wiersz: 1, Kolumna: 6905 Kod źródłowy: [...] Dodatkowo istnieje również łatwy do zainstalowania dodatek Firebug1, który pozwala pro- gramistom badać ruch XHR w czasie rzeczywistym — zarówno żądania, jak i odpowiedzi. Wykorzystywanie danych Po zwróceniu danych z właściwości responseXML można je pobrać tak, jakby były obiektem DOM. Załóżmy na przykład, że mamy następujący dokument: ?xml version= 1.0 encoding= UTF-8 standalone= yes ? cart book Title Ajax. Od podstaw. /Title Quantity 1 /Quantity /book /cart Można zwrócić element cart z dokumentu XML w następujący sposób: var XMLDoc = xHRObject.responseXML; var book = XMLDoc.getElementsByTagName( book ); Można również przejść do pierwszego elementu zawartego w book w następujący sposób: var title = book[0].firstChild; Istnieje znacząca różnica pomiędzy dwoma najważniejszymi przeglądarkami (Internet Explo- rer oraz Mozilla) w kwestii tego, w jaki sposób zawartość tekstowa zwracana jest z doku- mentów XML. W Internet Explorerze zawartość tekstowa zwracana jest za pomocą właściwości text, jak w poniższym kodzie: var title = book[0].firstChild.text; // Tytuł będzie równy Ajax. Od podstaw. W przeglądarkach Mozilla zawartość tekstową zwraca się za pomocą właściwości textContent, co widać w poniższym fragmencie kodu: var title = book[1].firstChild.textContent; // Tytuł będzie równy Ajax. Od podstaw. 1 Firebug, a także inne narzędzia i sposoby usuwania błędów z aplikacji, omówione są w rozdziale 6. — przyp. tłum. 102 Ajax. Od podstaw Nietrudno również zauważyć, że w Internet Explorerze do pierwszego węzła odnosi się przez book[0], natomiast w przypadku przeglądarki Firefox jest to book[1]. Dzieje się tak, ponieważ w Firefoksie book[0] zawiera węzeł tekstowy ze znakiem nowego wiersza, gdyż przeglądarka ta nie opuszcza białych znaków (ang. whitespace) — traktuje je jak osobne węzły, podczas gdy Internet Explorer tego nie robi. I znów niezbędne jest uwzględnienie tych różnic w kodzie, by dostęp do danych zwracanych z serwera działał we wszystkich przeglądarkach. Technologie po stronie serwera Dotychczas wspomniano jedynie o procesie, w którym dane mogą być przesyłane do ser- wera i odsyłane z niego; nie omawiano tego, co dzieje się na samym serwerze. Technologie po stronie serwera to zagadnienie niezależne od Ajaksa, dlatego trzeba się tych kwestii uczyć osobno. Załóżmy zatem, że Czytelnik posiada już praktyczną znajomość jednej z tych technologii, ponieważ bez umiejętności wykonywania przetwarzania na serwerze daleko się nie zajdzie. Poniżej znajduje się krótkie wprowadzenie do każdej z wybranych technologii wraz z prostą przykładową aplikacją opartą na Ajaksie, która z nich korzysta. Jeśli Czytelnik jest zaznajomiony z ASP.NET, ale z PHP czy Javą już nie, nie powinien pomijać podrozdziałów poświęconych tym ostatnim językom. Znajomość innych języków czy technologii poza tymi, które już się dobrze zna, daje programiście nie tylko dobre podstawy, ale także zabezpieczenie na przyszłość. Często można spotkać kontrakty czy zlecenia, które obejmują przeniesienie aplikacji z jednego języka na drugi, co wymaga dobrej znajomości obu. Klasyczny ASP oraz PHP są do siebie dość podobne i wkrótce ich podobieństwo zostanie zaprezentowane. W poniższym omówieniu zostanie krótko wspomniana Java, by pokazać, w jaki sposób zgrabnie łączy się ona z filozofią Ajaksa. Na początek jednak pora na aktualny sztandarowy produkt firmy Microsoft — ASP.NET. ASP.NET ASP.NET to technologia firmy Microsoft służąca tworzeniu dynamicznych stron interne- towych. By mogła działać na komputerze, konieczne jest spełnienie dwóch warunków: za- instalowanie platformy .NET Framework oraz posiadanie kompatybilnego serwera WWW, najczęściej IIS (Internet Information Services). .NET istnieje od 2002 roku, jednak aktualne większe wydanie (.NET 3.0) zostało opubli- kowane w listopadzie 2006 roku. Najnowszą wersję można pobrać ze strony http://update. microsoft.com. Należy wybrać opcję Instalacja niestandardowa, a nie Instalacja ekspresowa, i szukać w Oprogramowanie opcjonalne. Serwer IIS jest z kolei dostępny tylko jako część systemu operacyjnego Windows. W wielu wersjach systemu Windows domyślnie nie jest on zainstalowany i tym samym nie jest dostępny w Windows XP Home Edition. Można go jednak dodać, przechodząc do Panelu sterowania i wybierając Dodaj lub usuń programy, a później Dodaj/Usuń składniki systemu Windows. Rozdział 3. (cid:81) Ajax oraz technologie po stronie serwera 103 ASP.NET ma być niezależny od języka programowania. Pomysł polega na tym, że można używać implementacji dowolnego języka w .NET, w którym tworzy się aplikacje. Zazwy- czaj sprowadza się to do wyboru pomiędzy dwoma językami programowania — Visual Basic oraz C#. W tej książce przykłady w ASP.NET tworzone będą w języku C#, ponieważ jest on podobny do JavaScriptu, jeśli chodzi o strukturę oraz opcje, takie jak z
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Ajax. Od podstaw
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: