const hoge = 'hogehoge';
let fuga = 'fugafuga';

hoge = 'piyo'; // TypeError: Assignment to constant variable
fuga = 'piyo'; // OK

console.log(hoge); // ReferenceError: hoge is not defined

const hoge = 'hogehoge';

const hoge = (arg) => {
  return arg * 2;
};

const hoge = (arg) => (arg * 2);
const hoge = arg => arg * 2; // さらに()を省略することも可能

const hoge = x => y => x + y; // 謎記法の例
const fuga = x => (y => x + y); // 上と同じ
const piyo = fuga(3); // piyo = y => 3 + y;
console.log(piyo(2)); // -> 5
console.log(fuga(3)(2)); // -> 5

const hoge = x => x+5;
const fuga = x => hoge(x)*2;
console.log(fuga(3));

   const hoge = x => x + 5;
   const fuga = x => hoge(x * 2) * 3;
-> console.log(fuga(3));

   const hoge = x => x + 5;
-> const fuga = x => hoge(x * 2) * 3;
   console.log(fuga(3));

-> const hoge = x => x + 5;
   const fuga = x => hoge(x * 2) * 3;
   console.log(fuga(3));

const hogehoge = a => { throw new Error('Something Wrong'); };
const fugafuga = a => hogehoge(a);
fugafuga(1);

pen.js:4 Uncaught Error: Something Wrong
    at hogehoge (VM191 pen.js:4)
    at fugafuga (VM191 pen.js:7)
    at VM191 pen.js:9

let x = 10;
let y = 'abc';

const a = x;
const b = y;

x = 5;
y = 'def';

console.log(x, y, a, b); // -> 5 "def" 10 "abc"

const a = [0, 1, 2];

const b = a;

a.push(99);
console.log(a, b); // -> [0, 1, 2, 99] [0, 1, 2, 99]

const a = [0, 1, 2];
const b = [...a];

a.push(99);

console.log(a, b); // -> [0, 1, 2, 99] [0, 1, 2]

const a = [0, 1, 2];
a = []; // -> Uncaught TypeError: Assignment to constant variable.
a = a; // -> Uncaught TypeError: Assignment to constant variable.

String(123)           // '123'
String(-12.3)         // '-12.3'
String(null)          // 'null'
String(undefined)     // 'undefined'
String(true)          // 'true'
String(false)         // 'false'

String(''+0+1)        // '01'
String(0+''+1)        // '01'
String(0+1+'')        // '1' <- 0+1が先に計算される

Boolean('')           // false
Boolean(0)            // false     
Boolean(-0)           // false
Boolean(NaN)          // false
Boolean(null)         // false
Boolean(undefined)    // false
Boolean(false)        // false
Boolean({})           // true
Boolean([])           // true

// player.nameが設定されていなければ'NoName'となる
const name = player.name || 'NoName';

// if文で書くとこうなる
let name;
if(player.name){
  name = player.name;
} else {
  name = 'NoName';
}

Number(null)           // 0
Number(undefined)      // NaN
Number(true)           // 1
Number(false)          // 0
Number(" 12 ")         // 12
Number("-12.34")       // -12.34
Number("\n")           // 0
Number(" 12s ")        // NaN
Number(123)            // 123

null == 0               // false

false == 0              // true
false === 0             // false
0 == ""                 // true
0 === ""                // false

null == undefined       // true
null === undefined      // false

const a = NaN;
console.log(a === a);     // false
console.log(a === NaN);   // false
console.log(Number.isNaN(a));  // true

typeof 3                 // "number"
typeof 'abc'             // "string"
typeof {}                // "object"
typeof true              // "boolean"
typeof undefined         // "undefined"
typeof (()=>{})          // "function"

if (typeof hogehoge === 'number'){...}

const fugafuga = value => {
  switch (typeof value) {
    case 'string':
      return 'this is string';
    case 'number':
    ...
  }
}

