Files
reference/source/_posts/es6.md
T
2023-03-06 16:19:19 +08:00

945 lines
14 KiB
Markdown

---
title: ES6
date: 2023-01-08 18:26:55
background: bg-[#edc545]
tags:
- config
- format
categories:
- Programming
intro: |
A quick reference cheatsheet of what's new in JavaScript for ES2015, ES2016, ES2017, ES2018 and beyond
plugins:
- copyCode
---
Getting Started
--------
### Block-scoped {.row-span-2}
#### Let
```js{2,4}
function fn () {
let x = 0
if (true) {
let x = 1 // only inside this `if`
}
}
```
#### Const
```js
const a = 1
```
`let` is the new `var`. Constants (`const`) work just like `let`, but cannot be reassigned.
See: [Let and const](https://babeljs.io/learn-es2015/#let--const)
### Template Strings {.row-span-2}
#### Interpolation
```js
const message = `Hello ${name}`
```
#### Multi-line string
```js
const str = `
hello
the world
`
```
Templates and multiline strings.
See: [template strings](https://babeljs.io/learn-es2015/#template-strings)
### Binary and octal literals
```js
let bin = 0b1010010
let oct = 0o755
```
See: [Binary and Octal Literals](https://babeljs.io/learn-es2015/#binary-and-octal-literals)
### Exponential Operator
```js {1}
const byte = 2 **8
```
Same as: Math.pow(2, 8)
### New library additions
#### New string methods
```js
"hello".repeat(3)
"hello". includes("ll")
"hello". startsWith("he")
"hello".padStart(8) // "hello"
"hello".padEnd(8) // "hello"
"hello".padEnd(8, '!') // hello!!!
"\u1E9B\u0323".normalize("NFC")
```
#### New Number Methods
```js
Number.EPSILON
Number.isInteger(Infinity) // false
Number.isNaN("NaN") // false
```
#### New Math methods
```js
Math.acosh(3) // 1.762747174039086
Math.hypot(3, 4) // 5
Math.imul(Math.pow(2, 32) -1, Math.pow(2, 32) -2) // 2
```
#### New Array methods
```js
//return a real array
Array.from(document.querySelectorAll("*"))
//similar to new Array(...), but without the special single-argument behavior
Array.of(1, 2, 3)
```
See: [New library additions](https://babeljs.io/learn-es2015/#math--number--string--object-apis)
### kind
```js
class Circle extends Shape {
```
#### Constructor
```js {1}
constructor (radius) {
this.radius = radius
}
```
#### method
```js {1}
getArea () {
return Math.PI *2 *this.radius
}
```
#### Call the superclass method
```js {2}
expand(n) {
return super.expand(n) *Math.PI
}
```
#### Static methods
```js {1}
static createFromDiameter(diameter) {
return new Circle(diameter /2)
}
```
Syntactic sugar for prototypes.
See: [classes](https://babeljs.io/learn-es2015/#classes)
### Private class
The javascript default field is public (`public`), if you need to indicate private, you can use (`#`)
```js
class Dog {
#name;
constructor(name) {
this.#name = name;
}
printName() {
// Only private fields can be called inside the class
console.log(`Your name is ${this.#name}`)
}
}
const dog = new Dog("putty")
//console.log(this.#name)
//Private identifiers are not allowed outside class bodies.
dog.printName()
```
#### Static private class
```js
class ClassWithPrivate {
static #privateStaticField;
static #privateStaticFieldWithInitializer = 42;
static #privateStaticMethod() {
// …
}
}
```
Promises
--------
### make the commitment
```js {1}
new Promise((resolve, reject) => {
if (ok) { resolve(result) }
else { reject(error) }
})
```
for asynchronous programming.
See: [Promises](https://babeljs.io/learn-es2015/#promises)
### Using Promises
```js{2,3}
promise
.then((result) => { ··· })
.catch((error) => { ··· })
```
### Using Promises in finally
```js {4}
promise
.then((result) => { ··· })
.catch((error) => { ··· })
.finally(() => {
/*logic independent of success/error */
})
```
The handler is called when the promise is fulfilled or rejected
### Promise function
```js
Promise.all(···)
Promise.race(···)
Promise.reject(···)
Promise.resolve(···)
```
### Async-await
```js{2,3}
async function run () {
const user = await getUser()
const tweets = await getTweets(user)
return [user, tweets]
}
```
`async` functions are another way to use functions.
See: [Async Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function)
Destructuring
-------------
### Destructuring assignment
#### Arrays
```js {1}
const [first, last] = ['Nikola', 'Tesla']
```
#### Objects
```js {1}
let {title, author} = {
title: 'The Silkworm',
author: 'R. Galbraith'
}
```
Supports matching arrays and objects.
See: [Destructuring](https://babeljs.io/learn-es2015/#destructuring)
### Defaults
```js
const scores = [22, 33]
const [math = 50, sci = 50, arts = 50] = scores
```
----
```js
//Result:
//math === 22, sci === 33, arts === 50
```
A default value can be assigned when destructuring an array or object
### Function parameters
```js {1}
function greet({ name, greeting }) {
console.log(`${greeting}, ${name}!`)
}
```
----
```js
greet({ name: 'Larry', greeting: 'Ahoy' })
```
Destructuring of objects and arrays can also be done in function parameters
### Defaults
```js {1}
function greet({ name = 'Rauno' } = {}) {
console.log(`Hi ${name}!`);
}
```
----
```js
greet() // Hi Rauno!
greet({ name: 'Larry' }) // Hi Larry!
```
### Reassign keys
```js {1}
function printCoordinates({ left: x, top: y }) {
console.log(`x: ${x}, y: ${y}`)
}
```
----
```js
printCoordinates({ left: 25, top: 90 })
```
This example assigns `x` to the value of the `left` key
### Loop
```js {1}
for (let {title, artist} of songs) {
···
}
```
Assignment expressions also work in loops
### Object Deconstruction
```js {1}
const { id, ...detail } = song;
```
Use the `rest(...)` operator to extract some keys individually and the rest of the keys in the object
Spread operator Spread
------
### Object Extensions
#### with object extensions
```js {2}
const options = {
...defaults,
visible: true
}
```
#### No object extension
```js
const options = Object.assign(
{}, defaults,
{ visible: true })
```
The object spread operator allows you to build new objects from other objects.
See: [Object Spread](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator)
### Array Expansion
#### with array extension
```js{2,3}
const users = [
...admins,
...editors,
'rstacruz'
]
```
#### No array expansion
```js
const users = admins
.concat(editors)
.concat([ 'rstacruz' ])
```
The spread operator allows you to build new arrays in the same way.
See: [Spread operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator)
Functions
---------
### Function parameters {.row-span-3}
#### Default parameters
```js {1}
function greet (name = 'Jerry') {
return `Hello ${name}`
}
```
#### Rest parameters
```js {1}
function fn(x, ...y) {
// y is an array
return x * y.length
}
```
#### Extensions
```js {1}
fn(...[1, 2, 3])
//same as fn(1, 2, 3)
```
Default (default), rest, spread (extension).
See: [function parameters](https://babeljs.io/learn-es2015/#default--rest--spread)
### Arrow function {.row-span-3}
#### Arrow functions
```js {1}
setTimeout(() => {
···
})
```
#### with parameters
```js {1}
readFile('text.txt', (err, data) => {
...
})
```
#### implicit return
```js{1,4,5,6}
arr.map(n => n*2)
//no curly braces = implicit return
//Same as: arr.map(function (n) { return n*2 })
arr.map(n => ({
result: n*2
}))
//Implicitly returning an object requires parentheses around the object
```
Like a function, but preserves `this`.
See: [Arrow functions](https://babeljs.io/learn-es2015/#arrows-and-lexical-this)
### Parameter setting default value
```js
function log(x, y = 'World') {
console.log(x, y);
}
log('Hello') // Hello World
log('Hello', 'China') // Hello China
log('Hello', '') // Hello
```
### Used in conjunction with destructuring assignment defaults
```js
function foo({x, y = 5} = {}) {
console.log(x, y);
}
foo() // undefined 5
```
### name attribute
```js
function foo() {}
foo.name // "foo"
```
### length property
```js
function foo(a, b){}
foo.length // 2
```
Objects
-------
### Shorthand Syntax
```js
module.exports = { hello, bye }
```
same below:
```js
module.exports = {
hello: hello, bye: bye
}
```
See: [Object Literals Enhanced](https://babeljs.io/learn-es2015/#enhanced-object-literals)
### method
```js {2}
const App = {
start () {
console.log('running')
}
}
//Same as: App = { start: function () {···} }
```
See: [Object Literals Enhanced](https://babeljs.io/learn-es2015/#enhanced-object-literals)
### Getters and setters
```js{2,5}
const App = {
get closed () {
return this.status === 'closed'
},
set closed (value) {
this.status = value ? 'closed' : 'open'
}
}
```
See: [Object Literals Enhanced](https://babeljs.io/learn-es2015/#enhanced-object-literals)
### Computed property name
```js {3}
let event = 'click'
let handlers = {
[`on${event}`]: true
}
//Same as: handlers = { 'onclick': true }
```
See: [Object Literals Enhanced](https://babeljs.io/learn-es2015/#enhanced-object-literals)
### Extract value
```js{3,5}
const fatherJS = { age: 57, name: "Zhang San" }
Object.values(fatherJS)
//[57, "Zhang San"]
Object.entries(fatherJS)
//[["age", 57], ["name", "Zhang San"]]
```
Modules module
-------
### Imports import
```js
import 'helpers'
//aka: require('···')
```
----
```js
import Express from 'express'
//aka: const Express = require('···').default || require('···')
```
----
```js
import { indent } from 'helpers'
//aka: const indent = require('···').indent
```
----
```js
import *as Helpers from 'helpers'
//aka: const Helpers = require('···')
```
----
```js
import { indentSpaces as indent } from 'helpers'
//aka: const indent = require('···').indentSpaces
```
`import` is the new `require()`.
See: [Module imports](https://babeljs.io/learn-es2015/#modules)
### Exports export
```js
export default function () { ··· }
//aka: module.exports.default = ···
```
----
```js
export function mymethod () { ··· }
//aka: module.exports.mymethod = ···
```
----
```js
export const pi = 3.14159
//aka: module.exports.pi = ···
```
----
```js
const firstName = 'Michael';
const lastName = 'Jackson';
const year = 1958;
export { firstName, lastName, year };
```
----
```js
export *from "lib/math";
```
`export` is the new `module.exports`.
See: [Module exports](https://babeljs.io/learn-es2015/#modules)
### `as` keyword renaming
```js{2,8,12-14}
import {
lastName as surname // import rename
} from './profile.js';
function v1() { ... }
function v2() { ... }
export { v1 as default };
//Equivalent to export default v1;
export {
v1 as streamV1, // export rename
v2 as streamV2, // export rename
v2 as streamLatestVersion // export rename
};
```
### Dynamically load modules
```js
button.addEventListener('click', event => {
import('./dialogBox.js')
.then(dialogBox => {
dialogBox. open();
})
.catch(error => {
/*Error handling */
})
});
```
[ES2020 Proposal](https://github.com/tc39/proposal-dynamic-import) introduce `import()` function
### import() allows module paths to be dynamically generated
```js
const main = document.querySelector('main')
import(`./modules/${someVariable}.js`)
.then(module => {
module.loadPageInto(main);
})
.catch(err => {
main.textContent = err.message;
});
```
### import.meta
[ES2020](https://github.com/tc39/proposal-import-meta) Added a meta property `import.meta` to the `import` command, which returns the meta information of the current module
```js
new URL('data.txt', import.meta.url)
```
In the Node.js environment, `import.meta.url` always returns a local path, that is, a string of the `file:URL` protocol, such as `file:/// home/user/foo.js`
### Import Assertions {.col-span-2}
#### static import
```js
import json from "./package.json" assert {type: "json"}
//Import all objects in the json file
```
#### Dynamic Import
```js
const json =
await import("./package.json", { assert: { type: "json" } })
```
Generators
----------
### Generator function
```js
function*idMaker () {
let id = 0
while (true) { yield id++ }
}
```
----
```js
let gen = idMaker()
gen.next().value // → 0
gen.next().value // → 1
gen.next().value // → 2
```
it's complicated.
See: [Generators](https://babeljs.io/learn-es2015/#generators)
### For..of + iterator {.row-span-2}
```js
let fibonacci = {
[Symbol.iterator]() {
let pre = 0, cur = 1;
return {
next() {
[pre, cur] = [cur, pre + cur];
return { done: false, value: cur }
}
}
}
}
for (var n of fibonacci) {
// truncate sequence at 1000
if (n > 1000) break;
console.log(n);
}
```
For iterating over generators and arrays.
See: [For..of iteration](https://babeljs.io/learn-es2015/#iterators--forof)
### Relationship with Iterator interface
```js
var gen = {};
gen[Symbol.iterator] = function*() {
yield 1;
yield 2;
yield 3;
};
[...gen] // => [1, 2, 3]
```
The `Generator` function is assigned to the `Symbol.iterator` property, so that the `gen` object has the `Iterator` interface, which can be traversed by the `...` operator
### Symbol.iterator property
```js
function*gen() { /*some code */}
var g = gen();
g[Symbol.iterator]() === g // true
```
`gen` is a `Generator` function, calling it will generate a traverser object `g`. Its `Symbol.iterator` property, which is also an iterator object generation function, returns itself after execution
see also
---
- [Learn ES2015](https://babeljs.io/docs/en/learn/)_(babeljs.io)_
- [ECMAScript 6 Features Overview](https://github.com/lukehoban/es6features#readme) _(github.com)_