83 | ---
84 | ###Example
85 |
86 | ```javascript
87 | function httpGet(url) {
88 | return new Promise(
89 | function (resolve, reject) {
90 | var request = new XMLHttpRequest();
91 | request.onreadystatechange = function () {
92 | if (this.status === 200) {
93 | // Success
94 | resolve(this.response);
95 | } else {
96 | // Something went wrong (404 etc.)
97 | reject(new Error(this.statusText));
98 | }
99 | }
100 | request.onerror = function () {
101 | reject(new Error(
102 | 'XMLHttpRequest Error: '+this.statusText));
103 | };
104 | request.open('GET', url);
105 | request.send();
106 | });
107 | }
108 |
109 | ```
110 |
111 | ---
112 |
113 | ###Example
114 | ```javascript
115 | httpGet('http://example.com/file.txt')
116 | .then(
117 | function (value) {
118 | console.log('Contents: ' + value);
119 | },
120 | function (reason) {
121 | console.error('Something went wrong', reason);
122 | });
123 | ```
124 | ---
125 | ###Chaining (using then)
126 |
127 | ```javascript
128 |
129 | asyncFunc()
130 | .then(function (value1) {
131 | return 123;
132 | })
133 | .then(function (value2) {
134 | console.log(value2); // 123
135 | });
136 | ```
137 | ---
138 |
139 | ### Error handling
140 |
141 | ```javascript
142 |
143 | asyncFunc1()
144 | .then(asyncFunc2)
145 | .then(asyncFunc3)
146 | .catch(function (reason) {
147 | // Something went wrong above
148 | });
149 | ```
150 | ---
151 | ###Composition (map via Promise.all)
152 |
153 | ```javascript
154 | var fileUrls = [
155 | 'http://example.com/file1.txt',
156 | 'http://example.com/file2.txt'
157 | ];
158 | var promisedTexts = fileUrls.map(httpGet);
159 |
160 | Promise.all(promisedTexts)
161 | .then(function (texts) {
162 | texts.forEach(function (text) {
163 | console.log(text);
164 | });
165 | })
166 | .catch(function (reason) {
167 | // Receives first rejection among the promises
168 | });
169 | ```
170 | ---
171 | ###Workflow
172 | 
173 | ---
174 |
175 | #Итериране на обекти
176 |
177 | В ES5 нямаме много възможности да използваме някакви операции върху обекти и за това използвахме
178 | библиотеки като lodash и underscore.
179 |
180 | За радост в ES2015 това не е така. Вече имаме Iterators.
181 |
182 | ---
183 |
184 | #Какво е Iterator?
185 |
186 | ---
187 |
188 | Iterator е design pattern, който ни дава начин да достъпваме последователно елементи на някакъв контейнер (обект).
189 |
190 | Това значи, че можем да използваме един и същ интерфейс за итериране независимо от репрезентацията на обекта.
191 | 
213 | ---
214 | ###Пример
215 |
216 | ```javascript
217 | var someString = "hi";
218 |
219 | var iterator = someString[Symbol.iterator]();
220 |
221 | iterator.next(); // { value: "h", done: false }
222 | iterator.next(); // { value: "i", done: false }
223 | iterator.next(); // { value: undefined, done: true }
224 |
225 | var arr = ['a', 'b', 'c'];
226 | iterator = arr[Symbol.iterator]();
227 | iter.next() //{ value: 'a', done: false }
228 | iter.next() //{ value: 'b', done: false }
229 | iter.next() //{ value: 'c', done: false }
230 | iter.next() //{ value: undefined, done: true }
231 |
232 | ```
233 | ---
234 | ###Как да си пишем custom iterables
235 |
236 | ```javascript
237 | let iterable = {
238 | [Symbol.iterator]() {
239 | let step = 0;
240 | let iterator = {
241 | next() {
242 | if (step <= 2) {
243 | step++;
244 | }
245 | switch (step) {
246 | case 1:
247 | return { value: 'hello', done: false };
248 | case 2:
249 | return { value: 'world', done: false };
250 | default:
251 | return { value: undefined, done: true };
252 | }
253 | }
254 | };
255 | return iterator;
256 | }
257 | };
258 |
259 | for (let x of iterable) {
260 | console.log(x);
261 | }
262 | // Output:
263 | // hello
264 | // world
265 | ```
266 | ---
267 |
268 | for ... of е от ES2015 и работи с Iterator-и
269 | ```javascript
270 | for (variable of object) {
271 | statement
272 | }
273 | ```
274 |
275 | Някои вътрешни конструкции като spread оператора използват итератори
276 | ```javascript
277 | [...someString] // ["h", "i"]
278 | ```
279 | ---
280 |
281 | #Generators
282 |
283 | ---
284 |
285 | ###Какво са генераторите
286 |
287 | Генераторите са функциии с множество крайни точки.
288 |
289 | Чрез ключовата дума yield ние можем да замразим изпълнението на нашата генератор функция след което можем да продължим изпълнението и.
290 |
291 | ```javascript
292 | function* fibonacci() {
293 | var a = 0, b = 1, c = 0;
294 |
295 | while(true){
296 | yield a; //<-- suspend the generator function
297 | c = a, a = b, b = c + b;
298 | }
299 | }
300 |
301 |
302 | var seq = fibonacci(); //<--- call the generator function and to get an iterator object
303 |
304 | //След извикване на next получаваме обект { value: 0, done: false };
305 | console.log(seq.next().value); // 0
306 | console.log(seq.next().value); // 1
307 | console.log(seq.next().value); // 1
308 | console.log(seq.next().value); // 2
309 | console.log(seq.next().value); // 3
310 | console.log(seq.next().value); // 5
311 | ```
312 | ---
313 | 
53 |
54 | ---
55 | ### Какво ще стане тук?
56 | ```javascript
57 | var p1 = {
58 | x: 2,
59 | y: 5
60 | };
61 |
62 | var p2 = {
63 | x: 2,
64 | y: 5
65 | };
66 |
67 | var p3 = {
68 | y: 5,
69 | x: 7
70 | }
71 | ```
72 | ---
73 | ### Arrays
74 | * Скритите класове на масивите следят типовете на елементите
75 | * Ако един масив е пълен с doubles той се upgrade-ва (unboxed) към fast double
76 | * Невнимателно манипулиране на масивите може да причини оптимизационни проблеми (unboxing - boxing)
77 |
78 | ```javascript
79 | var a = new Array();
80 | a[0] = 77; // Allocates
81 | a[1] = 88;
82 | a[2] = 0.5; // Allocates, converts
83 | a[3] = true; // Allocates, converts
84 |
85 | var a = [77, 88, 0.5, true]; //Is better
86 | ```
87 | ---
88 | ### Arrays
89 |
90 | * Не пре-алокирайте големи масиви (>=100K елементи).
91 |
92 | * Ако знаем колко елемента ще се съдържат в масива е хубаво да пре-алокираме.
93 |
94 | * Не е хубаво да трием елементи. (Отнася се и за обекти).
95 |
96 | * За масиви с различни типове трябва да използваме Array literal.
97 | ---
98 | class: middle, center
99 |
100 | ##### Обектните литерали, които имат една и съща структура също използват едни и същи скрити класове.
101 |
102 | * За това е хубаво когато правим нови обекти да слагаме в тях всички property-та, които те ще съдържат.
103 | ---
104 | ###Какво прави v8?
105 |
106 | * v8 компилира Javascript директно до машинни инструкции (unoptimized native code) преди изпълнението му.
107 | (Няма никакво интерпретиране и bytecode)
108 |
109 | * Функциите не се компилират докато не бъдат извикани, което е хубаво защото виртуалната машина не губи време за големи библиотеки
110 |
111 | * След компилирането се пуска profiler, който избира "hot" функции, които да бъдат оптимизирани от Crankshaft (optimization compiler)
112 |
113 | ---
114 | class: middle, centeri
115 | ###Какво е NodeJS?
116 | ---
117 | class: middle, center
118 | ####Open-source, cross-platform runtime environment for developing 
121 |
122 | * libuv - high performance, cross-platform evented I/O library
123 |
124 | * js/c++ - Node екосистемата npm (node package manager) е най-голямата open-source екосистема от библиотеки в света.
125 |
126 | ---
127 | ###Малко история
128 | * Node e създаден 2009 от Ryan Dahl и други програмисти от Joyent.
129 |
130 | * 2011 година излиза npm
131 |
132 | * 2012 Ryan Dahl се оттегля от проекта
133 |
134 | * 2014 поради вътрешен конфликт излиза форк на node с името io.js
135 |
136 | * 2015 node and io.js merge
137 |
138 | ---
139 | ###Runtime
140 |
141 | * v8 event loop се грижи за javascript и C++ модулите, които работят в main thread-а.
142 |
143 | * Ако нещо работи извън main thread-а libev и libuv го обработват в thread pool. libuv прави връзката с main thread-а.
144 |
145 | 
146 | ---
147 | ###Конвенции
148 |
149 | ```javascript
150 |
151 | var callback = function(err, data) {
152 | //DO STUFF
153 | };
154 |
155 | saveData(myData, callback);
156 |
157 | ```
158 |
159 | * callback функцията е винаги последният аргумент, който се подава на асинхронната функция.
160 |
161 | * Първата стойност, която се подава на callback функцията е винаги error.
162 | ---
163 | ###Modules
164 |
165 | ```javascript
166 |
167 | var fs = require('fs'); //default module
168 | var myModule = require('../app_modules/myModule'); //custom module
169 |
170 | myModule.foo(); // > this is foo!
171 | ```
172 | Някои други default модули са:
173 |
174 | * http
175 | * crypto
176 | * os
177 | * path
178 |
179 | Тук може да откриете всички: https://nodejs.org/api/
180 |
181 | ---
182 | ###Как да пишем собствени модули:
183 |
184 | ```javascript
185 |
186 | module.exports = {
187 | foo: function() {
188 | return 'this is foo!';
189 | },
190 | bar: function() {
191 | return 'this is bar';
192 | }
193 | };
194 |
195 | ```
196 |
197 | ```javascript
198 |
199 | module.exports.foo = function() {
200 | return 'this is foo!';
201 | };
202 |
203 | module.exports.bar = function() {
204 | return 'this is bar!';
205 | };
206 | ```
207 | ---
208 | ###NPM
209 |
210 | * Когато започнем да правим нов проект започваме с npm init за да си създадем package.json, който съдържа полезна информация за проекта ни.
211 |
212 | ```javascript
213 | npm install module_name
214 | ```
215 |
216 | * При добавяне на нов модул към проекта е хубаво да използвамe npm install module_name --save за да запишем този модул към dependencies в package.json.
217 |
218 | * Свалените модули се запазват в папка node_modules, която трябва да добавям в .gitignore за да не я commit-ваме към source control-а.
219 |
220 | * При сваляне на приложението от github посто трябва да напишем npm install или накратко npm i за да се свалят всички dependency-та от package.json.
221 |
222 | * Понякога искаме модулите да се свалят глобално, за да можем да ги използваме навсякъде. Тогава използваме npm install module_name -g.
223 |
224 | ---
225 | ###Events
226 |
227 | * Събитията ни дават друг начин, по който можем да пишем асинхронни операции.
228 |
229 | ```javascript
230 | //Callback example
231 | getUserData(param1, function(err, results) {
232 | //Do stuff
233 | });
234 |
235 |
236 |
237 | //Event example
238 | var userData = getUserData(param1);
239 |
240 | //Subscribe to the data event
241 | userData.on('data', function(data) {
242 | //Do stuff
243 | });
244 |
245 | //Subscribe to the item event
246 | userData.on('item', function(item) {
247 | //Do stuff
248 | });
249 | ```
250 | Тук казваме, че всеки път когато възникне евент с име data, трябва да се изпълни тази функция. Ако искаме да се изпълни само веднъж, използваме once.
251 |
252 | ---
253 | ###Custom Event Emitters (1)
254 |
255 | ```javascript
256 | var EventEmitter = require('events').EventEmitter;
257 |
258 | var emitter = new EventEmitter();
259 |
260 | module.exports.getUserData = function() {
261 | setTimeout(function(){
262 | //Publish the item event after at least 5sec
263 | emitter.emit('item', { id: 123, name: 'ivan' });
264 | }, 5000);
265 | return emitter;
266 | };
267 | ```
268 |
269 | ---
270 | ###Custom Event Emitters (2)
271 | ```javascript
272 | var EventEmitter = require('events').EventEmitter;
273 | var util = require('util');
274 |
275 | function CustomEmitter() {
276 | EventEmitter.call(this);
277 | };
278 |
279 | CustomEmitter.prototype.connect = function() {
280 | var self = this;
281 | setTimeout(function(){
282 | self.emit('connected', { name: 'ivan', age: 19 });
283 | }, 5000);
284 | };
285 |
286 | util.inherits(CustomEmitter, EventEmitter);
287 | module.exports = CustomEmitter;
288 | ```
289 | ```javascript
290 | var CustomEmitter = require('./CustomEmitter');
291 |
292 | var cm = new CustomEmitter();
293 |
294 | cm.on('connected', function(data) {
295 | console.log(data);
296 | });
297 |
298 | cm.connect();
299 | ```
300 | ---
301 | ###Streams
302 |
303 | * Потоците разширяват EventEmitter.
304 |
305 | * Те представляват абстракция за менажиране на data flow. (Network traffic, File I/O ...)
306 |
307 | * Може да правим 3 типа потоци: Readable, Writable, Transform (Readable and Writable)
308 |
309 | * Можем да pipe-ваме Readable потоците към Writable (подобно на unix command pipeing)
310 | ---
311 | ###Readable Streams
312 |
313 |