Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00198 004212 14994359 na godz. na dobę w sumie
AngularJS. Profesjonalne techniki - ebook/pdf
AngularJS. Profesjonalne techniki - ebook/pdf
Autor: Liczba stron: 632
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-0200-6 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> webmasterstwo >> javascript - programowanie
Porównaj ceny (książka, ebook (-20%), audiobook).

Twój podręcznik programisty!

AngularJS to szkielet do tworzenia zaawansowanych aplikacji JavaScript, wykorzystujący w pełni możliwości współczesnych przeglądarek internetowych. Pozwala on na stosowanie wzorca MVC (ang. Model View Controller) po stronie klienta, a co za tym idzie, na zachowanie wysokiej jakości oraz przejrzystej struktury kodu nawet w przypadku aplikacji intensywnie używających komunikacji sieciowej. Za tym popularnym szkieletem stoi firma Google, która dba o jego ciągły rozwój.

Ta książka została w całości poświęcona szkieletowi AngularJS. Sięgnij po nią i przekonaj się, w jaki sposób przygotować środowisko programistyczne, zbudować pierwszą aplikację i uzyskać dostęp do kontekstu. W kolejnych rozdziałach zaznajomisz się z możliwościami biblioteki Bootstrap oraz przejdziesz krótki kurs programowania w języku JavaScript. W części drugiej szczególny nacisk został położony na detale związane z pracą z AngularJS. Dowiesz się stąd, jak korzystać z dyrektyw, tworzyć własne dyrektywy oraz używać kontrolerów i zakresów. Ostatnia część książki została poświęcona pracy z modułami i usługami. Odkryjesz tu, jak pobrać dane z usług sieciowych, przetworzyć je i zaprezentować użytkownikowi. Książka ta jest obowiązkową lekturą każdego programisty pracującego z AngularJS.

