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 (
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
What is ReasonML?
[2018-02-08] Warning: outdated content. Read the book “Exploring ReasonML”, instead (free online). This blog post gives a brief high-level explanation of Facebook’s new programming language, ReasonML. Blog posts in this series # Background: What is ReasonML [this blog post] Getting started with ReasonML What is planned for ReasonML? Core language: Basic values and types let bindings and scopes Pa
ReasonML: basic values and types
Table of contents for this series of posts: “What is ReasonML?” In this blog post, we’ll look at ReasonML’s support for booleans, integers, floats, strings, characters and the unit type. We’ll also see a few operators in action. To explore, we’ll use the interactive ReasonML command line rtop, which is part of the package reason-cli (the manual explains how to install it). Interactions in rtop #
Pattern matching in ReasonML: destructuring, `switch`, `if` expressions
There are many more ways of creating patterns # ReasonML supports more complex data types than just tuples. For example: lists and records. Many of those data types are also supported via pattern matching. More on that in upcoming blog posts. Pattern matching via let (destructuring) # You can do pattern matching via let. As an example, let’s start by creating a tuple: # let tuple = (7, 4); let t
JavaScript vs. TypeScript vs. ReasonML
In this blog post, I describe the pros and cons of three programming languages/dialects: JavaScript, TypeScript and ReasonML. My descriptions are based on recent experiences with TypeScript and ReasonML on a few smaller real-world projects and on years of experience with JavaScript. Before we take a look at the languages, let’s first consider the pros and cons of static typing, given that TypeScri
ES proposal: `import.meta` – module metadata
The proposal “import.meta” by Domenic Denicola is currently at stage 3. This blog post explains how it works. Module metadata # When it comes to working with a module, you are normally interested in what’s inside it. But occasionally, you need information about the module – its metadata. One example of module metadata for Node.js modules is the global variable __dirname which contains the path of
Using ES modules natively in Node.js
Update 2018-12-20: Warning: This blog post is outdated! Consult “ECMAScript modules in Node.js: the new plan” for the latest information. Update 2017-09-14: Major rewrite of Sect. “Checklist: things to watch out for”. New FAQ entries. Starting with version 8.5.0, Node.js supports ES modules natively, behind a command line option. Most of the credit for this new functionality goes to Bradley Farias
Passing data between Promise callbacks
In Promise-based code, there are usually many callbacks, each one having a separate scope for variables. What if you want to share data between those callbacks? This blog post describes techniques for doing so. The problem # The following code illustrates a common problem with Promise callbacks: The variable connection (line A) exists in one scope, but needs to be accessed in other scopes (line B
Node.js 8: `util.promisify()`
Node.js 8 has a new utility function: util.promisify(). It converts a callback-based function to a Promise-based one. util.promisify() in action # If you hand the path of a file to the following script, it prints its contents. // echo.js const {promisify} = require('util'); const fs = require('fs'); const readFileAsync = promisify(fs.readFile); // (A) const filePath = process.argv[2]; readFileAsy
Setting up multi-platform npm packages
Note: “ES5+” means “whatever language features are supported by the JavaScript engines you are targeting”. Background: JavaScript module formats # At the moment, these are the most common JavaScript module formats: AMD (asynchronous module definition): an asynchronous module format for browsers. CJS (CommonJS): a synchronous module format designed for servers (such as Node.js). Due to the popular
Module specifiers: what’s new with ES modules?
Update 2018-12-20: Warning: This blog post is outdated! Consult “ECMAScript modules in Node.js: the new plan” for the latest information. Update 2017-05-11: Complete rewrite of Sect. “Why a new filename extension for ES modules?”. This blog post describes how module specifiers (the path-like IDs of modules) change with ECMAScript modules (ESM). There are a few subtle differences, compared to the f
Making transpiled ES modules more spec-compliant
A proposed “spec mode” for Babel makes transpiled ES modules more spec-compliant. That’s a crucial step in preparing for native ES modules. You’ll also learn how ES modules and CommonJS modules will interoperate on Node.js and how far along ES module support is on browsers and Node.js. Update 2017-05-08: follow-up blog post: Module specifiers: differences between CJS and ESM Transpiling ES modules
ECMAScript 6: merging objects via Object.assign()
New version of this blog post: inside “ECMAScript 6: new OOP features besides classes”. Copying all properties of one object to another one is a common operation in JavaScript. This blog post explains ECMAScript 6’s implementation of it, which is called Object.assign(). This merging operation has a name in the JavaScript ecosystem that is only used there (and, unfortunately, clashes with classic O
JavaScript fatigue fatigue
Enough with the fatigue – tips against feeling overwhelmed: Don’t try to know everything – it’s impossible in modern web development. Given that there is always more to know, it doesn’t matter that much what you learn (unless you have a specific need). Go for depth in areas you love. Go for breadth and on-demand learning in areas you are merely interested in or think you should know more about. Wa
Evaluating JavaScript code via eval() and new Function()
This blog post examines how one can dynamically evaluate code in JavaScript. eval(str) evaluates the JavaScript code in str. For example: > var a = 12; > eval('a + 5') 17 Note that eval() parses in statement context [1]: > eval('{ foo: 123 }') // code block 123 > eval('({ foo: 123 })') // object literal { foo: 123 } eval() in strict mode For eval(), you really should use strict mode [2]. In sloppy
An introduction to JSDoc
Check out my book (free online): “Speaking JavaScript”. Updated version of this blog post: chapter “JSDoc: Generating API Documentation”. Update 2011-08-19. Tweet from JSDoc’s creator, Michael Mathews: Awesome article about JSDoc. I learned (er remembered) a few things from reading it myself! via @rauschma 2ality.com/2011/08/jsdoc-intro.html JSDoc is the de facto standard for documenting JavaScrip
Trying out Underscore on Node.js
Underscore is a library that nicely rounds out JavaScript’s rather limited standard library. Thanks to the Node Package Manager, it’s very simple to install on Node.js: $ npm install underscore Then you can use it in code as follows: var _ = require("underscore"); If you want to play with Underscore interactively in the Node.js REPL, you can’t give it the name _, because that is used by the REPL,
ECMAScript 6 modules: the final syntax
Warning: This blog post is outdated. Instead, read chapter “Modules” in “JavaScript for impatient programmers”. At the end of July 2014, TC39 [1] had another meeting, during which the last details of the ECMAScript 6 (ES6) module syntax were finalized. This blog post gives an overview of the complete ES6 module system. Module systems for current JavaScript # JavaScript does not have built-in supp
リリース、障害情報などのサービスのお知らせ
最新の人気エントリーの配信
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く
ReasonML: basic modules