Używamy cookies, aby ułatwić korzystanie z Portalu. Możesz określić warunki przechowywania, dostępu do plików cookies w Twojej przeglądarce. Dowiedz się więcej.
strona główna Strona główna | Nowości | Promocje | Zapowiedzi Twoje konto | Zarejestruj | Schowek | Kontakt | Pomoc
mapa działów
Szukaj: szukanie zaawansowane
Koszyk
Książki \ Programowanie \ JavaScript

Angular. Profesjonalne techniki programowania. Wydanie II Język: 1

978-83-283-4231-6

Cena Brutto: 119.00

Cena netto: 113.33

Ilość:
Wersja: Drukowana
Autor Adam Freeman
Liczba_stron 736
Wydawnictwo Helion
Oprawa miękka
Data_Wydania 2018-06-08

Angular. Profesjonalne techniki programowania. Wydanie II


Framework Angular 2 jest dziś uważany za jeden z najwydajniejszych sposobów rozwijania średnich i dużych aplikacji internetowych. Te aplikacje działają bez problemu niezależnie od platformy. Separacja kodu interfejsu od logiki aplikacji, prosta modularyzacja aplikacji, bezproblemowe przetwarzanie danych asynchronicznych, bogaty zestaw narzędzi i ogromne ułatwienia podczas projektowania interfejsu użytkownika - to tylko kilka z wielu zalet Angulara. Nawet jednak tak świetny framework wymaga od programisty wiedzy i umiejętności prawidłowego budowania kodu.


Książka rozpoczyna się od przedstawienia wzorca MVC i jego zalet. Ta wiedza następnie przydaje się do budowy własnego projektu za pomocą Angulara. Najpierw będzie to prosta, praktyczna aplikacja, a później zostaną przedstawione coraz bardziej zaawansowane funkcje. Każdy temat jasno i spójnie wyjaśniono, zamieszczając szczegóły konieczne do efektywnej pracy. Przedstawiono sposoby wykorzystywania różnych pożytecznych narzędzi, w tym frameworka Bootstrap, biblioteki Reactive Extensions czy frameworka Jasmine. Nie zabrakło objaśnień najczęściej występujących problemów oraz sposobów ich rozwiązywania.


