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

Programowanie zorientowane obiektowo w języku JavaScript. Wydanie III Język: 1

978-83-283-3782-4

Cena Brutto: 79.00

Cena netto: 75.24

Ilość:
Wersja: Drukowana
Autor Ved Antani, Stoyan Stefanov
Liczba_stron 472
Wydawnictwo Helion
Oprawa miękka
Data_Wydania 2017-12-01
Programowanie zorientowane obiektowo w języku

JavaScript

Wydanie III


Dziś JavaScript jest dojrzałym, wszechstronnym i potężnym językiem programowania, który świetnie się nadaje do programowania zorientowanego obiektowo. Pozwala przy tym na pisanie solidnego i efektywnego kodu. Stał się świetnym narzędziem do tworzenia bardzo złożonych, skalowalnych i łatwych w utrzymaniu aplikacji. Można zaobserwować, że JavaScript powoli nadaje kształt następnej generacji platform internetowych i serwerowych. Najnowsza specyfikacja tego języka, ES6, wprowadza ważne konstrukcje językowe, takie jak obietnice, klasy, funkcje strzałkowe.


Ta książka jest znakomitym podręcznikiem programowania obiektowego w JavaScripcie. Przedstawiono tu solidne podstawy języka oraz programowania obiektowego, co ułatwia zrozumienie zaawansowanych, nowoczesnych funkcjonalności ES6: iteratorów i generatorów. Wyjaśniono koncepcję prototypów i zasady dziedziczenia, a także zasady programowania asynchronicznego. Nie zabrakło kilku niezwykle przydatnych dodatków: listy słów zastrzeżonych, funkcji i obiektów wbudowanych w język, a także wprowadzenia do wyrażeń regularnych. Ponadto każdy rozdział zakończono zestawem przydatnych ćwiczeń do samodzielnego wykonania.

