ECMAScript proposal: RegExp flag `/v` makes character classes and character class escapes more powerful
ECMAScript proposal: RegExp flag /v makes character classes and character class escapes more powerful In this blog post, we look at the ECMAScript proposal “RegExp v flag with set notation + properties of strings” by Markus Scherer and Mathias Bynens. The new flag /v # The proposed new regular expression flag /v (.unicodeSets) enables three features: Support for multi-code-point graphemes (such a
JavaScript metaprogramming with the 2022-03 decorators API
More information on the syntax and semantics of decorators (optional section) # (This section is optional. If you skip it, you can still understand the remaining content.) The syntax of decorator expressions # A decorator expression starts with a chain of one or more identifiers, separated by dots. Each identifier except the first one can be private (prefix #). Square brackets [] are not allowed
Processing Arrays non-destructively: `for-of` vs. `.reduce()` vs. `.flatMap()`
Processing Arrays non-destructively: for-of vs. .reduce() vs. .flatMap() In this blog post, we look at three ways of processing Arrays: The for-of loop The Array method .reduce() The Array method .flatMap() The goal is to help you choose between these features whenever you need to process Arrays. In case you don’t know .reduce() and .flatMap() yet, they will both be explained to you. In order to g
RFC 9239: Updates to ECMAScript media types
(This blog post is based on a tweet thread and additional input by Mathias Bynens.) After work started on it in August 2017, May 2022 finally saw the publication of RFC 9239 “Updates to ECMAScript media types” by Matthew A. Miller, Myles Borins, Mathias Bynens, and Bradley Farias. It updates JavaScript MIME type registrations to align with reality: The JavaScript MIME type is now unambiguously tex
TypeScript and native ESM on Node.js
In this blog post, I’ll explain everything you need to know in order to use and produce native ECMAScript modules on Node.js. The GitHub repository iterable is an example of a TypeScript ESM package that works on Node.js. It still uses the "typesVersions" workaround (which isn’t needed in TypeScript 4.7 and later). (Thanks to Guy Beford and Oleg Drapeza for their feedback on this post.) TypeScript
`undefined` vs. `null` revisited
Many programming languages have one “non-value” called null. It indicates that a variable does not currently point to an object – for example, when it hasn’t been initialized yet. In contrast, JavaScript has two such non-values: undefined and null. In this blog post, we examine how they differ and how to best use or avoid them. undefined vs. null # Both values are very similar and often used inte
Looping over Arrays: `for` vs. `for-in` vs. `.forEach()` vs. `for-of`
Looping over Arrays: for vs. for-in vs. .forEach() vs. for-of This blog post compares four ways of looping over Arrays: The for loop: for (let index=0; index < someArray.length; index++) { const elem = someArray[index]; // ··· } The for-in loop: for (const key in someArray) { console.log(key); } The Array method .forEach(): someArray.forEach((elem, index) => { console.log(elem, index); }); The for
ECMAScript proposal: Import assertions
The ECMAScript proposal “Import assertions” (by Myles Borins, Sven Sauleau, Dan Clark, and Daniel Ehrenberg) introduces syntax for associating metadata with import statements. In this blog post, we examine what that looks like and why it’s useful. Import assertions # The motivating use case for import assertions was importing JSON data as a module. That looks as follows (and is further specified
Alternatives to enums in TypeScript
A recent blog post explored how TypeScript enums work. In this blog post, we take a look at alternatives to enums. Unions of singleton values # An alternative to creating an enum that maps keys to values, is to create a union of singleton types (one per value). Read on to see how that works. Unions of string literal types # Let’s start with an enum and convert it to a union of string literal typ
Hybrid npm packages (ESM and CommonJS)
Warning: This blog post is outdated. It may contain incorrect information. Update 2019-11-22: ESM support in Node.js is not experimental, anymore. This post was updated to reflect that. Conditional exports are now explained. In this blog post, we look at npm packages that contain both ES modules and CommonJS modules. Required knowledge: How ES modules are supported natively on Node.js. You can rea
Evaluating JavaScript code via `import()`
The import() operator lets us dynamically load ECMAScript modules. But they can also be used to evaluate JavaScript code (as Andrea Giammarchi recently pointed out to me), as an alternative to eval(). This blog post explains how that works. eval() does not support export and import # A significant limitation of eval() is that it doesn’t support module syntax such as export and import. If we use i
ES feature: `globalThis`
Warning: This blog post is outdated. Instead, read section “globalThis” in “JavaScript for impatient programmers”. The ECMAScript proposal “globalThis” by Jordan Harband provides a new standard way of accessing the global object. JavaScript’s global scope # JavaScript’s variable scopes are nested and form a tree whose root is the global scope. That scope is only the direct scope when a script run
The new ECMAScript module support in Node.js 12
Follow-up blog post: “Hybrid npm packages (ESM and CommonJS)” Node.js 12 (which was released on 2019-04-23) brings improved support for ECMAScript modules. It implements phase 2 of the plan that was released late last year. For now, this support is available behind the usual flag --experimental-modules. Read on to find out how exactly this new support for ECMAScript modules works. Brief spoiler: T
Future JavaScript: what is still missing?
In recent years, JavaScript has grown considerably in size. This blog post explores what’s still missing. Notes: I’m only listing the missing features that I find most important. Many others are useful, but there is also a risk of adding too much. My choices are subjective. Almost everything mentioned in this blog post is on TC39’s radar. That is, it also serves as a preview of a possible future J
ECMAScript modules in Node.js: the new plan
Status of ECMAScript module (ESM) support in Node.js: Experimental support for ESM was added in Node.js 8.5.0 (2017-09-12). Afterwards, the Node.js Foundation Technical Steering Committee formed the Modules Team to help design missing pieces and to guide the implementation towards its (non-experimental) release. The Modules Team is comprised of people from several different web development areas (
Creating and filling Arrays of arbitrary lengths in JavaScript
Creating and filling Arrays of arbitrary lengths in JavaScript Update 2019-01-02: Rewrote the section on performance. Switched from Array.from(new Array(LEN)) to Array.from({length: LEN}) (because the former argument can get large). New sections: “Recommended patterns”, “Acknowledgements”. The best way of creating an Array, is via a literal: const arr = [0,0,0]; Alas, that isn’t always an option,
Behind the scenes of my latest book on JavaScript
This blog post takes you behind the scenes of my latest book, “JavaScript for impatient programmers” (which I’ll occasionally abbreviate as “Impatient JS”). It describes: How I chose what to write about. My techniques for explaining topics. Tools I used for creating ebooks and other artifacts. How I unit-tested the code shown in the book and in its quizzes. Previewing “JavaScript for impatient pro
Working with stdout and stdin of a child process in Node.js
In this blog post, we run shell commands as child processes in Node.js. We then use async language features to read the stdouts of those processes and write to their stdins. Running commands in child processes # Let’s start with running a shell command in a child process: const {onExit} = require('@rauschma/stringio'); const {spawn} = require('child_process'); async function main() { const filePa
Reading streams via async iteration in Node.js
Update 2018-04-24: Using the library stringio to read lines from stdin. Node.js 10 was released on April 24, 2018. This version provides experimental support for asynchronously iterating over readable streams. This blog post explains how that works. Reading streams asynchronously # In this section, we examine two ways of reading data from a stream asynchronously: via callbacks and via asynchronou
Feature watch: ECMAScript 2018
Check out my book (free online): “Exploring ES2018 and ES2019”. Buy it now and get all future updates. The feature set of ECMAScript 2018 was finalized during the latest TC39 meeting (23-25 January 2018). This blog post describes it. A word on ECMAScript versions # Note that since the TC39 process was instituted, the importance of ECMAScript versions has much decreased. What really matters now is
リリース、障害情報などのサービスのお知らせ
最新の人気エントリーの配信
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く
