const e = 2.718281828459045;
const π = 3.141592653589793;
e < π; // → true
e = π; // → Line 4: "e" is read-only

let a = [ 1 ];
for (let i = 0; i < a.length; i++) {
  let x = a[i] + 1;
}
console.log(i, x, a); // → i is not defined, x is not defined, [1]

{
  function foo () { return 'hello'; }
  foo(); // → hello
  {
    function foo () { return 'world'; }
    foo(); // → world
  }
  foo(); // → hello
}

let admins = collection.map( m => m.get("admin") );
console.log(m); // → m is not defined

this.accepted = [];
this.collection.each((m) => {
  if (m.get("state") === "accepted")
    this.accepted.push(m);
});

{
  initialize: function(options = {}) {
    _(this.defaults).extend(options);
  },
  generateName: function(conversation, names...) {
    console.log(names); // → ["Angie", "Ariel", "Jared"]
    conversation.set("name", names.join(", "));
  }
}

var params = [ "kana", [true], 7 ];
[ 1, 2, ...params ].length; // → 5

var lastSeenAt = `Last Seen ${manawa(this.model.get("sent_at"))}`;

console.log(`Aloha
Hawaii`); // → Aloha Hawaii

String.raw `Hi, \n World ${ 42 }` === "Hi, \\n World 42"; // → true

0b110010100 === 404; // → true

"\u{0CA0}_\u{0CA0}" === "ಠ_ಠ" // → true

let regex = /foo.bar/gy;
regex.sticky; // → true
regex.lastIndex; // → 0

regex.test('foo-bar'); // → true

regex.lastIndex; // → 7
regex.test('..foo-bar'); // → false

regex.lastIndex = 2;
regex.test('..foo-bar'); // → true

regex.lastIndex; // → 9

var options = { animate, duration };

var properties = {
  color: "blue",
  [ "avatar_" + getSize() ]: 42
};

var helpers = {
    foo (a, b) {
      // …
    },
    *quux (x, y) {
      //  …
    }
};

var list = [ "Blue", "Red", "Yellow" ];
var [ first, , second ] = list;
[ second, first ] = [ first, second ];

var { members, meta: { total_count, updated_at } } = payload();

function sum ([ x, y ]) { return x + y; }
function msgText ({ name, body }) { return `${name}: ${body}`; }

var [ a = 1, b = 2, c = 3, d ] = [ 4, 5 ];

export function randomNumber {
  return Math.floor( Math.random() * 11 );
}

import { Input, Label } from "react-bootstrap";

export default (x) => x * x;

import * as _ from "underscore";

class Group extends Party {
  constructor (name, color) {
    super(name);
    this.color = color;
  }
  static defaultGroup () {
    return new Group("Engineering", "#232b38");
  }
  set name  (name) { this._name = name; }
  get name  ()     { return this._name; }
  get color ()     { return this._color; }
}
var engineering = Group.defaultGroup();
engineering.color === "#232b38"

let attributes = {};
const avatar = Symbol();
attributes[avatar] = new Avatar();

typeof avatar // → "symbol"
Object.getOwnPropertySymbols(attributes); // → [ avatar ]
Symbol("avatar") === Symbol("avatar"); // → false

let globalAvatar = Symbol.for("avatar");

globalAvatar === Symbol.for("avatar"); // → true
Symbol.keyFor(globalAvatar); // → avatar

let fibonacci = {
  [Symbol.iterator]() {
    let pre = 0, cur = 1;
    return {
       next () {
         [ pre, cur ] = [ cur, pre + cur ];
         return { done: false, value: cur };
       }
    };
  }
};

for (let n of fibonacci) {
  if (n > 1000) break;
  console.log(n);
}

function* range (start, end, step) {
    while (start < end) {
        yield start;
        start += step;
    }
}

let evens = range(0, 10, 2);
console.log(evens.next().value); // → 0

for (let n of evens) {
  console.log(n); // → 2, 4, 6, 8
}

let alphabet = new Set();
alphabet.add("A").add("B").add("A");
alphabet.size; // → 2
alphabet.has("A"); // → true
for (let key of alphabet.values()) // insertion order
  console.log(key);

let member = new Map();
member.set("id", 42);
member.set(state, "accepted");
member.get(state); // → "accepted"
member.size; // → 2
for (let [ key, val ] of member.entries())
  console.log(key + " = " + val);

let buffer = new ArrayBuffer(24); // generic

let amountDue = new Float32Array(buffer, 20,  1);

let imageData = new Uint8ClampedArray([42, 1337]);
console.log(imageData[1]); // → 255

Object.assign({a: 1}, {b: 2}, {c: 3}); // → { a: 1, b: 2, c: 3 }
[ 1, 3, 4, 2 ].find(x => x > 3); // → 4

"aloha".repeat(3); // alohaalohaaloha
"/networks/lua/latest".includes("networks"); // → true
"reddit".endsWith("it"); // → true
"facebook".startsWith("face"); // → true

Number.isNaN(NaN); // → true
Number.isFinite(Infinity); // → false
Number.isSafeInteger(10007199254740992); // → false
Number.EPSILON; // instead of 2.22e-16

Math.trunc(-42.7); // → -42
Math.sign(-7); // → -1

let networkPromises = this.networks.each((network) => {
  return new Promise((resolve, reject) => {
    return network.fetch((response) => {
      if (response.body) {
        resolve(response.body);
      } else {
        reject(response.error);
      }
    });
  });
});

Promise.all(networkPromises).then((data) => {
  NetworkActions.setNetworks(data);
}, (error) => {
  errorHandler(error);
});

var artist = { name: "Michelangelo", paintings: 253 };
var interceptor = {
  set: function (receiver, property, value) {
    console.log(property, 'is changed to', value);
    receiver[property] = value;
  }
};

artist = Proxy(artist, interceptor);
artist.paintings = 254; // → paintings is changed to 254

let obj = { a: 1 };
Object.defineProperty(obj, "b", { value: 2 });
obj[Symbol("c")] = 3;
Reflect.ownKeys(obj); // → [ "a", "b", Symbol(c) ]