O autorze (15)

O recenzentach (17)

Wstęp (19)

Rozdział 1. TypeScript - dostępne narzędzia i frameworki (25)

• Przedstawienie języka TypeScript (27)
  
  • Standard EcmaScript (27)
  • Zalety języka TypeScript (28)
• Zintegrowane środowiska programistyczne obsługujące język TypeScript (36)
  
  • Kompilacja w środowisku Node (36)
  • Visual Studio 2017 (38)
  • WebStorm (44)
  • Visual Studio Code (48)
  • Inne edytory (55)
• Podsumowanie (57)

Rozdział 2. Typy, zmienne oraz funkcje (59)

• Typy podstawowe (60)
  
  • Typy w języku JavaScript (60)
  • Określanie typów w języku TypeScript (61)
  • Składnia określania typów (62)
  • Wnioskowanie typów (64)
  • Kacze typowanie (65)
  • Łańcuchy szablonów (66)
  • Tablice (67)
  • Pętle for...in oraz for...of (68)
  • Typ any (69)
  • Jawne rzutowanie (70)
  • Typy wyliczeniowe (71)
  • Ustalone typy wyliczeniowe (73)
  • Stałe (74)
  • Słowo kluczowe let (75)
• Funkcje (77)
  
  • Typy wartości zwracanych przez funkcje (77)
  • Funkcje anonimowe (78)
  • Parametry opcjonalne (78)
  • Parametry domyślne (80)
  • Parametr reszty (80)
  • Funkcje zwrotne (82)
  • Sygnatury funkcji (84)
  • Przeciążanie funkcji (86)
• Zaawansowane typy (87)
  
  • Typ unii (88)
  • Strażniki typów (88)
  • Nazwy zastępcze typów (90)
  • Wartość null i undefined (91)
  • Reszta obiektu i rozproszenie (93)
• Podsumowanie (94)

Rozdział 3. Interfejsy, klasy i dziedziczenie (95)

• Interfejsy (96)
  
  • Właściwości opcjonalne (97)
  • Kompilacja interfejsów (98)
• Klasy (98)
  
  • Właściwości klas (99)
  • Implementacja interfejsów (100)
  • Konstruktory klas (101)
  • Funkcje klas (102)
  • Definicje funkcji interfejsów (105)
  • Modyfikatory klas (106)
  • Modyfikatory dostępu w konstruktorach (108)
  • Właściwości tylko do odczytu (109)
  • Akcesory właściwości klas (109)
  • Funkcje statyczne (111)
  • Właściwości statyczne (111)
  • Przestrzenie nazw (112)
• Dziedziczenie (113)
  
  • Dziedziczenie interfejsów (114)
  • Dziedziczenie klas (114)
  • Słowo kluczowe super (115)
  • Przeciążanie funkcji (116)
  • Składowe chronione (117)
  • Klasy abstrakcyjne (118)
  • Domknięcia JavaScript (121)
• Stosowanie interfejsów, klas i dziedziczenia - wzorzec projektowy Fabryka (123)
  
  • Wymagania biznesowe (123)
  • Co robi wzorzec Fabryka? (123)
  • Stosowanie klasy fabrykującej (127)
• Podsumowanie (128)

Rozdział 4. Dekoratory, typy ogólne i asynchroniczność (129)

• Dekoratory (130)
  
  • Składnia dekoratorów (131)
  • Stosowanie wielu dekoratorów (132)
  • Fabryki dekoratorów (132)
  • Parametry dekoratorów klas (133)
  • Dekoratory właściwości (135)
  • Dekoratory właściwości statycznych (136)
  • Dekoratory metod (137)
  • Stosowanie dekoratorów metod (138)
  • Dekoratory parametrów (139)
  • Metadane dekoratorów (140)
  • Stosowanie metadanych dekoratorów (142)
• Typy ogólne (143)
  
  • Składnia typów ogólnych (144)
  • Tworzenie instancji klas ogólnych (145)
  • Stosowanie typu T (146)
  • Ograniczenia typu T (148)
  • Interfejsy ogólne (150)
  • Tworzenie nowych obiektów w klasach ogólnych (151)
• Mechanizmy programowania asynchronicznego (153)
  
  • Obietnice (153)
  • Składnia obietnic (155)
  • Stosowanie obietnic (156)
  • Składnia funkcji zwrotnych a składnia obietnic (158)
  • Zwracanie wartości z obietnic (158)
  • Słowa kluczowe async i await (160)
  • Słowo kluczowe await a obsługa błędów (161)
  • Obietnice a składnia słowa kluczowego await (162)
  • Komunikaty a słowo kluczowe await (163)
