Effective ES6

Effective ES6
@teppeis
YAPC::Asia Tokyo 2015
Aug 21

Hello!
• Teppei Sato, @teppeis
• Cybozu, Inc. / kintone
• This is my ﬁrst and last YAPC :)

http://cybozushiki.cybozu.co.jp/articles/m000978.html

Today talk about:
• Introduce ES6 features
• Deprecated best-practice/patterns
• What’s ES2016, ES2017…
• How to use ES6 from now

–Brendan Eich
from Effective JavaScript
“My solution to the challenging
requirements and crazy-short schedule
was to make JavaScript extremely
malleable from the start.”
https://www.ﬂickr.com/photos/jsconf/4587502948/

–Douglas Crockford
2001, http://www.crockford.com/javascript/javascript.html
“JavaScript: The world’s most
misunderstood programming
language”
https://www.ﬂickr.com/photos/charliebrewer/2897862701/

JavaScript has many pitfalls…
• Prototype inheritance (No class)
• new, this
• Function scope (No block scope)
• Global variables (No module system)
• Hoisting
• NaN, undeﬁned
• typeof null
• with, eval

Example: No Class
function Person(name) {
this.name = name;
}
Person.prototype.greet = function() {
console.log("Hello, I'm " + this.name);
};
var bob = new Person("Bob");
bob.greet();
// "Hello, I'm Bob"
• Use Prototype to emulate Classes

If you miss "new", dangerous!
this.name = name;
}
// Oh! You forget `new`
var bob = Person("Bob");
console.log(bob); // undefined
// Global leak!!!!!!!!!!
console.log(window.name); // "Bob"

We've made best-practices
a.k.a. “work around”

Practice: Be sure to call with "new"
// check!
if (this instanceof Person) {
return new Person(name);
}
this.name = name;
}
// without `new`
bob.greet();
// "Hello, I'm Bob"

ECMAScript 6
• Published on June 17, 2015
• Formally "ECMAScript 2015"
• 6 years! from ES5

ECMAScript 6
• Modern syntax ﬁxing pitfalls
• Better support for large applications
• No (or few) breaking changes

ES6 Classes: Simple!
class Person {
constructor(name) {
this.name = name;
}
greet() {
}
}
bob.greet();
// without `new`
var bob = Person("Bob"); // Error!

Classes based on Prototype
this.name = name;
}
Person.prototype.greet = function() {
};
bob.greet();
// "Hello, I'm Bob"
OUT OF DATE!

Be sure to call with `new`
// check!
if (this instanceof Person) {
return new Person(name);
}
this.name = name;
}
// without `new`
bob.greet();
// "Hello, I'm Bob"
OUT OF DATE!

New ES6 features deprecates
yesterday’s best-practices
No more altJS!
https://www.ﬂickr.com/photos/jorge-11/2765216505/

ES6 compatibility table
https://kangax.github.io/compat-table/es6/

You can use ES6 now!
• Modern browsers and io.js (node.js) support  
half of ES6 features.
• Safari 9 (WebKit) will support many ES6 features soon.
• Except for IE11…

Transpiler and polyﬁll
• ES6 Transpiler: 
source code converter from ES6 to ES5/ES3
• ES6 Polyﬁll: 
library to provide ES6 built-in classes,
functions and objects for ES5/ES3

Babel
• The most compatible (71%) ES6 transpiler
• Integrated with core-js (polyﬁll library)
• Usage:
• CLI: npm i -g babel
• Browserify: babelify
• REPL on the Web (Try it out!)

ES6 features
• New syntax
• New built-in classes and objects
• Improvement of existing classes

New syntax
• Arrow Function
• Classes
• Modules
• Block Scope (let/const)
• Extended Object
Literal
• Default Params
• Rest Params
• Spread Operator
• Destructuring
• Iterator
• Generator
• Template Literal
• Tail Call Optimization

Prefer arrow function
// ES5 old function
var add = function(a, b) {
return a + b;
};
// ES6 arrow function!
var add = (a, b) => {
return a + b;
};
var add = (a, b) => a + b;
var square = n => n * n;
// good for array filter chains
[1, 2, 3, 4].filter(n => n % 2 === 0).map(n => n * n);

Assign “this” to “self”
var john = {
name: "John",
helloLater: function() {
// save `this` as `self`
var self = this;
setTimeout(function() {
// `this` is not available. use `self`.
console.log("Hello, I'm " + self.name);
}, 1000);
}
}
john.helloLater();
// "Hello, I'm John" after 1sec
OUT OF DATE!

