Szczegóły ebooka

JavaScript. Programowanie zaawansowane

JavaScript. Programowanie zaawansowane

Tomasz "Comandeer" Jakut

Ebook

Zostań specem od JavaScriptu!

JavaScript to prawdopodobnie najpopularniejszy język skryptowy świata, a jego dobra znajomość otwiera wiele interesujących perspektyw zawodowych i ułatwia znalezienie świetnie płatnej pracy zarówno w kraju, jak i za granicą. Fachowcy od JS mogą wręcz przebierać w ofertach, najpierw jednak... muszą stać się fachowcami. Mimo że w internecie dostępnych jest bardzo wiele stron poświęconych temu językowi, a księgarskie półki aż uginają się od literatury informatycznej na jego temat, trudno znaleźć publikację, która wprowadzałaby w zaawansowane zagadnienia tworzenia kodu. Książka, którą właśnie trzymasz w ręku, rozwija te kwestie w sposób praktyczny i rzeczowy, poparty realnymi przykładami, na których można oprzeć głębszą wiedzę o JavaScripcie.

Zostań specjalistą! Z ta książką poznasz JavaScript od podszewki i zmierzysz się z ciekawymi wyzwaniami. Na podstawie praktycznych przykładów dowiesz się, jak zorganizować swoje środowisko pracy, podzielić projekt na odpowiednie moduły, napisać testy tworzonego kodu zgodnie z metodyką TDD, zbudować silnik selektorów, zadbać o szybkość działania swojego rozwiązania, właściwie obsłużyć zdarzenia DOM, opracować wydajne animacje, napisać dokumentację projektu i udostępnić go światu. Sporo? Pewnie, że tak – a w dodatku bez zadęcia, naturalnym językiem i przede wszystkim na temat!

  • Tworzenie wygodnego środowiska pracy
  • Podział projektu na moduły
  • Pisanie testów kodu JS
  • Tworzenie silnika selektorów
  • Łączenie własnych modułów z zewnętrznymi
  • Budowa asynchronicznego API dla DOM
  • Obsługa zdarzeń i animacji
  • Pisanie dokumentacji i publikacja modułu

Pora zrobić krok dalej i poznać zaawansowane techniki tworzenia kodu JS!

Wstęp (11)

Rozdział 1. Ale o co w ogóle chodzi? (13)

  • Nasz cel: BEMQuery (13)
    • BEM zamiast DOM (13)
    • Moduły i jeszcze raz moduły (14)
    • Najnowsza wersja JS-a (14)
    • Eksperymentowanie (14)
  • Ale zaraz, zaraz... Biblioteka, nie framework? (14)
  • Dlaczego ES6? (16)
    • Wsparcie przeglądarek (16)
    • Wsparcie ekosystemu i środowiska (17)
    • ECMAScript - żywy standard? (17)
  • BEM - ale właściwie co to takiego? (18)
    • Blok (18)
    • Element (19)
    • Modyfikator (19)
    • Konwencja nazewnicza (20)
  • Podsumowanie (22)

Rozdział 2. Tworzymy nasze środowisko pracy! (25)

  • Git + GitHub, czyli mamy wszystko pod kontrolą (25)
  • Node.js + npm (27)
    • Pierwszy skrypt w Node.js (28)
  • npm - a na co mi to? (29)
  • ESLint - czyli poznajemy trochę ECMAScript 6, wyrabiając sobie... styl (30)
    • ESLint? (31)
    • Nasz styl (31)
  • npm - "ogarniamy" prosty projekt! (39)
    • Tworzymy nowy projekt! (39)
    • Instalujemy ESLinta i chalk (41)
    • Tworzymy logger (42)
    • Skrypty npm (43)
    • Konfiguracja ESLinta (45)
  • Zadanie domowe (49)
  • Podsumowanie (49)

