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

Język TypeScript. Tajniki kodu. Wydanie II Język: 1

978-83-283-3641-4

Cena Brutto: 89.00

Cena netto: 84.76

Ilość:
Wersja: Drukowana
Autor Nathan Rozentals
Liczba_stron 504
Wydawnictwo Helion
Oprawa miękka
Data_Wydania 2017-11-24

Język

TypeScript

Tajniki kodu. Wydanie II



Język TypeScript, który wraz z kompilatorem i zestawem narzędzi jest udostępniany na zasadach open source, zyskuje ogromne uznanie tysięcy projektantów aplikacji. TypeScript pozwala na pracę w zgodzie ze standardami języka JavaScript (ES5, ES6 i ES7), co pozwala programistom na używanie klas, interfejsów, typów ogólnych itd. Okazuje się, że TypeScript umożliwia tworzenie solidnych aplikacji przy wykorzystaniu technik obiektowych — i są to nie tylko aplikacje WWW, lecz także aplikacje serwerowe, aplikacje dla urządzeń mobilnych, a nawet oprogramowanie do sterowania urządzeniami w internecie rzeczy (IoT).


Niniejsza książka jest przewodnikiem po TypeScript dla programistów. Przedstawiono tu zarówno podstawy, jak i zaawansowane możliwości języka, takie jak typy ogólne i techniki programowania asynchronicznego. Sporo miejsca poświęcono prezentacji najpopularniejszych frameworków JavaScript. Opisano sposoby korzystania z mechanizmów ścisłej kontroli typów i omówiono techniki programowania obiektowego w języku TypeScript. Nie zabrakło również wskazówek dotyczących najlepszych praktyk projektowania aplikacji. Dzięki lekturze tej książki osiągnięcie profesjonalnego poziomu pisania aplikacji w TypeScript stanie się o wiele łatwiejsze!

Najważniejsze zagadnienia:

  • składnia języka TypeScript: podstawy i zagadnienia zaawansowane
  • środowisko pracy: kompilator, narzędzia, frameworki
  • tworzenie plików deklaracji i korzystanie z bibliotek
  • programowanie oparte na testach
  • modularyzacja i programowanie zorientowane obiektowo w TypeScript
  • podstawowe elementy konstrukcyjne aplikacji internetowych

    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)

powrót
 
Produkty Podobne
Python dla profesjonalistów. Debugowanie, testowanie i utrzymywanie kodu
Adaptywny kod. Zwinne programowanie, wzorce projektowe i SOLID-ne zasady. Wydanie II
Ciągłe dostarczanie oprogramowania. Kompletny przewodnik
Język R. Kompletny zestaw narzędzi dla analityków danych
Programowanie zorientowane obiektowo w języku JavaScript. Wydanie III
Tablice informatyczne. Bootstrap
Angular 2. Programowanie z użyciem języka TypeScript
Język TypeScript. Tajniki kodu. Wydanie II
Python. Uczenie maszynowe
Programming the Microsoft Bot Framework: A Multiplatform Approach to Building Chatbots
Więcej produktów