Arrow function don’t need "self"
let john = {
name: "John",
helloLater: function() {
// use arrow function
setTimeout(() => {
// `this` is available here!
}, 1000);
}
}
john.helloLater();
// "Hello, I'm John" after 1sec

ES6 Classes
class Person {
constructor(name) {
this.name = name;
}
greet() {
}
}
bob.greet();

Handmade inheritance function
// handmade function to extend
function __extends(child, parent) {
for (var key in parent) {
if (Object.prototype.hasOwnProperty.call(parent, key)) {
child[key] = parent[key];
}
}
function ctor() {
this.constructor = child;
}
ctor.prototype = parent.prototype;
child.prototype = new ctor();
child.__super__ = parent.prototype;
return child;
};
function Programmer(name, language) {
Person.call(this, name);
this.language = language;
}
__extends(Programmer, Person);
OUT OF DATE!

ES6 Class inheritance
class Programmer extends Person {
constructor(name, language) {
super(name);
this.language = language;
}
greet() {
super.greet();
console.log("I like " + this.language);
}
}
var bob = new Programmer("Bob", "JavaScript");
bob.greet();
// "Hello, I'm Bob"
// "I like JavaScript"
• with "extends" and "super"
• can extends built-in classes like "Error"

Module pattern
// Global module
var myModule = (function () {
// Module object
var module = {},
privateVariable = "Hello World";
function privateMethod() {
// ...
}
module.publicProperty = "Foobar";
module.publicMethod = function () {
console.log( privateVariable );
};
return module;
})();
OUT OF DATE!

CommonJS Modules
// import
var foo = require('foo');
foo();
// export
exports.bar = function() {
console.log('bar');
}
OUT OF DATE!
• node.js/npm friendly
• browserify/webpack to build for browser

ES6 Modules
• run anywhere (browsers, node.js…) if ES6 available
• easy to parse statically
• strict mode by default in modules
// export (./module.js)
export var foo = "foo!";
export function bar() {}
export class Baz {
baz() {}
}
// import
import {foo, bar, Baz} from "./module";
console.log(foo); // "foo!"
bar();
new Baz();

Write “use strict;”
• Strict mode is useful even in ES6.
• In ES6 Module, always strict mode!
• You don’t have write “use strict;” in ES6 modules.
"use strict";
// Error!
with (obj) {}
// Error!
var obj = {a: 1, a: 1};
OUT OF DATE!

ES5 has only function scope
function foo() {
var num = 1;
// ... too many statements
if (true_condition) {
// same scope! overwrite above `num`!
var num = 2;
// .. some process
}
console.log(num);
// 2 !!!
}

Weird hoisting（巻き上げ）
var a = 'outer';
function bar() {
console.log(a);
var a = 'inner';
}
bar();
// undefined !!!

Weird hoisting（巻き上げ）
var a = 'outer';
function bar() {
// hoisting!
var a;
console.log(a);
a = 'inner';
}
bar();
// undefined !!!

Place “var”s at the top of the scope
• for function scope and hoisting
function init() {
// `var` once at the top of the scope!
var i,
cell,
cells = document.getElementsByTagName('td');
for (i = 0; i < cells.length; i++) {
cell = cells[i];
cell.addEventListener('click', function() {
cell.style.backgroundColor = '#00F';
}, false);
}
}
OUT OF DATE!

Use ES6 let or const anytime!
• let and const create block scope
• no hoisting
• no more "var"!
function foo() {
let num = 1;
// ... too many statements
if (true_condition) {
// different scope!
let num = 2;
}
console.log(num);
// 1
}

with for-loop
• each iterate creates its own block scope
for (let i = 0; i < 5; i++) {
// new block scope is created for each iteration
setTimeout(() => console.log(i), i * 100);
}
// display "1", "2", "3", "4", "5"

const
• immutable value (not immutable object)
• use like Java's ﬁnal
const foo = 1;
foo = 100; // Error!
const foo = 1000; // Error!
// properties are mutable
const obj = {};
obj.foo = 1; // No error

Incorrect default params
function add(a, b) {
// if "a" is 0, 1 is assigned to "a".
a = a || 1;
b = b || 2;
return a + b;
}
add(0, 0); // 1 + 2 = 3
• Incorrect, but occur frequently

ES6 Default Parameters
// default value for each param
function add(a = 1, b = 2) {
return a + b;
}
add(); // 1 + 2 = 3
add(0); // 0 + 2 = 2
add(undefined, 0); // 1 + 0 = 1
add(0, 0); // 0 + 0 = 0

