O autorze (11)

Wstęp (13)

Wprowadzenie (15)

• Droga do ECMAScript 6 (15)
• O tej książce (16)
  
  • Zgodność przeglądarki WWW i Node.js (17)
  • Dla kogo przeznaczona jest ta książka? (17)
  • Ogólne omówienie zawartości książki (17)
  • Konwencje typograficzne użyte w książce (19)
  • Pomoc i wsparcie (20)

1. Wiązanie bloków (21)

• Deklaracje var i hoisting (21)
• Deklaracje na poziomie bloku (23)
  
  • Deklaracje let (23)
  • Brak możliwości ponownej deklaracji (24)
  • Deklaracja const (25)
  • Tymczasowo martwa strefa (27)
• Wiązanie bloku w pętli (28)
  
  • Funkcja w pętli (29)
  • Deklaracja let w pętli (30)
  • Deklaracja const w pętli (31)
• Wiązanie bloku globalnego (32)
• Zastosowanie najlepszych praktyk dotyczących wiązania bloku (33)
• Podsumowanie (34)

2. Ciągi tekstowe i wyrażenia regularne (35)

• Lepsza obsługa Unicode (35)
  
  • Punkty kodowe UTF-16 (36)
  • Metoda codePointAt() (37)
  • Metoda String.fromCodePoint() (38)
  • Metoda normalize() (38)
  • Opcja u dla wyrażeń regularnych (40)
• Inne zmiany dotyczące ciągu tekstowego (42)
  
  • Metody przeznaczone do identyfikacji podciągów tekstowych (42)
  • Metoda repeat() (44)
• Zmiany wprowadzone w wyrażeniach regularnych (45)
  
  • Opcja y w wyrażeniach regularnych (45)
  • Powielanie wyrażenia regularnego (48)
  • Właściwość flags (49)
• Szablony literałów (50)
  
  • Składnia podstawowa (50)
  • Wielowierszowy ciąg tekstowy (51)
  • Zastępowanie ciągu tekstowego (53)
  • Szablony wraz z tagami (54)
• Podsumowanie (58)

3. Funkcje (59)

• Funkcje wraz z wartościami parametrów domyślnych (59)
  
  • Symulowanie wartości parametrów domyślnych w ECMAScript 5 (60)
  • Wartości parametrów domyślnych w ECMAScript 6 (61)
  • Jaki wpływ na argumenty Object mają wartości parametrów domyślnych? (62)
  • Wyrażenia parametru domyślnego (64)
  • Parametr domyślny i koncepcja TDZ (66)
• Praca z nienazwanymi parametrami (68)
  
  • Nienazwane parametry w ECMAScript 5 (68)
  • Parametry resztowe (69)
• Zwiększone możliwości konstruktora Function (72)
• Operator rozszczepiania (72)
• Właściwość name (74)
  
  • Wybór odpowiedniej nazwy (74)
  • Przypadki specjalne dotyczące właściwości name (75)
• Wyjaśnienie podwójnego przeznaczenia funkcji (76)
  
  • Ustalenie, jak funkcja była wywoływana w ECMAScript 5 (77)
  • Metawłaściwość new.target (78)
• Funkcje na poziomie bloku (79)
  
  • Ustalenie, kiedy należy używać funkcji na poziomie bloku (80)
  • Funkcje na poziomie bloku w trybie nieścisłym (81)
• Funkcja strzałki (81)
  
  • Składnia funkcji strzałki (82)
  • Utworzenie natychmiast wykonywanego wyrażenia funkcji (84)
  • Brak wiązania this (85)
  • Funkcja strzałki i tablica (88)
  • Brak wiązania arguments (88)
  • Identyfikacja funkcji strzałki (88)
• Optymalizacja wywołania ogonowego (89)
  
  • Co nowego w wywołaniu ogonowym w specyfikacji ECMAScript 6? (90)
  • Jak okiełznać optymalizację wywołania ogonowego? (92)
