javascript - this keyword

https://huzefabiyawarwala.medium.com/reincarnated-this-keyword-in-javascript-19488a26d796

CommonJS vs AMD vs RequireJS vs ES6 Modules

 https://medium.com/computed-comparisons/commonjs-vs-amd-vs-requirejs-vs-es6-modules-2e814b114a0b

Javascript - Module Pattern & ES6 Class syntax

https://coryrylan.com/blog/javascript-module-pattern-basics 

https://coryrylan.com/blog/javascript-es6-class-syntax

Javascript Generators

 https://github.com/gajus/gajus.com-blog/blob/master/posts/the-definitive-guide-to-the-javascript-generators/index.md

https://exploringjs.com/es6/ch_generators.html

An Intro to JavaScript Modules

https://livecodestream.dev/post/2020-07-08-an-intro-to-javascript-modules/

ES6 Computed Property Names

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer#Computed_property_names

// Computed property names (ES2015)
let i = 0
let a = {
  ['foo' + ++i]: i,
  ['foo' + ++i]: i,
  ['foo' + ++i]: i
}

console.log(a.foo1) // 1
console.log(a.foo2) // 2
console.log(a.foo3) // 3

ES6 - Chaining functions using Generator Function

Chaining functions using Generator Function

function* doSomething2() {
  yield* [
    () => {
      console.log("hello2");
      gen2.next();
      gen2.next().value();
     },
    () => {
      console.log("world2");
    },
    () => {
      console.log("world22");
    },
  ];
}

var gen2 = doSomething2();

gen2.next().value();


Output:
---------

hello2

world22

ES6 related

https://javascript.tutorialhorizon.com//2015/06/23/es6-modules-examples/

ES6 - const (for objects and arrays)

Excerpt from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const

// const also works on objects
const MY_OBJECT = {'key': 'value'};

// Attempting to overwrite the object throws an error
MY_OBJECT = {'OTHER_KEY': 'value'};

// However, object keys are not protected,
// so the following statement is executed without problem
MY_OBJECT.key = 'otherValue'; // Use Object.freeze() to make object immutable

// The same applies to arrays
const MY_ARRAY = [];
// It's possible to push items into the array
MY_ARRAY.push('A'); // ["A"]
// However, assigning a new array to the variable throws an error
MY_ARRAY = ['B']

ES6 - new syntax about 'const'

http://stackoverflow.com/questions/42153423/es-6-new-syntax-about-const/42153715

ES6 - What do function parameter lists inside of curly braces do in es6?

http://stackoverflow.com/questions/37661166/what-do-function-parameter-lists-inside-of-curly-braces-do-in-es6/37661289

const func = ({ param1, param2 }) => {

    //do stuff

}

It is destructuring, but contained within the parameters. The equivalent without the destructuring would be:

const func = o => {
    var param1 = o.param1;
    var param2 = o.param2;
    //do stuff
}

It is basically shorthand for {param1: param1, param2: param2}

ES6 - Arrow Functions

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Functions/Arrow_functions
https://hacks.mozilla.org/2015/06/es6-in-depth-arrow-functions/

Syntax

Basic Syntax

(param1, param2, …, paramN) => { statements }
(param1, param2, …, paramN) => expression
// equivalent to: (param1, param2, …, paramN) => { return expression; }

// Parentheses are optional when there's only one parameter:
(singleParam) => { statements }
singleParam => { statements }

// A function with no parameters requires parentheses:
() => { statements }
() => expression // equivalent to: () => { return expression; }

Advanced Syntax

// Parenthesize the body to return an object literal expression:
params => ({foo: bar})

// Rest parameters and default parameters are supported
(param1, param2, ...rest) => { statements }
(param1 = defaultValue1, param2, …, paramN = defaultValueN) => { statements }

// Destructuring within the parameter list is also supported
var f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c;
f();  // 6

Detailed syntax examples can be seen here.