Revisiting My 2020 ES6 Cheat-Sheet

Exactly five years ago, I shared a simple ES6 cheat-sheet, a quick reference guide for the modern JavaScript features that were finally becoming mainstream. Today, I’m looking back at that list to see what held up, what faded out, and what I’d add if I wrote it again in 2025.

This post is a follow-up to my broader reflection: Was ES6 the Rebirth of JavaScript?.
There, I explored the bigger picture. Here, we zoom in on the practical bits.

JavaScript in 2020: A Quick Time Capsule

In early 2020, modern JavaScript was still going through growing pains.

Most teams relied on Babel and Webpack.
import/export syntax was technically part of the spec, but not yet stable in Node or widely used natively in browsers.
Arrow functions, template strings, destructuring, these were still considered “new” in many codebases.
ES6 had been official for nearly five years already, but many devs were just catching up.

In that context, I wrote a quick cheat-sheet to summarize the 10 most important features ES6 brought in. It was meant to help my team get comfortable with the newer syntax and patterns. But even I didn’t realize how permanent those changes would become.

Looking Back at the Original List

Let’s go through that cheat-sheet again, but this time with a 2025 lens:

Feature	What Made It Matter in 2015	Where It Stands Today	Example
Default params	Eliminated `x		fallback` hacks
Template strings	Interpolation, multiline text	Used constantly	`Hello, ${name}`
Multi-line text	Cleaner than `'\n'` chaining	Common with tagged templates	`const poem = line\nline;`
Destructuring	Less boilerplate for props	Default in JS/React code	`const { id } = user;`
Object literals	Shorthand props and computed keys	Key in Redux, Vue, etc.	`{ id, ['k' + id]: true }`
Arrow functions	Compact syntax, lexical `this`	Go-to for callbacks	`arr.map(x => x * 2)`
Promises	Solved callback hell	Still relevant with `await`	`fetch(url).then(...);`
let / const	Safer scoping than `var`	Now considered best practice	`const MAX = 10;`
Classes	Familiar syntax for OOP devs	Still used in some patterns	`class User { constructor(n){...} }`
Modules	Native modular code	Fully adopted in all tools	`import X from './file.js';`

Not one of these features has become irrelevant. Every single one is still part of the default way we write JavaScript today.

What That List Didn’t Cover

The cheat-sheet was focused on ES6, so naturally it missed features that came just after it. But by 2025, several of those have become just as essential:

Optional chaining (user?.profile?.email)
Nullish coalescing (value ?? 'default')
Logical assignment operators (x ||= 10)
Promise.allSettled, Promise.any
Top-level await
Dynamic imports, import.meta, and import maps

These weren’t on my radar at the time, but they’ve become second nature now.

What I’d Emphasize If I Wrote It Today

If I had to write a 2025 version of the same cheat-sheet, I’d shift the focus slightly. Less syntax, more patterns:

async function* and for await...of for working with streams
Object.freeze and immutable object practices
Cleaner error handling with try/catch, including AggregateError
Using native ESM and import maps without bundlers
Writing code that runs directly in browsers and Node without transpilation

I’d also explicitly state this: write for the platform first, transpile last. Modern JavaScript runtimes are capable. Most of what we once relied on Babel for is now native.

Final Thoughts: Then vs. Now

Here’s what stood out most as I reflected:

That original cheat-sheet aged well. It didn’t cover everything, but it captured a turning point.
We’ve gone from “modern” JavaScript to just... JavaScript. Nobody says “ES6” anymore, even though we’re all still writing it.
Cheat-sheets are more than reference cards. They reflect the shape of our thinking at a point in time.
The ecosystem matured. Browsers, Node, and tooling all stabilized. The wild experiments gave way to solid, dependable workflows.

Looking Ahead

Five years ago, ES6 felt like the “future of JavaScript.” Today, it’s the foundation. The tooling has changed. The runtimes evolved. The ecosystem matured. But those ten features? They’re still doing work in nearly every codebase.

Revisiting My 2020 ES6 Cheat-Sheet: Five Years Later