• Podsumowanie (165)

Rozdział 5. Pisanie i stosowanie plików deklaracji (167)

• Zmienne globalne (168)
• Stosowanie bloków kodu JavaScript w kodzie HTML (170)
  
  • Dane strukturalne (171)
• Pisanie własnych plików deklaracji (173)
  
  • Słowo kluczowe module (175)
  • Interfejsy (177)
  • Typy unii (179)
• Scalanie modułów (180)
• Składnia plików deklaracji (180)
  
  • Przesłanianie funkcji (181)
  • Zagnieżdżone przestrzenie nazw (181)
  • Klasy (182)
  • Przestrzenie nazw klas (182)
  • Przeciążanie konstruktora klas (182)
  • Właściwości klas (183)
  • Funkcje klas (183)
  • Właściwości i funkcje statyczne (183)
  • Funkcje globalne (184)
  • Sygnatury funkcji (184)
  • Właściwości opcjonalne (184)
  • Scalanie funkcji i modułów (185)
• Podsumowanie (185)

Rozdział 6. Biblioteki innych twórców (187)

• Pobieranie plików definicji (188)
• Stosowanie NuGet (190)
  
  • Stosowanie menedżera pakietów (190)
  • Instalowanie plików deklaracji (191)
  • Stosowanie konsoli menedżera pakietów (191)
• Stosowanie narzędzia Typings (192)
  
  • Poszukiwanie pakietów (193)
  • Inicjalizacja Typings (194)
  • Instalowanie plików definicji (194)
  • Instalowanie konkretnej wersji pliku (195)
  • Ponowna instalacja plików definicji (195)
• Stosowanie programu Bower (196)
• Stosowanie npm i @types (196)
• Stosowanie bibliotek innych twórców (197)
  
  • Wybór frameworka JavaScript (197)
• Backbone (198)
  
  • Stosowanie dziedziczenia we frameworku Backbone (199)
  • Stosowanie interfejsów (201)
  • Stosowanie składni typów ogólnych (201)
  • Stosowanie języka ECMAScript 5 (202)
  • Zgodność frameworka Backbone z językiem TypeScript (203)
• Angular (203)
  
  • Klasy Angular i zmienna $scope (205)
  • Zgodność frameworka AngularJS z językiem TypeScript (207)
• Dziedziczenie - Angular kontra Backbone (207)
• ExtJS (208)
  
  • Tworzenie klas w ExtJS (208)
  • Stosowanie rzutowania typów (210)
  • Kompilator TypeScript dla ExtJS (211)
• Podsumowanie (211)

Rozdział 7. Frameworki zgodne z językiem TypeScript (213)

• Czym jest MVC? (214)
  
  • Model (215)
  • Widok (215)
  • Kontroler (216)
  • Podsumowanie wzorca MVC (217)
  • Zalety stosowania wzorca MVC (218)
  • Szkic przykładowej aplikacji (219)
• Stosowanie frameworka Backbone (220)
  
  • Wydajność wyświetlania (221)
  • Konfiguracja frameworka Backbone (222)
  • Modele Backbone (223)
  • Widok ItemView (224)
  • Widok CollectionView (225)
  • Aplikacja Backbone (227)
• Stosowanie frameworka Aurelia (228)
  
  • Konfiguracja frameworka Aurelia (228)
  • Zagadnienia do rozważenia (229)
  • Wydajność frameworka Aurelia (230)
  • Modele frameworka Aurelia (230)
  • Widoki frameworka Aurelia (231)
  • Wczytywanie aplikacji Aurelia (232)
  • Zdarzenia frameworka Aurelia (233)
• Framework Angular 2 (234)
  
  • Konfiguracja frameworka Angular 2 (234)
  • Modele frameworka Angular 2 (235)
  • Widoki Angular 2 (235)
  • Wydajność frameworka Angular 2 (237)
  • Zdarzenia Angular 2 (237)
• Stosowanie frameworka React (238)
  
  • Konfiguracja frameworka React (238)
  • Widoki React (240)
  • Wczytywanie aplikacji React (243)
  • Zdarzenia React (245)
• Podsumowanie (246)

Rozdział 8. Programowanie w oparciu o testy (247)

• Programowanie w oparciu o testy (248)
• Testy jednostkowe, integracyjne oraz akceptacyjne (249)
  
  • Testy jednostkowe (250)
  • Testy integracyjne (250)
  • Testy akceptacyjne (250)
