Wstęp (11)

1. Wprowadzenie (15)

• Wzorce (15)
  
• JavaScript - podstawowe cechy (16)
  
  • Zorientowany obiektowo (16)
  • Brak klas (17)
  • Prototypy (18)
  • Środowisko (18)
• ECMAScript 5 (18)
  
  • Narzędzie JSLint (19)
  • Konsola (20)

2. Podstawy (21)

• Tworzenie kodu łatwego w konserwacji (21)
  
• Minimalizacja liczby zmiennych globalnych (22)
  
  • Problem ze zmiennymi globalnymi (22)
  • Efekty uboczne pominięcia var (24)
  • Dostęp do obiektu globalnego (25)
  • Wzorzec pojedynczego var (25)
  • Przenoszenie deklaracji - problem rozrzuconych deklaracji var (26)
• Pętle for (27)
  
• Pętle for-in (29)
  
• Modyfikacja wbudowanych prototypów (31)
  
• Wzorzec konstrukcji switch (31)
  
• Unikanie niejawnego rzutowania (32)
  
• Unikanie eval() (32)
  
• Konwertowanie liczb funkcją parseInt() (34)
  
• Konwencje dotyczące kodu (34)
  
  • Wcięcia (35)
  • Nawiasy klamrowe (35)
  • Położenie nawiasu otwierającego (36)
  • Białe spacje (37)
• Konwencje nazewnictwa (38)
  
  • Konstruktory pisane od wielkiej litery (38)
  • Oddzielanie wyrazów (39)
  • Inne wzorce nazewnictwa (39)
• Pisanie komentarzy (40)
  
• Pisanie dokumentacji interfejsów programistycznych (41)
  
  • Przykład dokumentacji YUIDoc (42)
• Pisanie w sposób ułatwiający czytanie (44)
  
• Ocenianie kodu przez innych członków zespołu (45)
  
• Minifikowanie kodu tylko w systemie produkcyjnym (46)
  
• Uruchamiaj narzędzie JSLint (47)
  
• Podsumowanie (47)

3. Literały i konstruktory (49)

• Literał obiektu (49)
  
  • Składnia literału obiektowego (50)
  • Obiekty z konstruktora (51)
  • Pułapka konstruktora Object (51)
• Własne funkcje konstruujące (52)
  
  • Wartość zwracana przez konstruktor (53)
• Wzorce wymuszania użycia new (54)
  
  • Konwencja nazewnictwa (54)
  • Użycie that (54)
  • Samowywołujący się konstruktor (55)
• Literał tablicy (56)
  
  • Składnia literału tablicy (56)
  • Pułapka konstruktora Array (56)
  • Sprawdzanie, czy obiekt jest tablicą (57)
• JSON (58)
  
  • Korzystanie z formatu JSON (58)
• Literał wyrażenia regularnego (59)
  
  • Składnia literałowego wyrażenia regularnego (60)
• Otoczki typów prostych (61)
  
• Obiekty błędów (62)
  
• Podsumowanie (63)

4. Funkcje (65)

• Informacje ogólne (65)
  
  • Stosowana terminologia (66)
  • Deklaracje kontra wyrażenia - nazwy i przenoszenie na początek (67)
  • Właściwość name funkcji (68)
  • Przenoszenie deklaracji funkcji (68)
• Wzorzec wywołania zwrotnego (70)
  
  • Przykład wywołania zwrotnego (70)
  • Wywołania zwrotne a zakres zmiennych (72)
  • Funkcje obsługi zdarzeń asynchronicznych (73)
  • Funkcje czasowe (73)
  • Wywołania zwrotne w bibliotekach (74)
• Zwracanie funkcji (74)
  
• Samodefiniujące się funkcje (75)
  
• Funkcje natychmiastowe (76)
  
  • Parametry funkcji natychmiastowych (77)
  • Wartości zwracane przez funkcje natychmiastowe (77)
  • Zalety i zastosowanie (79)
• Natychmiastowa inicjalizacja obiektu (79)
  
• Usuwanie warunkowych wersji kodu (80)
  
• Właściwości funkcji - wzorzec zapamiętywania (82)
  
• Obiekty konfiguracyjne (83)
  
• Rozwijanie funkcji (84)
  
  • Aplikacja funkcji (84)
  • Aplikacja częściowa (85)
  • Rozwijanie funkcji (87)
  • Kiedy używać aplikacji częściowej (89)
• Podsumowanie (89)

5. Wzorce tworzenia obiektów (91)

• Wzorzec przestrzeni nazw (91)
  
  • Funkcja przestrzeni nazw ogólnego stosowania (92)
• Deklarowanie zależności (94)
  
• Metody i właściwości prywatne (95)
  
  • Składowe prywatne (96)
  • Metody uprzywilejowane (96)
  • Problemy z prywatnością (96)
  • Literały obiektów a prywatność (98)
  • Prototypy a prywatność (98)
  • Udostępnianie funkcji prywatnych jako metod publicznych (99)
