Using ES-2015/2016/2017/2018 features in Node.js (ESnext in Node.js)

Debugging Syntax Error Unexpected Reserved Word in Mocha on Modern Node.js

(Sun Aug 07 2022 00:00:00 GMT+0300 (Eastern European Summer Time)) The error Unexpected Reserved Word usually means you're using await in a non-async function. But what if Mocha throws this error, citing a test suite file that's clean of such problems? To save spending fruitless hours, read this short article.

Importing an ES6 modules over HTTP/HTTPS in a Node.js

(Sat Feb 26 2022 00:00:00 GMT+0200 (Eastern European Standard Time)) In Node.js 17.6.0, an experimental new feature allows us to import modules from an HTTP or HTTPS URL. That will close one of the differences between Node.js and Deno, which is that Deno allows packages to be imported using HTTPS. Further, ES6 modules in the browser allow importing modules over HTTPS. Until now, the Node.js team did not allow this, citing security concerns.

Complete guide to using ES6 modules to create Node.js packages that are easily usable from CJS modules

(Thu Apr 22 2021 00:00:00 GMT+0300 (Eastern European Summer Time)) It is very tempting to write all JavaScript code on Node.js with ES6 modules. But that creates a problem of interoperability with the large number of existing CommonJS (CJS) modules. Namely, it is difficult to use ES6 modules from a CJS module. Node.js makes it easy to use both CJS and ES6 modules from an ES6 module, and CJS modules can easily use CJS modules, but a CJS module using an ES6 module is painful. At the same time ES6 modules offer enough attractive benefits to warrant rewriting our code to switch from CJS to ES6 modules. This means we need a strategy for easily using Node.js ES6 modules from CJS modules.

Loading an ES6 module in a Node.js CommonJS module

(Thu Apr 22 2021 00:00:00 GMT+0300 (Eastern European Summer Time))

ES6 modules are a nifty new way to write modules. They're rather similar to the CommonJS module format traditionally used by Node.js, but there are significant differences. When ES6 module support was first added to Node.js, it was an experimental feature with significant limitations. One limitation was whether you could use ES6 modules from CJS modules, and there was a 3rd party package to fill that gap. Today, ES6 modules are a first class feature in Node.js, and ES6 modules can be used from CJS without any add-on support.

Using Dynamic import in Node.js lets us import ES6 modules in CommonJS code, and more - UPDATED

(Tue Jan 21 2020 00:00:00 GMT+0200 (Eastern European Standard Time)) With ES6, JavaScript programmers finally gained a standard module format that worked on both browser-side and server-side (Node.js) JavaScript runtimes. Plus, ES6 modules offer many interesting features. But Node.js programmers need to know how to integrate ES6 modules with the CommonJS module format we're accustomed to using. Now that Node.js v14 is coming, and bringing with it full ES6 module support as a standard feature, it is time to update a previous blog post about Dynamic Import on Node.js. The Dynamic Import feature, a.k.a. the import() function, gives JavaScript programmers much more freedom over the standard import statement, plus it lets us import an ES6 module into CommonJS code.

A deep dive guide to JavaScript Symbols (ES-6 and beyond)

(Thu Aug 29 2019 00:00:00 GMT+0300 (Eastern European Summer Time))

ES2015 added a ton of useful new features, and among them is the Symbol type. Symbol lets us avoid property name collisions in a way where we can almost implement private properties in JavaScript objects.

Why publish Node.js packages to npm using Babel/Webpack?

(Fri Feb 22 2019 00:00:00 GMT+0200 (Eastern European Standard Time)) Babel and Webpack are widely used tools for front-end-engineering. Between the two you can code JavaScript using the latest ES2016/2017/2018/etc features, with multiple modules, and transpile it down to a simple JavaScript file using ES5 syntax. This is a big step forward in JavaScript tooling. But, since Node.js natively supports a huge fraction of ES2016/2017/2018/etc features, why do Node.js programmers even need to know Babel/Webpack? After reading a tutorial on using Babel/Webpack with Node.js modules, I have the beginning of an inkling for why.

Implementing __dirname in ES6 modules using import.meta.url

(Sun Apr 08 2018 00:00:00 GMT+0300 (Eastern European Summer Time))

ES6 modules are a nifty new way to write modules. In Node.js, our traditional CommonJS modules had several injected variables one of which, __dirname, was incredibly useful. None of those variables exist in ES6 modules. The Node.js team is working on replacements that work in ES6 module contexts, and a new feature has been added in Node.js 10.0.0-pre giving us a way forward to implement the __dirname variable in ES6 modules.

Dynamic import lands in Node.js, we can import ES6 modules in CommonJS code

(Fri Mar 02 2018 00:00:00 GMT+0200 (Eastern European Standard Time))

ES6 modules are a cool new feature coming with Node.js 10.x, and a pre-release version available is avaible in 9.x. ES6 modules implement most of what we can do with Node.js's traditional CommonJS modules. One feature missing is the ability to dynamically select the module to load. The ES6 import statement only takes a static string. A new feature, landing in Node.js 9.7.x, adds an import() function offering a new way to load modules.

The most important feature may be that import() can be used in a CommonJS module to import an ES6 module.

Handling unhandled Promise rejections, avoiding application crash

(Thu Mar 01 2018 00:00:00 GMT+0200 (Eastern European Standard Time))

With Promises and async functions, errors are automatically caught and are turned into a Promise rejection. What happens if nothing inspects the rejected Promise? Turns out that, currently, Node.js detects the unhandled Promise rejection and it prints a warning. In the warning, it says the behavior of catching unhandled Promise rejections is deprecated and will be returned, and instead the application will crash. Therefore it's worth our while to figure out what to do with unhandled Promise rejections.

Hiding data, creating encapsulation, in JavaScript ES-2015 classes

(Tue Feb 27 2018 00:00:00 GMT+0200 (Eastern European Standard Time))

ES2015 added a ton of useful new features, and with ES2016/2017/2018 we're getting a whole new language with a list of exciting new capabilities. One of them is the new Class defintion syntax that brings Class definitions closer to what's done in other languages. Unfortunately the new Class syntax does not provide a robust implementation hiding mechanism. Hiding the implementation is important in object oriented programming, if only to have the freedom to change the implementation at any time.

What is Babel, and when should one use Babel?

(Sun Feb 25 2018 00:00:00 GMT+0200 (Eastern European Standard Time))

Fast advances in the JavaScript language mean the new features are not evenly distributed. Fortunately the JavaScript language is flexible enough that in many cases new features can be retrofitted by using a polyfill among other techniques. One of those techniques is Babel, a so-called Transpiler that can convert code using new features into equivalent code using old features, so that a programmer can code with the new features and still deploy to older JavaScript implementations.