const hoge = 'hogehoge';
{
  console.log(hoge); // Uncaught ReferenceError: hoge is not defined
  const hoge = 'fugafuga';
  console.log(hoge); // -> "fugafuga"
}
console.log(hoge); // -> "hogehoge"

const hoge = 'hogehoge';
{
  console.log(hoge); // -> "hogehoge"
}
{
  // JavaScriptでは同じスコープで同名の変数が宣言されているとエラーになる
  console.log(hoge); // ReferenceError
  const hoge = 'fugafuga';
}

{
  let hoge;
  console.log(hoge); // -> undefined
  hoge = 'hogehoge';
}
{
  console.log(hoge); // ReferenceError
  let hoge = 'fugafuga';
}

function(){
  ...
}();  // -> Unexpected token

(function(){
  ...
})();  // -> OK

(function(){
  ...
}());  // -> これもOK

(function() {
  var innerScope = 'hoge';
})();

console.log(innerScope); // ReferenceError

var hogehoge = 'hoge';

(function() {
  var hogehoge = 'fuga';
  console.log(hogehoge); // -> "fuga"
})();

console.log(hogehoge); // -> "hoge"

const hogehoge = 'hoge';

{
  const hogehoge = 'fuga';
  console.log(hogehoge); // -> "fuga"
}

console.log(hogehoge); // -> "hoge"

let cnt = 0;
export const inc = () => ++cnt;

import { inc } from './hogehoge.js';
console.log(inc()); // -> 1
console.log(inc()); // -> 2

import * as counter from './hogehoge.js';
console.log(counter.inc()); // -> 1
console.log(counter.inc()); // -> 2

import { inc as hogehogeIncrement } from './hogehoge.js';
console.log(hogehogeIncrement()); // -> 1
console.log(hogehogeIncrement()); // -> 2

let cnt = 0;
console.log('hogehoge');
export const inc = () => ++cnt;

import { inc } from 'hogehoge.js';
console.log('foo');
inc();

import { inc } from 'hogehoge.js';
console.log('bar');
inc();

import './foo.js';
import './bar.js';
// -> 'hogehoge'
// -> 'foo'
// -> 1
// -> 'bar'
// -> 2

class Hogehoge {
  constructor(){
    this.count = 0;
  }
  inc(){
    return ++this.count;
  }
}
export default Hogehoge;

import Hoge from './module';

const counter = new Hoge();
console.log(counter.inc()); // -> 1
console.log(counter.inc()); // -> 2

   ┌───────────────────────────┐
┌─>│           タイマー          │
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
│  │      未解決のコールバック      │
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
│  │       idle, prepare       │
│  └─────────────┬─────────────┘      ┌───────────────┐
│  ┌─────────────┴─────────────┐      │   incoming:   │
│  │           poll            │<─────┤  connections, │
│  └─────────────┬─────────────┘      │   data, etc.  │
│  ┌─────────────┴─────────────┐      └───────────────┘
│  │           check           │
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
└──┤      close callbacks      │
   └───────────────────────────┘

setTimeout(A, 100);
setTimeout(B, 200);
setTimeout(C, 300);
setTimeout(D, 400);

console.log('startTime:', new Date());

setTimeout(()=>{
  console.log('timeout:', new Date());
}, 1000);
const timeout = setInterval(()=>{
  console.log('interval:', new Date());
}, 1000);

setTimeout(()=>{
  clearInterval(timeout);
}, 5000);

$ babel-node index.js
startTime: 2018-11-04T02:54:44.630Z
timeout: 2018-11-04T02:54:45.635Z
interval: 2018-11-04T02:54:45.635Z
interval: 2018-11-04T02:54:46.640Z
interval: 2018-11-04T02:54:47.643Z
interval: 2018-11-04T02:54:48.647Z
✨  Done in 5.68s.

setTimeout(()=>{
  throw new Error('error');  
}, 1000);

$ babel-node index.js
/Users/watace/qiita_repos/sandbox/index.js:4
  throw new Error('error');
  ^