• Podsumowanie (93)

4. Rozbudowana funkcjonalność obiektu (95)

• Kategorie obiektu (95)
• Rozszerzenia składni literału obiektu (96)
  
  • Skrót inicjalizacji właściwości (96)
  • Zwięzłe metody (97)
  • Generowane nazwy właściwości (98)
• Nowe metody (100)
  
  • Metoda Object.is() (100)
  • Metoda Object.assign() (101)
• Powielenie właściwości literału obiektu (103)
• Kolejność właściwości typu wyliczeniowego (104)
• Usprawnienia dla prototypów (105)
  
  • Zmiana prototypu obiektu (105)
  • Łatwy dostęp do prototypu za pomocą odwołania super (107)
• Formalna definicja metody (110)
• Podsumowanie (111)

5. Destrukturyzacja w celu łatwiejszego dostępu do danych (113)

• Dlaczego destrukturyzacja może być użyteczna? (113)
• Destrukturyzacja obiektu (114)
  
  • Destrukturyzacja przypisania (115)
  • Wartości domyślne (116)
  • Przypisanie do różnych nazw zmiennych lokalnych (117)
  • Destrukturyzacja zagnieżdżonego obiektu (118)
• Destrukturyzacja tablicy (120)
  
  • Destrukturyzacja przypisania (121)
  • Wartości domyślne (123)
  • Destrukturyzacja zagnieżdżonej tablicy (123)
  • Elementy resztowe (123)
• Destrukturyzacja mieszana (125)
• Destrukturyzacja parametrów (125)
  
  • Destrukturyzowane parametry są wymagane (127)
  • Wartości domyślne dla destrukturyzowanych parametrów (128)
• Podsumowanie (128)

6. Symbole i ich właściwości (131)

• Utworzenie symbolu (132)
• Użycie symbolu (133)
• Współdzielenie symboli (134)
• Koercja symbolu (135)
• Pobieranie właściwości symbolu (136)
• Udostępnienie wewnętrznych operacji za pomocą powszechnie znanych symboli (137)
  
  • Metoda Symbol.hasInstance (138)
  • Właściwość Symbol.isConcatSpreadable (140)
  • Właściwości Symbol.match, Symbol.replace, Symbol.search i Symbol.split (142)
  • Metoda Symbol.toPrimitive (144)
  • Właściwość Symbol.toStringTag (146)
  • Właściwość Symbol.unscopables (150)
• Podsumowanie (151)

7. Zbiory i mapy (153)

• Zbiory i mapy w ECMAScript 5 (154)
• Problemy związane z obejściami (155)
• Zbiory w specyfikacji ECMAScript 6 (156)
  
  • Utworzenie zbioru i dodanie do niego elementów (156)
  • Usunięcie elementu ze zbioru (158)
  • Metoda forEach() dla zbioru (159)
  • Konwersja zbioru na postać tablicy (161)
  • Słaby zbiór (162)
• Mapy w specyfikacji ECMAScript 6 (164)
  
  • Metody mapy (165)
  • Inicjalizacja mapy (166)
  • Metoda forEach() dla mapy (167)
  • Słabe mapy (168)
• Podsumowanie (172)

8. Iteratory i generatory (175)

• Problem związany z pętlą (175)
• Czym jest iterator? (176)
• Czym jest generator? (177)
  
  • Wyrażenie funkcji generatora (179)
  • Metody obiektu generatora (180)
• Pętla for-of i elementy poddające się iteracji (181)
  
  • Uzyskanie dostępu do domyślnego iteratora (182)
  • Utworzenie obiektu poddającego się iteracji (183)
• Wbudowane iteratory (184)
  
  • Iteratory kolekcji (184)
  • Iteratory ciągu tekstowego (189)
  • Iteratory NodeList (190)
