O autorze (15)

O recenzencie technicznym (16)

CZĘŚĆ I ZACZYNAMY (17)

Rozdział 1. Zaczynamy (19)

• 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ł 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)
  • 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ł 3. Umieszczenie AngularJS w kontekś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ł 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ł 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)
• 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)

Rozdział 6. SportsStore - przykł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)

Rozdział 7. 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)

Rozdział 8. 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)
• 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ĘŚĆ II PRACA Z ANGULARJS (209)

Rozdział 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ł 10. Użycie dyrektyw dołą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ł 11. Użycie dyrektyw elementów i zdarzeń (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)
• 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ł 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ł 13. Uż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ł 14. Uż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)
  • 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ł 15. Tworzenie wł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ł 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)

Rozdział 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ĘŚĆ III USŁUGI ANGULARJS (453)

Rozdział 18. Praca z modułami i usł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ł 19. Usługi dla obiektów globalnych, błędów i wyrażeń (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)
• 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ł 20. Usł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ł 21. Usł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ł 22. Usł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)
  • 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ł 23. Usługi dla animacji i dotknięć (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ł 24. Usł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ł 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)
• Testowanie innych komponentów (612)
  
  • Testowanie filtru (612)
  • Testowanie dyrektywy (614)
  • Testowanie usługi (615)
• Podsumowanie (617)

Skorowidz (619)

• Tytuł: AngularJS. Profesjonalne techniki
• Autor: Adam Freeman
• Tytuł oryginału: Pro AngularJS
• Tłumaczenie: Robert Górczyński
• ISBN: 978-83-283-0198-6, 9788328301986
• Data wydania: 2015-02-06
• Format: Ebook
• Identyfikator pozycji: angupt
• Wydawca: Helion