Error: error
    at Timeout._onTimeout (/Users/watace/qiita_repos/sandbox/index.js:2:9)
    at ontimeout (timers.js:424:11)
    at tryOnTimeout (timers.js:288:5)
    at listOnTimeout (timers.js:251:5)
    at Timer.processTimers (timers.js:211:10)
error Command failed with exit code 1.

const animation = ()=>{
  requestAnimationFrame(animation);
  // ここで描画処理
};
requestAnimationFrame(animation);

var a;

{
  "type": "Program",
  "start": 0,
  "end": 6,
  "range": [
    0,
    6
  ],
  "body": [
    {
      "type": "VariableDeclaration",
      "start": 0,
      "end": 6,
      "range": [
        0,
        6
      ],
      "declarations": [
        {
          "type": "VariableDeclarator",
          "start": 4,
          "end": 5,
          "range": [
            4,
            5
          ],
          "id": {
            "type": "Identifier",
            "start": 4,
            "end": 5,
            "range": [
              4,
              5
            ],
            "name": "a"
          },
          "init": null
        }
      ],
      "kind": "var"
    }
  ],
  "sourceType": "module"
}

const f = (a, b, c) => {
  const d = c - 100;
  return a + d * b;
}

LdaSmi #100 // accumulatorに100をコピー
Sub a2      // a2からaccumulatorを引く (c-100)
Star r0     // r0にaccumulatorをコピー (d=50)
Ldar a1     // a1からaccumulatorにコピー
Mul r0      // accumulatorにr0を掛ける (d*b)
Add a0      // accumulatorにa0を足す (a+(d*b))
Return      // accumulatorの値を返します

movl rbx, [rax+0x1b]
REX.W movq r10,0x100000000
REX.W cmpq r10,rbx
...

console.log(3 & 6);     // -> 2
console.log(12 & 15);   // -> 12

console.log(3 | 6);     // -> 7
console.log(12 | 15);   // -> 15

console.log(~3);    // -> -4
console.log(~12);   // -> -13

console.log(3 ^ 6);   // -> 5
console.log(12 ^ 15); // -> 3

console.log(9 << 2);  // -> 36

console.log(9 >> 2);  // -> 2
console.log(-9 >> 2); // -> -3

console.log(9 >>> 2); // -> 2
console.log(-9 >>> 2);// -> 1073741821

const xFlag = 1;
const wFlag = 1 << 1;
const rFlag = 1 << 2;