• Operator rozszczepiania i niebędące tablicami elementy poddające się iteracji (191)
• Zaawansowana funkcjonalność iteratorów (192)
  
  • Przekazanie argumentów do iteratora (192)
  • Zgłaszanie błędu w iteratorze (194)
  • Polecenie return w generatorze (196)
  • Delegowanie generatora (197)
• Asynchroniczne wykonywanie zadania (199)
  
  • Wykonywanie prostych zadań (200)
  • Wykonanie zadania wraz z danymi (201)
  • Asynchroniczne wykonywanie zadań (202)
• Podsumowanie (205)

9. Wprowadzenie do klas JavaScript (207)

• Przypominające klasy struktury w ECMAScript 5 (208)
• Deklaracja klasy (208)
  
  • Podstawowa deklaracja klasy (208)
  • Dlaczego należy używać składni klasy? (210)
• Wyrażenia klasy (212)
  
  • Podstawowe wyrażenie klasy (212)
  • Wyrażenia nazwanych klas (213)
• Klasa jako typ pierwszoklasowy (214)
• Właściwości akcesora (216)
• Generowane nazwy elementów składowych (217)
• Metody generatora (218)
• Statyczne elementy składowe (220)
• Dziedziczenie z użyciem klas pochodnych (221)
  
  • Przesłanianie metod klasy (224)
  • Dziedziczone statyczne elementy składowe (224)
  • Klasy pochodne na podstawie wyrażeń (225)
  • Dziedziczenie po wbudowanych klasach (228)
  • Właściwość Symbol.species (229)
• Użycie właściwości new.target w konstruktorze klasy (232)
• Podsumowanie (234)

10. Usprawnione możliwości tablicy (237)

• Tworzenie tablicy (237)
  
  • Metoda Array.of() (238)
  • Metoda Array.from() (239)
• Nowe metody we wszystkich tablicach (243)
  
  • Metody find() i findIndex() (243)
  • Metoda fill() (244)
  • Metoda copyWithin() (245)
• Typowane tablice (246)
  
  • Liczbowe typy danych (246)
  • Bufor tablicy (247)
  • Przeprowadzanie operacji na buforze tablicy za pomocą widoku (248)
• Podobieństwa między tablicami typowanymi i zwykłymi (255)
  
  • Metody używane w obu typach tablic (256)
  • Te same iteratory (256)
  • Metody of() i from() (257)
• Różnice między tablicami typowaną i zwykłą (257)
  
  • Różnice behawioralne (258)
  • Brakujące metody (259)
  • Metody dodatkowe (259)
• Podsumowanie (260)

11. Obietnice i programowanie asynchroniczne (263)

• Kontekst programowania asynchronicznego (264)
  
  • Model zdarzeń (264)
  • Wzorzec wywołania zwrotnego (265)
• Podstawy obietnic (267)
  
  • Cykl życiowy obietnicy (268)
  • Tworzenie nierozstrzygniętej obietnicy (270)
  • Utworzenie spełnionej obietnicy (273)
  • Błędy funkcji executor (275)
• Globalna procedura obsługi odrzucenia obietnicy (276)
  
  • Obsługa odrzucenia obietnicy w Node.js (277)
  • Obsługa odrzucenia obietnicy w przeglądarce WWW (279)
• Łączenie obietnic (281)
  
  • Przechwytywanie błędów (282)
  • Wartość zwrotna w łańcuchu obietnic (283)
  • Zwrot obietnicy przez łańcuch obietnic (284)
• Udzielanie odpowiedzi wielu obietnicom (287)
  
  • Metoda Promise.all() (287)
  • Metoda Promise.race() (288)
• Dziedziczenie po obietnicach (289)
• Asynchroniczne wykonywanie zadania za pomocą obietnicy (291)
• Podsumowanie (295)

12. Proxy i API refleksji (297)

