reklama - zainteresowany?

Język TypeScript. Tajniki kodu. Wydanie II - Helion


ebook
Autor: Nathan Rozentals
Tytuł oryginału: Mastering TypeScript - Second Edition
Tłumaczenie: Piotr Rajca
ISBN: 978-83-283-3642-1
stron: 504, Format: ebook
Data wydania: 2017-11-24
Księgarnia: Helion

Cena książki: 71,20 zł (poprzednio: 87,90 zł)
Oszczędzasz: 19% (-16,70 zł)

Dodaj do koszyka

Tagi: JavaScript - Programowanie

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

TypeScript: poznaj język najlepszych projektantów!


Nathan Rozentals — może pochwalić się imponującym doświadczeniem w kodowaniu: tworzył programy do analizy statystycznej na komputerach mainframe na długo przed erą internetu. Brał również udział w rozwiązywaniu tzw. problemu roku 2000. Perfekcyjnie poznał wiele obiektowych języków programowania, takich jak C++, Java czy C#. Ostatnio skoncentrował się na nowoczesnym programowaniu aplikacji internetowych, a język TypeScript okazał się jego ulubionym narzędziem. W chwilach wolnych od programowania zajmuje się windsurfingiem lub piłką nożną.

Dodaj do koszyka

 

Osoby które kupowały "Język TypeScript. Tajniki kodu. Wydanie II", wybierały także:

  • Unreal Engine. Nauka pisania gier dla kreatywnych
  • JavaScript. Programowanie zaawansowane
  • HTML5. Tworzenie gier z wykorzystaniem CSS i JavaScript

Dodaj do koszyka

Spis treści

Język TypeScript. Tajniki kodu. Wydanie II eBook -- spis treści

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)

Dodaj do koszyka

Code, Publish & WebDesing by CATALIST.com.pl



(c) 2005-2020 CATALIST agencja interaktywna, znaki firmowe należą do wydawnictwa Helion S.A.