if(flags & rFlag){  // flagsは7とか4とかの数字
  // rが立っている場合に処理が走る
}
if(flags & (rFlag | wFlag) === (rFlag | wFlag){
  // rとwが両方立っていれば走る
}

let flags = 0;
// もちろん let flags = wFlag | rFlag; とかでも良い

flags |= rFlag;

<!DOCTYPE html>
<html>
  <head>
    ...
  </head>
  <body>
    <div>
      ...
    </div>
    <script src="..."></script>
    <script src="..."></script>
  </body>
</html>

DOCUMENT (always the root)
 └─HTML
   ├─HEAD
   │  └─...
   └─BODY
      ├─DIV
      │  └─...
      ├─SCRIPT
      └─SCRIPT

// <... id="hoge">みたいにidが"hoge"の要素を取得
const element1 = document.getElementById('hoge');

// <... class="foo bar baz">みたいにクラスに含まれていればまとめて取得
// 返り値はリストになる。
const element2 = document.getElementsByClassName('foo');

// cssのセレクター形式で要素を取得。返り値はリスト。
const element3 = document.querySelectorAll('#hoge'); // id="hoge"の要素を取得
const element4 = document.querySelectorAll('div.highlighted > p'); // p要素のうち直接の親が'highlighted'クラスを持つものを取得

const element = document.getElementById('...');

// 要素を作成
const hogehoge = document.createElement('div');

// 要素を追加
element.appendChild(hogehoge);

// 要素を削除
element.removeChild(hogehoge);
// 子要素を全削除
while(element.firstChild){
  element.removeChild(element.firstChild);
}

// クラスを取得
const classList = element.classList;
if(classList.contains('fugafuga'){
  // 要素にfugafugaクラスが設定されていれば走る
}

// クラスを追加・削除・切り替え
classList.add('fugafuga');
classList.remove('fugafuga');
classList.toggle('fugafuga'); // 地味にこいつが便利で重宝する

element.addEventListener('click', (event)=>{
  // preventDefault()を呼ぶと通常の動作が行われなくなる。
  // 例えばaタグをクリックしても移動しなくなったり。
  event.preventDefault();
  console.log('要素がクリックされました');
});

// removeの方は両方の引数を同じにする必要がある
const clickHandler = (event)=>{...};
element.addEventListener('click', clickHandler);
element.removeEventListener('click', clickHandler);

class Hoge {
  // 引数を一つのオブジェクトにするという約束にして、argsで纏めて受け取る
  constructor(args){
    // 初期化処理

    /* 方法1
    this.state = Object.assign({
      name: 'NoName',
      age: 0
    }, args);
    */

    // 方法2
    const { name, age } = args || {};
    this.name = name || 'NoName';
    this.age = age || 0;
  }
  sayHello(){
    return `Hello! I am ${this.name}.`;
  }
  selfIntro(){
    return `${this.sayHello()} And I'm ${this.age} years old.`
  }
}

const hoge = new Hoge();
const fuga = new Hoge({name:'watace', age:23});

console.log(hoge.selfIntro()); // -> "Hello! I am NoName. And I'm 0 years old."
console.log(fuga.selfIntro()); // -> "Hello! I am watace. And I'm 23 years old."

class Piyo extends Hoge {
  constructor(args){
    // super()を使うと親のconstructorを呼び出せます
    super(args);

    const { nakigoe } = args || {};
    this.nakigoe = nakigoe || 'piyo';
    this.capital = this.nakigoe.charAt(0).toUpperCase()
      + this.nakigoe.slice(1); // 先頭を大文字にしてます
  }
  sayHello(){
    return `${this.capital}! ${this.name} ${this.nakigoe}!`
  }
}

const piyo = new Piyo({name:'watace'});
console.log(piyo.selfIntro()); // -> "Piyo! watace piyo! And I'm 0 years old."

class Foo {
  constructor(args){
    const { name } = args || {};
    this.name = name || 'NoName';
  }
  say(){
    return `${this.name} here!`;
  }
  onClick(event){
    console.log(this.say());  // 上のsay()を呼び出したいが...
  }
}

const foo = new Foo({name:'pizza'});
const elem = document.getElementById('hoge');
elem.addEventListener('click', foo.onClick);
// クリックすると TypeError: this.say is not a function になる
// ↑この時のthisにはelemが入っているため

class Foo {
  constructor(args){
    ...
    // bind(this)を行うことで、呼び出された際のthisを今のthisのままにできる
    this.onClick = this.onClick.bind(this);
  }
  ...
}
...
// クリックすると目的通り"pizza here!"となる

// 自分自身としか一致しないユニークなオブジェクトを生成する
const symbolA = Symbol();
console.log(symbolA === symbolA); // -> true
console.log(symbolA === Symbol()); // -> false

const __name__ = Symbol();

class Bar {
  constructor(args){
    const { name } = args || {};
    this[__name__] = name || 'NoName';  // Symbolの場合
    this.name = name || 'NoName';       // 通常のプロパティ
  }
  sayHello(){
    return `Hi, I'm ${this[__name__]}`;
  }
}
const bar = new Bar({name:'watace'});
bar.name = 'hoge';          // 直接プロパティを編集できる
console.log(bar.name);      // -> "hoge"😢
console.log(bar.sayHello());// -> "Hi, I'm watace"👍

// __name__を知っていれば直接アクセスできる
console.log(bar[__name__]); // -> "watace"

// これを避けるにはモジュール化してclassだけをexportすればOK
// インポート先では__name__は分からない
export default Bar;

const __name__ = new WeakMap();
class Baz {
  constructor(args){
    const { name } = args || {};
    __name__.set(this, name);
  }
  sayHello(){
    return `Hi, I'm ${__name__.get(this)}`;
  }
}
const baz = new Baz({name: 'watace'});
console.log(baz.sayHello());    // "Hi, I'm watace"

class Hoge {
  /**
   * ここにclassの説明
   * @param {Object} args ここにargsの説明
   * @param {string} args.name what's your name?
   * @param {number} args.age how old are you?
   */
  constructor(args){
    ...

  /**
   * 挨拶します。
   * @returns {String} hello sentence
   */
  sayHello(){
    return `Hello! I am ${this.name}.`;
  }

// 年齢を半分に詐称するfactory関数
const factory = (name, age) => {
  return new Hoge({name, age: age / 2});
}

const createIssue = (title, description)=>{
  return {
    title,
    description,
    tag: ['new'],
    date: new Date(),
    status: 'open'
  }
}

const receiveData = data => (
  {
    type: 'RECEIVE_DATA',
    data
  }
);

function hoge(){
  console.log(this);
}

hoge();         // -> global

const obj = {
  hoge
};
obj.hoge();     // -> obj

const obj2 = {
  fuga: function(){
    hoge();
  }
};
obj2.fuga();    // -> global???!!!?!?!!?!??!!

const hoge = () => {
  //この段階でthisがglobalなのでどこで呼び出してもglobalになる
  console.log(this);
};

hoge();         // -> global

const obj = {
  hoge
};
obj.hoge();     // -> global

const obj2 = {
  fuga: function(){
    hoge();
  }
};
obj2.fuga();    // -> global

const hoge = (arg) => {
  console.log(arg);
  console.log(this);
};
function fuga(arg){
  console.log(arg);
  console.log(this);
}

const obj = {};
const args = ['arg1', 'arg2'];
hoge.call(obj, args);
// -> ["arg1", "arg2"]
// -> global

fuga.call(obj, args);
// -> ["arg1", "arg2"]
// -> Object {}

hoge.apply(obj, args);
// -> "arg1"  (配列が展開されて渡される)
// -> global

fuga.apply(obj, args);
// -> "arg1"
// -> Object {}

const hoge = () => {
  console.log(this);
};
function fuga(){
  console.log(this);
}

const obj = {};

// bindは新しい関数を返す
const hoge2 = hoge.bind(obj);
const fuga2 = fuga.bind(obj);

hoge();     // -> global (元の関数を変化させない)
fuga();     // -> global
hoge2();    // -> global (アロー関数には効かない)
fuga2();    // -> Object {}

class Hoge {
  constructor(args){
    console.log(this);
    const { name } = args || {};
    this.name = name || 'NoName';
  }
}
const Fuga1 = (args) => {
  console.log(this);
  const { name } = args || {};
  this.name = name || 'NoName';
}
function Fuga2(args) {
  console.log(this);
  const { name } = args || {};
  this.name = name || 'NoName';
}
                                // thisの中身は？
const hoge1 = Hoge();           // -> TypeError: Class constructor Hoge cannot be invoked without 'new'
const hoge2 = new Hoge();       // -> Object { name:"NoName" }
const fuga1_1 = Fuga1();        // -> global
const fuga1_2 = new Fuga1();    // -> TypeError: Fuga1 is not a constructor
const fuga2_1 = Fuga2();        // -> global
const fuga2_2 = new Fuga2();    // -> Object { name:"NoName" }

class Hoge {
  constructor(args){
    ...
  }
}
class Fuga extends Hoge {
  constructor(args){
    super(args);
    ...
  }
}
const hoge = new Hoge();
const fuga = new Fuga();
console.log(hoge instanceof Hoge);  // -> true
console.log(hoge instanceof Fuga);  // -> false
console.log(fuga instanceof Hoge);  // -> true
console.log(fuga instanceof Fuga);  // -> true