O autorze (11)

O recenzencie technicznym (13)

Podziękowania (15)

Wstęp (17)

Rozdział 1. Instalowanie Node.js i podstawowe zagadnienia (21)

• Instalowanie Node.js i menedżera NPM (21)
  • Gotowe instalatory (22)
  • Instalowanie za pomocą HomeBrew lub MacPorts (22)
  • Instalowanie z wykorzystaniem pliku tar (23)
  • Instalowanie bez użycia sudo (24)
  • Instalowanie z repozytorium Git (24)
  • Instalacja kilku wersji z wykorzystaniem Nave (25)
  • Instalacja kilku wersji z wykorzystaniem menedżera Node Version Manager (NVM) (26)
  • Alternatywne systemy służące do instalowania kilku wersji (26)
  • Weryfikacja instalacji (26)
  • Konsola Node.js (REPL) (27)
• Uruchamianie skryptów Node.js (28)
• Podstawy i składnia Node.js (28)
  • Typowanie słabe (28)
  • Buffer - typ danych Node.js (29)
  • Notacja literałów obiektowych (29)
  • Funkcje (29)
  • Tablice (31)
  • Natura prototypowa (31)
  • Konwencje (32)
  • Zakres globalny w Node.js i słowa zarezerwowane (33)
  • __dirname a process.cwd (35)
  • Funkcje pomocnicze interfejsu programistycznego aplikacji przeglądarki (35)
  • Podstawowe moduły Node.js (36)
  • Przydatne narzędzia Node.js (37)
  • Odczyt i zapisywanie plików z systemu plików w Node.js (38)
  • Strumieniowe przesyłanie danych w Node.js (38)
  • Instalowanie modułów Node.js za pomocą NPM (38)
  • Poskramianie wywołań zwrotnych w Node.js (39)
  • Tworzenie serwera "Witaj, świecie" za pomocą modułu HTTP Node.js (40)
• Debugowanie programów Node.js (41)
  • Debuger Node.js (41)
  • Debugowanie za pomocą narzędzia Node Inspector (42)
• Środowiska IDE dla Node.js oraz edytory kodu (44)
• Obserwowanie zmian w plikach (46)
• Podsumowanie (48)

Rozdział 2. Wykorzystanie Express.js 4 do tworzenia aplikacji WWW Node.js (49)

• Czym jest Express.js? (49)
• Jak działa Express.js? (52)
• Instalowanie Express.js (52)
  • Wersja Express.js (53)
  • Express.js Generator (53)
  • Lokalna instalacja Express.js (54)
• Tworzenie szkieletu aplikacji z wykorzystaniem Express.js (56)
  • Interfejs wiersza poleceń Express.js (57)
  • Trasy w Express.js (59)
  • Oprogramowanie pośredniczące jako kręgosłup Express.js (60)
  • Konfiguracja aplikacji Express.js (60)
  • Jade to Haml w Express.js (Node.js) (60)
  • Podsumowanie tworzenia szkieletów aplikacji (61)
• Omówienie projektu Blog (61)
  • Przesyłanie danych (62)
• Przykład "Witaj, świecie" w Express.js (64)
  • Tworzenie folderów (64)
  • Inicjalizacja NPM i plik package.json (65)
  • Deklarowanie zależności - npm install (66)
  • Plik app.js (67)
  • Spotkanie z Jade - jeden szablon, by wszystkimi rządzić (70)
  • Uruchamianie aplikacji "Witaj, świecie" (71)
• Podsumowanie (71)

Rozdział 3. Wykorzystanie technik TDD i BDD w Node.js z użyciem platformy Mocha (73)

• Instalowanie i zrozumienie platformy Mocha (73)
  • Zrozumieć haki platformy Mocha (75)
• TDD z wykorzystaniem modułu assert (76)
  • Moduł Chai assert (78)
• BDD z wykorzystaniem Expect.js (79)
  • Składnia Expect.js (80)
• Projekt - pisanie pierwszego testu BDD dla aplikacji Blog (80)
  • Umieszczanie konfiguracji w pliku Makefile (82)