• Wzorzec modułu (100)
  
  • Odkrywczy wzorzec modułu (102)
  • Moduły, które tworzą konstruktory (102)
  • Import zmiennych globalnych do modułu (103)
• Wzorzec piaskownicy (103)
  
  • Globalny konstruktor (104)
  • Dodawanie modułów (105)
  • Implementacja konstruktora (106)
• Składowe statyczne (107)
  
  • Publiczne składowe statyczne (107)
  • Prywatne składowe statyczne (109)
• Stałe obiektów (110)
  
• Wzorzec łańcucha wywołań (112)
  
  • Wady i zalety wzorca łańcucha wywołań (112)
• Metoda method() (113)
  
• Podsumowanie (114)

6. Wzorce wielokrotnego użycia kodu (115)

• Klasyczne i nowoczesne wzorce dziedziczenia (115)
  
• Oczekiwane wyniki w przypadku stosowania wzorca klasycznego (116)
  
• Pierwszy wzorzec klasyczny - wzorzec domyślny (117)
  
  • Podążanie wzdłuż łańcucha prototypów (117)
  • Wady wzorca numer jeden (119)
• Drugi wzorzec klasyczny - pożyczanie konstruktora (119)
  
  • Łańcuch prototypów (120)
  • Dziedziczenie wielobazowe przy użyciu pożyczania konstruktorów (121)
  • Zalety i wady wzorca pożyczania konstruktora (122)
• Trzeci wzorzec klasyczny - pożyczanie i ustawianie prototypu (122)
  
• Czwarty wzorzec klasyczny - współdzielenie prototypu (123)
  
• Piąty wzorzec klasyczny - konstruktor tymczasowy (124)
  
  • Zapamiętywanie klasy nadrzędnej (125)
  • Czyszczenie referencji na konstruktor (125)
• Podejście klasowe (126)
  
• Dziedziczenie prototypowe (129)
  
  • Dyskusja (129)
  • Dodatki do standardu ECMAScript 5 (130)
• Dziedziczenie przez kopiowanie właściwości (131)
  
• Wzorzec wmieszania (132)
  
• Pożyczanie metod (133)
  
  • Przykład - pożyczenie metody od obiektu Array (134)
  • Pożyczenie i przypisanie (134)
  • Metoda Function.prototype.bind() (135)
• Podsumowanie (136)

7. Wzorce projektowe (137)

• Singleton (137)
  
  • Użycie słowa kluczowego new (138)
  • Instancja we właściwości statycznej (139)
  • Instancja w domknięciu (139)
• Fabryka (141)
  
  • Wbudowane fabryki obiektów (143)
• Iterator (143)
  
• Dekorator (145)
  
  • Sposób użycia (145)
  • Implementacja (146)
  • Implementacja wykorzystująca listę (148)
• Strategia (149)
  
  • Przykład walidacji danych (150)
• Fasada (152)
  
• Pośrednik (153)
  
  • Przykład (153)
  • Pośrednik jako pamięć podręczna (159)
• Mediator (160)
  
  • Przykład mediatora (160)
• Obserwator (163)
  
  • Pierwszy przykład - subskrypcja magazynu (163)
  • Drugi przykład - gra w naciskanie klawiszy (166)
• Podsumowanie (169)

8. DOM i wzorce dotyczące przeglądarek (171)

• Podział zadań (171)
  
• Skrypty wykorzystujące DOM (172)
  
  • Dostęp do DOM (173)
  • Modyfikacja DOM (174)
• Zdarzenia (175)
  
  • Obsługa zdarzeń (175)
  • Delegacja zdarzeń (177)
• Długo działające skrypty (178)
  
  • Funkcja setTimeout() (178)
  • Skrypty obliczeniowe (179)
• Komunikacja z serwerem (179)
  
  • Obiekt XMLHttpRequest (180)
  • JSONP (181)
  • Ramki i wywołania jako obrazy (184)
• Serwowanie kodu JavaScript klientom (184)
  
  • Łączenie skryptów (184)
  • Minifikacja i kompresja (185)
  • Nagłówek Expires (185)
  • Wykorzystanie CDN (186)
• Strategie wczytywania skryptów (186)
  
  • Lokalizacja elementu <script> (187)
  • Wysyłanie pliku HTML fragmentami (188)
  • Dynamiczne elementy <script> zapewniające nieblokujące pobieranie (189)
  • Wczytywanie leniwe (190)
  • Wczytywanie na żądanie (191)
  • Wstępne wczytywanie kodu JavaScript (192)
• Podsumowanie (194)

Skorowidz (195)

• Tytuł: JavaScript. Wzorce
• Autor: Stoyan Stefanov
• Tytuł oryginału: JavaScript Patterns
• Tłumaczenie: Rafał Jońca
• ISBN: 978-83-246-5034-7, 9788324650347
• Data wydania: 2012-04-26
• Format: Ebook
• Identyfikator pozycji: jascwz
• Wydawca: Helion