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 \ JavaScript

ECMAScript 6. Przewodnik po nowym standardzie języka JavaScript Język: 1

978-83-283-3403-8

Cena Brutto: 67.00

Cena netto: 63.81

Ilość:
Wersja: Drukowana
Autor Nicholas C. Zakas
Liczba_stron 321
Wydawnictwo Helion
Oprawa miękka
Data_Wydania 2017-08-04

ECMAScript 6

Przewodnik po nowym standardzie języka JavaScript



Najnowsza specyfikacja języka JavaScript ECMAScript 6 — jest najważniejszym uaktualnieniem w dotychczasowej historii tego języka. Jej Zrozumienie specyfikacji ECMAScript 6 ma kluczowe znaczenie dla wszystkich programistów JavaScript. Tworzy ona solidny fundament i to właśnie na nim będą budowane wszystkie aplikacje JavaScriptu w przyszłości.

Oto podręcznik przeznaczony dla średnio zaawansowanych i zaawansowanych programistów JavaScriptu, którzy korzystają ze środowiska przeglądarki WWW lub Node.js. Omówiono tu zagadnienia wiązania bloków, ciągów tekstowych, wyrażeń regularnych, a także zmiany wprowadzone w funkcjach. Przedstawiono pełne wprowadzenie do typów obiektów oraz składni, które pojawiły się w JavaScripcie wraz ze specyfikacją ECMAScript 6. Nie zabrakło przykładów kodu działającego w dowolnym środowisku JavaScriptu. Dodatkowo zaprezentowano zmiany wprowadzone wraz z nowym standardem ECMAScript 7 (2016).

W tej książce omówiono między innymi:
  • natywne tablice JavaScriptu i ich nowe możliwości
  • obietnice i programowanie asynchroniczne
  • API refleksji
  • wykorzystanie proxy do kontroli obiektów
  • hermetyzację kodu za pomocą modułów

    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)

powrót
 
Produkty Podobne
ECMAScript 6. Przewodnik po nowym standardzie języka JavaScript
Programowanie funkcyjne z JavaScriptem. Sposoby na lepszy kod
JavaScript i wzorce projektowe. Programowanie dla zaawansowanych. Wydanie II
Mistrzowski JavaScript. Programowanie zorientowane obiektowo
JavaScript. Przewodnik dla absolutnie początkujących
Refactoring JavaScript
React dla zaawansowanych
Learning Node.js: A Hands-On Guide to Building Web Applications in JavaScript, 2nd Edition
HTML, CSS i JavaScript dla każdego. Wydanie VII
Node.js for Embedded Systems
Więcej produktów