E-book details

Tajemnice JavaScriptu. Podręcznik ninja

Tajemnice JavaScriptu. Podręcznik ninja

Bear Bibeault, John Resig

Ebook

Najlepsze porady dla programistów JavaScript!

JavaScript to język programowania, który wymaga od programisty szerokiej wiedzy i dokładności. Chwila nieuwagi może spowodować poważne problemy, trudne do wykrycia. Jak sobie radzić w tym wymagającym środowisku? Jak zwinnie poruszać się pomiędzy zastawionymi pułapkami?

Na te i wiele innych pytań znajdziesz odpowiedź w tej książce. Dzięki niej będziesz zwinnie jak ninja przemykał pomiędzy niuansami języka JavaScript. W trakcie lektury poznasz dogłębnie najlepszą broń przeciw błędom — debuger oraz testy automatyczne. W kolejnych rozdziałach nauczysz się korzystać z potencjału funkcji oraz domknięć. W tej doskonałej książce znajdziesz również szerokie omówienie wyrażeń regularnych — tematu, który spędza programistom sen z oczu. Ponadto szczegółowo poznasz zasady programowania obiektowego w JavaScripcie, modyfikowania drzewa DOM, wsparcia dla różnych przeglądarek oraz obsługi zdarzeń. Książka ta zawiera praktyczne porady, które sprawdzą się w codziennej pracy z językiem JavaScript. Jest to obowiązkowa pozycja dla każdego programisty!

Dzięki tej książce:

- nauczysz się pisać testy automatyczne
- wykorzystasz wyrażenia regularne w JavaScripcie
- zmodyfikujesz drzewo DOM
- opanujesz niuanse języka JavaScript

Pisz kod JavaScript jak prawdziwy ninja!

 


 

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)

  • Title: Tajemnice JavaScriptu. Podręcznik ninja
  • Author: John Resig, Bear Bibeault
  • Original title: Secrets of the JavaScript Ninja
  • Translation: Piotr Pilch
  • ISBN: 978-83-246-8507-3, 9788324685073
  • Date of issue: 2014-05-16
  • Format: Ebook
  • Item ID: tajani
  • Publisher: Helion