W tej książce między innymi:

  • Solidne podstawy koncepcji MVC
  • Obiektowy model dokumentu (DOM)
  • Usługi i dostawcy usług
  • Routing i animacja w Angularze
  • Testowanie aplikacji

    O autorze (17)

    O recenzencie technicznym (19)

    CZĘŚĆ I. ZACZYNAMY (21)

    Rozdział 1. Rozpoczęcie pracy (23)

    • Co powinieneś wiedzieć? (23)
    • Jaka jest struktura niniejszej książki? (24)
      • Część I. Zaczynamy (24)
      • Część II. Praca z Angular (24)
      • Część III. Zaawansowane funkcje Angular (24)
    • Czy w książce znajdę wiele przykładów? (24)
    • Jak skonfigurować środowisko programistyczne? (26)
    • Podsumowanie (26)

    Rozdział 2. Pierwsza aplikacja w Angular (27)

    • Przygotowanie środowiska programistycznego (27)
      • Instalowanie Node.js (27)
      • Instalowanie pakietu angular-cli (28)
      • Instalowanie narzędzia git (28)
      • Instalowanie edytora tekstu (29)
      • Instalowanie przeglądarki WWW (30)
    • Utworzenie i przygotowanie projektu (30)
      • Utworzenie projektu (30)
      • Uaktualnienie pliku package.json (30)
      • Uruchamianie serwera (32)
      • Edytowanie pliku HTML (33)
    • Dodanie frameworka Angular do projektu (35)
      • Przygotowanie pliku HTML (36)
      • Utworzenie danych modelu (36)
      • Utworzenie szablonu (38)
      • Uaktualnienie komponentu (39)
      • Połączenie wszystkiego w całość (41)
    • Dodawanie funkcji do przykładowej aplikacji (43)
      • Dodanie tabeli wyświetlającej listę rzeczy do zrobienia (43)
      • Utworzenie dwukierunkowego mechanizmu dołączania danych (46)
      • Dodawanie zadań (48)
    • Podsumowanie (50)

    Rozdział 3. Umieszczenie frameworka Angular w kontekście (51)

    • Sytuacje, w których Angular sprawdza się doskonale (52)
      • Aplikacje dwukierunkowe oraz w postaci pojedynczej strony (52)
    • Wzorzec MVC (54)
      • Model (56)
      • Kontroler (komponent) (58)
      • Widok (szablon) (58)
    • Usługi typu RESTful (59)
    • Najczęstsze pułapki podczas stosowania wzorca MVC (61)
      • Umieszczenie logiki w nieodpowiednim miejscu (61)
      • Przyjęcie formatu danych stosowanego w magazynie danych (62)
      • Wystarczająca ilość wiedzy, aby wpaść w tarapaty (62)
    • Podsumowanie (62)

    Rozdział 4. Krótkie wprowadzenie do HTML i CSS (63)

    • Utworzenie przykładowego projektu (63)
    • Język HTML (64)
      • Element samozamykający się (65)
      • Atrybut (66)
      • Stosowanie atrybutu bez wartości (66)
      • Cytowanie literałów w atrybucie (66)
      • Treść elementu (67)
      • Struktura dokumentu (67)
    • Framework Bootstrap (68)
      • Stosowanie podstawowych klas Bootstrap (69)
      • Użycie frameworka Bootstrap do nadawania stylu tabeli (72)
      • Użycie frameworka Bootstrap do tworzenia formularzy HTML (74)
      • Użycie frameworka Bootstrap do utworzenia układu opartego na siatce (75)
    • Podsumowanie (80)

    Rozdział 5. Wprowadzenie do języków JavaScript i TypeScript - część 1 (81)

    • Utworzenie przykładowego projektu (82)
      • Utworzenie plików HTML i JavaScript (83)
      • Konfiguracja kompilatora TypeScript (84)
      • Uruchomienie przykładowego projektu (84)
    • Element <script> (85)
      • Użycie procedury wczytującej moduł JavaScript (85)
      • Podstawowy sposób pracy (86)
    • Używanie poleceń (87)
    • Definiowanie i używanie funkcji (88)
      • Definiowanie funkcji z parametrami (89)
      • Definiowanie funkcji zwracającej wartość (91)
      • Używanie funkcji jako argumentu innej funkcji (91)
    • Używanie zmiennych i typów (92)
      • Używanie typów podstawowych (94)
    • Używanie operatorów JavaScript (95)
      • Używanie konstrukcji warunkowych (96)
      • Operator równości kontra operator identyczności (97)
      • Jawna konwersja typu (97)
    • Praca z tablicą (99)
      • Użycie literału tablicy (100)
      • Odczyt i modyfikacja zawartości tablicy (100)
      • Wyświetlenie zawartości tablicy (100)
      • Używanie wbudowanych metod przeznaczonych do pracy z tablicą (101)
    • Podsumowanie (103)

    Rozdział 6. Wprowadzenie do języków JavaScript i TypeScript - część 2 (105)

    • Utworzenie przykładowego projektu (105)
    • Praca z obiektami (106)
      • Używanie literału obiektu (107)
      • Używanie funkcji jako metod (107)
      • Zdefiniowanie klasy (108)
    • Praca z modułami JavaScript (111)
      • Utworzenie modułu (111)
      • Import z modułu JavaScript (112)
    • Użyteczne funkcje języka TypeScript (115)
      • Używanie adnotacji typu (115)
      • Używanie krotki (120)
      • Używanie typów indeksowanych (120)
      • Używanie modyfikatorów dostępu (121)
    • Podsumowanie (122)

    Rozdział 7. SportsStore - rzeczywista aplikacja (123)

    • Utworzenie przykładowego projektu (123)
      • Utworzenie struktury katalogów (124)
      • Instalowanie dodatkowych pakietów npm (124)
      • Utworzenie usługi sieciowej typu RESTful (126)
      • Utworzenie pliku HTML (127)
      • Uruchomienie przykładowej aplikacji (128)
      • Uruchomienie usługi sieciowej typu RESTful (128)
    • Przygotowanie funkcji projektu Angular (129)
      • Uaktualnienie komponentu głównego (129)
      • Uaktualnienie modułu głównego (130)
      • Analiza pliku typu bootstrap (130)
    • Utworzenie danych modelu (131)
      • Utworzenie klas modelu (131)
      • Utworzenie fikcyjnego źródła danych (132)
      • Utworzenie repozytorium modelu (133)
      • Utworzenie modułu funkcjonalnego (134)
    • Rozpoczęcie pracy nad utworzeniem sklepu internetowego (135)
      • Utworzenie szablonu i komponentu sklepu internetowego (135)
      • Utworzenie modułu funkcjonalnego dla sklepu (136)
      • Uaktualnienie komponentu i modułu głównego (137)
    • Dodawanie funkcji związanych z produktem (138)
      • Wyświetlanie szczegółów produktu (138)
      • Dodawanie możliwości wyboru kategorii (140)
      • Dodawanie stronicowania produktów (141)
      • Utworzenie własnej dyrektywy (144)
    • Podsumowanie (147)

    Rozdział 8. SportsStore - zamówienia i zakupy (149)

    • Utworzenie przykładowego projektu (149)
    • Utworzenie koszyka na zakupy (149)
      • Utworzenie modelu koszyka na zakupy (150)
      • Utworzenie komponentów podsumowania koszyka na zakupy (151)
      • Integracja koszyka na zakupy ze sklepem internetowym (153)
    • Zaimplementowanie routingu (155)
      • Utworzenie komponentów zawartości koszyka i procesu składania zamówienia (156)
      • Utworzenie i zastosowanie konfiguracji routingu (157)
      • Nawigacja po aplikacji (158)
      • Zabezpieczanie tras (160)
    • Ukończenie funkcji obsługi zawartości koszyka (163)
    • Przetwarzanie zamówienia (165)
      • Rozbudowa modelu (165)
      • Pobieranie szczegółów zamówienia (167)
    • Używanie usługi sieciowej typu RESTful (171)
      • Zastosowanie źródła danych (172)
    • Podsumowanie (173)

    Rozdział 9. SportsStore - administracja (175)

    • Utworzenie przykładowej aplikacji (175)
      • Utworzenie modułu (175)
      • Konfigurowanie systemu routingu (178)
      • Nawigacja do administracyjnego adresu URL (179)
    • Implementowanie uwierzytelniania (179)
      • Poznajemy system uwierzytelniania (180)
      • Rozbudowa źródła danych (181)
      • Konfigurowanie usługi uwierzytelniania (182)
      • Włączenie uwierzytelniania (183)
    • Rozbudowa źródła danych i repozytoriów (185)
    • Utworzenie struktury funkcji administracyjnych (189)
      • Utworzenie komponentów w postaci miejsc zarezerwowanych (190)
      • Przygotowanie wspólnej treści i modułu funkcjonalnego (190)
      • Zaimplementowanie funkcji obsługi produktu (193)
      • Zaimplementowanie funkcji obsługi zamówienia (196)
    • Podsumowanie (198)

    Rozdział 10. SportsStore - wdrożenie (199)

    • Przygotowanie aplikacji do wdrożenia (199)
    • Umieszczenie aplikacji SportsStore w kontenerze (199)
      • Instalowanie narzędzia Docker (200)
      • Przygotowanie aplikacji (200)
      • Utworzenie kontenera (201)
      • Uruchamianie aplikacji (202)
    • Podsumowanie (203)

    CZĘŚĆ II. PRACA Z ANGULAR (205)

    Rozdział 11. Utworzenie projektu Angular (207)

    • Przygotowanie projektu Angular opartego na języku TypeScript (207)
      • Utworzenie projektu (208)
      • Utworzenie i udostępnianie dokumentu HTML (208)
      • Przygotowanie konfiguracji projektu (209)
      • Dodawanie pakietów (209)
    • Rozpoczęcie programowania Angular z użyciem TypeScript (214)
      • Utworzenie modelu (217)
      • Utworzenie szablonu i modułu głównego (220)
      • Modyfikacja modułu Angular (221)
      • Pliku typu bootstrap dla aplikacji (222)
      • Konfigurowanie procedury wczytywania modułu JavaScript (222)
      • Nadanie stylu treści (223)
      • Uruchamianie aplikacji (223)
    • Podsumowanie (225)

    Rozdział 12. Mechanizm dołączania danych (227)

    • Utworzenie przykładowego projektu (228)
    • Jednokierunkowe dołączanie danych (229)
      • Cel dla operacji dołączania danych (231)
      • Wyrażenie dołączania danych (231)
      • Nawias kwadratowy (233)
      • Element HTML (234)
    • Używanie standardowego dołączania właściwości i atrybutu (234)
      • Używanie standardowego dołączania właściwości (234)
      • Używanie dołączania danych w postaci interpolacji ciągu tekstowego (235)
      • Używanie dołączania atrybutu (236)
    • Przypisywanie klas i stylów (238)
      • Używanie dołączania klasy (238)
      • Używanie dołączania stylu (242)
    • Uaktualnienie danych w aplikacji (245)
    • Podsumowanie (248)

    Rozdział 13. Używanie wbudowanych dyrektyw (249)

    • Utworzenie przykładowego projektu (250)
    • Używanie wbudowanej dyrektywy (251)
      • Używanie dyrektywy ngIf (252)
      • Używanie dyrektywy ngSwitch (254)
      • Używanie dyrektywy ngFor (256)
      • Używanie dyrektywy ngTemplateOutlet (264)
    • Ograniczenia jednokierunkowego dołączania danych (267)
      • Używanie wyrażeń idempotentnych (267)
      • Kontekst wyrażenia (270)
    • Podsumowanie (272)

    Rozdział 14. Używanie zdarzeń i formularzy (273)

    • Utworzenie przykładowego projektu (274)
      • Przygotowanie komponentu i szablonu (274)
    • Używanie dołączania zdarzenia (275)
      • Poznajemy właściwości zdefiniowane dynamicznie (277)
      • Używanie danych zdarzenia (279)
      • Używanie zmiennej odwołania w szablonie (281)
    • Używanie dwukierunkowego dołączania danych (282)
      • Używanie dyrektywy ngModel (284)
    • Praca z formularzem HTML (285)
      • Dodawanie formularza do przykładowej aplikacji (285)
      • Dodawanie weryfikacji danych formularza (287)
      • Weryfikacja danych całego formularza (296)
    • Używanie formularza opartego na modelu (302)
      • Włączenie funkcji tworzenia formularza opartego na modelu (302)
      • Zdefiniowanie klas modelu formularza (303)
      • Używanie modelu do weryfikacji danych (306)
      • Generowanie elementów na podstawie modelu (309)
    • Utworzenie własnych reguł weryfikacji formularza (310)
      • Zastosowanie własnej reguły weryfikacji (311)
    • Podsumowanie (313)

    Rozdział 15. Tworzenie dyrektywy atrybutu (315)

    • Utworzenie przykładowego projektu (316)
    • Utworzenie prostej dyrektywy atrybutu (318)
      • Zastosowanie własnej dyrektywy (319)
    • Uzyskanie w dyrektywie dostępu do danych aplikacji (320)
      • Odczyt atrybutów elementu HTML (321)
      • Utworzenie właściwości dołączania danych wejściowych (323)
      • Reagowanie na zmianę właściwości danych wejściowych (325)
    • Utworzenie własnego zdarzenia (327)
      • Dołączanie do własnego zdarzenia (329)
    • Utworzenie operacji dołączania danych w elemencie HTML (330)
    • Używanie dwukierunkowego dołączania danych w elemencie HTML (331)
    • Wyeksportowanie dyrektywy do użycia w zmiennej szablonu (335)
    • Podsumowanie (337)

    Rozdział 16. Tworzenie dyrektywy strukturalnej (339)

    • Utworzenie przykładowego projektu (340)
    • Utworzenie prostej dyrektywy strukturalnej (340)
      • Implementowanie klasy dyrektywy strukturalnej (342)
      • Włączanie dyrektywy strukturalnej (344)
      • Używanie zwięzłej składni dyrektywy strukturalnej (346)
    • Utworzenie iteracyjnej dyrektywy strukturalnej (347)
      • Dostarczanie dodatkowych danych kontekstu (349)
      • Używanie zwięzłej składni dyrektywy strukturalnej (351)
      • Zmiany danych na poziomie właściwości (352)
      • Zmiany danych na poziomie kolekcji (353)
    • Pobieranie treści elementu HTML (363)
      • Wykonywanie zapytań do wielu elementów potomnych w treści (366)
      • Otrzymywanie powiadomień o zmianie zapytania (367)
    • Podsumowanie (369)

    Rozdział 17. Poznajemy komponent (371)

    • Utworzenie przykładowego projektu (372)
    • Strukturyzacja aplikacji z użyciem komponentów (372)
      • Utworzenie nowych komponentów (374)
      • Definiowanie szablonu (377)
      • Zakończenie restrukturyzacji komponentu głównego (386)
    • Używanie stylów komponentu (387)
      • Definiowanie zewnętrznych stylów komponentu (388)
      • Używanie zaawansowanych funkcji stylów (389)
    • Pobieranie treści szablonu (396)
    • Podsumowanie (397)

    Rozdział 18. Tworzenie i używanie potoku (399)

    • Utworzenie przykładowego projektu (400)
    • Poznajemy potok (402)
    • Utworzenie własnego potoku (403)
      • Rejestrowanie własnego potoku (405)
      • Zastosowanie własnego potoku (405)
      • Łączenie potoków (406)
      • Utworzenie potoku nieczystego (407)
    • Używanie wbudowanych potoków (411)
      • Formatowanie wartości liczbowych (412)
      • Formatowanie wartości walutowych (414)
      • Formatowanie wartości procentowych (416)
      • Formatowanie wartości daty i godziny (418)
      • Zmiana wielkości znaków ciągu tekstowego (421)
      • Serializowanie danych jako JSON (421)
      • Podział danych tablicy (423)
    • Podsumowanie (424)

    Rozdział 19. Poznajemy usługę (425)

    • Utworzenie przykładowego projektu (426)
    • Poznajemy problem związany z przekazywaniem obiektów (427)
      • Prezentacja problemu (427)
      • Wykorzystanie mechanizmu wstrzykiwania zależności do rozprowadzania obiektu jako usługi (431)
      • Zadeklarowanie zależności w innych elementach konstrukcyjnych (437)
    • Problem izolacji testu (443)
      • Izolowanie komponentów za pomocą usług i mechanizmu wstrzykiwania zależności (443)
    • Dokończenie zastosowania usług w aplikacji (446)
      • Uaktualnienie komponentu głównego i szablonu (447)
      • Uaktualnianie komponentów potomnych (447)
    • Podsumowanie (449)

    Rozdział 20. Poznajemy dostawcę usługi (451)

    • Utworzenie przykładowego projektu (452)
    • Używanie dostawcy usługi (453)
      • Używanie dostawcy klasy (456)
      • Używanie dostawcy wartości (463)
      • Używanie dostawcy fabryki (465)
      • Używanie dostawcy istniejącej usługi (468)
    • Używanie dostawcy lokalnego (469)
      • Ograniczenia pojedynczego obiektu usługi (469)
      • Utworzenie dostawcy lokalnego w dyrektywie (470)
      • Utworzenie dostawcy lokalnego w komponencie (471)
      • Kontrolowanie spełniania zależności (477)
    • Podsumowanie (479)

    Rozdział 21. Używanie i tworzenie modułu (481)

    • Utworzenie przykładowego projektu (482)
    • Moduł główny (483)
      • Właściwość imports (485)
      • Właściwość declarations (486)
      • Właściwość providers (486)
      • Właściwość bootstrap (487)
    • Utworzenie modułu funkcjonalnego (489)
      • Utworzenie modułu modelu (490)
      • Utworzenie modułu narzędziowego (494)
      • Utworzenie modułu wraz z komponentami (498)
    • Podsumowanie (501)

    CZĘŚĆ III. ZAAWANSOWANE FUNKCJE ANGULAR (503)

    Rozdział 22. Utworzenie przykładowego projektu (505)

    • Rozpoczęcie pracy nad przykładowym projektem (505)
    • Dodawanie i konfigurowanie pakietów (506)
    • Utworzenie modułu modelu (507)
      • Utworzenie typu danych produktu (507)
      • Utworzenie źródła danych i repozytorium (507)
      • Zakończenie pracy nad modułem modelu (509)
    • Utworzenie modułu core (509)
      • Utworzenie współdzielonej usługi informacji o stanie (509)
      • Utworzenie komponentu tabeli (510)
      • Utworzenie komponentu formularza (511)
      • Zakończenie pracy nad modułem core (513)
    • Utworzenie modułu messages (514)
      • Utworzenie modelu i usługi (514)
      • Utworzenie komponentu i szablonu (515)
      • Zakończenie pracy nad modułem messages (515)
    • Zakończenie pracy nad projektem (516)
      • Plik typu bootstrap (516)
      • Dokument HTML (516)
    • Uruchomienie przykładowego projektu (517)
    • Podsumowanie (517)

    Rozdział 23. Poznajemy bibliotekę Reactive Extensions (519)

    • Utworzenie przykładowego projektu (520)
    • Poznajemy problem (521)
    • Rozwiązanie problemu za pomocą biblioteki Reactive Extensions (523)
      • Klasa Observable (523)
      • Klasa Observer (525)
      • Klasa Subject (526)
    • Używanie potoku async (527)
      • Używanie potoku async wraz z niestandardowym potokiem (528)
    • Skalowanie w górę modułów funkcjonalnych aplikacji (530)
    • Wyjście poza podstawy (532)
      • Filtrowanie zdarzeń (533)
      • Transformowanie zdarzeń (535)
      • Otrzymywanie jedynie odmiennych zdarzeń (537)
      • Pobieranie i pomijanie zdarzeń (539)
    • Podsumowanie (540)

    Rozdział 24. Wykonywanie asynchronicznych żądań HTTP (541)

    • Utworzenie przykładowego projektu (542)
      • Konfigurowanie modułu funkcjonalności modelu (543)
      • Uaktualnienie komponentu formularza (544)
      • Uruchomienie przykładowego projektu (545)
    • Poznajemy usługę sieciową typu RESTful (546)
    • Zastąpienie statycznego źródła danych (547)
      • Utworzenie usługi nowego źródła danych (547)
      • Konfigurowanie źródła danych (549)
      • Używanie źródła danych typu REST (550)
      • Zapisywanie i usuwanie danych (551)
    • Konsolidowanie żądań HTTP (554)
    • Wykonywanie żądań między domenami (556)
      • Używanie żądań JSONP (557)
    • Konfigurowanie nagłówków żądania (559)
    • Obsługa błędów (561)
      • Wygenerowanie komunikatów przeznaczonych dla użytkownika (562)
      • Faktyczna obsługa błędu (563)
    • Podsumowanie (564)

    Rozdział 25. Routing i nawigacja - część 1 (567)

    • Utworzenie przykładowego projektu (568)
      • Wyłączenie wyświetlania zdarzenia zmiany stanu (569)
    • Rozpoczęcie pracy z routingiem (571)
      • Utworzenie konfiguracji routingu (571)
      • Utworzenie komponentu routingu (573)
      • Uaktualnienie modułu głównego (574)
      • Zakończenie konfiguracji (574)
      • Dodawanie łączy nawigacyjnych (575)
      • Efekt zastosowania routingu (577)
    • Dokończenie implementacji routingu (579)
      • Obsługa zmiany trasy w komponencie (579)
      • Używanie parametrów trasy (581)
      • Nawigacja w kodzie (587)
      • Otrzymywanie zdarzeń nawigacyjnych (589)
      • Usunięcie dołączania zdarzeń i obsługującego je kodu (591)
    • Podsumowanie (593)

    Rozdział 26. Routing i nawigacja - część 2 (595)

    • Utworzenie przykładowego projektu (595)
      • Dodawanie komponentów do projektu (598)
    • Używanie znaków wieloznacznych i przekierowań (601)
      • Używanie znaków wieloznacznych w trasie (601)
      • Używanie przekierowania w trasie (603)
    • Nawigacja w komponencie (604)
      • Reakcja na zmiany w routingu (606)
      • Nadawanie stylu łączu aktywnej trasy (608)
      • Poprawienie przycisku Wszystkie (611)
    • Utworzenie trasy potomnej (612)
      • Utworzenie outletu trasy potomnej (613)
      • Uzyskanie dostępu do parametrów z poziomu tras potomnych (615)
    • Podsumowanie (618)

    Rozdział 27. Routing i nawigacja - część 3 (619)

    • Utworzenie przykładowego projektu (619)
    • Zabezpieczanie tras (620)
      • Opóźnienie nawigacji za pomocą resolvera (621)
      • Uniemożliwienie nawigacji dzięki użyciu strażników (628)
    • Dynamiczne wczytywanie modułów funkcjonalnych (640)
      • Utworzenie prostego modułu funkcjonalnego (640)
      • Dynamiczne wczytywanie modułu (641)
      • Zabezpieczanie dynamicznie wczytywanego modułu (644)
    • Odwołania do nazwanych outletów (647)
      • Utworzenie dodatkowych elementów <router-outlet> (648)
      • Nawigacja podczas użycia wielu outletów (649)
    • Podsumowanie (651)

    Rozdział 28. Animacje (653)

    • Utworzenie przykładowego projektu (654)
      • Dodanie modułu zapewniającego obsługę animacji (655)
      • Wyłączenie opóźnienia HTTP (655)
      • Uproszczenie szablonu tabeli i konfiguracji routingu (656)
    • Rozpoczęcie pracy z animacjami frameworka Angular (657)
      • Utworzenie animacji (658)
      • Zastosowanie animacji (661)
      • Przetestowanie animacji (664)
    • Poznajemy wbudowane stany aplikacji (665)
    • Poznajemy transformację elementu (666)
      • Utworzenie transformacji dla wbudowanych stanów (666)
      • Kontrolowanie animacji transformacji (669)
    • Poznajemy grupy stylów animacji (674)
      • Zdefiniowanie najczęściej używanych stylów w grupie przeznaczonej do wielokrotnego użycia (674)
      • Używanie transformacji elementu (675)
      • Zastosowanie stylów frameworka CSS (677)
    • Poznajemy zdarzenia wyzwalacza animacji (678)
    • Podsumowanie (681)

    Rozdział 29. Testy jednostkowe w Angular (683)

    • Utworzenie przykładowego projektu (685)
      • Dodawanie pakietów przeznaczonych do wykonywania testów (685)
      • Utworzenie prostego testu jednostkowego (687)
      • Uruchamianie narzędzi (687)
    • Praca z frameworkiem Jasmine (688)
    • Testowanie komponentu Angular (690)
      • Praca z klasą TestBed (690)
      • Testowanie operacji dołączania danych (693)
      • Testowanie komponentu wraz z zewnętrznym szablonem (696)
      • Testowanie zdarzeń komponentu (697)
      • Testowanie właściwości danych wyjściowych (699)
      • Testowanie właściwości danych wejściowych (701)
      • Testowanie operacji asynchronicznej (703)
    • Testowanie dyrektywy Angular (705)
    • Podsumowanie (707)

    Skorowidz (709)

powrót
 
Produkty Podobne
React Native. Tworzenie aplikacji mobilnych w języku JavaScript. Wydanie II
Nowoczesny JavaScript. Poznaj ES6 i praktyczne zastosowania nowych rozwiązań
JavaScript. Wyrażenia regularne dla programistów
Angular. Profesjonalne techniki programowania. Wydanie II
Programowanie zorientowane obiektowo w języku JavaScript. Wydanie III
Node.js. Projektowanie, wdrażanie i utrzymywanie aplikacji
Python, C++, JavaScript. Zadania z programowania
Platforma Node.js. Przewodnik webdevelopera. Wydanie III
ECMAScript 6. Przewodnik po nowym standardzie języka JavaScript
Programowanie funkcyjne z JavaScriptem. Sposoby na lepszy kod
Więcej produktów