• Podsumowanie (84)

Rozdział 4. Silniki szablonów - Jade i Handlebars (85)

• Składnia i funkcje Jade (85)
  • Znaczniki (86)
  • Zmienne (Locals) (86)
  • Atrybuty (86)
  • Literały (87)
  • Tekst (88)
  • Skrypt i bloki stylów (88)
  • Kod JavaScript (88)
  • Komentarze (89)
  • Warunki (if) (89)
  • Iteracje (pętle each) (90)
  • Filtry (90)
  • Interpolacja (90)
  • Case (91)
  • Domieszki (91)
  • Include (92)
  • Extend (92)
• Samodzielne użycie Jade (93)
• Składnia Handlebars (96)
  • Zmienne (96)
  • Iteracja (each) (97)
  • Niecytowany wynik (97)
  • Warunki (if) (98)
  • Unless (98)
  • With (99)
  • Komentarze (99)
  • Własne funkcje pomocnicze (100)
  • Włączenia (szablony częściowe) (101)
• Samodzielne użycie Handlebars (101)
• Wykorzystanie Jade i Handlebars w Express.js 4 (103)
  • Jade i Express.js (104)
  • Handlebars i Express.js (104)
• Projekt - dodanie szablonów Jade do aplikacji Blog (105)
  • layout.jade (105)
  • index.jade (107)
  • article.jade (109)
  • login.jade (109)
  • post.jade (110)
  • admin.jade (111)
• Podsumowanie (113)

Rozdział 5. Zapewnienie trwałości z wykorzystaniem MongoDB i Mongoskin (115)

• Łatwa i poprawna instalacja MongoDB (115)
• Jak uruchomić serwer Mongo (117)
• Manipulacja danymi z poziomu konsoli Mongo (118)
• Szczegóły dotyczące powłoki MongoDB (119)
• Przykład minimalistycznego natywnego sterownika MongoDB dla Node.js (120)
• Główne metody Mongoskin (122)
• Projekt - przechowywanie danych aplikacji Blog w MongoDB z wykorzystaniem Mongoskin (124)
  • Projekt - dodawanie danych początkowych do bazy MongoDB (125)
  • Projekt - pisanie testów Mocha (125)
  • Projekt - zapewnienie trwałości (127)
  • Uruchamianie aplikacji (137)
• Podsumowanie (138)

Rozdział 6. Wykorzystanie sesji i OAuth do autoryzacji i uwierzytelniania użytkowników w aplikacjach Node.js (139)

• Autoryzacja z wykorzystaniem oprogramowania pośredniczącego Express.js (139)
• Uwierzytelnianie z wykorzystaniem tokena (140)
• Uwierzytelnianie z wykorzystaniem sesji (141)
• Projekt - dodawanie logowania z wykorzystaniem adresu e-mail i hasła do aplikacji Blog (142)
  • Oprogramowanie pośredniczące sesji (142)
  • Uwierzytelnianie aplikacji Blog (143)
  • Uwierzytelnianie w aplikacji Blog (146)
  • Uruchamianie aplikacji (147)
• OAuth w Node.js (147)
  • Przykład Twitter OAuth 2.0 z OAuth Node.js (148)
  • Everyauth (149)
• Projekt - dodawanie rejestracji Twitter OAuth 1.0 do aplikacji Blog z wykorzystaniem Everyauth (150)
  • Dodawanie łącza Zaloguj za pomocą Twittera (150)
  • Konfigurowanie strategii Twitter modułu Everyauth (151)
• Podsumowanie (156)

Rozdział 7. Lepsza obsługa danych Node.js z wykorzystaniem biblioteki Mongoose ORM (157)

• Instalacja Mongoose (158)
  • Ustanawianie połączenia w samodzielnym skrypcie Mongoose (158)
• Klasa Schema Mongoose (159)
• Haki pozwalające utrzymać organizację kodu (161)
• Własne metody statyczne i instancji (162)
• Modele Mongoose (162)
• Relacje i złączenia w populowaniu danych (164)
• Dokumenty zagnieżdżone (166)
• Pola wirtualne (167)
• Poprawianie zachowania typów schematów (168)
• Express.js + Mongoose = prawdziwy model MVC (170)
• Podsumowanie (179)

