├── README.md
└── app
├── test.js
├── zadanie01.js
├── zadanie02.js
├── zadanie03.js
└── zadanieDnia.js
/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | # Node.js challenge
4 |
5 | Witaj w challengu Node.js, gdzie codziennie przez 7 dni zdobędziesz konkretną dawkę informacji dotyczących Node.js oraz wykorzystasz ją w praktyce. **Pamiętaj żeby wykonywać dni challengu po kolei - od dnia pierwszego do ostatniego** (dzięki temu Twoja wiedza będzie poukładana i kompletna).
6 |
7 | Każdy dzień to jeden temat przewodni. W jego ramach **stworzysz aplikację Node.js, która faktycznie będzie potrafiła coś zrobić** - od razu zobaczysz wynik swojej pracy.
8 |
9 | ___
10 |
11 | > Kilka ważnych informacji
12 |
13 | Przed przystąpieniem do rozwiązywania zadań przeczytaj poniższe wskazówki
14 |
15 | **Do pełnego i satysfakcjonującego doświadczania tego challengu jest potrzebna znajomość JavaScript z elementami ES6.** Jeżeli potrzebujesz informacji z zakresu ES6 to znajdziesz je tutaj: [*tutorial ES6*][es6-tutorial].
16 |
17 | ## Jak zacząć?
18 |
19 | 1. Stwórz [*fork*][forking] repozytorium z zadaniami.
20 | 2. [*Sklonuj*][ref-clone] repozytorium na swój komputer.
21 |
22 | Poszczególne zadania rozwiązuj w odpowiednich plikach.
23 |
24 | ## Plan challengu
25 |
26 | * Pierwszy dzień to wstęp do Twojej przygody z Node.js - dowiesz się w jaki sposób przygotować środowisko oraz jak pisać i testować programy Node.js.
27 | * W kolejnych dniach dowiesz się w jaki sposób za pomocą Node.js wchodzić w interakcję z systemem operacyjnym (np. modyfikować pliki czy dokonywać szyfrowania).
28 | * Druga część challengu jest poświęcona tworzeniu back-endu - dowiesz się jak stworzyć własny serwer.
29 | * Pod koniec doświadczysz roli full-stack developera - stworzysz komunikujący się ze sobą front-end i back-end.
30 |
31 | ___
32 |
33 | # Dzień 1: Początki Node.js Developera
34 |
35 | ## Czym jest Node.js
36 |
37 |
38 |
39 | Node.js jest środowiskim uruchomieniowym JavaScript poza przeglądarką. Pozwala więc na użycie znanego Ci JS po stronie back-endu, ale także do tworzenia aplikacji systemowych, narzędziowych i innych.
40 |
41 | Podczas tych 7 dni poznasz zarówno możliwości integracji z systemem operacyjnym, jak i stworzenia w pełni działającego back-endu. Dogłębne poznanie Node.js pozwala także wykorzystywać go w innych zastosowaniach, np. do pisania aplikacji okienkowych, mobilnych, w chmurze, IoT, czy sztucznych sieciach neuronowych.
42 |
43 | ## Przygotowanie środowiska
44 |
45 | Jeżeli jesteś programistą front-end to bardzo możliwe, że posiadasz już zainstalowany Node.js! Jest on szeroko używany w takich narzędziach jak WebPack czy Gulp.
46 |
47 | Uruchom terminal/linię komend i wpisz następujące polecenie:
48 |
49 | ```cmd
50 | node -v
51 | ```
52 |
53 | Jeżeli zobaczysz napis podobny do tego:
54 |
55 | ```cmd
56 | $ node -v
57 | v6.9.5
58 | ```
59 |
60 | to Twoje środowisko jest już gotowe do działania z Node.js - możesz pominąć dział _Instalacja Node.js_! Jeżeli widzisz natomiast informację o braku polecenia lub programu, bądź wersja jest poniżej v6 to wykonaj poniższe kroki.
61 |
62 | ### Instalacja Node.js
63 |
64 | Wejdź na stronę [*pobierania Node.js*][download-node], wybierz wersję **LTS** odpowiednią dla Twojego systemu operacyjnego. Postępuj według wskazówek, żeby zainstalować Node.js.
65 |
66 | > Jeżeli ciekawi Cię co oznacza wersja LTS - jest to taka wersja oprogramowania, której wsparcie zostało przedłużone (z ang. *long term support*). Nie będzie więc szybko porzucona i jest wspierana przez kilka lat.
67 |
68 | ## Uruchamianie programu Node.js
69 |
70 | Wszystkie ćwiczenia będziesz wykonywać na plikach w folderze `app` tego repozytorium. **Pamiętaj, aby otrzorzyć linię komend/terminal i przejść nim do tego folderu.** Przykładowo, jeżeli to repozytorium sklonowałeś/aś do folderu `/home/ja/Node.js_challenge_dzien_1` to wykonaj komendę:
71 | ```cmd
72 | cd /home/ja/Node.js_challenge_dzien_1/app
73 | ```
74 |
75 | Teraz już możesz uruchomić program Node.js :) Wykonujemy to za pomocą komendy:
76 |
77 | ```cmd
78 | node nazwa_pliku [ewentualne argumenty]
79 | ```
80 |
81 | Śmiało, spróbuj to zrobić już teraz! W katalogu `app` znajduje się plik `test.js`, aby go uruchomić wpisz:
82 |
83 | ```cmd
84 | node ./test.js
85 | ```
86 |
87 | Powinna się pokazać poniższa informacja:
88 | ```cmd
89 | Wygląda na to, że wszystko działa :)
90 | ```
91 |
92 | > **Pamiętaj, aby linia komend/terminal był otwarty na katalogu `app`!**
93 | >
94 | > Jeżeli ta komenda nie działa u Ciebie to możesz ew. spróbować:
95 | > ```cmd
96 | > nodejs ./test.js
97 | > ```
98 | > Jeżeli nadal nic to nie da to jeszcze raz zainstaluj Node.js jeszcze raz, a następnie zrestatuj komputer.
99 |
100 | ## Flow aplikacji Node.js
101 |
102 | Kiedy uruchamiamy program napisany w Node.js poprzez wskazanie pliku, to jest on traktowany podobnie jak w przeglądarkowym JavaScript-cie. Wykonywane są wszystkie komendy od góry do dołu.
103 |
104 | ## Podstawowe API Node.js
105 |
106 | Nauczymy się teraz kilku podstawowych i standardowych funkcji/metod wbudowanych w Node.js i dostępnych dla nas od razu. To pomoże nam zrozumieć działanie Node oraz wykonać pierwsze operacje.
107 |
108 | ### Hello, World, czyli jak wypisywać własne komunikaty?
109 |
110 | W Node.js możesz korzystać z bardzo podobnego API do wypisania tekstu, jak w przypadku przeglądarki. Jest to przemyślana decyzja twórców Node, żeby front-endowiec mógł łatwo wykorzystać nowe narzędzie.
111 |
112 | W związku z tym aby w linii komend/terminali wypiswać dowolną informację możesz skorzystać np. z:
113 |
114 | ```JS
115 | console.log('Mój tekst');
116 | ```
117 |
118 | ### Funkcje czasu
119 |
120 | Możemy także wykorzystać standardowe funkcje czasu takie jak np.:
121 |
122 | ```JS
123 | setTimeout(() => {
124 | //Funkcja wykona się po 2s.
125 | }, 2000);
126 | ```
127 |
128 | czy
129 |
130 | ```JS
131 | setInterval(() => {
132 | //Funkcja wykona się co 1s.
133 | }, 1000);
134 | ```
135 |
136 | Należy zwrócić szczególną uwagę na znaczenie tych funkcji w kontekście Node.js.
137 |
138 | Jeżeli nasz program zawiera np. komendę która od razu ma coś zrobić i nic więcej - to od razu po jej wykonaniu Node.js zakończy wykonywane programu.
139 |
140 | Jeżeli jednak w naszym kodzie jest `setTimeout`, `setInterval` (lub inne funkcje powodujące uruchomienie czegoś w przyszłości) to Node.js zgodnie z naszą intencję nie zakończy od razu programu.
141 |
142 | - W przypadku setTimeout dopiero po wykonaniu odroczonej w czasie funkcji program zakończy się.
143 | - Użycie setInterval spowoduje natomiast, że _taki program w Node.js nigdy sam się nie zakończy w normalnych warunkach_. Aby go zakończyć najprościej będzie użyć `clearInterval` lub ręcznie zakończyć proces (np. skrótem `Ctrl+C`).
144 |
145 | Jeżeli korzystasz z WebPacka, czy Gulpa z `watch` to znasz już miejsce gdzie jest to potrzebne. Dzięki temu proces działa cały czas i wykonuje powierzone mu zadania.
146 |
147 | Za kilka dni zobacysz, że takie specjalne traktowanie pewnych funkcji przez Node.js jest też bardzo przydatne przy budowaniu back-endu.
148 |
149 | ### Przykład
150 |
151 | Oto przykładowy program Node.js, który wypisuje po jednym znaku "Hello, World", a na końcu przerywa swoje działanie.
152 |
153 | ```JavaScript
154 | const text = 'Hello, World!';
155 |
156 | let counter = 0;
157 | //Program wyświetla po znaku z tekstu...
158 | const intervalId = setInterval(() => {
159 | console.log(text[counter]);
160 | counter++;
161 |
162 | //...ręcznie musimy mu powiedzieć kiedy należy przerwać wykonywanie - wtedy proces Node.js się zakończy
163 | if (counter === text.length){
164 | clearInterval(intervalId);
165 | }
166 | }, 400);
167 | ```
168 |
169 | Po uruchomieniu takiego programu zobaczymy:
170 | ```cmd
171 | $ node ./test.js
172 | H
173 | e
174 | l
175 | l
176 | o
177 | ,
178 |
179 | W
180 | o
181 | r
182 | l
183 | d
184 | !
185 |
186 | $_
187 | ```
188 |
189 | ## Argumenty
190 |
191 | Na samym początku, podczas uruchamiania programu, była informacja o opcjonalnych argumentach. Są to dane wejściowe, które możemy przekazać do naszego programu - są one **jak parametry funkcji**.
192 |
193 | Korzystając z różnych narzędzi możesz trafić na sytuację, że przekazujemy do programu Node.js jakiś argument, np.:
194 |
195 | ```cmd
196 | gulp watch
197 | ```
198 |
199 | > To polecenie jest tak na prawdę wewnętrznie skrótem np. do:
200 | > ```cmd
201 | > node /home/some/path/bin/gulp.js watch
202 | > ```
203 |
204 | Jeżeli będziemy potrafili obsłużyć przekazywane argumenty, to nasz program może stać się przydatnym narzędziem.
205 |
206 | ### Zmienna globalna `process`
207 |
208 | W każdym programie Node.js masz do dyspozycji zmienną globalną `process`, która reprezentuje uruchomienie właśnie Twojego programu. Można z niej odczytać wiele informacji na temat środowiska uruchomieniowego.
209 |
210 | ### Odczytywanie argumentów
211 |
212 | Aby otrzymać listę wszystkich argumentów możemy wykorzystać tablicę `process.argv`. Zawiera ona następujące informacje:
213 |
214 | 1. Pierwszy argumentem jest pełna ścieżka do procesu interpretera Node.js.
215 | 2. Drugi argument to pełna ścieżka do głównego pliku Twojego programu.
216 | 3. Drugi i kolejne argumenty mogą być dodatkowymi argumentami - przekazywanymi właśnie podczas uruchamiania programu.
217 |
218 | Zobacz poniższy kod:
219 |
220 | ```JavaScript
221 | process.argv.forEach((val, index) => {
222 | console.log(`${index}: ${val}`);
223 | });
224 | ```
225 |
226 | Jeżeli uruchomisz swój program tak:
227 |
228 | ```cmd
229 | node ./test.js
230 | ```
231 |
232 | to zobaczysz przykładowo:
233 |
234 | ```cmd
235 | 0: /home/bin/node
236 | 1: /home/js/challenge/test.js
237 | ```
238 |
239 | Możesz jednak przekazać dodatkowe argumenty, np.:
240 |
241 | Jeżeli uruchomisz swój program tak:
242 |
243 | ```cmd
244 | node ./test.js test 123 Halo halo
245 | ```
246 |
247 | wtedy zobaczysz np.:
248 |
249 | ```cmd
250 | 0: /home/bin/node
251 | 1: /home/js/challenge/test.js
252 | 2: test
253 | 3: 123
254 | 4: Halo
255 | 5: halo
256 | ```
257 |
258 | Jeżeli chcesz przekazać argument, który zawiera w środku spację, to otocz go `"` (cudzysłowem), np.:
259 |
260 | ```cmd
261 | node ./test.js "Hello, World, dłuższy tekst!" test2
262 | ```
263 |
264 | da np.:
265 |
266 | ```cmd
267 | 0: /home/bin/node
268 | 1: /home/js/challenge/test.js
269 | 2: Hello, World, dłuższy tekst!
270 | 3: test2
271 | ```
272 |
273 | # Ćwiczenia
274 |
275 | > Ćwiczenia wykonuj w odpowiednich plikach. W folderze `app` są one ponumerowane tak samo jak poniżej - zadaniu `1. Rozgrzewka` odpowiada plik `app/zadanie01.js` itd.
276 | > Aby uruchomić zadanie podaj jego nazwę (pamiętaj, aby linia komend/terminal był otwarty na katalogu `app` tego repozytorium), np.:
277 | > ```cmd
278 | > node ./zadanie01.js
279 | > ```
280 |
281 | ## 1. Rozgrzewka!
282 |
283 | Napisz taki program Node.js, w którym wyświetlisz swoje imię i nazwisko. Następnie po 5 sekundach program powinien jeszcze wypisać `wita się z Node.js!` i zakończyć swoje działanie.
284 |
285 | ## 2. Odpowiednia kolejność
286 |
287 | Napisz program, który wypisze poniższe tekst zgodnie z zadaną kolejnością. Najpierw jest informacja po jakim czasie od uruchomienia programu tekst powinien się pojawić, a następnie jaki to tekst. _Jaki tekst się ułożył :) ?_
288 |
289 | - Po 4 sekundach od uruchomienia: `Node.js`
290 | - Po 1 sekundzie od uruchomienia: `się`
291 | - Od razu po uruchomieniu wyświetl: `Witam`
292 | - Po 6 sekundach od uruchomienia: `i korzystam`
293 | - Po 5 sekundach od uruchomienia: `w konsoli`
294 | - Po 7 sekundach od uruchomienia: `z funkcji czasu!`
295 | - Po 2 sekundach od uruchomienia: `z`
296 | - Po 3 sekundach od uruchomienia: `programem`
297 |
298 | ### 3. Dodawanie
299 |
300 | Napisz program Node.js, który może przyjąć dwa argumenty: dwie liczby. **Pamiętaj, że argumenty są zawsze tekstem - zamień je w liczbę np. za pomocą `Number(liczba)` lub `parseInt(liczba)`.**
301 |
302 | Następnie wykonaj dodawanie tych dwóch liczb i je wypisz.
303 |
304 | Przykładowo uruchomienie:
305 |
306 | ```cmd
307 | node ./zadanie03.js 2 4
308 | ```
309 |
310 | Powinno wypisać `6`.
311 |
312 | > \* Jeżeli chcesz to możesz spróbować zrobić bardziej zaawansową wersję tego zadania. Twój program umożliwia w niej podanie dowolnej ilości liczb jako argumenty i wyświetla ich sumę.
313 | > Przykładowo uruchomienie:
314 | >
315 | > ```cmd
316 | > node ./zadanie03.js 1 2 3 4
317 | > ```
318 | >
319 | > Powinno wypisać `10`.
320 | >
321 | > Pamiętaj, że dwa pierwsze argumenty tablicy `process.argv` trzeba pominąć!
322 |
323 | ### Zadanie dnia: sleep sort
324 |
325 |
326 |
327 | Sleep sort to zabawny sposób sortowania liczb. Polega on na tym, że każda liczba jest wypisana dopiero po tylu sekundach ile wynosi jej wartość.
328 |
329 | Przykładowo posiadając liczby: `4, 1, 7, 4, 5` wypisujemy `4` po 4 sekundach, `1` po sekundzie, `7` po 7 sekundach itd. Przez to program w tym przypadku wykonuje się 7 sekund a jego wyjście wygląda w ten sposób:
330 |
331 | ```cmd
332 | 1
333 | 4
334 | 4
335 | 5
336 | 7
337 | ```
338 |
339 | Stwórz program Node.js, który może przyjąć dowolną ilość argumentów: liczby. **Pamiętaj, że argumenty są zawsze tekstem - zamień je w liczbę np. za pomocą `Number(liczba)` lub `parseInt(liczba)`.** Pamiętaj, że dwa pierwsze argumenty tablicy `process.argv` trzeba pominąć!
340 |
341 |
342 | Następnie wypisz w konsoli liczby od najmniejszej do największej korzystając ze sleep sort. Do zadania użyj `setTimeout`, a czas mnóż razy 1000 (żeby `1` odpowiadało jednej sekundzie).
343 |
344 | Przykładowo uruchomienie programu w ten sposób:
345 | ```cmd
346 | node ./zadanieDnia.js 8 4 10 8 4 6 1 2
347 | ```
348 |
349 | Potrwa 10 sekund i wyświetli na końcu:
350 |
351 | ```cmd
352 | 1
353 | 2
354 | 4
355 | 4
356 | 6
357 | 8
358 | 8
359 | 10
360 | ```
361 |
362 | **To wszystko na dziś - gratulacje! Do jutra :)**
363 |
364 |
365 | [forking]: https://guides.github.com/activities/forking/
366 | [ref-clone]: http://gitref.org/creating/#clone
367 | [es6-tutorial]: http://qnimate.com/post-series/ecmascript-6-complete-tutorial/
368 | [download-node]: https://nodejs.org/en/download/
--------------------------------------------------------------------------------
/app/test.js:
--------------------------------------------------------------------------------
1 | console.log('Wygląda na to, że wszystko działa :)');
--------------------------------------------------------------------------------
/app/zadanie01.js:
--------------------------------------------------------------------------------
1 | //Twój kod
--------------------------------------------------------------------------------
/app/zadanie02.js:
--------------------------------------------------------------------------------
1 | //Twój kod
--------------------------------------------------------------------------------
/app/zadanie03.js:
--------------------------------------------------------------------------------
1 | //Twój kod
--------------------------------------------------------------------------------
/app/zadanieDnia.js:
--------------------------------------------------------------------------------
1 | //Twój kod
--------------------------------------------------------------------------------