• Frameworki testów jednostkowych (251)
• Jasmine (251)
  
  • Prosty test Jasmine (252)
  • Plik SpecRunner (252)
  • Obiekty dopasowujące (254)
  • Uruchamianie i kończenie testów (256)
  • Testy bazujące na danych (256)
  • Stosowanie szpiegów (258)
  • Szpiegowanie funkcji zwrotnych (259)
  • Stosowanie szpiegów jako imitacji (261)
  • Testy asynchroniczne (261)
  • Stosowanie funkcji done() (263)
  • Modyfikacje DOM w Jasmine (264)
  • Zdarzenia DOM (265)
• Mechanizmy wykonawcze Jasmine (266)
  
  • Testem (267)
  • Karma (268)
  • Protractor (270)
• Stosowanie ciągłej integracji (272)
  
  • Zalety ciągłej integracji (273)
  • Wybór serwera budowy (274)
  • Raportowanie testów integracyjnych (275)
• Podsumowanie (276)

Rozdział 9. Testowanie frameworków zgodnych z językiem TypeScript (277)

• Testowanie naszej aplikacji przykładowej (278)
• Modyfikacja aplikacji przykładowej w celu umożliwienia testowania (279)
• Testowanie frameworka Backbone (280)
  
  • Złożone modele (280)
  • Aktualizacje widoków (283)
  • Modyfikacje obsługi zdarzeń DOM (283)
  • Testy modeli (285)
  • Testy modelu złożonego (287)
  • Testy wyświetlania (288)
  • Testy zdarzeń DOM (289)
  • Podsumowanie testów Backbone (291)
• Testowanie frameworka Aurelia (291)
  
  • Komponenty frameworka Aurelia (291)
  • Model widoku komponentów Aurelia (292)
  • Komponent widoku frameworka Aurelia (293)
  • Wyświetlanie komponentu (293)
  • Konwencje nazewnicze frameworka Aurelia (294)
  • Konfiguracja testów we frameworku Aurelia (295)
  • Testy jednostkowe we frameworku Aurelia (296)
  • Testy wyświetlania (297)
  • Testy przekrojowe we frameworku Aurelia (299)
  • Podsumowanie testów frameworka Aurelia (303)
• Testowanie frameworka Angular 2 (303)
  
  • Aktualizacja aplikacji (303)
  • Konfiguracja testów we frameworku Angular 2 (305)
  • Testy modelu w Angular 2 (305)
  • Testy wyświetlania w Angular 2 (306)
  • Testowanie DOM w Angular 2 (307)
  • Podsumowanie testów Angular 2 (308)
• Testowanie frameworka React (308)
  
  • Wiele punktów wejścia (309)
  • Modyfikacje w aplikacji React (309)
  • Testy jednostkowe komponentów React (312)
  • Testy modelu i widoków React (313)
  • Testy zdarzeń we frameworku React (315)
• Podsumowanie (316)

Rozdział 10. Modularyzacja (317)

• Podstawowe informacje o modułach (318)
  
  • Eksportowanie modułów (320)
  • Importowanie modułów (320)
  • Zmiana nazwy modułu (321)
  • Eksporty domyślne (322)
  • Eksportowanie zmiennych (323)
• Wczytywanie modułów AMD (324)
  
  • Kompilacja modułów AMD (324)
  • Konfiguracja modułów AMD (326)
  • Konfiguracja Require (326)
  • Konfiguracja przeglądarki dla modułów AMD (327)
  • Zależności w modułach AMD (328)
  • Wczytywanie frameworka Require (331)
  • Poprawianie błędów konfiguracji Require (333)
• Wyczytywanie modułów przy użyciu SystemJS (334)
  
  • Instalacja SystemJS (335)
  • Konfiguracja SystemJS do użycia w przeglądarce (335)
  • SystemJS i zależności modułów (337)
  • Wczytywanie Jasmine (340)
• Stosowanie Express i Node (340)
  
  • Konfiguracja Express (341)
  • Stosowanie modułów w aplikacjach Express (342)
  • Określanie i obsługa tras w aplikacjach Express (344)
  • Stosowanie szablonów w Express (346)
  • Stosowanie Handlebars (347)
  • Zdarzenia POST we frameworku Express (350)
  • Przekierowywanie żądań HTTP (353)
  • Podsumowanie informacji o Node i Express (355)
• Podsumowanie (355)

Rozdział 11. Programowanie obiektowe (357)

• Zasady programowania obiektowego (358)
  
  • Programowanie w oparciu o interfejsy (358)
  • Zasady SOLID (359)
• Projektowanie interfejsu użytkownika (360)
  
  • Projekt koncepcyjny (361)
  • Konfiguracja aplikacji Angular 2 (363)
  • Stosowanie frameworka Bootstrap (364)
  • Tworzenie panelu bocznego (365)
  • Tworzenie nakładki (369)
  • Koordynacja efektów przejść (371)