Dzięki tej książce: Obowiązkowa lektura programisty AngularJS!
Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: Pro AngularJS Tłumaczenie: Robert Górczyński ISBN: 978-83-283-0197-9 Original edition copyright © 2014 by Adam Freeman. All rights reserved. Polish edition copyright © 2015 by HELION SA. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie bierze jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Wydawnictwo HELION nie ponosi również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/angupt.zip Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/angupt Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis tre(cid:258)ci O autorze ...............................................................................................................15 O recenzencie technicznym ....................................................................................16 Cz(cid:246)(cid:264)(cid:232) I Zaczynamy ........................................................................17 Zaczynamy .............................................................................................................19 Rozdzia(cid:239) 1. Wymagania ........................................................................................................................................... 19 Jaka jest struktura niniejszej książki? ................................................................................................ 20 Część I. Zaczynamy ...................................................................................................................... 20 Część II. Praca z AngularJS ......................................................................................................... 20 Część III. Praca z modułami i usługami .................................................................................... 20 Czy w książce znajdę wiele przykładów? .......................................................................................... 20 Gdzie znajdę przykładowe fragmenty kodu? ................................................................................... 23 Jak skonfigurować środowisko programistyczne? .......................................................................... 23 Wybór przeglądarki internetowej .............................................................................................. 23 Wybór edytora tekstów ................................................................................................................ 24 Instalacja Node.js .......................................................................................................................... 24 Instalacja serwera WWW ............................................................................................................ 25 Instalacja systemu przeznaczonego do testowania .................................................................. 25 Utworzenie katalogu AngularJS ................................................................................................. 26 Przeprowadzenie prostego testu ................................................................................................. 28 Podsumowanie ..................................................................................................................................... 29 Rozdzia(cid:239) 2. Pierwsza aplikacja w AngularJS .............................................................................31 Przygotowanie projektu ...................................................................................................................... 31 Użycie AngularJS ................................................................................................................................. 33 Dodanie biblioteki AngularJS do pliku HTML ........................................................................ 33 Utworzenie modelu danych ........................................................................................................ 35 Utworzenie kontrolera ................................................................................................................. 37 Utworzenie widoku ...................................................................................................................... 39 Wyjście poza podstawy ....................................................................................................................... 42 Użycie dwukierunkowego dołączania modelu ......................................................................... 42 Zdefiniowanie i stosowanie funkcji w kontrolerach ................................................................ 44 Kup książkęPoleć książkę Spis tre(cid:258)ci Użycie funkcji w zależności od innych zdefiniowanych funkcji ............................................ 46 Reakcja na działania użytkownika .............................................................................................. 48 Filtrowanie i zmiana kolejności danych modelu ...................................................................... 51 Pobieranie danych z wykorzystaniem technologii Ajax ......................................................... 55 Podsumowanie ..................................................................................................................................... 57 Rozdzia(cid:239) 3. Umieszczenie AngularJS w kontek(cid:258)cie ...................................................................59 Sytuacje, w których AngularJS sprawdza się doskonale ................................................................. 59 Poznanie aplikacji dwukierunkowych oraz w postaci pojedynczej strony .......................... 60 Wzorzec MVC ...................................................................................................................................... 62 Model .............................................................................................................................................. 63 Kontroler ........................................................................................................................................ 65 Widok ............................................................................................................................................. 65 Usługi typu RESTful ............................................................................................................................ 66 Najczęstsze pułapki podczas stosowania wzorca MVC ................................................................. 68 Umieszczenie logiki w nieodpowiednim miejscu .................................................................... 68 Przyjęcie formatu danych stosowanego w magazynie danych ............................................... 68 Kurczowe trzymanie się starych sposobów ............................................................................... 69 Podsumowanie ..................................................................................................................................... 69 Rozdzia(cid:239) 4. Wprowadzenie do HTML i Bootstrap CSS ..............................................................71 Poznajemy HTML ............................................................................................................................... 72 Anatomia elementu HTML ......................................................................................................... 73 Atrybuty ......................................................................................................................................... 74 Zawartość elementu ...................................................................................................................... 74 Elementy typu void ....................................................................................................................... 75 Struktura dokumentu ................................................................................................................... 75 Poznajemy framework Bootstrap ...................................................................................................... 77 Stosowanie podstawowych klas Bootstrap ................................................................................ 79 Użycie frameworka Bootstrap do nadawania stylu tabeli ....................................................... 80 Użycie frameworka Bootstrap do tworzenia formularzy sieciowych ................................... 83 Użycie frameworka Bootstrap do utworzenia układu opartego na siatce ............................ 85 Podsumowanie ..................................................................................................................................... 89 Rozdzia(cid:239) 5. Wprowadzenie do JavaScript ................................................................................91 Przygotowanie przykładowego projektu .......................................................................................... 92 Element script .................................................................................................................................. 93 Polecenia w JavaScript ........................................................................................................................ 94 Definiowanie i użycie funkcji ............................................................................................................. 94 Definiowanie funkcji z parametrami ......................................................................................... 95 Definiowanie funkcji zwracającej wartość ................................................................................ 96 Wykrywanie funkcji ..................................................................................................................... 97 Użycie zmiennych i typów ................................................................................................................. 98 Użycie typów podstawowych ...................................................................................................... 99 Tworzenie obiektów ................................................................................................................... 101 Praca z obiektami ........................................................................................................................ 104 Użycie operatorów JavaScript .......................................................................................................... 110 Użycie konstrukcji warunkowych ............................................................................................ 110 Operatory równości i identyczności ........................................................................................ 111 Jawna konwersja typów ............................................................................................................. 114 6 Kup książkęPoleć książkę Spis tre(cid:258)ci Tablice ................................................................................................................................................. 116 Użycie stylu dosłownej tablicy .................................................................................................. 117 Wykrywanie tablicy .................................................................................................................... 117 Odczyt i modyfikacja zawartości tablicy ................................................................................. 118 Wyświetlenie zawartości tablicy ............................................................................................... 119 Użycie wbudowanych metod przeznaczonych do pracy z tablicami .................................. 119 Porównywanie wartości undefined i null ....................................................................................... 120 Sprawdzenie pod kątem wartości null lub undefined ........................................................... 122 Obietnice ............................................................................................................................................. 124 Format JSON ...................................................................................................................................... 128 Podsumowanie ................................................................................................................................... 129 SportsStore — przyk(cid:239)adowa aplikacja .................................................................131 Rozpoczęcie pracy .............................................................................................................................. 132 Przygotowanie danych ............................................................................................................... 132 Przygotowanie aplikacji ............................................................................................................. 135 Wyświetlenie przykładowych danych produktu ........................................................................... 138 Utworzenie kontrolera ............................................................................................................... 138 Wyświetlanie informacji o produktach ................................................................................... 140 Wyświetlenie listy kategorii ............................................................................................................. 143 Utworzenie listy kategorii .......................................................................................................... 143 Generowanie łączy nawigacji po kategoriach ......................................................................... 144 Wybór kategorii .......................................................................................................................... 148 Podświetlenie wybranej kategorii ............................................................................................. 150 Dodanie stronicowania .............................................................................................................. 152 Podsumowanie ................................................................................................................................... 156 SportsStore — nawigacja i zakupy ......................................................................157 Przygotowanie przykładowego projektu ........................................................................................ 157 Użycie rzeczywistych danych produkcyjnych ............................................................................... 157 Obsługa błędów Ajax ................................................................................................................. 159 Utworzenie widoków częściowych .................................................................................................. 161 Utworzenie koszyka na zakupy ....................................................................................................... 163 Zdefiniowanie modułu koszyka i usługi .................................................................................. 163 Utworzenie widżetu koszyka na zakupy .................................................................................. 165 Dodanie przycisku wyboru produktu ...................................................................................... 168 Dodanie nawigacji na podstawie adresu URL ............................................................................... 170 Definiowanie tras URL ............................................................................................................... 170 Użycie routingu adresów URL do zapewnienia nawigacji ................................................... 173 Rozpoczęcie prac nad finalizacją zamówienia ............................................................................... 174 Finalizacja zamówienia .............................................................................................................. 176 Podsumowanie ................................................................................................................................... 177 SportsStore — zamówienia i administracja .........................................................179 Przygotowanie przykładowego projektu ........................................................................................ 179 Pobieranie danych adresowych ....................................................................................................... 179 Dodanie formularza weryfikacji danych ................................................................................. 181 Dodanie pozostałych elementów formularza sieciowego ..................................................... 185 7 Rozdzia(cid:239) 6. Rozdzia(cid:239) 7. Rozdzia(cid:239) 8. Kup książkęPoleć książkę Spis tre(cid:258)ci Składanie zamówień .......................................................................................................................... 187 Rozbudowa serwera Deployd .................................................................................................... 187 Zdefiniowanie funkcji kontrolera ............................................................................................. 189 Wywołanie funkcji kontrolera .................................................................................................. 190 Zdefiniowanie widoku ............................................................................................................... 190 Usprawnienia w aplikacji .................................................................................................................. 191 Administrowanie katalogiem produktów ...................................................................................... 192 Przygotowanie serwera Deployd .............................................................................................. 192 Utworzenie aplikacji administracyjnej .................................................................................... 194 Implementacja uwierzytelniania .............................................................................................. 195 Definiowanie widoku głównego i kontrolera ......................................................................... 198 Implementacja funkcji przeglądania zamówień ..................................................................... 200 Implementacja funkcji zmiany zawartości katalogu produktów ......................................... 203 Podsumowanie ................................................................................................................................... 207 Cz(cid:246)(cid:264)(cid:232) II Praca z AngularJS ............................................................209 Rozdzia(cid:239) 9. Anatomia aplikacji AngularJS ..............................................................................211 Przygotowanie przykładowego projektu ........................................................................................ 212 Praca z modułami .............................................................................................................................. 213 Określenie granic aplikacji AngularJS ..................................................................................... 213 Użycie modułów do zdefiniowania komponentów AngularJS ................................................... 214 Definiowanie kontrolera ............................................................................................................ 215 Definiowanie dyrektywy ............................................................................................................ 221 Definiowanie filtru ..................................................................................................................... 223 Definiowanie usługi .................................................................................................................... 226 Użycie modułów do organizacji kodu ............................................................................................ 229 Cykl życiowy modułu ................................................................................................................. 232 Podsumowanie ................................................................................................................................... 233 Rozdzia(cid:239) 10. U(cid:285)ycie dyrektyw do(cid:239)(cid:200)czania i szablonów ............................................................235 Kiedy i dlaczego należy używać dyrektyw? .................................................................................... 236 Przygotowanie przykładowego projektu ........................................................................................ 236 Użycie dyrektyw dołączania danych ............................................................................................... 237 Przeprowadzenie (lub uniknięcie) jednokierunkowego dołączenia danych ..................... 239 Przeprowadzenie dwukierunkowego dołączania danych ..................................................... 241 Użycie szablonów dyrektyw ............................................................................................................. 243 Generowanie powtarzających się elementów ......................................................................... 244 Generowanie wielu elementów najwyższego poziomu ......................................................... 250 Praca z widokami częściowymi ................................................................................................. 251 Użycie dyrektywy ng-include jako atrybutu ........................................................................... 255 Warunkowe zastępowanie elementów .................................................................................... 256 Ukrycie nieprzetworzonych osadzonych szablonów wyrażeń dołączania danych ........... 259 Podsumowanie ................................................................................................................................... 261 Rozdzia(cid:239) 11. U(cid:285)ycie dyrektyw elementów i zdarze(cid:241) ................................................................263 Przygotowanie przykładowego projektu ........................................................................................ 264 Użycie dyrektyw elementu ............................................................................................................... 264 Wyświetlanie, ukrywanie i usuwanie elementów .................................................................. 265 Zarządzanie klasami i stylami CSS ........................................................................................... 269 8 Kup książkęPoleć książkę Spis tre(cid:258)ci Obsługa zdarzeń ................................................................................................................................. 274 Utworzenie własnej dyrektywy zdarzeń .................................................................................. 277 Zarządzanie atrybutami specjalnymi .............................................................................................. 279 Zarządzanie atrybutami boolowskimi ..................................................................................... 279 Zarządzanie innymi atrybutami ............................................................................................... 281 Podsumowanie ................................................................................................................................... 282 Rozdzia(cid:239) 12. Praca z formularzami sieciowymi ........................................................................283 Przygotowanie przykładowego projektu ........................................................................................ 284 Użycie dwukierunkowego dołączania danych w elementach formularza sieciowego ............ 285 Niejawne tworzenie właściwości modelu ................................................................................ 286 Sprawdzenie, czy obiekt modelu danych został utworzony ................................................. 289 Weryfikacja formularzy sieciowych ................................................................................................ 290 Przeprowadzenie podstawowej weryfikacji formularza sieciowego .................................... 292 Wyświetlanie komunikatów w trakcie weryfikacji formularza sieciowego .............................. 296 Użycie CSS do nadania stylu komunikatom ........................................................................... 297 Użycie zmiennych specjalnych w celu wyświetlania komunikatów .................................... 301 Wstrzymanie wyświetlania komunikatów .............................................................................. 304 Użycie atrybutów dyrektywy formularza sieciowego ................................................................... 306 Użycie elementów input ....................................................................................................... 306 Użycie elementu textarea ...................................................................................................... 309 Użycie elementów select ....................................................................................................... 310 Podsumowanie ................................................................................................................................... 314 Rozdzia(cid:239) 13. U(cid:285)ycie kontrolerów i zakresów ............................................................................315 Kiedy i dlaczego używać kontrolerów i zakresów? ....................................................................... 316 Przygotowanie przykładowego projektu ........................................................................................ 316 Poznajemy podstawy ......................................................................................................................... 317 Utworzenie i zastosowanie kontrolera .................................................................................... 317 Konfiguracja zakresu .................................................................................................................. 318 Modyfikacja zakresu ................................................................................................................... 320 Organizowanie kontrolerów ............................................................................................................ 321 Użycie kontrolera monolitycznego .......................................................................................... 322 Ponowne użycie kontrolera ....................................................................................................... 324 Dziedziczenie kontrolerów ........................................................................................................ 328 Użycie wielu kontrolerów .......................................................................................................... 335 Kontroler bez zakresu ....................................................................................................................... 337 Wyraźne uaktualnienie zakresu ....................................................................................................... 338 Konfiguracja jQuery UI ............................................................................................................. 338 Kontrola stanu przycisku ........................................................................................................... 340 Zliczanie kliknięć przycisku ...................................................................................................... 341 Podsumowanie ................................................................................................................................... 342 Rozdzia(cid:239) 14. U(cid:285)ycie filtrów ......................................................................................................343 Kiedy i dlaczego używać filtrów? ..................................................................................................... 344 Przygotowanie przykładowego projektu ........................................................................................ 344 Pobieranie pliku lokalizacji ....................................................................................................... 345 Filtrowanie pojedynczych wartości danych ................................................................................... 346 Formatowanie wartości pieniężnych ....................................................................................... 347 Formatowanie innych wartości pieniężnych .......................................................................... 348 9 Kup książkęPoleć książkę Spis tre(cid:258)ci Formatowanie dat ....................................................................................................................... 349 Zmiana wielkości liter ciągu tekstowego ................................................................................. 352 Generowanie danych w formacie JSON .................................................................................. 353 Lokalizacja danych wyjściowych filtru .................................................................................... 354 Filtrowanie kolekcji ........................................................................................................................... 357 Ograniczenie liczby elementów ................................................................................................ 357 Wybór elementów ...................................................................................................................... 360 Sortowanie elementów ............................................................................................................... 362 Łączenie filtrów .................................................................................................................................. 366 Utworzenie własnego filtru .............................................................................................................. 367 Utworzenie filtru przeznaczonego do formatowania wartości daty ................................... 367 Utworzenie filtru kolekcji .......................................................................................................... 369 Budowa filtru na bazie istniejącego filtru ................................................................................ 371 Podsumowanie ................................................................................................................................... 372 Rozdzia(cid:239) 15. Tworzenie w(cid:239)asnych dyrektyw ............................................................................373 Kiedy i dlaczego tworzyć własne dyrektywy? ................................................................................ 374 Przygotowanie przykładowego projektu ........................................................................................ 374 Utworzenie własnej dyrektywy ........................................................................................................ 375 Zdefiniowanie dyrektywy .......................................................................................................... 375 Implementacja funkcji link ....................................................................................................... 376 Zniesienie zależności właściwości danych .............................................................................. 379 Obsługa zmiany danych ............................................................................................................. 382 Praca z jqLite ...................................................................................................................................... 387 Nawigacja po obiektowym modelu dokumentu .................................................................... 387 Modyfikacja elementów ............................................................................................................. 391 Tworzenie i usuwanie elementów ............................................................................................ 393 Obsługa zdarzeń .......................................................................................................................... 396 Inne metody jqLite ..................................................................................................................... 397 Uzyskanie dostępu do funkcji AngularJS z poziomu jqLite ................................................. 398 Zastąpienie jqLite przez jQuery ....................................................................................................... 399 Podsumowanie ................................................................................................................................... 400 Rozdzia(cid:239) 16. Tworzenie skomplikowanych dyrektyw ...............................................................401 Przygotowanie przykładowego projektu ........................................................................................ 402 Definiowanie skomplikowanych dyrektyw .................................................................................... 402 Definiowanie sposobu zastosowania dyrektywy .................................................................... 403 Użycie szablonu dyrektywy .............................................................................................................. 407 Użycie funkcji jako szablonu ..................................................................................................... 409 Użycie zewnętrznego szablonu ................................................................................................. 410 Wybór szablonu zewnętrznego za pomocą funkcji ............................................................... 411 Zastępowanie elementu ............................................................................................................. 413 Zarządzanie zakresami dyrektywy .................................................................................................. 415 Utworzenie wielu kontrolerów ................................................................................................. 417 Zdefiniowanie oddzielnego zakresu dla każdego egzemplarza dyrektywy ........................ 418 Utworzenie odizolowanych zakresów ..................................................................................... 421 Podsumowanie ................................................................................................................................... 430 10 Kup książkęPoleć książkę Spis tre(cid:258)ci Rozdzia(cid:239) 17. Zaawansowane funkcje dyrektyw .......................................................................431 Przygotowanie przykładowego projektu ........................................................................................ 432 Użycie transkluzji .............................................................................................................................. 432 Użycie funkcji compile ............................................................................................................... 435 Użycie kontrolerów w dyrektywach ................................................................................................ 438 Dodanie innej dyrektywy ........................................................................................................... 441 Utworzenie własnych elementów formularza sieciowego ........................................................... 443 Obsługa zmian zewnętrznych ................................................................................................... 445 Obsługa zmian wewnętrznych .................................................................................................. 447 Formatowanie wartości danych ................................................................................................ 448 Weryfikacja własnych elementów formularza sieciowego ................................................... 449 Podsumowanie ................................................................................................................................... 452 Cz(cid:246)(cid:264)(cid:232) III Us(cid:228)ugi AngularJS ..............................................................453 Rozdzia(cid:239) 18. Praca z modu(cid:239)ami i us(cid:239)ugami ...............................................................................455 Kiedy i dlaczego należy tworzyć usługi i moduły? ........................................................................ 455 Przygotowanie przykładowego projektu ........................................................................................ 456 Użycie modułów do nadania struktury aplikacji .......................................................................... 458 Obsługa pojedynczego modułu ................................................................................................ 458 Utworzenie nowego modułu ..................................................................................................... 460 Utworzenie i użycie usługi ............................................................................................................... 461 Użycie metody factory() ............................................................................................................ 461 Użycie metody service() ............................................................................................................. 464 Użycie metody provider() ......................................................................................................... 466 Użycie wbudowanych modułów i usług ......................................................................................... 468 Podsumowanie ................................................................................................................................... 469 Rozdzia(cid:239) 19. Us(cid:239)ugi dla obiektów globalnych, b(cid:239)(cid:218)dów i wyra(cid:285)e(cid:241) ............................................471 Przygotowanie przykładowego projektu ........................................................................................ 471 Uzyskanie dostępu do obiektów globalnych API DOM .............................................................. 471 Kiedy i dlaczego używać usług obiektu globalnego? ............................................................. 472 Uzyskanie dostępu do obiektu window ................................................................................... 472 Uzyskanie dostępu do obiektu document ............................................................................... 473 Użycie usług $interval i $timeout ............................................................................................. 474 Uzyskanie dostępu do adresu URL .......................................................................................... 475 Rejestracja danych ...................................................................................................................... 481 Wyjątki ................................................................................................................................................ 482 Kiedy i dlaczego używać usługi $exceptionHandler? ............................................................ 482 Praca z wyjątkami ....................................................................................................................... 483 Bezpośrednia praca z usługą $exceptionHandler .................................................................. 483 Implementacja własnej procedury obsługi wyjątków ........................................................... 484 Praca z niebezpiecznymi danymi .................................................................................................... 485 Kiedy i dlaczego używać usług przeznaczonych do pracy z niebezpiecznymi danymi? .... 486 Wyświetlanie niebezpiecznych danych ................................................................................... 486 Użycie niebezpiecznego mechanizmu dołączania danych ................................................... 487 Wyraźne zaufanie danym .......................................................................................................... 490 11 Kup książkęPoleć książkę Spis tre(cid:258)ci Praca z wyrażeniami i dyrektywami AngularJS ............................................................................ 491 Kiedy i dlaczego używać usług wyrażeń i dyrektyw? ............................................................. 492 Konwersja wyrażenia na funkcję .............................................................................................. 492 Interpolacja ciągów tekstowych ................................................................................................ 495 Kompilacja zawartości ............................................................................................................... 498 Podsumowanie ................................................................................................................................... 499 Rozdzia(cid:239) 20. Us(cid:239)ugi dla technologii Ajax i obietnic ..................................................................501 Kiedy i dlaczego używać usług Ajax? .............................................................................................. 502 Przygotowanie przykładowego projektu ........................................................................................ 502 Żądania Ajax ....................................................................................................................................... 502 Wykonywanie żądania Ajax ...................................................................................................... 505 Otrzymywanie odpowiedzi na żądanie Ajax .......................................................................... 506 Konfiguracja żądań Ajax ............................................................................................................ 509 Ustawienie wartości domyślnych żądania Ajax ..................................................................... 513 Użycie interceptorów Ajax ........................................................................................................ 515 Obietnice ............................................................................................................................................. 516 Pobieranie i użycie obiektu deferred ........................................................................................ 518 Użycie obietnicy .......................................................................................................................... 519 Dlaczego obietnice nie są zwykłymi zdarzeniami? ................................................................ 521 Łączenie obietnic ze sobą ........................................................................................................... 522 Grupowanie obietnic .................................................................................................................. 524 Podsumowanie ................................................................................................................................... 526 Rozdzia(cid:239) 21. Us(cid:239)ugi dla REST ....................................................................................................527 Kiedy i dlaczego używać usług typu REST? ................................................................................... 528 Przygotowanie przykładowego projektu ........................................................................................ 528 Utworzenie usługi typu RESTful .............................................................................................. 528 Utworzenie aplikacji AngularJS ................................................................................................ 531 Użycie usługi $http ............................................................................................................................ 536 Wyświetlenie danych produktu ................................................................................................ 536 Usunięcie produktu .................................................................................................................... 538 Utworzenie produktu ................................................................................................................. 538 Uaktualnienie produktu ............................................................................................................ 539 Przetestowanie implementacji Ajax ......................................................................................... 539 Ukrycie żądań Ajax ............................................................................................................................ 539 Instalacja modułu ngResource .................................................................................................. 542 Użycie usługi $resource ............................................................................................................. 543 Konfiguracja akcji usługi $resource ......................................................................................... 548 Utworzenie komponentu gotowego do użycia z usługą $resource ..................................... 549 Podsumowanie ................................................................................................................................... 551 Rozdzia(cid:239) 22. Us(cid:239)ugi dla widoków .............................................................................................553 Kiedy i dlaczego używać usług widoku? ......................................................................................... 553 Przygotowanie przykładowego projektu ........................................................................................ 554 Istota problemu ........................................................................................................................... 554 Użycie routingu URL ........................................................................................................................ 556 Instalacja modułu ngRoute ....................................................................................................... 556 Definiowanie adresów URL tras ............................................................................................... 557 12 Kup książkęPoleć książkę Spis tre(cid:258)ci Wyświetlanie wybranego widoku ............................................................................................. 558 Połączenie kodu i znaczników HTML ..................................................................................... 559 Użycie parametrów trasy .................................................................................................................. 562 Uzyskanie dostępu do tras i parametrów tras ........................................................................ 564 Konfiguracja tras ................................................................................................................................ 567 Użycie kontrolerów z trasami ................................................................................................... 568 Dodanie zależności do tras ........................................................................................................ 570 Podsumowanie ................................................................................................................................... 573 Rozdzia(cid:239) 23. Us(cid:239)ugi dla animacji i dotkni(cid:218)(cid:202) ..............................................................................575 Przygotowanie przykładowego projektu ........................................................................................ 575 Animacja elementów ......................................................................................................................... 575 Kiedy i dlaczego używać usługi animacji? ............................................................................... 576 Instalacja modułu ngAnimation ............................................................................................... 576 Definiowanie i stosowanie animacji ........................................................................................ 577 Uniknięcie niebezpieczeństwa w postaci jednoczesnych animacji ..................................... 579 Obsługa zdarzeń dotknięć ................................................................................................................ 580 Kiedy i dlaczego używać zdarzeń dotknięć? ........................................................................... 581 Instalacja modułu ngTouch ...................................................................................................... 581 Obsługa gestu machnięcia ......................................................................................................... 581 Użycie zamiennika dla dyrektywy ng-click ............................................................................. 582 Podsumowanie ................................................................................................................................... 582 Rozdzia(cid:239) 24. Us(cid:239)ugi rejestracji komponentów i ich wstrzykiwania ...........................................583 Kiedy i dlaczego używać usług rejestracji komponentów i ich wstrzykiwania? ....................... 583 Przygotowanie przykładowego projektu ........................................................................................ 583 Rejestracja komponentów AngularJS ............................................................................................. 584 Zarządzanie wstrzykiwaniem zależności ........................................................................................ 586 Ustalenie zależności funkcji ...................................................................................................... 586 Pobieranie egzemplarzy usługi ................................................................................................. 588 Uproszczenie procesu wywołania ............................................................................................ 589 Pobranie usługi $injector z elementu głównego .................................................................... 590 Podsumowanie ................................................................................................................................... 591 Rozdzia(cid:239) 25. Testy jednostkowe ...............................................................................................593 Kiedy i dlaczego przeprowadzać testy jednostkowe? ................................................................... 594 Przygotowanie przykładowego projektu ........................................................................................ 594 Instalacja modułu ngMock ........................................................................................................ 594 Utworzenie konfiguracji testowej ............................................................................................. 594 Utworzenie przykładowej aplikacji .......................................................................................... 596 Praca z Karma i Jasmine ................................................................................................................... 597 Przeprowadzanie testów ............................................................................................................ 599 Poznajemy atrapę obiektu ................................................................................................................ 601 API i obiekty testowe .................................................................................................................. 601 Testowanie kontrolera ...................................................................................................................... 602 Przygotowanie testu ................................................................................................................... 603 Użycie atrap obiektów ....................................................................................................................... 604 Symulacja odpowiedzi HTTP ................................................................................................... 604 Symulacja czasu ........................................................................................................................... 608 Testowanie rejestracji danych ................................................................................................... 610 13 Kup książkęPoleć książkę Spis tre(cid:258)ci Testowanie innych komponentów .................................................................................................. 612 Testowanie filtru ......................................................................................................................... 612 Testowanie dyrektywy ................................................................................................................ 614 Testowanie usługi ....................................................................................................................... 615 Podsumowanie ................................................................................................................................... 617 Skorowidz ...........................................................................................................619 14 Kup książkęPoleć książkę R O Z D Z I A (cid:146) 2 (cid:132) (cid:132) (cid:132) Pierwsza aplikacja w AngularJS Najlepszym sposobem rozpoczęcia pracy z AngularJS jest po prostu utworzenie aplikacji sieciowej. W tym rozdziale zostanie zaprezentowany proces przygotowania prostej aplikacji. Na początku przygotujemy statyczną atrapę aplikacji docelowej, a następnie dodamy do niej funkcje AngularJS, tworząc w ten sposób prostą, dynamiczną aplikację sieciową. W rozdziałach od 6. do 8. zobaczysz, jak utworzyć znacznie bardziej skomplikowaną i realistyczną aplikację AngularJS. Prosty przykład z tego rozdziału jest w zupełności wystarczający do zademonstrowania najważniejszych komponentów aplikacji AngularJS i jednocześnie przygotowuje grunt dla materiału znajdującego się w pozostałych rozdziałach. Przygotowanie projektu W rozdziale 1. zobaczyłeś, jak przygotować i przetestować środowisko programistyczne, z którego korzystałem podczas pisania niniejszej książki. Jeżeli chcesz wypróbować zaprezentowane w niej przykłady, najwyższa pora, aby wspomniane środowisko było w pełni skonfigurowane i działało. Na początek utworzymy atrapę aplikacji w postaci statycznego dokumentu HTML pokazującego docelową aplikację, nad którą będziemy pracować w tym rozdziale. Aplikacja to lista rzeczy do zrobienia. W katalogu angularjs utwórz nowy plik o nazwie todo.html i umieść w nim kod przedstawiony na listingu 2.1. Listing 2.1. Początkowa zawartość pliku todo.html !DOCTYPE html html data-ng-app head title Lista rzeczy do zrobienia /title link href= bootstrap.css rel= stylesheet / link href= bootstrap-theme.css rel= stylesheet / /head body div class= page-header h1 Lista rzeczy do zrobienia u(cid:285)ytkownika Adam /h1 /div div class= panel div class= input-group input class= form-control / span class= input-group-btn button class= btn btn-default Dodaj /button /span /div Kup książkęPoleć książkę AngularJS. Profesjonalne techniki table class= table table-striped thead tr th Opis /th th Zrobione /th /tr /thead tbody tr td Kupi(cid:202) kwiaty /td td Nie /td /tr tr td Kupi(cid:202) buty /td td Nie /td /tr tr td Odebra(cid:202) bilety /td td Tak /td /tr tr td Zadzwoni(cid:202) do Janka /td td Nie /td /tr /tbody /table /div /body /html (cid:132) Wskazówka Od tej chwili, o ile nie zostanie wskazane inaczej, wszystkie pliki umieszczaj w katalogu angularjs, który utworzy(cid:239)e(cid:258) w poprzednim rozdziale. Przedstawionych w ksi(cid:200)(cid:285)ce przyk(cid:239)adowych fragmentów kodu nie musisz wpisywa(cid:202) samodzielnie. Wszystkie przyk(cid:239)ady mo(cid:285)na pobra(cid:202) bezp(cid:239)atnie ze strony po(cid:258)wi(cid:218)conej ksi(cid:200)(cid:285)ce (http://helion.pl/ksiazki/angupt.htm). Przygotowane do pobrania przyk(cid:239)ady s(cid:200) kompletne, pogrupowane rozdzia(cid:239)ami i zawieraj(cid:200) wszystkie pliki niezb(cid:218)dne do utworzenia oraz przetestowania omawianych aplikacji. Tak przygotowany plik nie używa AngularJS. W rzeczywistości nie zawiera nawet elementu script odpowiedzialnego za import pliku angular.js. Wkrótce dodamy plik JavaScript i zaczniemy stosować funkcje oferowane przez AngularJS. Jednak na obecnym etapie plik todo.html zawiera statyczne elementy HTML tworzące szkielet atrapy aplikacji — na górze znajduje się nagłówek, poniżej tabela zawierająca listę rzeczy do zrobienia. Aby zobaczyć efekt dotychczasowej pracy, wyświetl plik todo.html w przeglądarce internetowej (patrz rysunek 2.1). Rysunek 2.1. Wygenerowana w przeglądarce internetowej zawartość początkowego pliku todo.html 32 Kup książkęPoleć książkę Rozdzia(cid:239) 2. (cid:132) Pierwsza aplikacja w AngularJS (cid:132) Uwaga Aby zachowa(cid:202) prostot(cid:218) przyk(cid:239)adu omawianego w tym rozdziale, ca(cid:239)y kod aplikacji b(cid:218)dzie umieszczony w pliku todo.html. W przypadku standardowych aplikacji AngularJS zwykle stosowana jest starannie wybrana struktura dla plików. Poniewa(cid:285) tutaj nie tworzymy skomplikowanego przyk(cid:239)adu, umieszczenie wszystkiego w pojedynczym pliku nie spowoduje (cid:285)adnych utrudnie(cid:241). W rozdziale 6. rozpoczniemy proces tworzenia znacznie bardziej zaawansowanej aplikacji AngularJS i wtedy porusz(cid:218) temat struktury plików w kontek(cid:258)cie budowanej aplikacji. U(cid:285)ycie AngularJS Statyczny kod HTML w pliku todo.html służy jako miejsce zarezerwowane dla podstawowej funkcjonalności, którą chcemy utworzyć. Użytkownik powinien mieć możliwość wyświetlenia listy rzeczy do zrobienia, zaznaczenia już wykonanych zadań oraz dodawania nowych do listy. W kolejnych punktach rozdziału do aplikacji dodamy bibliotekę AngularJS i pewne podstawowe funkcje, a tym samym ożywimy aplikację listy rzeczy do zrobienia. W celu zachowania prostoty przyjąłem założenie, że istnieje tylko jeden użytkownik i nie ma konieczności zachowywania stanu danych w aplikacji. Dodanie biblioteki AngularJS do pliku HTML Dodanie biblioteki AngularJS do pliku HTML jest bardzo łatwe. W dokumencie HTML wystarczy jedynie umieścić element script odpowiedzialny za import pliku angular.js, utworzyć moduł AngularJS oraz zastosować odpowiedni atrybut dla elementu html , jak przedstawiono na listingu 2.2. Listing 2.2. Utworzenie i zastosowanie modułu AngularJS w pliku todo.html !DOCTYPE html html ng-app= todoApp head title Lista zada(cid:241) do zrobienia /title link href= bootstrap.css rel= stylesheet / link href= bootstrap-theme.css rel= stylesheet / script src= angular.js /script script var todoApp = angular.module( todoApp , []); /script /head body div class= page-header h1 Lista rzeczy do zrobienia u(cid:285)ytkownika Adam /h1 /div div class= panel div class= input-group input class= form-control / span class= input-group-btn button class= btn btn-default Dodaj /button /span /div table class= table table-striped thead tr th Opis /th th Zrobione /th /tr /thead tbody tr td Kupi(cid:202) kwiaty /td td No /td /tr 33 Kup książkęPoleć książkę AngularJS. Profesjonalne techniki tr td Kupi(cid:202) buty /td td No /td /tr tr td Odebra(cid:202) bilety /td td Yes /td /tr tr td Zadzwoni(cid:202) do Janka /td td No /td /tr /tbody /table /div /body /html Aplikacje AngularJS są tworzone na podstawie co najmniej jednego modułu. Z kolei moduł jest tworzony za pośrednictwem wywołania angular.module(), jak pokazano w poniższym fragmencie kodu: ... var todoApp = angular.module( todoApp , []); ... Omówienie modułów znajdziesz w rozdziałach 9. i 18. Powyżej zobaczyłeś, jak utworzony został moduł dla aplikacji przedstawionej na listingu 2.2. Argumentami metody angular.module() są nazwa modułu przeznaczonego do utworzenia oraz tablica innych modułów, które będą niezbędne. W omawianym przykładzie utworzyłem moduł o nazwie todoApp, stosując tym samym nieco dezorientującą konwencję dodawania przyrostka App do nazwy modułu aplikacji. Drugi argument wywołania angular.module() to pusta tablica, która wskazuje, że do działania tworzonego modułu nie są wymagane żadne inne moduły. (Pewne funkcje AngularJS są dostępne w różnych modułach. Sposób tworzenia własnych modułów będzie przedstawiony w rozdziale 18.). (cid:132) Ostrze(cid:285)enie Najcz(cid:218)(cid:258)ciej pope(cid:239)niany b(cid:239)(cid:200)d polega na pomini(cid:218)ciu argumentu wskazuj(cid:200)cego zale(cid:285)no(cid:258)ci, co prowadzi do wygenerowania b(cid:239)(cid:218)du. Koniecznie musisz poda(cid:202) argument okre(cid:258)laj(cid:200)cy zale(cid:285)no(cid:258)ci. Je(cid:258)li zale(cid:285)no(cid:258)ci nie s(cid:200) wymagane, to wskazuj(cid:200)cy je argument powinien mie(cid:202) posta(cid:202) pustej tablicy. Temat u(cid:285)ywania zale(cid:285)no(cid:258)ci zostanie poruszony w rozdziale 18. Nakazanie bibliotece AngularJS zastosowania modułu odbywa się za pomocą atrybutu ng-app. Sposób działania AngularJS polega na rozszerzeniu kodu znaczników HTML, co odbywa się przez dodawanie nowych elementów, atrybutów, klas i specjalnych komentarzy (te ostatnie są jednak rzadko stosowane). Biblioteka AngularJS dynamicznie kompiluj
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

AngularJS. Profesjonalne techniki
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ą: