NodeJS: Node.js i EcmaScript 2015
w Praktyce
10 godz. 44 min · Node.js · Full-stack i Programowanie
Piotr PalarzWeb DeveloperCzego się nauczysz
- Omówienie platformy Node.js od podstaw
- Techniki tworzenia aplikacji typu CLI
- Rózne metody tworzenia serwerów sieciowych
- Omówienie wewnetrznej budowy platformy Node.js
- Prace z zewnetrznymi modulami i npm
- Framework express.js i wspólprace z baza danych MongoDB
- Przyklady praktycznych aplikacji
- Mase cennych porad i wskazówek
Co znajdziesz w Kursie?
W kursie tym poznasz platformę Node.js od podstaw, aż po bardziej zaawansowane koncepcje. Zaczniemy od omówienia czym jest Node, a także jakie może być zastosowanie tej technologii. Następnie przejdziemy przez proces instalacji i napisanie swojego pierwszego skryptu. Już na samym początku dokładnie omówimy tworzenie własnych modułów, gdyż jest to wiedza niezbędna, by dobrze zrozumieć funkcjonowanie Node. Następnie dowiesz się czym są zdarzenia, jak działa model “publish / subscribe”, a także czym jest “event-driven development”. Chwilę później omówimy pracę z buforami, stream’ami, a także ze standardowym wejściem i wyjściem. Ta wiedza pozwoli Ci zrozumieć jak tworzone aplikacje mogą otrzymywać od użytkownika dane oraz jak je wyświetlają.
Praca z Systemem Plików
Niezwykle ważnym rozdziałem będzie ten, poświęcony pracy z systemem plików. Szczególnie dla dewelopera, pracującego dotychczas z językiem JavaScript wyłącznie w środowisku przeglądarki internetowej. Node pozwala bowiem tworzyć nowe pliki, zapisywać w nich dane oraz odczytywać i usuwać pliki i katalogi. Przy wszystkich tych operacjach, niezwykle ważna jest jednak asynchroniczna natura Node. Dowiesz się jak działa, a także jakie są jej zalety. Na tym etapie nie zabraknie oczywiście praktycznego projektu, którym będzie aplikacja typu CLI (Command Line Interface). Pozwoli nam ona grupowo zmienić nazwy wielu plików, według podanego wzorca.
Tworzenie Serwerów Siecowych
W kolejnym rozdziale poruszymy fundamentalną dla Node kwestię, mianowicie tworzenie serwerów sieciowych. Zaczniemy od najniższego poziomu, tworząc prosty serwer bazujący na protokole TCP/IP. Wiedza w jaki sposób Node radzi sobie z takim zadaniem, pozwoli później lepiej zrozumieć wyższe warstwy, takie jak np. HTTP czy WebSockets. Chwilę później stworzymy swój pierwszy serwer HTTP, do którego będzie można wysyłać zapytania wprost z przeglądarki internetowej. Omówimy również jak w Node wykorzystać bezpieczne szyfrowanie HTTPS.Na tym etapie będziesz już miał solidną wiedzę jak pracować z Node, jednak zanim przejdziemy dalej, zatrzymamy się, by omówić jak dokładnie działa Node.js, a także jak ta platforma została zbudowana. Dwie dość obszerne lekcje, będą być może jednymi z najważniejszych w tym kursie. Dowiesz się w nich czym jest, a także jak działa jednowątkowa pętla zdarzeń, czym jest proces i wątek, a także zobaczysz kod źródłowy Node.js i wszystkie bloki budulcowe, z jakich Node się składa. To naszym zdaniem niezwykle ważny temat, często jednak pomijany w wielu materiałach. Dzięki dogłębnemu zrozumieniu jednowątkowej natury języka JavaScript i asynchroniczności Node, będziesz mógł tworzyć dużo lepsze aplikacje.
Node.js + Express.js + MongoDB
Node.js posiada kilkanaście wbudowanych modułów, z których w dowolnej chwili można skorzystać. Wszystkie jednak dają nam dużą, niskopoziomową kontrolę, ale czasami sporo kodu należy napisać, by zrealizować jakieś zadanie. Jest to jednak świadomy wybór twórców Node, gdyż całą resztę świetnych rozwiązań, dopisuje nieustannie ogólnoświatowa społeczność deweloperów. Zdecydowana większość z modułów ląduje w rejestrze npm. Jest to genialny package manager, który pozwoli nam wyszukiwać, pobierać i aktualizować niezliczoną ilość modułów. Dowiesz się zatem jak korzystać z npm, a chwilę później zaczniemy wykorzystywać zgromadzone tam moduły w dalszej pracy.Jednym z najpopularniejszych modułów jest express.js, który pozwala w bardzo prosty sposób tworzyć serwery HTTP. Grzechem byłoby zatem z niego nie skorzystać. Dowiesz się wszystkiego co niezbędne, by zacząć tworzyć własne aplikacje bazujące na protokole HTTP z użyciem express.js, a także kilku dodatków do tego systemu. Zobaczysz jak routować zapytania, jak korzystać z middleware czy serwować statyczne pliki. Następnie omówimy współpracę z bazą danych MongoDB i z jej wykorzystaniem stworzymy API typu REST. Stworzona aplikacja pozwoli odczytywać dane z bazy i przesyłać je do klienta w formacie JSON, a także dodawać nowe dane, aktualizować i usuwać je. Wszystko to zgodnie z dobrymi praktykami pracy z REST.
Praktyczny Projekt i ES6
Chwilę później czeka Cię kolejny praktyczny projekt - skracacz linków. Stworzymy wspólnie aplikację, która pozwoli skrócić dowolny adres URL do krótkiej formy. Oczywiście będzie działać również w drugą stronę! Kiedy przejdziemy pod skrócony adres, przekieruje nas do odpowiedniej witryny. Node.js to platforma wręcz stworzona do tworzenia aplikacji typu real-time, dlatego w kolejnym rodziale podejmiemy temat technologii WebSockets. Dowiesz się jakie są jej zalety, a także jak pracować z nią po stronie serwera i klienta. Tutaj czeka nas kolejny praktyczny, niezwykle ciekawy projekt. Wykonamy bowiem czat grupowy. Aplikacja ta pozwoli dowolnej ilości użytkowników podłączyć się do czatu podając swój nick, a następnie wysyłać widoczne dla wszystkich wiadomości. Zaimplementujemy nawet takie rozwiązania jak wyświetlanie statusów o dołączeniu kogoś do czatu, a także o jego opuszczeniu.W przedostatnim rodziale tego kursu podejmiemy tematykę dobrych praktyk pracy z Node.js. Na początku omówimy najważniejsze konstrukcje nowej specyfikacji EcmaScript 2015, które są znakomicie wspierane w Node. Chwilę później omówimy jak korzystanie z Promises uprości, a także ulepszy nasz kod. Wśród dobrych praktyk nie zabraknie również informacji o debugowaniu aplikacji. Zobaczysz sprawdzone sposoby, by znaleźć błędy lub lepiej, krok po kroku, zrozumieć jak działa napisany wcześniej kod. Dowiesz się również jak pracować z błędami, by Twoje aplikacje działały w sposób przewidywalny.
Praktyczny projekt z Git i Heroku
Ostatni rozdział w całości został poświęcony temu, co zwykle jest pomijane w innych materiałach, mianowicie wdrażaniu aplikacji do produkcji. Przez cały ten kurs pracować będziemy lokalnie, lecz kiedy aplikacje są już gotowe, wypadałoby udostępnić je światu. Wdrażanie aplikacji napisanych z użyciem Node.js nie jest jednak tak oczywiste, jak np. wgrywanie WordPress’a u wybranego hostingodawcy. Ty będziesz miał jednak możliwość zobaczyć, jak wdrożyć napisany przez nas grupowy czat na platformie Heroku. Jest to bardzo popularny serwis działający jako PaaS (Platform as a Service). Za darmo będziesz mógł w ciągu kilku chwil uruchomić swoją aplikację.Zobaczysz o co należy zadbać, by wszystko poszło gładko. Serwisy typu PaaS dbają o bardzo wiele aspektów wdrażania i serwowania naszych aplikacji, takich jak bezpieczeństwo oraz nieustanną dostępność. Mają jednak pewne ograniczenia. Z tego powodu, dowiesz się również jak wdrożyć swoją aplikację na serwerze wirtualnym VPS z systemem Ubuntu Server. Takie rozwiązanie daje nam całkowitą kontrolę, ale także obarczone jest większą odpowiedzialnością. Zaczniemy od instalacji na serwerze platformy Node.js, systemu kontroli wersji GIT, a także innych niezbędnych modułów
Konfiguracja środowiska i porady
Następnie zobaczysz jak skonfigurować swoje lokalne środowisko tak, by za pomocą GIT’a wysyłać kod do zdalnego serwera, a potem jednym poleceniem wdrażać go do produkcji. Dowiesz się również jak jednocześnie serwować wersję produkcyjną oraz developmencką. W rodziale tym poruszymy również inne kwestie, takie jak procesy potomne czy tworzenie klastrów. Dzięki tej wiedzy, będziesz mógł maksymalnie wykorzystać dostępne zasoby serwera. Na sam koniec tego kursu rzucimy okiem również na inne, nie przedstawione wcześniej zastosowania Node, a także nakreślimy dalszą drogę nauki w tym zakresie.
Dla kogo jest ten kurs?
Kurs ten jest dla wszystkich osób, które dobrze czują się w technologiach frontendowych, tj. HTML, CSS i JavaScript, a teraz chcą rozpocząć swoją przygodę z back-endem. Im zatem lepiej znasz język JavaScript, tym więcej wyciśniesz z Node, natomiast nie jest wymagana bardzo zaawansowana wiedza z zakresu tego języka.
W tej lekcji pokażę ci, jak wygląda wsparcie dla ECMAScript 2015 w Node.js,
w jego najnowszych wersjach. ES2015 lub w skrócie nazywane również ES6 jest to najnowsza wersja języka
ECMAScript
czy można powiedzieć, że języka JavaScript, bo jest to wersja specyfikacji z 2015 roku.
Przeglądarki internetowe jeszcze nie są aż tak dobre we wspieraniu wszystkich najnowszych rzeczy, które
są dostępne w EcmaScript 6.
Może Chrome radzi sobie dobrze, ale jeżeli napiszemy kod typowo pod ES6, to może to nie działać w Firefox
albo w jakiejś innej starszej przeglądarce.
Dlatego musimy korzystać z różnych kompilerów, takich jak np. Babel.
Natomiast jeżeli chodzi o Node, to w najnowszych wersjach Node bardzo dobrze wspiera ES6 i możesz to zobaczyć
na stronie node.green.
Tutaj widzimy naszą wersję, czyli 6.7.0, na której pracujemy w tym kursie. I możesz zobaczyć drobnym drukiem,
że jest to 99%, jeżeli chodzi o kompatybilność.
I tutaj można zobaczyć oczywiście poszczególne rzeczy, które są wspierane, a które nie są. W tym momencie
nie będę ci tego pokazywał, ale możesz sobie to sprawdzić. I teraz to, co jest istotne, to będę chciał ci
pokazać, z których rzeczy warto korzystać, jeżeli chodzi o ECMAScript 2015 w Node.js, a z części z nich już do
tej pory korzystaliśmy. Dlatego teraz zamknę to okno i przejdziemy sobie prosto do kodu, w którym mamy taki
plik examples i w tym examples będę chciał ci pokazać, jak działają najważniejsze rzeczy w ES6.
Podstawowa sprawa, z której korzystaliśmy przez cały ten kurs, jest to tworzenie stałych za pomocą const.
Zazwyczaj stałe powinniśmy nazywać wielkimi literami, zależy co to będzie. Więc możemy utworzyć stałą A = 1.
I to, co jest ważne, stałe działają w ten sposób, że nie można zmienić ich wartości.
Gdybym chciał napisać teraz A = 2, to wykonajmy sobie ten kod.
Node examples i zobaczysz, że mamy błąd: Assigment to constant variable. Czyli nie możemy po prostu zmieniać stałych.
Jest to jedna z najważniejszych rzeczy.
Może ja to po prostu wykomentuję w ten sposób.
Kolejną rzeczą, która jest również bardzo ciekawa, jeżeli chodzi o ECMAScript, jest tworzenie zmiennych nie za
pomocą var, ale za pomocą let.
Najpierw może utwórzmy zmienną a za pomocą var - a = 1. I zobaczmy, co stanie się, jeżeli spróbujemy
użyć tej zmiennej, zanim ją zadeklarujemy.
Zobaczmy, czy pojawi się błąd.
Wykonujemy plik. Mamy wartość undefined.
To jest bardzo ważne i tłumaczyłem to w kursie JavaScript od podstaw.
Zmienne są wynoszone (i z angielskiego to nazywa się variable hoisting), to znaczy, że chociaż my tutaj ją tak
naprawdę deklarujemy, to ona jest wynoszona na samą górę zakresu zmiennych.
Gdybyśmy byli w jakiejś funkcji - tak naprawdę wiesz, że cały ten nasz kod będzie opleciony funkcją i
wszędzie możemy z tej zmiennej korzystać, ale ma ona wartość undefined, czyli to działa dokładnie tak,
jakbyśmy napisali gdzieś u góry var a, następnie zrobili console.log(a), a potem dopiero przypisali
a = 1.
Tak to zadziałało przed momentem.
Natomiast jeżeli skorzystamy sobie nie z var a, tylko let a = 1, to tutaj zobaczysz - będziemy mieli błąd.
Czyli nie możemy korzystać ze zmiennej, zanim nie została ona zadeklarowana.
Tutaj już to variable hoisting nie działa.
Innym ciekawym zastosowaniem let - pokażę ci to na przykładzie pętli, zrobimy pętlę standardową for - jest
fakt, że jeżeli robiliśmy pętlę i tutaj inicjalizowałem sobie i na zero, to po dziesięciu iteracjach ta wartość
i w tym przypadku tutaj będzie miała 10. Zobaczmy w console.log, czy możemy ją wyświetlić.
Tak. Mamy tutaj 10. Natomiast nie po to tu włożyłem tę zmienną, żeby ona mi przeciekała do tego zakresu, ale po
to, aby korzystać z niej w pętli. Natomiast wystarczy, że zamienimy to na let.
To jest świetne użycie właśnie słowa kluczowego let do tworzenia zmiennych. I okazuje się, że mamy błąd: i is not
defined, czyli nie możemy korzystać z tej zmiennej, bo jej nie ma.
Podobnie jeżeli chodzi o bloki if. Jeżeli mamy if i jakąś wartość, to jeżeli tutaj zrobimy let na przykład a = 1
i spróbujemy sobie tutaj wyświetlić a, to będziemy mieli błąd: a is not defined.
Dokładnie tak samo. A w przypadku var mielibyśmy dostęp do tej zmiennej. Czyli warto z let również korzystać
w takich przypadkach. Kolejną z ciekawych rzeczy jest jakby taki skrócony zapis tworzenia metod w obiektach.
Czyli gdybym chciał sobie stworzyć obiekt o i w środku chciałbym mieć funkcję, która nazywa się log, to mógłbym
to napisać w ten sposób. Ona przyjmie jakiś message i sobie go wyświetlimy za pomocą console.log.
Przy okazji skorzystamy również z kolejnej świetnej rzeczy w ECMAScript, z której już korzystaliśmy, czyli
template stringi.
Możemy sobie tutaj napisać Message: msg. To również jest w ECMAScript i teraz odwołamy się do o.log i podamy Hej.
W konsoli wynik będzie jak najbardziej przewidywalny. Natomiast to, co jest ciekawe w ECMAScript 6, to nie musimy
pisać tego function. Możemy od razu zrobić to w ten sposób,
czyli log. I to tak samo będzie zwyczajna funkcja. To jest tylko tzw. syntactic sugar, czyli wygląda to
ładniej w zapisie, ale działa dokładnie w taki sam sposób.
Zauważ - wynik jest dokładnie ten sam.
I teraz jeszcze jedna rzecz, którą chciałbym ci pokazać. Zrobimy sobie moduł gdzieś osobny. Tutaj go będę chciał
sobie zainkludować, więc napiszemy mod = require("./module") i teraz sobie go utworzymy w tym katalogu, w którym jesteśmy, czyli
37/module.js.
Pamiętasz, jak tutaj robiliśmy module.exports. Może ja najpierw wstawię tutaj dwie funkcje, czyli mamy jakąś wartość
i funkcję get, która ją zwraca, i funkcję set, która ją ustawia. I pamiętasz, że robiliśmy module.exports do
tej pory. Bo ja nie pokazywałem ci wielu rzeczy, jeżeli chodzi o ECMAScript 6
w tym kursie, żeby ci nie zamieszać. Jeżeli z tego jeszcze nie korzystałeś, to ucząc się Node, gdybyś od
razu widział to wszystko, to mogłoby ci na tyle zamieszać, że trudno byłoby ci się w tym ogarnąć. Dlatego
pokazuję część z tych rzeczy teraz. Jeżeli np. chcieliśmy wyeksportować funkcję, która się będzie nazywać
get i kierować na get, no to pisaliśmy w ten sposób. I set: set. To jest normalna sprawa. Te funkcje się
tak nazywają, więc tak to eksportujemy. I po tej stronie możemy z tego skorzystać, np. mod.set i ustawimy
sobie na 2 i następnie console.log zrobimy mod.get. I zobaczymy, co nam się wyświetli.
Widzimy, że mamy jakiś błąd. Czyli pewnie w złym folderze to utworzyłem. Tak, utworzyłem to w folderze 37 - ten module.
Przenieśmy go sobie do folderu 38. W porządku. Teraz wykonam raz jeszcze ten kod i mamy dwójkę. Natomiast
jaka jest nowość, jeżeli chodzi o ECMAScript 6? Taka, że jeżeli chcemy eksportować taki obiekt, gdzie będziemy
mieli nazwę tutaj tego klucza taką samą, jak nazwę, którą przypisujemy do tego, czyli to jest referencja na funkcję,
to możemy to skrócić do takiego zapisu get, set. Dokładnie znowu jest to syntctic sugar, czyli działa
to w ten sam sposób. Dziwnie wygląda na pierwszy rzut oka, ale efekt będzie dokładnie ten sam. Więc możemy
jeszcze skrócić sobie ten zapis, wpisując to w ten sposób. Powiedzmy get i set. I taki zapis sprawi, że
to będzie działać dokładnie w ten sam sposób, czyli wtedy nie musimy się po prostu powtarzać.
Ostatnie dwie rzeczy, które chcę ci pokazać zrobimy na module Puller, który stworzyliśmy na początku tego
kursu.
Mam nadzieję, że go pamiętasz.
Tutaj mamy jego plik index.
I pamiętaj, że tutaj sobie robiliśmy require("./puller) i wykonywaliśmy takiego nowego Pullera, podając mu ten adres.
On działa w ten sposób - zróbmy sobie node index - że wyświetlał nam tutaj jakby dane pobrane z Internetu.
Pewnie pamiętasz ten przykład. I za chwilę to się zakończy. Jeżeli nie, to dokładnie sobie go jeszcze przejrzyj.
Jest on tutaj. Natomiast będę chciał ci pokazać, jak możemy tworzyć klasy w
ECMAScript 6.
Standardowo w JavaScript klasy tworzy się tak, że tworzymy funkcję, tak jak tutaj Puller, a potem tworzymy
nowy obiekt, wywołując new Puller, tak jak to zrobiliśmy tutaj.
Natomiast ECMAScript 6 pozwala tworzyć klasy w trochę prostszy sposób, mianowicie za pomocą słowa kluczowego
class. Czyli można napisać Puller i w ten sposób stworzyć klasę.
To wszystko co do funkcji - tutaj mamy funkcję - dodawaliśmy na prototypie.
To w przypadku takiej klasy dodajemy sobie od razu w środku, czyli np. pull i nie przypisujemy funkcji, tylko
od razu podajemy to w ten sposób.
Więc dokładnie tak samo to działa. To znowu jest syntactic sugar, czyli wygląda inaczej, ale pod spodem to jest dokładnie
to samo, czyli class Puller.
I tutaj metoda pull. To jest dokładnie to samo, jak stworzenie funkcji Puller, a potem dodanie do niej prototypu
pull, do jej prototypu pull.
W przypadku funkcji, jeżeli ją wywołujemy, to od razu tutaj podawaliśmy URL, czyli to był tzw. konstruktor.
Tutaj podawaliśmy ten URL. W przypadku klas w ECMAScript podajemy sobie specjalną funkcję, która nazywa się
constructor.
I tutaj przekażemy ten URL. Czyli ta funkcja wywoła się, kiedy zrobimy new Puller, bo to pozostaje bez zmian.
Tutaj sobie go eksportujemy na końcu tego Pullera. Prawda?
Na dole module.exports.
Więc tutaj działa to dokładnie tak samo. Czyli kiedy zrobimy new Puller i to przekażemy, to
wywoła się ta funkcja i tutaj będzie przekazany ten parametr.
Dlatego teraz będę chciał sobie tego Pullera, którego mieliśmy poniżej, zamienić, ale jedna ważna rzecz jest taka, że my sobie dziedziczyliśmy
z EventEmittera. I teraz jak wygląda dziedziczenie?
Otóż tworzenie standardowej klasy wygląda tak, ale jeżeli chcesz, by ona dziedziczyła z jakiegoś innego
konstruktora, to musimy tutaj napisać extends.
I tutaj musimy podać właśnie taką klasę, czyli EventEmitter.
Wcześniej musieliśmy to zrobić za pomocą utils.inherits. To ci pokazałem i to tak naprawdę pod spodem
ustawiało prototypy.
Gdybyś zajrzał do kodu źródłowego tej funkcji, ja takie rzeczy tłumaczyłem w kursie JavaScript w praktyce
bardzo dokładnie, nie jest to zbyt skomplikowane.
Natomiast teraz to, co mamy tutaj, musimy sobie wszystko wykomentować i przepiszemy to na ten nowy syntax.
Czyli konstruktor to jest to, co mieliśmy w tym miejscu. Skopiuję sobie ten kod.
Ale zauważ jedną niesłychanie ważną rzecz. Otóż robiliśmy tutaj coś takiego jak EventEmitter.call(this).
Mówiłem ci, że to jest po to, aby do tego obiektu nowo utworzonego za pomocą new, który jest tutaj, będzie
to puller, aby przypisać wszystko, co przypisałby konstruktor EventEmittera.
Teraz już nie musimy tego robić. Wystarczy, że w tym miejscu wpiszemy sobie super. Znowu na początku wygląda to
dziwnie, ale mamy taką funkcję super, która odwołuje się do tej klasy, z której dziedziczymy.
Tyle wystarczy i efekt jest dokładnie taki sam. Czyli znowu jest to tylko syntactic sugar. To wygląda
inaczej, ale działa dokładnie tak samo.
Czyli mamy już konstruktor i teraz metodę pull będę sobie chciał skopiować.
Ona była w tym miejscu.
Wrzucę to w tym miejscu. Zauważ, że tutaj nie dajemy przecinków. Możemy sobie zrobić Enter. Ok.
I ostatnia metoda to była metoda stop, więc teraz sobie ją dodamy.
Ok.
Zauważ, że wygląda to ładniej, trochę czyściej i na końcu Puller
oczywiście sobie eksportujemy.
Więc to powinno działać tak samo, jak działało przed momentem. Spróbujmy to wykonać. Powinien być efekt
ten sam.
Jak widzisz, dokładnie tak się dzieje.
Czyli w ten sposób możemy ładniej i łatwiej tworzyć klasy. Pojawił się jakiś błąd, zaraz go obsłużymy i
dodatkowo możemy dziedziczyć bez żadnego problemu.
Błąd to jest callback is not defined w pliku puller.js, w 38 linijce. Zobaczmy. Dokładnie. Bo tutaj metoda stop
jeszcze przyjmowała callback, więc teraz to już będzie działać jak należy.
Dokładnie tak się stało.
I ostatnia rzecz, którą chcę ci pokazać, jest to tak zwana arrow function.
Są to funkcje, które znowu wyglądają dziwnie. Chcę ci pokazać, gdzie mieliśmy problem. Mianowicie w metodzie
pull i szczególnie dobrze widać to było tutaj pod spodem.
Musiałem do self zapisać sobie this, dlatego że jeżeli wykonywałem funkcję w setInterval - tutaj tę funkcję -
to wewnątrz chciałem się odwołać właśnie do this.url.
Ale tutaj słowo kluczowe this nie kierowałoby na to samo this, co w tym zakresie, tylko na globalny obiekt,
jeżeli bylibyśmy w tej funkcji. Natomiast mamy coś takiego w ECMAScript 6 jak arrow functions.
One są po pierwsze krótsze, a po drugie nie mają tego problemu. Więc w którym miejscu to było? Było to dokładnie
tutaj. Wyrzućmy sobie to, co było tutaj. I wyciągnę sobie kod tej funkcji. Zamiast tej funkcji i zamiast całej tej
deklaracji function wpiszemy sobie coś takiego.
Zauważ. Czyli piszę sobie takie nawiasy okrągłe, one mogą przyjmować jakieś parametry, w tym przypadku nie są
potrzebne, strzałka i następnie blok tej funkcji i wklejam to tutaj. Teraz zamiast self mogę skorzystać
z this.
Tutaj wyżej też mogło być this. I tutaj będę mógł skorzystać z this.
Czyli to, co stworzyłem, jest to tak zwana arrow function.
Bardzo dziwnie wygląda, ale gdybym to zaznaczył, to jest to, co mieliśmy wcześniej, czyli deklaracja funkcji
anonimowej, tylko że ta funkcja nie ma już tego problemu z this. Ona sobie pobierze this z tego zakresu, który
był wcześniej.
Czyli nie ma problemu z kontekstem.
Jeżeli to sobie zapiszemy, to nie powinno być również problemu z wykonaniem tego modułu.
Zobaczmy.
Nie ma błędów, a więc wszystko działa poprawnie.
Takie funkcje arrow mogą przyjmować również parametry. I te parametry mogą być później tutaj obsługiwane, ale
jeszcze w tym kursie to zobaczysz.
Podsumowując, tak wygląda w skrócie wsparcie ECMAScript.
Oczywiście jest jeszcze dużo więcej rzeczy, z których można by było korzystać w Node.
Pamiętaj, że musisz mieć wersję, która wspiera takie rzeczy, więc najlepiej korzystać z najnowszej wersji
lub zerknąć na stronę node.green,
czy twoja wersja jest dobrze wspierana.
Jeśli natomiast chciałbyś się nauczyć korzystania z ECMAScript 6, to śledź uważnie eduweb.pl,
dlatego że w momencie, kiedy te słowa wypowiadam, planuję materiał, który będzie poświęcony wyłącznie
ECMAScript 6.