mariusGundersen

//The file foobar.js contains these two lines of code
var foo = "foo", bar = "bar";
export default = {foo, bar}; 

//It can now be imported into another module using either of these two lines:
import foobar from "foobar";
module foobar from "foobar";
//But not this line:
import {foo, bar} from "foobar";

mariusGundersen

Currently you can export things from a module in at least six different ways, and import things in at least six different ways, resulting in 36 different combinations, most of which are not semantically valid.

Here is a greatly simplified (and probably naive) suggestion for modules in ES6:

###export You can only export named things, including variables and functions.

let a = "hello";
export a;

mariusGundersen

JavaScript has labels, which can be placed before blocks to create a named section of code, serving almost the same use as an imidiately invoked function expression (IIFE)

(function iife(){
  var scoped = "this is scoped stuff";
})();

iife: {
  let scoped = "this is scoped";
}

mariusGundersen

The ES6 Promise specification contains the very useful constructor for creating a promise, like so:

var promise = new Promise(function(resolve, reject){
  resolve("hi");
});

promise.then(function(message){
  console.log(message);
});

mariusGundersen

function Lazy(list, ...steps){
  this.list = list;
  this.steps = steps; 
}

Lazy.prototype.map = function(f){
  return new Lazy(this.list, ...this.steps, iteration 
    => ( for (entry of iteration) f(entry)));
}

mariusGundersen

function toHex(rgb){
  var a = /rgb\((\d+),\s*(\d+),\s*(\d+)\)/.exec(rgb).reverse();
  a.pop();
  return '#'+a.map(a => parseInt(a, 10).toString(16)).join('');
}

var variables = {
  '#747474': '#FF0000',
  '#f8b912': '#00FFBB'
};

mariusGundersen

define("expose", [], function(){
	function toType(obj){
		return ({}).toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase()
	}

	return function(){
		var list = arguments;
		var func = /^function\s+([^(]+)/i;
		var i=0;
		var obj;

mariusGundersen

export default class AsyncQueue {
  constructor() {
    this.items = [];
    this.receivers = [];
  }
  
  push(value) {
    if(this.receivers.length == 0){
      this.items.push(value);
    }else{

mariusGundersen

var a = 5;
function whatIsA() {
  if(a == undefined) {
    var a = 7;
  }
  return a;
}

whatIsA()//is it 5 or 7?

mariusGundersen

/*
This is how 3 dependencies are defined using AMD.
Notice how when the number of dependencies grows the
distance between the path to the dependency and the
variable it is stored in grows. It quickly becomes
difficult to see which variable corresponds to which
module name.
*/

define(["jQuery", "an/other/module", "knockout"], function($, dep, ko){