reklama - zainteresowany?

Node.js w praktyce. Tworzenie skalowalnych aplikacji sieciowych - Helion

Node.js w praktyce. Tworzenie skalowalnych aplikacji sieciowych
ebook
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
stron: 272, Format: ebook
Data wydania: 2015-08-25
Księgarnia: Helion

Cena książki: 27,45 zł (poprzednio: 53,82 zł)
Oszczędzasz: 49% (-26,37 zł)

Dodaj do koszyka Node.js w praktyce. Tworzenie skalowalnych aplikacji sieciowych

Tagi: JavaScript - Programowanie | Node.js | secret-sale

O tym jak tworzyć złożone aplikacje sieciowe z wykorzystaniem Node.js

JavaScript to język programowania rozwijany od 1995 roku. Przez długi czas był kojarzony tylko i wyłącznie ze stronami internetowymi i przeglądarkami, jednak te czasy odchodzą w niepamięć, a JavaScript z powodzeniem jest dziś stosowany po stronie serwera.

Jeżeli chcesz sprawdzić, jak to działa, sięgnij po tę książkę i zainstaluj Node.js. Jest to platforma, która zapewnia najwyższą wydajność, ponieważ korzysta z nieblokujących operacji I/O oraz asynchronicznego mechanizmu zdarzeń. Co więcej, została ona oparta na najwydajniejszym silniku wspierającym język JavaScript, czyli na V8. Dzięki tej książce masz niepowtarzalną okazję poznać podstawy działania Node.js, zaznajomić się ze składnią języka JavaScript, a także zacząć korzystać z zaawansowanych mechanizmów autoryzacji, przechowywania danych czy zdarzeń. Ponadto nauczysz się tworzyć aplikacje czasu rzeczywistego z użyciem WebSocket, Socket.IO i DerbyJS oraz zbudujesz superwydajne API REST-owe. Książka ta jest obowiązkową lekturą dla wszystkich osób, dla których ważna jest najwyższa wydajność i które chcą poznać nowinki technologiczne. Warto ją mieć!

Książka Node.js w praktyce prezentuje:
  • Tworzenie aplikacji sieciowych z wykorzystaniem Express.js 4, MongoDB i silnika szablonów Jade
  • Przetwarzanie danych z poziomu konsoli MongoDB
  • Testowanie usług sieciowych Node.js z wykorzystaniem Mocha, Expect i TravisCI
  • Uwierzytelnianie z wykorzystaniem tokena i oparte na sesji
  • Implementowanie strategii OAuth zewnętrznego dostawcy (Twitter) z wykorzystaniem Everyauth
  • Przygotowanie kodu do produkcji z wykorzystaniem Redis, domen Node.js, biblioteki cluster i inne wskazówki
  • Instalowanie potrzebnych komponentów Node.js w instancji Amazon Web Services (AWS)

Poznaj możliwości platformy Node.js!



Azat Mardan — przedsiębiorca, inżynier oprogramowania, entuzjasta jogi i diety paleo. Ma ponad 12 lat doświadczenia w wytwarzaniu oprogramowania. Jest autorem dziewięciu książek poświęconych językowi JavaScript oraz platformie Node.js. Aktualnie zajmuje stanowisko starszego inżyniera oprogramowania oraz lidera zespołu w DocuSign. Był współzałożycielem Gizmo (platformy do prowadzenia kampanii marketingowych dla urządzeń mobilnych) oraz członkiem zespołów wytwarzających oprogramowanie dla organizacji rządowych.

Dodaj do koszyka Node.js w praktyce. Tworzenie skalowalnych aplikacji sieciowych

 

Osoby które kupowały "Node.js w praktyce. Tworzenie skalowalnych aplikacji sieciowych", wybierały także:

  • Frontend developer. Kurs video. React. Poziom podstawowy
  • jQuery. Kurs video. Poziom pierwszy. Interaktywne interfejsy internetowe
  • JavaScript. Kurs video. Poziom pierwszy. Programowanie interaktywnych stron internetowych

Dodaj do koszyka Node.js w praktyce. Tworzenie skalowalnych aplikacji sieciowych

Spis treści

Node.js w praktyce. Tworzenie skalowalnych aplikacji sieciowych eBook -- spis treści

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)

Dodaj do koszyka Node.js w praktyce. Tworzenie skalowalnych aplikacji sieciowych

Code, Publish & WebDesing by CATALIST.com.pl



(c) 2005-2020 CATALIST agencja interaktywna, znaki firmowe należą do wydawnictwa Helion S.A.