• Wzorzec Stan (372)
  
  • Interfejs stanu (372)
  • Konkretne stany (373)
• Wzorzec Mediator (374)
  
  • Modularny kod (375)
  • Komponent Navbar (376)
  • Komponent SideNav (377)
  • Komponent RightScreen (378)
  • Komponenty podrzędne (380)
  • Implementacja interfejsu mediatora (381)
  • Klasa Mediator (382)
  • Stosowanie klasy Mediator (385)
  • Reagowanie na zdarzenia DOM (386)
• Podsumowanie (387)

Rozdział 12. Wstrzykiwanie zależności (389)

• Wysyłanie poczty elektronicznej (390)
  
  • Wykorzystanie pakietu nodemailer (390)
  • Ustawienia konfiguracyjne (393)
  • Stosowanie lokalnego serwera SMTP (395)
  • Wstrzykiwanie zależności (396)
  • Wzorzec Lokalizacja usługi (396)
  • Lokalizacja usługi - antywzorzec (398)
  • Wstrzykiwanie zależności (399)
• Implementacja wstrzykiwania zależności (399)
  
  • Wyznaczanie interfejsów (399)
  • Wyznaczanie z użyciem typów wyliczeniowych (400)
  • Wyznaczanie nazwy klasy (401)
  • Wstrzykiwanie przy użyciu konstruktora (402)
• Wstrzykiwanie przy użyciu dekoratora (403)
  
  • Stosowanie definicji klasy (404)
  • Analiza parametrów konstruktora (405)
  • Określanie typów parametrów (406)
  • Wstrzykiwanie właściwości (407)
  • Stosowanie wstrzykiwania zależności (408)
  • Wstrzykiwanie rekurencyjne (409)
• Podsumowanie (410)

Rozdział 13. Tworzenie aplikacji (411)

• Interfejs użytkownika (412)
  
  • Stosowanie edytora Brackets (413)
  • Stosowanie rozszerzenia Emmet (415)
  • Tworzenie panelu logowania (417)
• Witryna korzystająca z frameworka Aurelia (419)
  
  • Kompilacja Node i frameworka Aurelia (420)
  • Udostępnianie aplikacji Aurelia (421)
  • Strony frameworka Aurelia w aplikacji Express (422)
  • Komponenty aplikacji Aurelia (424)
  • Przetwarzanie danych JSON (425)
  • Formularze we frameworku Aurelia (427)
  • Przesyłanie danych (430)
  • Stosowanie komunikatów we frameworku Aurelia (431)
• Witryna Angular 2 (434)
  
  • Konfiguracja Angular 2 (434)
  • Udostępnianie stron aplikacji Angular 2 (434)
  • Komponenty aplikacji Angular 2 (437)
  • Przetwarzanie danych JSON (440)
  • Przesyłanie danych do aplikacji (442)
• Witryna Express i React (443)
  
  • Express i React (443)
  • Udostępnianie aplikacji React (445)
  • Większa liczba plików package.json (447)
  • Komponenty React (448)
  • Korzystanie z punktów końcowych REST (451)
  • Komponent panelu logowania (452)
  • Wiązanie danych w aplikacji React (454)
  • Przesyłanie danych JSON w żądaniach POST (456)
• Podsumowanie (457)

Rozdział 14. Czas zakasać rękawy! (459)

• Aplikacja SurfDechy (460)
• Wyjściowa aplikacja Angular 2 (461)
  
  • Testy jednostkowe (463)
  • Testy implementacji wzorców projektowych (464)
  • Stan panelu logowania (468)
  • Integracja paneli (471)
  • Struktura danych JSON (474)
  • Komponent BoardList (476)
  • Testy jednostkowe żądań HTTP (477)
  • Wyświetlanie listy desek (483)
  • Testowanie zdarzeń interfejsu użytkownika (484)
  • Widok szczegółów deski (487)
  • Stosowanie filtra (489)
  • Panel logowania (492)
  • Architektura aplikacji (496)
• Podsumowanie (497)

Skorowidz (499)

• Titel: Język TypeScript. Tajniki kodu. Wydanie II
• Autor: Nathan Rozentals
• Originaler Titel: Mastering TypeScript - Second Edition
• Übersetzung: Piotr Rajca
• ISBN: 978-83-283-3642-1, 9788328336421
• Veröffentlichungsdatum: 2017-11-24
• Format: E-book
• Artikelkennung: jeztyp
• Verleger: Helion