function query() {
  // ...
}

const thisIsMyObject = {};
function thisIsMyFunction() {}

class User {
  constructor(options) {
    this.name = options.name;
  }
}
const good = new User({
  name: 'yup',
});

class CheckBox {
  // ...
}
export default CheckBox;
export default function fortyTwo() { return 42; }
import CheckBox from './CheckBox'; // PascalCase export/import/filename
import fortyTwo from './fortyTwo'; // camelCase export/import/filename

const AirbnbStyleGuide = {
  es6: {
  },
};
export default AirbnbStyleGuide;

import SMSContainer from './containers/SMSContainer';
const HTTPRequests = [
  // ...
];
const httpRequests = [
  // ...
];

const superPower = new SuperPower();
const goSportsTeam = true;
let dragonball;
let i;

function checkName(hasName) {
  if (hasName === 'test') {
    return false;
  }
  const name = getName();
  if (name === 'test') {
    this.setName('');
    return false;
  }
  return name;
}

(function example() {
  let a = 1;
  let b = a;
  let c = a;
}());
console.log(a); // throws ReferenceError
console.log(b); // throws ReferenceError
console.log(c); // throws ReferenceError
// 对于 `const` 也一样

/**
* make() returns a new element
* based on the passed-in tag name
*/
function make(tag) {
  // ...
  return element;
}

// 注释
function getType() {
  console.log('fetching type...');

  // set the default type to 'no type'
  const type = this.type || 'no type';
  return type;
}

function baz() {
∙∙let name;
}

function test() {
  console.log('test');
}
dog.set('attr', {
  age: '1 year',
  breed: 'Bernese Mountain Dog',
});

if (isJedi) {
  fight();
}
function fight() {
  console.log('Swooosh!');
}

const x = y + 5;

const arr = [
  function foo() {
  },

  function bar() {
  },
];

return arr;

if (foo) {
  console.log(foo);
}

const foo = [1, 2, 3];
console.log(foo[0]);

function foo() { return true; }
if (foo) { bar = 0; }

var foo = 1, bar = 2;
var arr = [1, 2];

const luke = {};
const leia = {};
[luke, leia].forEach((jedi) => {
  jedi.father = 'vader';
});

const short = function longUniqueMoreDescriptiveLexicalFoo() {
  // ...
};

(function () {
  console.log('Welcome to the Internet. Please follow me.');
}());

var b = 1;
count();  // 1
count();  // 2
count(3); // 3
count();  // 3

function handleThings(name, opts = {}) {
  // ...
}

const x = function () {};
const y = function a() {};

const x = [1, 2, 3, 4, 5];
console.log(...x);
new Date(...[2016, 8, 5]);

[1, 2, 3].map((x) => {
  const y = x + 1;
  return x * y;
});

['get', 'post', 'put'].map(httpMethod => (
  Object.prototype.hasOwnProperty.call(
    httpMagicObjectWithAVeryLongName,
    httpMethod,
  )
));

[1, 2, 3].map(x => x * x);
[1, 2, 3].map(number => (
  `A long string with the ${number}. It’s so long that we don’t want it to take up space on the .map line!`
));
[1, 2, 3].map((x) => {
  const y = x + 1;
  return x * y;
});

const itemHeight = item => (item.height > 256 ? item.largeSize : item.smallSize);
const itemHeight = (item) => {
  const { height, largeSize, smallSize } = item;
  return height > 256 ? largeSize : smallSize;
};

(foo) => bar;
(foo) => (bar);
(foo) => (
  bar
)

class Queue {
  constructor(contents = []) {
    this.queue = [...contents];
  }
  pop() {
    const value = this.queue[0];
    this.queue.splice(0, 1);
    return value;
  }
}

class PeekableQueue extends Queue {
  peek() {
    return this.queue[0];
  }
}

class Jedi {
  jump() {
    this.jumping = true;
    return this;
  }
  setHeight(height) {
    this.height = height;
    return this;
  }
}
const luke = new Jedi();
luke.jump()
.setHeight(20);

class Rey extends Jedi {
  constructor(...args) {
    super(...args);
    this.name = 'Rey';
  }
}

class Foo {
  bar() { return 1; }
}
class Foo {
  bar() { return 2; }
}

import AirbnbStyleGuide from './AirbnbStyleGuide';
export default AirbnbStyleGuide.es6;
import { es6 } from './AirbnbStyleGuide';
export default es6;

import AirbnbStyleGuide from './AirbnbStyleGuide';

// filename es6.js
import { es6 } from './AirbnbStyleGuide';
export default es6;

import foo, { named1, named2 } from 'foo';
import foo, {
  named1,
  named2,
} from 'foo';

const foo = 3;
export { foo };

export default function foo() {}

import foo from 'foo';
import bar from 'bar';
foo.init();

import {
  longNameA,
  longNameB,
  longNameC,
  longNameD,
  longNameE,
} from 'path';

import fooSass from 'foo.scss';
import barCss from 'bar.css';

const binary = 2 ** 10;

if ([0] && []) {
  // true
  // 一个数组（既是是空的）是一个对象，对象的取值为 true
}

if (isValid) {
  // ...
}
if (collection.length > 0) {
  // ...
}

switch (foo) {
  case 1: {
    let x = 1;
    break;
  }
  case 2: {
    const y = 2;
    break;
  }
  case 3: {
    function f() {
      // ...
    }
    break;
  }
}

// 分离为两个三目表达式
const maybeNull = value1 > value2 ? 'baz' : null;
// better
const foo = maybe1 > maybe2
  ? 'bar'
  : maybeNull;

// best
const foo = maybe1 > maybe2 ? 'bar' : maybeNull;

const foo = a || b;
const bar = !!c;
const baz = !c;

const foo = (a && b < 0) || c > 0 || (d + 1 === 0);
const bar = (a ** b) - (5 % d);
if (a || (b && c)) {
  return d;
}
const bar = a + b / c * d;

if (test) return false;
if (test) {
  return false;
}

if (test) {
  thing1();
  thing2();
} else {
  thing3();
}

function cats() {
  if (x) {
    return x;
  }
  if (y) {
    return y;
  }
}

function dogs(x) {
  if (x) {
    if (z) {
      return y;
    }
  } else {
    return z;
  }
}