Rozdział 3. Wielki głaz czy małe kamyczki? Monolityczność vs modularność (51)

  • Stara, dobra era jQuery (51)
    • Duży głaz = większy rozmiar (52)
  • Wielki monolit = jeden moduł (53)
    • Jednowersjonowość, czyli kiepski neologizm w natarciu (53)
    • Łysiejący developerzy i znerwicowani maintainerzy (54)
    • Bo co jest do wszystkiego... (54)
  • Dzielimy BEMQuery! (55)
    • Silnik selektorów (55)
    • Trzon biblioteki (55)
    • Moduł DOM (56)
    • Moduł eventów (56)
    • Moduł animacji (56)
    • Bycze monstrum, czyli jak użytkownik spotkał developera (56)
    • Moduły a npm i GitHub (57)
  • Standardy modułów w JS-ie (58)
    • Moduł, czyli co? (59)
    • Wzorzec modułu (60)
    • Standard CJS (60)
    • Standard AMD (62)
    • Standard UMD (64)
    • Moduły ES6 (65)
  • Jak wczytać moduły ES6? (66)
    • jsnext:main (68)
    • Szybki test (69)
  • Zadanie domowe (69)
  • Podsumowanie (70)

Rozdział 4. TDD - najpierw testy, potem kod! (71)

  • Testy? (71)
  • Rodzaje testów (72)
  • TDD, czyli wywracamy wszystko do góry nogami (73)
  • Testowanie w JS-ie (74)
  • Karma (75)
  • Mocha (77)
  • Chai (80)
  • Sinon (81)
  • Test coverage (83)
  • Continuous Integration (84)
  • Zadanie domowe (85)
  • Podsumowanie (85)

Rozdział 5. Tworzymy idealny projekt modułu w JS-ie! (87)

  • Ściągamy boilerplate'a! (87)
  • Struktura katalogów projektu (89)
    • Katalog src (90)
    • Katalog tests (90)
    • Katalog config (90)
    • Katalog dist (91)
  • Zależności (92)
    • Narzędzia do testowania (93)
    • Narzędzia do budowania (93)
    • Narzędzia do publikacji (94)
    • Narzędzia do dokumentacji (94)
  • Skrypty npm (94)
  • Testowanie (95)
    • Konfiguracja (96)
  • Jak użyć boilerplate'a? (98)
    • Droga niegitowa (98)
    • Droga gitowa (98)
    • Aktualizacja boilerplate'a (101)
  • Zadanie domowe (102)
  • Podsumowanie (102)

Rozdział 6. Silnik selektorów (103)

  • Silnik selektorów - WTF? (103)
  • Rozwiązanie natywne (104)
  • Sizzle (106)
  • Selektory BEM (107)
  • Drzewko BEM (108)
  • Projektujemy silnik selektorów! (109)
    • SOLID (109)
    • Dzielimy silnik selektorów na części! (112)
  • Klasy?! (113)
  • Tworzymy klasę Selector! (117)
  • Konwerter selektorów (120)
    • Konfiguracja (121)
    • Konwertowanie selektorów (123)
    • Łączymy to do kupy! (127)
    • Piszemy sensowne regułki (130)
  • Zatem tworzymy silnik! (134)
    • Testy, testy (134)
    • Kod, kod (136)
  • Fabryka (139)
  • Eksporter (141)
  • Zadanie domowe (141)
  • Podsumowanie (142)

Rozdział 7. Worek na elementy (145)

  • "Podstawowa funkcjonalność" (145)
    • Zawsze zwracaj obiekt BEMQuery (146)
    • Bardziej intuicyjna metoda each (146)
  • Klasa BEMQuery (146)
    • Konstruktor (147)
    • Metoda get (147)
    • Metoda each (148)
  • Testy - znowu (148)
    • Mocki (148)
    • Fixtures (149)
    • Testy dla konstruktora (150)
  • Piszemy konstruktor! (152)
  • Iteratory (156)
    • Obiekty "iterowalne" (158)
    • Symbol - WTF?! (158)
    • Implementujemy iterator w BEMQuery! (158)
  • Metoda get (161)
  • Metoda each (162)
  • Fluent API (163)
  • Pseudotablica (163)
    • Niepotrzebnie udziwniony i utrudniony, ale dający respekt na dzielni (164)
    • Cholernie prostacki i prymitywny, z którego na dzielni się śmieją (164)
    • Udziwniony, utrudniony, bez respektu i bez śmiechu, ale całkiem, całkiem (164)
  • Fabryka (167)
  • Główny plik modułu (169)
  • Zadanie domowe (170)
  • Podsumowanie (171)

