added maps_sets_symbols_callable_entities

Author: Vitalii Telychko

ES6/Callable_entities/avoid_IIFE.js

@@ -0,0 +1,58 @@
+// 1. Replace an IIFE with a block  if you wanted to keep a variable local
+
+// // ES5
+// (function () {
+//   var tmp = 'hello';
+// }());
+//
+// console.log(tmp); // Reference Error
+
+// ES6
+// {
+//   let tmp = 'Hello';
+// }
+//
+// console.log(tmp); //Reference Error
+
+// 2. Replace an IIFE with a module
+
+// ES5 Revealing Module Pattern
+
+// var my_module = (function () {
+//   // Module-private variable:
+//   var countInvocations = 0;
+//
+//   function myFunc(x) {
+//     countInvocations++;
+//
+//   }
+//
+//   // Exported by module:
+//   return {
+//     myFunc: myFunc
+//   };
+// }());
+
+// This module pattern produces a global variable and is used as follows:
+//
+// my_module.myFunc(33);
+
+// ES6
+// In ECMAScript 6, modules are built in, which is why the barrier to adopting them is low:
+//
+// // my_module.js
+//
+// // Module-private variable:
+//   let countInvocations = 0;
+//
+// export function myFunc(x) {
+//   countInvocations++;
+//
+// }
+// This module does not produce a global variable and is used as follows:
+//
+// import { myFunc } from 'my_module.js';
+//
+// myFunc(33);
+
+// !!! Method calls: work as with traditional functions, but additionally allow super.

ES6/Callable_entities/dispatched_direct_method_calls.js

@@ -0,0 +1,28 @@
+// 1. Dynamic dispatch - arr.slice(1)
+// 2. Direct call - Array.prototype.call.slice(1)
+
+// 1. Prototype chain
+// var arr = ['a', 'b'];
+// var p = Object.getPrototypeOf;
+//
+// console.log(p(arr) === Array.prototype); // true
+// console.log(p(p(arr)) === Object.prototype); // true
+// p(p(p(arr))); // null
+
+// Properties in “earlier” objects override properties in “later” objects.
+// const obj = {a: 1, b: 2};
+// console.log(Object.getPrototypeOf(obj));
+
+// 2. Dispatched method calls
+// var func = arr.toString(); // 1. retrieve the value of the first property whose name is toString.
+// func.call(arr); // 2. Call the value and set the implicit parameter this to the receiver arr
+
+// 3. Direct method calls
+// Function.prototype.call(thisValue, arg0?, arg1?, ···)
+// Function.prototype.apply(thisValue, argArray)
+
+// const arr = ['a', 'b', 'c'];
+// console.log(Object.prototype.toString.call(arr)); // [object Array]
+// console.log(Array.prototype.toString.call(arr)); // a, b, c
+
+// Abbreviations for Object.prototype = {} and Array.prototype = []

ES6/Callable_entities/fn_name.js

@@ -0,0 +1,10 @@
+// let func1 = function () {};
+// // console.log(func1.name); // func1
+
+// const func = () => {};
+// console.log(func.name); // func
+
+// 1. the name of a function is always assigned at creation
+// 2. Function names are subject to minification, which means that they will usually change in minified code.
+// Depending on what you want to do, you may have to manage function names via strings (which are not minified) or
+// you may have to tell your minifier what names not to minify.

ES6/Callable_entities/overview.js

@@ -0,0 +1,23 @@
+/*
+
+In ES5, a single construct, the (traditional) function, played three roles:
+
+Real (non-method) function
+Method
+Constructor
+
+In ES6, there is more specialization.
+The three duties are now handled as follows.
+As far as function definitions and class definitions are concerned, a definition is either a declaration or an expression.
+
+Real (non-method) function:
+Arrow functions (only have an expression form)
+Traditional functions (created via function definitions)
+Generator functions (created via generator function definitions)
+Method:
+Methods (created by method definitions in object literals and class definitions)
+Generator methods (created by generator method definitions in object literals and class definitions)
+Constructor:
+Classes (created via class definitions)
+
+*/

ES6/Callable_entities/recommendations.js

@@ -0,0 +1,43 @@
+// 1. Prefer arrow functions as callbacks
+// 2. Prefer function declarations as stand-alone functions (versus callbacks)
+// 3. Prefer method definitions for methods
+
+// ES5
+// MyClass.prototype.foo = function (arg1, arg2) {
+//
+// };
+
+// ES6
+// Object.assign(MyClass.prototype, {
+//   foo(arg1, arg2) {
+//
+//   }
+// });
+
+// Generator method definitions
+// const obj = {
+//   *generatorMethod() {
+//
+//   }
+// };
+//
+// class MyClass {
+//   * generatorMethod() {
+//
+//   }
+// }
+//
+// Calling a generator method returns a generator object.
+// You can use this and super as you would in normal method definitions;
+
+// class Hello {
+//   constructor() {
+//     this.fn = () => {
+//
+//     }
+//   }
+//
+//   showName = () => {
+//
+//   }
+// }

