wprowadź własne kryteria wyszukiwania książek: (jak szukać?)
Twój koszyk:   0 zł   zamówienie wysyłkowe >>>
Strona główna > opis książki
English version
Książki:

polskie
podział tematyczny
 
anglojęzyczne
podział tematyczny
 
Newsletter:

Zamów informacje o nowościach z wybranego tematu
 
Informacje:

o księgarni

koszty wysyłki

kontakt

Cookies na stronie

 
Szukasz podpowiedzi?
Nie znasz tytułu?
Pomożemy Ci, napisz!


Podaj adres e-mail:


możesz też zadzwonić
+48 512 994 090

ANGULARJS PROFESJONALNE TECHNIKI


FREEMAN A.

wydawnictwo: HELION, 2015, wydanie I

cena netto: 103.95 Twoja cena  98,75 zł + 5% vat - dodaj do koszyka

AngularJS

Profesjonalne techniki


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:

  • poznasz tajniki programowania w JavaScripcie

  • dowiesz się, do czego służą dyrektywy i jak tworzyć własne

  • pobierzesz dane z udostępnionych usług sieciowych

  • przetestujesz stworzony kod

  • poznasz tajemnice AngularJS


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)


632 strony, Format: 16.5x24.5cm, oprawa twarda

Po otrzymaniu zamówienia poinformujemy pocztą e-mail lub telefonicznie,
czy wybrany tytuł polskojęzyczny lub anglojęzyczny jest aktualnie na półce księgarni.

 
Wszelkie prawa zastrzeżone PROPRESS sp. z o.o. www.bankowa.pl 2000-2022