Niektóre zagadnienia omówione w książce:

  • Konfiguracja środowiska programistycznego
  • Środowisko przeglądarki, model BOM i DOM
  • Technika AJAX
  • Wzorce kodowania i wzorce projektowe
  • Framework Jasmine i projektowanie oparte na testach
  • Programowanie reaktywne i biblioteka React

    O autorach (13)

    O korektorze merytorycznym (14)

    Przedmowa (15)

    Rozdział 1. Obiektowy język JavaScript (19)

    • Trochę historii (20)
      • Wojny przeglądarkowe i renesans (21)
      • Teraźniejszość (22)
      • Przyszłość (23)
    • ECMAScript 5 (24)
      • Tryb ścisły w ES6 (24)
    • ECMAScript 6 (25)
      • Obsługa ES6 w przeglądarkach (25)
      • Babel (26)
    • Programowanie obiektowe (27)
      • Obiekty (28)
      • Klasy (28)
      • Hermetyzacja (29)
      • Agregacja (29)
      • Dziedziczenie (30)
      • Polimorfizm (30)
    • Programowanie obiektowe - podsumowanie (31)
    • Konfiguracja środowiska szkoleniowego (31)
      • Web Inspector dla silnika WebKit (32)
      • JavaScriptCore na komputerach Mac (33)
      • Inne konsole (34)
    • Podsumowanie (36)

    Rozdział 2. Proste typy danych, tablice, pętle i warunki (37)

    • Zmienne (37)
      • Wielkość liter w nazwach zmiennych ma znaczenie (39)
    • Operatory (40)
    • Proste typy danych (43)
      • Ustalanie typu danych - operator typeof (43)
      • Liczby (44)
      • Łańcuchy znaków (49)
      • Typ boolean (54)
      • Undefined i null (59)
      • Symbole (60)
    • Proste typy danych - podsumowanie (61)
    • Tablice (62)
      • Dodawanie i aktualizacja elementów tablicy (63)
      • Usuwanie elementów (63)
      • Tablice tablic (64)
    • Warunki i pętle (65)
      • Bloki kodu (65)
      • Pętle (71)
    • Komentarze (75)
    • Ćwiczenia (76)
    • Podsumowanie (77)

    Rozdział 3. Funkcje (79)

    • Czym jest funkcja? (80)
      • Wywoływanie funkcji (80)
      • Parametry (80)
    • Parametry domyślne (82)
    • Parametry reszty (83)
    • Operator rozwijania (84)
    • Funkcje predefiniowane (85)
      • parseInt() (85)
      • parseFloat() (86)
      • isNaN() (87)
      • isFinite() (88)
      • encodeURI() i encodeURIComponent() (88)
      • eval() (88)
    • Zakres zmiennych (89)
      • Wynoszenie zmiennych (91)
    • Zakres bloku (92)
    • Funkcje są danymi (93)
      • Funkcje anonimowe (95)
      • Wywołania zwrotne (95)
      • Funkcje natychmiastowe (98)
      • Funkcje wewnętrzne (prywatne) (99)
      • Funkcje, które zwracają funkcje (100)
      • Funkcjo, przepiszże się! (101)
    • Domknięcia (102)
      • Łańcuch zakresów (103)
      • Przerwanie łańcucha za pomocą domknięcia (103)
      • Funkcje dostępowe (109)
      • Iterator (110)
    • IIFE a bloki (111)
    • Funkcje strzałkowe (111)
    • Ćwiczenia (112)
    • Podsumowanie (113)

    Rozdział 4. Obiekty (115)

    • Od tablic do obiektów (115)
      • Elementy, właściwości, metody i składowe (117)
      • Tablice asocjacyjne (118)
      • Dostęp do właściwości obiektu (118)
      • Wywoływanie metod obiektu (119)
      • Modyfikacja właściwości i metod (120)
      • Wartość this (121)
      • Konstruktory (122)
      • Obiekt globalny (123)
      • Właściwość constructor (124)
      • Operator instanceof (125)
      • Funkcje zwracające obiekty (125)
      • Przekazywanie obiektów (126)
      • Porównywanie obiektów (127)
      • Obiekty w konsoli silnika WebKit (128)
      • Literały obiektowe ES6 (129)
    • Właściwości i atrybuty obiektów (131)
    • Metody obiektów w ES6 (132)
      • Kopiowanie właściwości za pomocą Object.assign (132)
      • Porównywanie właściwości za pomocą Object.is (133)
    • Destrukturyzacja (133)
    • Obiekty wbudowane (136)
      • Object (136)
      • Array (137)
      • Function (143)
      • Inferencja typów obiektów (150)
      • Boolean (151)
      • Number (152)
      • String (153)
      • Math (157)
      • Date (159)
      • RegExp (163)
      • Obiekty Error (168)
    • Ćwiczenia (171)
    • Podsumowanie (173)

    Rozdział 5. Iteratory i generatory ES6 (175)

    • Pętla for...of (175)
    • Iteratory i obiekty iterowalne (176)
      • Iteratory (176)
      • Obiekty iterowalne (177)
    • Generatory (178)
      • Iterowanie przez generatory (181)
    • Kolekcje (182)
      • Map (182)
      • Set (185)
      • WeakMap i WeakSet (186)
    • Podsumowanie (186)

    Rozdział 6. Prototypy (189)

    • Właściwość prototype (189)
      • Dodawanie metod i właściwości przy użyciu prototypu (190)
    • Korzystanie z metod i właściwości obiektu prototype (191)
      • Właściwości własne a właściwości prototypu (192)
      • Nadpisywanie właściwości prototypu właściwością własną (193)
      • Korzystanie z metody isPrototypeOf() (196)
      • Ukryte powiązanie __proto__ (197)
    • Rozszerzanie obiektów wbudowanych (199)
      • Rozszerzanie obiektów wbudowanych - kontrowersje (200)
      • Pułapki związane z prototypami (201)
    • Ćwiczenia (203)
    • Podsumowanie (203)

    Rozdział 7. Dziedziczenie (205)

    • Łańcuchy prototypów (205)
      • Przykładowy łańcuch prototypów (206)
      • Przenoszenie wspólnych właściwości do prototypu (209)
    • Dziedziczenie samego prototypu (211)
      • Konstruktor tymczasowy - new F() (212)
    • Uber: dostęp do obiektu nadrzędnego z obiektu potomnego (214)
    • Zamknięcie dziedziczenia wewnątrz funkcji (215)
    • Kopiowanie właściwości (216)
    • Uwaga na kopiowanie przez referencję! (218)
    • Obiekty dziedziczą z obiektów (221)
    • Głębokie kopiowanie (222)
    • Korzystanie z metody object() (224)
    • Połączenie dziedziczenia prototypowego z kopiowaniem właściwości (225)
    • Dziedziczenie wielokrotne (227)
      • Domieszki (228)
    • Dziedziczenie pasożytnicze (229)
    • Wypożyczanie konstruktora (230)
      • Pożyczanie konstruktora i kopiowanie jego prototypu (232)
    • Studium przypadku: rysujemy kształty (232)
      • Analiza (233)
      • Implementacja (233)
      • Testowanie (237)
    • Ćwiczenia (238)
    • Podsumowanie (238)

    Rozdział 8. Klasy i moduły (243)

    • Definiowanie klas (245)
      • Konstruktor (247)
      • Metody prototypowe (247)
      • Metody statyczne (248)
      • Właściwości statyczne (248)
      • Metody generatora (248)
    • Podklasy (249)
      • Domieszki (251)
    • Moduły (252)
      • Listy eksportów (254)
    • Podsumowanie (255)

    Rozdział 9. Obietnice i obiekty proxy (257)

    • Asynchroniczny model programowania (259)
    • Stos wywołań JavaScriptu (261)
      • Kolejka komunikatów (262)
      • Pętla zdarzeń (262)
      • Timery (262)
    • Obietnice (264)
      • Tworzenie obietnic (266)
      • Metaprogramowanie i obiekty proxy (268)
      • Obiekt pośredniczący proxy (269)
      • Pułapki na funkcje (270)
    • Podsumowanie (271)

    Rozdział 10. Środowisko przeglądarki (273)

    • Załączanie JavaScriptu na stronie HTML (273)
    • BOM i DOM - przegląd (274)
    • BOM (275)
      • Ponownie odkrywamy obiekt window (275)
      • Korzystanie z właściwości window.navigator (276)
      • Konsola jako ściąga (276)
      • Korzystanie z właściwości window.location (277)
      • Korzystanie z właściwości window.history (278)
      • Korzystanie z właściwości window.frames (279)
      • Korzystanie z właściwości window.screen (281)
      • Metody window.open() i window.close() (281)
      • Metody window.moveTo() i window.resizeTo() (282)
      • Metody window.alert(), window.prompt() i window.confirm() (282)
      • Metody window.setTimeout() i window.setInterval() (284)
      • Właściwość window.document (286)
    • DOM (286)
      • Core DOM i HTML DOM (288)
      • Dostęp do węzłów DOM (289)
      • Modyfikacja węzłów DOM (297)
      • Tworzenie nowych węzłów (300)
      • Usuwanie węzłów (303)
      • Obiekty DOM istniejące tylko w HTML (304)
    • Zdarzenia (308)
      • Kod obsługi zdarzeń wpleciony w atrybuty HTML (308)
      • Właściwości elementów (308)
      • Nasłuchiwacze zdarzeń DOM (309)
      • Przechwytywanie i bąbelkowanie (311)
      • Zatrzymanie propagacji (312)
      • Anulowanie zachowania domyślnego (314)
      • Obsługa zdarzeń w różnych przeglądarkach (314)
      • Typy zdarzeń (316)
    • XMLHttpRequest (317)
      • Wysłanie żądania (317)
      • Przetworzenie odpowiedzi (318)
      • Tworzenie obiektów XHR w IE w wersjach starszych niż 7 (319)
      • A jak asynchroniczny (320)
      • X jak XML (321)
      • Przykład (321)
    • Ćwiczenia (323)
    • Podsumowanie (325)

    Rozdział 11. Wzorce kodowania i wzorce projektowe (327)

    • Wzorce kodowania (328)
      • Izolowanie zachowania (328)
      • Przestrzenie nazw (331)
      • Rozgałęzianie kodu w czasie inicjowania (333)
      • Leniwe definicje (335)
      • Obiekt konfiguracyjny (335)
      • Prywatne właściwości i metody (337)
      • Metody uprzywilejowane (338)
      • Funkcje prywatne w roli metod publicznych (339)
      • Funkcje natychmiastowe (339)
      • Moduły (340)
      • Łańcuchowanie (341)
      • JSON (342)
      • Funkcje wyższego rzędu (343)
    • Wzorce projektowe (345)
      • Singleton (345)
      • Singleton 2 (346)
      • Fabryka (347)
      • Dekorator (349)
      • Obserwator (351)
    • Podsumowanie (354)

    Rozdział 12. Testowanie i debugowanie (355)

    • Testy jednostkowe (356)
      • Programowanie sterowane testami (357)
      • Programowanie oparte na zachowaniach (357)
      • Mocha, Chai i Sinon (362)
    • Debugowanie kodu JavaScript (363)
      • Błędy składniowe (363)
      • Wyjątki w trakcie wykonywania programu (364)
    • Podsumowanie (371)

    Rozdział 13. Programowanie reaktywne i biblioteka React (373)

    • Programowanie reaktywne (373)
      • Dlaczego warto rozważyć programowanie reaktywne? (376)
    • Biblioteka React (376)
    • Wirtualny DOM (377)
    • Instalacja i uruchomienie React (378)
      • Komponenty i ich parametry wejściowe (381)
      • Stan (382)
      • Zdarzenia cyklu życia (384)
    • Podsumowanie (386)

    Dodatek A. Słowa zarezerwowane (387)

    • Słowa kluczowe (387)
    • Słowa zarezerwowane w ES6 (388)
      • Słowa zarezerwowane dla przyszłych implementacji (389)
    • Poprzednio zarezerwowane słowa (389)

    Dodatek B. Funkcje wbudowane (391)

    Dodatek C. Obiekty wbudowane (395)

    • Object (395)
      • Składowe konstruktora Object (396)
      • Składowe Object.prototype (396)
      • Dodatki do obiektów w ECMAScript 5 (398)
    • Dodatki do obiektów w ES6 (402)
      • Skrócona składnia właściwości (402)
      • Obliczane nazwy właściwości (403)
      • Object.assign (403)
    • Array (403)
      • Składowe Array.prototype (404)
      • Dodatki do Array w ECMAScript 5 (406)
      • Dodatki do tablic w ES6 (409)
    • Function (410)
      • Składowe Function.prototype (411)
      • Dodatki do Function w ECMAScript 5 (412)
      • Dodatki do Function w ES6 (412)
    • Boolean (413)
    • Number (413)
      • Składowe konstruktora Number (414)
      • Składowe Number.prototype (414)
    • String (415)
      • Składowe konstruktora String (416)
      • Składowe String.prototype (416)
      • Dodatki do String w ECMAScript 5 (418)
      • Dodatki do String w ES6 (419)
    • Date (419)
      • Składowe konstruktora Date (420)
      • Składowe Date.prototype (420)
      • Dodatki do Date w ECMAScript 5 (423)
    • Math (424)
      • Składowe obiektu Math (424)
    • RegExp (426)
      • Składowe RegExp.prototype (426)
    • Obiekty Error (427)
      • Składowe Error.prototype (428)
    • JSON (428)
      • Składowe obiektu JSON (428)

    Dodatek D. Wyrażenia regularne (431)

    Dodatek E. Odpowiedzi do ćwiczeń (437)

    Skorowidz (467)

powrót
 
Produkty Podobne
Programowanie zorientowane obiektowo w języku JavaScript. Wydanie III
Node.js. Projektowanie, wdrażanie i utrzymywanie aplikacji
Python, C++, JavaScript. Zadania z programowania
Platforma Node.js. Przewodnik webdevelopera. Wydanie III
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
Więcej produktów