Przedmowa (9)

Podziękowania (11)

O książce (13)

O autorach (19)

CZĘŚĆ I. PRZYGOTOWANIE DO TRENINGU (21)

Rozdział 1. Zostań wojownikiem (23)

• 1.1. Omawiane biblioteki języka JavaScript (24)
• 1.2. Język JavaScript (25)
• 1.3. Kwestie dotyczące obsługi wielu przeglądarek (26)
• 1.4. Najlepsze obecnie praktyki (30)
  
  • 1.4.1. Najlepsze obecnie praktyki - testowanie (30)
  • 1.4.2. Najlepsze obecnie praktyki - analizowanie wydajności (31)
• 1.5. Podsumowanie (32)

Rozdział 2. Broń w postaci testowania i debugowania (33)

• 2.1. Debugowanie kodu (34)
  
  • 2.1.1. Rejestrowanie (34)
  • 2.1.2. Punkty wstrzymania (36)
• 2.2. Generowanie testu (38)
• 2.3. Środowiska testowania (40)
  
  • 2.3.1. QUnit (43)
  • 2.3.2. YUI Test (43)
  • 2.3.3. JsUnit (43)
  • 2.3.4. Nowsze środowiska testów jednostkowych (43)
• 2.4. Fundamenty pakietu testów (44)
  
  • 2.4.1. Asercja (44)
  • 2.4.2. Grupy testów (45)
  • 2.4.3. Testowanie asynchroniczne (47)
• 2.5. Podsumowanie (49)

CZĘŚĆ II. TRENING UCZNIA (51)

Rozdział 3. Funkcje są najważniejsze (53)

• 3.1. Na czym polega funkcyjność? (54)
  
  • 3.1.1. Dlaczego ważna jest funkcyjna natura języka JavaScript? (55)
  • 3.1.2. Sortowanie za pomocą komparatora (60)
• 3.2. Deklaracje (63)
  
  • 3.2.1. Określanie zasięgu i funkcje (66)
• 3.3. Wywołania (71)
  
  • 3.3.1. Od argumentów do parametrów funkcji (72)
  • 3.3.2. Wywołanie funkcji jako funkcji (73)
  • 3.3.3. Wywołanie funkcji jako metody (74)
  • 3.3.4. Wywołanie funkcji jako konstruktora (77)
  • 3.3.5. Wywołanie za pomocą metod apply() i call() (80)
• 3.4. Podsumowanie (84)

Rozdział 4. Posługiwanie się funkcjami (87)

• 4.1. Funkcje anonimowe (88)
• 4.2. Rekurencja (90)
  
  • 4.2.1. Rekurencja w funkcjach z nazwą (90)
  • 4.2.2. Rekurencja z metodami (92)
  • 4.2.3. Problem z podkradanym odwołaniem (93)
  • 4.2.4. Wstawiane funkcje z nazwą (95)
  • 4.2.5. Właściwość callee (97)
• 4.3. Używanie funkcji jako obiektów (98)
  
  • 4.3.1. Przechowywanie funkcji (99)
  • 4.3.2. Funkcje z automatycznym zapamiętywaniem (100)
  • 4.3.3. Oszukiwanie metod tablicowych (103)
• 4.4. Listy argumentów o zmiennej długości (105)
  
  • 4.4.1. Użycie metody apply() do dostarczania zmiennej argumentów (105)
  • 4.4.2. Przeciążanie funkcji (107)
• 4.5. Sprawdzanie pod kątem funkcji (116)
• 4.6. Podsumowanie (118)

Rozdział 5. Zamknięcie się w domknięciach (119)

• 5.1. Sposób działania domknięć (120)
• 5.2. Praktyczne wykorzystanie domknięć (125)
  
  • 5.2.1. Zmienne prywatne (125)
  • 5.2.2. Wywołania zwrotne i liczniki czasu (127)
• 5.3. Powiązanie kontekstów funkcji (131)
• 5.4. Częściowe stosowanie funkcji (136)
• 5.5. Przesłanianie działania funkcji (139)
  
  • 5.5.1. Zapamiętywanie (139)
  • 5.5.2. Opakowanie funkcji (142)
• 5.6. Funkcje bezpośrednie (144)
  
  • 5.6.1. Zasięg tymczasowy i zmienne prywatne (146)
  • 5.6.2. Pętle (150)
  • 5.6.3. Opakowywanie biblioteki (152)
• 5.7. Podsumowanie (153)

Rozdział 6. Obiektowość z prototypami (155)

• 6.1. Tworzenie instancji i prototypy (156)
  
  • 6.1.1. Tworzenie instancji obiektu (156)
  • 6.1.2. Określanie typu obiektu za pośrednictwem konstruktorów (164)
  • 6.1.3. Dziedziczenie i łańcuch prototypów (166)
  • 6.1.4. Prototypy modelu DOM języka HTML (171)