Use "arguments" for variable-length
arguments
function foo(first, second) {
console.log("first:", first);
console.log("second:", second);
// arguments is an ArrayLike, not an Array.
var rest = Array.prototype.slice.call(arguments, 2);
console.log("rest:", rest);
}
foo(1, 2, 3, 4, 5);
// first: 1
// second: 2
// rest: [3, 4, 5]
OUT OF DATE!

ES6 Rest Params instead of arguments
• You don’t have to use `arguments`
function foo(first, second, ...rest) {
console.log("first:", first);
console.log("second:", second);
console.log("rest:", rest);
}
foo(1, 2, 3, 4, 5);
// first: 1
// second: 2
// rest: [3, 4, 5]

Destructuring assignment
• Array assignment
let match = /(d{4})(d{2})(d{2})/.exec("20151231");
// match: [2015151231, 2015, 12, 31]
let [, year, month, day] = match;
console.log(year, month, day); // 2015 12 31
// Swapping
[x, y] = [y, x]

• Object assignment
let {name: a, age: b} = {name: "Bob", age: 20};
console.log(a, b); // "Bob" 20
// shorthand
let {name, age} = {name: "Bob", age: 20};
console.log(name, age); // "Bob" 20

• Function params like "named-params"
• Options object param
function draw(x, y, {width = 320, height = 160} = {}) {
// do the task
}
size(0, 0);
size(0, 0, {});
size(0, 0, {width: 1});
size(0, 0, {height: 2});
size(0, 0, {width: 1, height: 2});

Handmade Options object handlingOUT OF DATE!
function draw(x, x, options) {
if (options.width === undefined) {
options.width = 320;
}
if (options.height === undefined) {
options.height = 320;
}
// do the task
}

Concat with "+" or String#join()
// concat with variables
var name = 'Bob';
var str = "Hello, I'm " + name + ".";
// create multiple lines
var multi = ["line1", "line2", "line3"].join("n");
OUT OF DATE!

Template Literal
// interpolation
var name = 'Bob';
var str = `Hello, I'm ${name}.`;
// multiple lines
var multi =
`line1
line2
line3`;
• back-quoted string

Extended object literal for shorthand
let foo = 1;
let bar = 2;
// shorthand
let obj = {foo, bar};
// same as: {foo: foo, bar: bar};
let prefix = 'foo';
let obj = {
// computed property
[prefix + 'abc']: 1,
// method definition without "function" keyword
foo() {
console.log('foo!');
}
};

and…
• Iterator
• Spread Operator
• Generator
• Tail Call Optimization
78

New built-in classes and objects
• Promise
• Map
• Set
• WeakMap/WeakSet
• TypedArray
• Symbol
• Proxy/Reﬂect

Callback args for async API
function asyncTask(a, b, callback) {
// ...some async task
if (error) {
callback(error);
} else {
callback(null, result);
}
}
asyncTask(1, 2, function(error, result) {
if (error) {
// ...error handling
}
console.log(result);
});
OUT OF DATE!

Callback args for async API
asyncTask1(function(error, result) {
if (error) {
}
if (error) {
}
if (error) {
}
});
});
});
OUT OF DATE!

ES6 Promise
function asyncTask(a, b, callback) {
// ...some async task
return new Promise((resolve, reject) => {
if (error) {
reject(error);
} else {
resolve(result);
}
});
}
asyncTask(1, 2).then(result => {
console.log(result);
}).catch(error => {
});

ES6 Promise
// series
asyncTask1().then(result => {
return asyncTask2();
}).then(result => {
return asyncTask3();
}).catch(error => {
});

ES6 Promise
// parallel
Promise.all([
asyncTask1(),
asyncTask2(),
asyncTask3()
]).then(results => {
console.log(results[0]);
// result of asyncTask1
});

Use Object as a dictionary
// some keys are dangerous
var obj = {};
var key = "toString";
obj[key] = "value1";
String(obj);
// TypeError: can't convert obj to string
OUT OF DATE!
• some special keys are dangerous

Use Object as a dictionary
// cannot use object as a key
var key1 = {name: "key1"};
var key2 = {name: "key2"};
obj[key1] = "value1";
obj[key2] = "value2";
console.log(obj[key1]);
// "value2"
console.log(Object.keys(obj));
// ["[object Object]"]
OUT OF DATE!
• cannot use an object as a key