• Problem tablicy (298)
• Wprowadzenie proxy i refleksji (298)
• Utworzenie prostego proxy (300)
• Weryfikacja właściwości za pomocą pułapki set (300)
• Weryfikacja kształtu obiektu za pomocą pułapki get (302)
• Ukrycie istnienia właściwości za pomocą pułapki has (304)
• Uniemożliwienie usunięcia właściwości za pomocą pułapki deleteProperty (305)
• Pułapki prototypu proxy (307)
  
  • Jak działają pułapki prototypu proxy? (308)
  • Dlaczego mamy dwa zbiory metod? (309)
• Pułapki związane z rozbudową obiektu (311)
  
  • Dwa proste przykłady (311)
  • Powielone metody związane z rozbudową obiektów (312)
• Pułapki deskryptora właściwości (313)
  
  • Blokowanie Object.defineProperty() (314)
  • Ograniczenia deskryptora obiektu (315)
  • Powielone metody deskryptora (316)
• Pułapka ownKeys (318)
• Funkcje proxy używane podczas konstruowania i stosowania pułapek (319)
  
  • Weryfikacja parametrów funkcji (320)
  • Wywołanie konstruktora bez operatora new (322)
  • Nadpisanie konstruktora abstrakcyjnej klasy bazowej (323)
  • Możliwy do wywołania konstruktor klasy (325)
• Proxy możliwe do odwołania (326)
• Rozwiązanie problemu tablicy (327)
  
  • Wykrywanie indeksu tablicy (328)
  • Zwiększenie wielkości po dodaniu nowego elementu (328)
  • Usuwanie elementów po zmniejszeniu wartości właściwości length (330)
  • Implementacja klasy MyArray (332)
• Użycie proxy jako prototypu (334)
  
  • Użycie pułapki get w prototypie (335)
  • Użycie pułapki set w prototypie (336)
  • Użycie pułapki has w prototypie (337)
  • Proxy jako prototyp w klasie (338)
• Podsumowanie (341)

13. Hermetyzacja kodu za pomocą modułów (343)

• Co to jest moduł? (344)
• Podstawowe operacje eksportu (344)
• Podstawowe operacje importu (345)
  
  • Import pojedynczego wiązania (346)
  • Import wielu wiązań (346)
  • Import całego modułu (347)
  • Drobne dziwactwo zaimportowanych wiązań (348)
• Zmiana nazwy elementu podczas eksportu i importu (349)
• Wartość domyślna w module (350)
  
  • Eksport wartości domyślnej (350)
  • Import wartości domyślnej (351)
• Ponowny eksport wiązania (352)
• Import bez wiązań (353)
• Wczytywanie modułu (354)
  
  • Użycie modułu w przeglądarce WWW (354)
  • Określanie specyfikatora modułu w przeglądarce WWW (359)
• Podsumowanie (360)

A. Mniejsze zmiany w ECMAScript 6 (361)

• Praca z liczbami całkowitymi (361)
  
  • Identyfikacja liczby całkowitej (362)
  • Bezpieczne liczby całkowite (362)
• Nowe metody obiektu Math (363)
• Identyfikatory Unicode (364)
• Formalizacja właściwości __proto__ (365)

B. Poznajemy ECMAScript 7 (2016) (369)

• Operator wykładniczy (370)
  
  • Kolejność operacji (370)
  • Ograniczenie operandu (370)
• Metoda Array.prototype.includes() (371)
  
  • Jak używać metody Array.prototype.includes()? (372)
  • Porównywanie wartości (372)
• Zmiana w trybie ścisłym o zasięgu funkcji (373)

Skorowidz (375)

• Tytuł: ECMAScript 6. Przewodnik po nowym standardzie języka JavaScript
• Autor: Nicholas C. Zakas
• Tytuł oryginału: Understanding ECMAScript 6: The Definitive Guide for JavaScript Developers
• Tłumaczenie: Robert Górczyński
• ISBN: 978-83-283-3404-5, 9788328334045
• Data wydania: 2017-08-02
• Format: Ebook
• Identyfikator pozycji: ecmasc
• Wydawca: Helion