• 6.2. Pułapki! (173)
  
  • 6.2.1. Rozszerzanie obiektu (173)
  • 6.2.2. Rozszerzanie liczby (175)
  • 6.2.3. Używanie podklas dla wbudowanych obiektów (177)
  • 6.2.4. Problemy z tworzeniem instancji (178)
• 6.3. Pisanie kodu bardziej zbliżonego do kodu z klasami (183)
  
  • 6.3.1. Sprawdzanie pod kątem serializacji funkcji (186)
  • 6.3.2. Inicjalizacja podklas (187)
  • 6.3.3. Zachowywanie supermetod (188)
• 6.4. Podsumowanie (190)

Rozdział 7. Borykanie się z wyrażeniami regularnymi (193)

• 7.1. Dlaczego wyrażenia regularne są tak ważne? (194)
• 7.2. Odświeżenie informacji o wyrażeniach regularnych (195)
  
  • 7.2.1. Omówienie wyrażeń regularnych (195)
  • 7.2.2. Wyrazy i operatory (197)
• 7.3. Kompilowanie wyrażeń regularnych (201)
• 7.4. Przechwytywanie pasujących segmentów (204)
  
  • 7.4.1. Wykonywanie prostych przechwytywań (204)
  • 7.4.2. Dopasowywanie za pomocą globalnych wyrażeń regularnych (205)
  • 7.4.3. Przywoływanie przechwytywań (207)
  • 7.4.4. Grupy bez przechwytywania (208)
• 7.5. Zastępowanie za pomocą funkcji (209)
• 7.6. Rozwiązywanie typowych problemów z wykorzystaniem wyrażeń regularnych (212)
  
  • 7.6.1. Obcinanie łańcucha (212)
  • 7.6.2. Dopasowywanie znaków nowego wiersza (214)
  • 7.6.3. Unicode (215)
  • 7.6.4. Znaki o zmienionym znaczeniu (216)
• 7.7. Podsumowanie (217)

Rozdział 8. Wątki i liczniki czasu (219)

• 8.1. Sposób działania liczników czasu i wątkowości (220)
  
  • 8.1.1. Ustawianie i usuwanie liczników czasu (220)
  • 8.1.2. Wykonywanie licznika czasu w obrębie wątku wykonywania (221)
  • 8.1.3. Różnice między czasami oczekiwania i interwałami (223)
• 8.2. Minimalne opóźnienie licznika czasu i wiarygodność (225)
• 8.3. Radzenie sobie z przetwarzaniem kosztownym obliczeniowo (228)
• 8.4. Scentralizowane kontrolowanie liczników czasu (231)
• 8.5. Testowanie asynchroniczne (235)
• 8.6. Podsumowanie (236)

CZĘŚĆ III. TRENING WOJOWNIKA (237)

Rozdział 9. Alchemia wojownika. Analizowanie kodu w środowisku wykonawczym (239)

• 9.1. Mechanizmy analizy kodu (240)
  
  • 9.1.1. Analizowanie za pomocą metody eval() (240)
  • 9.1.2. Analizowanie za pośrednictwem konstruktora Function (243)
  • 9.1.3. Analizowanie przy użyciu liczników czasu (244)
  • 9.1.4. Analizowanie w zasięgu globalnym (244)
  • 9.1.5. Bezpieczne analizowanie kodu (247)
• 9.2. "Dekompilacja" funkcji (248)
• 9.3. Analizowanie kodu w praktyce (251)
  
  • 9.3.1. Przekształcanie łańcuchów JSON (251)
  • 9.3.2. Importowanie kodu z przestrzenią nazw (253)
  • 9.3.3. Kompresja i ukrywanie kodu JavaScript (254)
  • 9.3.4. Dynamiczne przebudowywanie kodu (256)
  • 9.3.5. Znaczniki skryptu zorientowanego aspektowo (257)
  • 9.3.6. Metajęzyki i języki DSL (258)
• 9.4. Podsumowanie (262)

Rozdział 10. Instrukcje with (263)

• 10.1. O co chodzi z instrukcją with? (264)
  
  • 10.1.1. Przywoływanie właściwości w zasięgu instrukcji with (264)
  • 10.1.2. Przypisania w zasięgu instrukcji with (266)
  • 10.1.3. Kwestie dotyczące wydajności (268)
• 10.2. Rzeczywiste przykłady (270)
• 10.3. Importowanie kodu z przestrzenią nazw (272)
• 10.4. Testowanie (272)
• 10.5. Stosowanie szablonów z instrukcją with (273)
• 10.6. Podsumowanie (276)

Rozdział 11. Opracowywanie strategii obsługi wielu przeglądarek (277)

• 11.1. Wybór przeglądarek do obsługi (278)
• 11.2. Pięć podstawowych kwestii programistycznych (279)
  
  • 11.2.1. Błędy i różnice w przeglądarkach (281)
  • 11.2.2. Poprawki błędów w przeglądarce (281)
  • 11.2.3. Radzenie sobie z zewnętrznym kodem i znacznikami (283)
  • 11.2.4. Brakujące funkcje (289)
  • 11.2.5. Regresje (290)