ES6 Map
// no dangerous keys
let map = new Map();
map.set("toString", "value1");
map.get("toString"); // "value1"
String(map); // "[object Map]"
// object as a key
let key1 = {};
let key2 = {};
let m = new Map();
m.set(key1, "v1");
m.set(key2, "v2");
m.get(key1); // "v1"

ES6 Set
let set = new Set();
set.add("value1");
console.log(set.size); // 1
// unique
set.add("value1");
console.log(set.size); // 1
• not easy to implement Set in ES5

and…
• WeakMap/WeakSet
• TypedArray
• Symbol
• Proxy/Reﬂect

Improvement of existing classes
• String
• RegExp
• Array
• Object
• Math
• Number

Object.assign
var target = {a: 1, b: 2};
var s1 = {b: 3, c: 4};
var s2 = {c: 5, d: 6};
var ret = Object.assign(target, s1, s2);
console.log(target); // {a: 1, b: 3, c: 5, d: 6}
• no more $.extend() !

Unicode surrogate pair support
• 野家 valid
"𠮷野家".codePointAt(0).toString(16); // "20BB7"
String.fromCodePoint(0x20BB7); // "𠮷"

What's happen?
if (a => 1) {
// ...
}

Oh! Arrow function!
// expected
if (a >= 1) {
}
// arrow function! confusing..
if (a => 1) {
}
// clear
if ((a) => 1) {
}

The TC39 Process: Annual
• TC39 committee approves acceptance for each stage.
Stage 0: Strawman (idea)
Stage 1: Proposal (problem, solution and demo/polyﬁll)
Stage 2: Draft (initial spec)
Stage 3: Candidate (review and feedback)
Stage 4: Finished (two implementations at least)
• Stage 4 features are published as ES201X 
on July every year.

Exponentiation Operator
// x ** y
let squared = 2 ** 2;
// same as: 2 * 2
let cubed = 2 ** 3;
// same as: 2 * 2 * 2
// x **= y
let a = 2;
a **= 2;
// same as: a = a * a;

Array.prototype.includes(str, pos)
[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
[1, 2, NaN].includes(NaN); // true
["a", "b", "c"].includes("a", 0); // true
["a", "b", "c"].includes("a", 1); // false

Object.observe(obj, observer)
let records;
function observer(recs) {
records = recs;
}
let obj = {id: 1};
Object.observe(obj, observer);
obj.a = 'b';
obj.id++;
Object.deliverChangeRecords(observer);
assertChangesAre(records, [
{object: obj, type: 'add', name: 'a'},
{object: obj, type: 'update', name: 'id', oldValue: 1}
]);

Async/await
async function chainAnimationsAsync(elem, animations) {
let ret = null;
try {
for (let anim of animations) {
ret = await anim(elem);
}
} catch(e) { /* ignore */ }
return ret;
}

SIMD
let a = SIMD.Float32x4(1.0, 2.0, 3.0, 4.0);
let b = SIMD.Float32x4(5.0, 10.0, 15.0, 20.0);
let c = SIMD.Float32x4.add(a,b);
// c: (6.0, 12.0, 18.0, 24.0)
• Single Instruction Multiple Data
• Vector data calculation

How can I get along with
ES6 and ES.next?

May the Babel be with you!
• It's too far for all browsers to support ES6.
• IE11 will live until Jun 10, 2023…
• You will be able to stop transpiling features
that browsers support natively.
• Also ES201X features are available via Babel.

Design your policy:
Which ES6 features do you use?
• Which browsers/node.js do you support?
• If you need IE8 (ES3), it's not easy to use ES6…
• Which feature is effective for your project?
• Is the feature easy to transpile/polyﬁll?

Easy to transpile/polyﬁll?
• No problem
Arrow function, let/const, Extended Object literal, Classes 
Extended function params, Template literal, Map/Set, Promise…
• Be careful/Partial
Module, Generator, Symbol
• Hard/Impossible
WeakMap/Set, Proxy, Reﬂect, Tail Call Optimization

Customize Babel conﬁg
• Specify TC39 Stage (default: Stage 2)
• Specify your blacklist features
// .babelrc
{
"stage": 3,
"blacklist": [
"es6.tailCall",
"regenerator"
]
}

Conclusion
• ES6 is awesome!
• Some best-practices are deprecated.
• Try ES6 with Babel from now!

Effective ES6

More Related Content

What's hot

Similar to Effective ES6

More from Teppei Sato

Recently uploaded

Effective ES6