Rozdział 8. Tworzenie API RESTowych na serwerze Node.js z wykorzystaniem Express.js i Hapi (181)

• Podstawy API RESTowego (182)
• Zależności w projekcie (183)
• Pokrycie testami Mocha i superagent (184)
• Implementacja serwera API RESTowego z wykorzystaniem Express i Mongoskin (189)
• Refaktoryzacja - serwer API RESTowego z wykorzystaniem Hapi.js (194)
• Podsumowanie (200)

Rozdział 9. Aplikacje czasu rzeczywistego z wykorzystaniem WebSocket, Socket.IO i DerbyJS (201)

• Czym jest WebSocket? (201)
• Natywna obsługa WebSocket w Node.js z przykładem wykorzystania modułu ws (202)
  • Implementacja WebSocket w przeglądarce (202)
  • Serwer Node.js z wykorzystaniem modułu ws (203)
• Przykład Socket.IO i Express.js (205)
• Przykład edytora online do pracy w zespole z wykorzystaniem DerbyJS, Express.js i MongoDB (209)
  • Zależności projektu i package.json (209)
  • Kod po stronie serwera (210)
  • Aplikacja DerbyJS (212)
  • Widok DerbyJS (214)
  • Próba edytora (216)
• Podsumowanie (216)

Rozdział 10. Przygotowywanie aplikacji Node.js do wykorzystania produkcyjnego (217)

• Zmienne środowiskowe (217)
• Express.js w produkcji (218)
• Socket.IO w produkcji (220)
• Obsługa błędów (221)
• Domeny Node.js przeznaczone do obsługi błędów (223)
• Wielowątkowość z wykorzystaniem modułu Cluster (226)
• Wielowątkowość z wykorzystaniem modułu Cluster2 (228)
• Logowanie i monitorowanie błędów (229)
  • Monitorowanie (229)
  • REPL w produkcji (230)
  • Winston (231)
  • Logowanie z wykorzystaniem aplikacji Papertrail (232)
• Tworzenie zadań z wykorzystaniem modułu Grunt (232)
• Kontrola wersji i wdrażanie z wykorzystaniem Git (236)
  • Instalowanie Git (236)
  • Generowanie kluczy SSH (237)
  • Tworzenie lokalnego repozytorium Git (239)
  • Przesyłanie lokalnego repozytorium do GitHub (239)
• Uruchamianie testów w chmurze z wykorzystaniem TravisCI (240)
  • Konfiguracja TravisCI (241)
• Podsumowanie (242)

Rozdział 11. Wdrażanie aplikacji Node.js (243)

• Wdrażanie do Heroku (243)
• Wdrażanie do Amazon Web Services (AWS) (248)
• Utrzymywanie działania aplikacji Node.js z wykorzystaniem forever, Upstart i init.d (251)
  • forever (252)
  • Skrypty Upstart (253)
  • init.d (254)
• Właściwy sposób udostępniania zasobów statycznych z wykorzystaniem Nginx (256)
• Pamięć podręczna z wykorzystaniem Varnish (258)
• Podsumowanie (259)

Rozdział 12. Publikowanie modułów Node.js i udział w projektach open source (261)

• Zalecana struktura folderów (262)
• Wymagane wzorce (262)
• package.json (264)
• Publikowanie w NPM (265)
• Wersje zablokowane (266)
• Podsumowanie (266)
• To już koniec (266)
• Dalsza lektura (267)

Skorowidz (268)

• Tytuł: Node.js w praktyce. Tworzenie skalowalnych aplikacji sieciowych
• Autor: Azat Mardan
• Tytuł oryginału: Practical Node.js: Building Real-world Scalable Web Apps
• Tłumaczenie: Joanna Zatorska
• ISBN: 978-83-283-1086-5, 9788328310865
• Data wydania: 2015-08-25
• Format: Ebook
• Identyfikator pozycji: nodewp
• Wydawca: Helion