ES6/Callable_entities/ways_of_calling.js

@@ -0,0 +1,26 @@
+/*
+  Three kinds of calls can be made anywhere in ES6:
+  Function calls: func(3, 1)
+  Method calls: obj.method('abc')
+  Constructor calls: new Constr(8)
+*/
+
+// Calls via super are restricted to specific locations
+
+/*
+
+Super-method calls: super.method('abc')
+Only available within method definitions inside either object literals or derived class definitions.
+Super-constructor calls: super(8)
+Only available inside the special method constructor() inside a derived class definition.
+
+*/
+
+// const obj = {
+//   name: 'Vitalii',
+//   showName: () => {
+//     console.log(this);
+//   }
+// };
+//
+// obj.showName();

ES6/Maps_and_Sets/maps.js

@@ -0,0 +1,47 @@
+// Map is a data collection type (in a more fancy way — abstract data structure type), i
+// n which, data is stored in a form of pairs, which contains a unique key and value mapped to that key.
+// And because of the uniqueness of each stored key, there is no duplicate pair stored.
+// - key and value in Map can be in any data type, not limited to only string or integer.
+// - Map is mainly used for fast searching and looking up data.
+
+// const map = new Map();
+// map.set('foo', 123);
+// map.get('foo'); // 123
+// map.has('foo'); // true
+// map.delete('foo'); // true
+// map.has('foo'); // false
+// map.size; // 1
+// map.clear(); // 0
+// map.size; // 0
+
+// const map = new Map([
+//   [ 1, 'one' ],
+//   [ 2, 'two' ],
+//   [ 3, 'three' ], // trailing comma is ignored
+// ]);
+//
+// console.log(map);
+
+// Alternatively, the set() method is chainable:
+
+// const map = new Map()
+//   .set(1, 'one')
+//   .set(4, 'one')
+//   .set(2, 'two')
+//   .set(3, 'three');
+//
+// console.log(map);
+
+// 1. Any value can be a key, even an object
+// const map = new Map();
+//
+// const KEY1 = {};
+// map.set(KEY1, 'hello');
+// console.log(map.get(KEY1)); // hello
+
+// const map = new Map();
+//
+// map.set(NaN, 123);
+// map.get(NaN);
+
+// new Map().get('asfddfsasadf') // undefined

ES6/Maps_and_Sets/maps_iterating.js

@@ -0,0 +1,67 @@
+// const map = new Map([
+//   [false, 'no'],
+//   [true,  'yes'],
+// ]);
+
+// for (const key of map.keys()) {
+//   console.log(key);
+// }
+//
+// for (const key of map.values()) {
+//   console.log(key);
+// }
+
+// for (const entry of map.entries()) {
+//   console.log(entry[0], entry[1]);
+// }
+
+// for (const [key, value] of map.entries()) {
+//   console.log(key, value);
+// }
+
+// for (const [key, value] of map) {
+//   console.log(key, value);
+// }
+
+// 1. Converting iterables (incl. Maps) to Arrays
+// const map = new Map().set(false, 'no').set(true, 'yes');
+// console.log([...map.keys()]);
+// console.log([...map.values()]);
+// console.log([...map]);
+
+// 2. Looping over Map entries
+// const map = new Map([
+//   [false, 'no'],
+//   [true,  'yes'],
+// ]);
+//
+// map.forEach((value, key, array) => {
+//   console.log(key, value, array);
+// });
+
+// 3. Filtering (or map) Maps
+// const originalMap = new Map()
+//   .set(1, 'a')
+//   .set(2, 'b')
+//   .set(3, 'c');
+//
+// const filteredMap = new Map( // Convert the result back to a Map.
+//   [...originalMap] // Convert the Map into an Array of [key,value] pairs
+//     .filter(([k, v]) => k < 3) // Map or filter the Array.
+// );
+//
+// console.log(filteredMap);
+
+// 4. Combining Maps
+// const map1 = new Map()
+//   .set(1, 'a1')
+//   .set(2, 'b1')
+//   .set(3, 'c1');
+//
+// const map2 = new Map()
+//   .set(2, 'b2')
+//   .set(3, 'c2')
+//   .set(4, 'd2');
+//
+// const combineMaps = new Map([...map1, ...map2]);
+// console.log(combineMaps); // or [...combineMaps] or JSON.stringify([...combineMaps] or new Map(JSON.parse(jsonStr));

ES6/Maps_and_Sets/maps_versus_objects.js

@@ -0,0 +1,9 @@
+// Differences
+// 1. Key fields => in Object either string or integer or symbols, in Map - any
+// 2. Element order => in Map original order of elements (pairs) is preserved, in Object - no
+// 3. Inheritance => Map is an instance of Object, but Object is definitely not an instance of Map.
+
+// var map = new Map([[1,2],[3,4]]);
+// console.log(map instanceof Object); //true
+// var obj = new Object();
+// console.log(obj instanceof Map); //false