• 11.3. Strategie implementowania (292)
  
  • 11.3.1. Bezpieczne poprawki dla różnych przeglądarek (292)
  • 11.3.2. Wykrywanie obiektu (294)
  • 11.3.3. Symulacja funkcji (295)
• 11.4. Zmniejszanie liczby założeń (301)
• 11.5. Podsumowanie (303)

Rozdział 12. Atrybuty, właściwości i arkusze stylów CSS (305)

• 12.1. Atrybuty i właściwości modelu DOM (307)
  
  • 12.1.1. Nazewnictwo w różnych przeglądarkach (308)
  • 12.1.2. Ograniczenia dotyczące nazw (309)
  • 12.1.3. Różnice między językami XML i HTML (310)
  • 12.1.4. Działanie atrybutów niestandardowych (310)
  • 12.1.5. Kwestie dotyczące wydajności (311)
• 12.2. Problemy z atrybutami w przypadku obsługi wielu przeglądarek (315)
  
  • 12.2.1. Rozszerzanie nazwy (identyfikatora) modelu DOM (315)
  • 12.2.2. Normalizacja adresu URL (317)
  • 12.2.3. Atrybut style (318)
  • 12.2.4. Atrybut type (319)
  • 12.2.5. Problem z indeksem tabulacji (320)
  • 12.2.6. Nazwy węzłów (321)
• 12.3. Problemy związane z atrybutami stylów (321)
  
  • 12.3.1. Gdzie są moje style? (322)
  • 12.3.2. Określanie nazw właściwości stylów (324)
  • 12.3.3. Właściwość stylów float (326)
  • 12.3.4. Konwersja wartości pikseli (326)
  • 12.3.5. Określanie wysokości i szerokości (327)
  • 12.3.6. Przenikanie nieprzezroczystości (332)
  • 12.3.7. Poskromienie kolorowego koła (335)
• 12.4. Uzyskiwanie stylów obliczanych (338)
• 12.5. Podsumowanie (341)

CZĘŚĆ IV. TRENING MISTRZA (343)

Rozdział 13. Radzenie sobie ze zdarzeniami (345)

• 13.1. Techniki wiązania zdarzeń i anulowania powiązań (346)
• 13.2. Obiekt Event (351)
• 13.3. Zarządzanie procedurami obsługi (355)
  
  • 13.3.1. Scentralizowane przechowywanie powiązanych informacji (355)
  • 13.3.2. Zarządzanie procedurami obsługi zdarzeń (358)
• 13.4. Wyzwalanie zdarzeń (369)
  
  • 13.4.1. Zdarzenia niestandardowe (371)
• 13.5. Propagacja i delegowanie (375)
  
  • 13.5.1. Delegowanie zdarzeń do elementu nadrzędnego (376)
  • 13.5.2. Radzenie sobie z mankamentami przeglądarek (377)
• 13.6. Zdarzenie gotowości dokumentu (387)
• 13.7. Podsumowanie (389)

Rozdział 14. Modyfikowanie modelu DOM (393)

• 14.1. Umieszczanie kodu HTML w modelu DOM (394)
  
  • 14.1.1. Przekształcanie kodu HTML w model DOM (396)
  • 14.1.2. Wstawianie do dokumentu (399)
  • 14.1.3. Wykonywanie skryptu (401)
• 14.2. Klonowanie elementów (403)
• 14.3. Usuwanie elementów (405)
• 14.4. Treść tekstowa (407)
  
  • 14.4.1. Ustawianie tekstu (408)
  • 14.4.2. Pobieranie tekstu (409)
• 14.5. Podsumowanie (410)

Rozdział 15. Mechanizmy selektorów CSS (411)

• 15.1. Interfejs API selektorów organizacji W3C (413)
• 15.2. Użycie języka XPath do znajdowania elementów (416)
• 15.3. Implementacja czystego modelu DOM (418)
  
  • 15.3.1. Analizowanie selektora (421)
  • 15.3.2. Znajdowanie elementów (422)
  • 15.3.3. Filtrowanie zestawu (423)
  • 15.3.4. Rekurencja i scalanie (424)
  • 15.3.5. Wstępujący mechanizm selektorów (425)
• 15.4. Podsumowanie (427)

Skorowidz (429)

• Titel: Tajemnice JavaScriptu. Podręcznik ninja
• Autor: John Resig, Bear Bibeault
• Originaler Titel: Secrets of the JavaScript Ninja
• Übersetzung: Piotr Pilch
• ISBN: 978-83-246-8507-3, 9788324685073
• Veröffentlichungsdatum: 2014-05-16
• Format: E-book
• Artikelkennung: tajani
• Verleger: Helion