Rozdział 8. "Ma być szybko!", czyli operacje na DOM (173)

  • Co będziemy robić? (173)
  • Rozgrzewka (174)
  • Dlaczego DOM jest wolny? (175)
    • Obserwowanie zjawiska (177)
  • Wirtualny DOM (179)
    • BEM Tree jako wirtualny DOM? (180)
  • Incremental DOM (180)
  • Asynchroniczny DOM (180)
  • Obiecanki (182)
  • Piszemy nasz moduł! (186)
    • Batch (186)
    • Włączamy Batch do biblioteki (188)
    • Mocki (190)
    • Dobieramy się do stanów! (191)
    • Pokaż kotku, co masz w środku! (194)
    • Główny plik modułu (196)
    • Testujemy! (197)
  • Wild refactoring appears! (197)
  • Zadanie domowe (199)
  • Podsumowanie (200)

Rozdział 9. "PRZESTAŃ MNIE KLIKAĆ!", czyli o zdarzeniach słów kilka (201)

  • Co to właściwie są "zdarzenia DOM"? (201)
    • Listenery (201)
    • Obiekt Event (203)
    • Fazy propagacji zdarzenia (203)
    • Uruchamianie zdarzeń (209)
  • Piszemy moduł (210)
    • Metoda on (210)
    • Metoda off (215)
    • Plik modułu (221)
  • Zadanie domowe (221)
  • Podsumowanie (221)

Rozdział 10. "Coś mi się tu rusza" - o animacji słów kilka (223)

  • Po co nam animacje? (223)
  • Dlaczego animacje są wolne? (225)
    • Model RAIL (225)
  • Jak animować? (226)
    • Przykład (226)
    • Liczniki (227)
    • Optymalizacja CSS (228)
    • Porzucamy liczniki! (229)
    • Transitions (231)
    • Animacje (232)
    • Web Animations API (232)
    • SMIL (233)
    • Użycie "gotowca" (233)
  • Zadanie domowe (233)
  • Podsumowanie (234)

Rozdział 11. Piszemy dokumentację... (235)

  • Plik README.md (235)
  • Plik CHANGELOG.md (236)
  • Plik CONTRIBUTING.md (237)
  • Pliki w katalogu .github (237)
  • Plik LICENSE (238)
  • Plik tonic-example.js (238)
  • Metadane w pliku package.json (239)
  • Dokumentacja kodu JS (239)
    • Generowanie dokumentacji (241)
    • Publikowanie dokumentacji (241)
  • Zadanie domowe (242)
  • Podsumowanie (242)

Rozdział 12. Rozprowadzamy ten towar... (243)

  • Publikacja modułu na npm (243)
    • Podbicie numeru wersji wraz z publikacją jej na GitHubie (244)
    • Publikacja pakietu na npm (245)
    • Budowanie? (246)
  • Piszemy moduł bemquery (248)
  • Szybki test (249)
  • Jak używać? (249)
  • Zadanie domowe (250)
  • Podsumowanie (250)

Podziękowania (253)

Skorowidz (254)

  • Tytuł: JavaScript. Programowanie zaawansowane
  • Autor: Tomasz "Comandeer" Jakut
  • ISBN: 978-83-283-3116-7, 9788328331167
  • Data wydania: 2016-09-11
  • Format: Ebook
  • Identyfikator pozycji: jascpz
  • Wydawca: Helion