Exploring aggressive options in Node.js v18 and v19

Node.js has been a preferred JavaScript runtime since its launch in 2009. However the introduction of two new runtimes, Deno and Bun, has introduced a whole lot of hype for the brand new options they current in distinction to Node.

From afar, it could seem to be Node.js is stagnating and nothing thrilling is going on — however the actuality is totally different. Two current Node.js releases, v18 and v19, got here with a whole lot of vital options:

• Experimental help for browser APIs, corresponding to Fetch and the online streams API
• An experimental, inbuilt take a look at runner
• Assist for the current model of Chromium’s V8 engine
• Experimental help for watch mode, which replaces a instrument like nodemon

On this tutorial, we are going to discover the next cool new options in Node.js v18 and v19:

Node.js v18 options

Node.js v18 was launched on April 19, 2022, and have become a present launch by October 2022, when Node.js v19 was launched. A present launch implies that the model good points non-breaking options from a more recent model of Node.js.

Node.js v18 gained the watch mode function, which was backported in Node v18 when v19 was launched. On October 25, 2022, Node.js v18 was promoted to LTS (long-term help) and can proceed receiving help till 2025.

The next are among the options which are accessible in Node.js v18.

Inbuilt Fetch API

Earlier than Node.js v18, you needed to set up node-fetch or Axios to request a useful resource from a server. With Node.js v18, you not want to put in both bundle because of v18’s experimental Fetch API, which is on the market globally.

Let’s take a look at how you can use the Fetch API in Node.js v18. First, create a getData.js file and add the next operate that sends a request to an API:

async operate fetchData() {
  const response = await fetch(
    "https://random-data-api.com/api/identify/random_name"
  );
  if (response.okay) {
    const information = await response.json();
    console.log(information);
  }
}

fetchData();

Save the file contents, then run the file with the node command:

node getData.js

When the command runs, the output will appear like the next:

(node:29835) ExperimentalWarning: The Fetch API is an experimental function. This function may change at any time
(Use `node --trace-warnings ...` to indicate the place the warning was created)
{
  id: 6638,
  uid: '75026571-e272-4298-b2c0-c3e9e6363437',
  identify: 'Sweet Kane',
  ...
  prefix: 'Rep.',
  initials: 'LBS'
}

Within the output, Node.js logs a warning that the Fetch API is experimental. After the warning, we see the JSON information that the API returned.

Inbuilt take a look at runner module

Builders sometimes use unit testing to check software program elements. From the early releases of Node.js, we may write easy exams with the assert library. However as our exams grew bigger, so did our want to arrange exams and write descriptive messages.

As an answer, take a look at runners corresponding to Jest, Jasmine, and Mocha emerged, and have been the go-to instruments for unit testing.

With the discharge of Node.js v18, a take a look at runner is now included in Node.js and could be accessed with:

import take a look at from 'node:take a look at';

Notice that we’re utilizing the node: scheme to import the module. You may also use CommonJS:

const take a look at = require('node:take a look at')

Let’s discover ways to use it. First, initialize npm with the next:

npm init -y

In your bundle.json file, allow the ES modules:

{
  ...
  "license": "ISC"
  "kind": "module",
}

Subsequent, create a math.js file and add a operate that returns the results of including two numbers:

const sum = (a, b) => {
  return a + b;
};

export default sum;

To check the operate with the Node.js take a look at runner, create a take a look at.js file with the next content material:

import take a look at from "node:take a look at";
import assert from "assert/strict";
import sum from "./math.js";

take a look at("Sum operate", async (t) => {
  await t.take a look at("It ought to add two numbers", () => {
    assert.equal(sum(2, 2), 4);
  });
  await t.take a look at("It mustn't subtract numbers", () => {
    assert.notEqual(sum(3, 2), 1);
  });
});

Within the first line, we import the take a look at runner. Within the second line, we import the assert library, and subsequently, the sum() operate within the math.js file.

After that, we create a take a look at case that has two subtests, which take a look at if the sum() operate works correctly.

Now, run the exams:

node take a look at.js

Your output will appear like the next:

TAP model 13
# Subtest: Sum operate
    # Subtest: It ought to add two numbers
    okay 1 - It ought to add two numbers
      ---
      duration_ms: 1.171389
      ...
    # Subtest: It mustn't subtract numbers
    okay 2 - It mustn't subtract numbers
      ---
      duration_ms: 0.279246
      ...
    1..2
okay 1 - Sum operate
  ---
  duration_ms: 5.522232
  ...
1..1
# exams 1
# cross 1
# fail 0
# cancelled 0
# skipped 0
# todo 0

Within the output, we will see that Node.js has description messages of the exams that run.

Net Streams API help

The Net Streams API is an experimental function in Node.js that allows you to break a big file, like a video or textual content file, into smaller chunks that may be consumed steadily. This helps keep away from reminiscence points. In older variations of Node.js, you may use Node.js streams to eat massive recordsdata. However this performance wasn’t accessible for JavaScript apps within the browser. Later, WHATWG outlined the Net Streams API, which has now turn into the usual for streaming information in JavaScript apps.

Node.js didn’t help this API till v18. With v18, all the Streams API objects, corresponding to ReadableStream, WritableStream, and TransformStream, can be found. To study extra about how you can use the Streams API, try the documentation.

Constructing binaries with the snapshot function

One other thrilling function is the flexibility to construct a single-executable Node.js binary. Earlier than Node.js v18, the one method to construct a Node.js binary was to make use of a third-party bundle, like pkg.

However now, you can also make use of the experimental snapshot flag --node-snapshot-main to construct a binary. For extra particulars on how this function works, see this tutorial.

V8 engine upgraded to v10.1

Node.js is constructed on prime of the V8 engine, created by Google and maintained for Chromium to execute JavaScript. With every launch, it introduces new options and a few efficiency enhancements, which find yourself in Node.js.

Google launched V8 10.1, which launched some new array strategies, corresponding to findLast() and findLastIndex(), in addition to Intl.supportedValuesOf(code). The V8 engine additionally added new strategies to the Intl.Locale API, and optimized the class fields and personal strategies.

watch mode and different Node.js v19 options

Node.js v19 was launched on October 18, 2022. Since 19 is an odd quantity, it would by no means be promoted to LTS, however will proceed receiving help till April 2023, when a brand new, even-numbered Node.js model is launched.

Whereas Node.js v19 has not launched a whole lot of options compared to Node.js v18, it has shipped one of the crucial requested options to previous Node variations as properly: watch mode.

Whenever you create and begin a server in Node.js, then later make modifications to the file, Node.js doesn’t decide up the brand new modifications robotically. You both must restart the server or use a instrument like nodemon, which robotically reruns a file when it detects new modifications.

With the discharge of Node.js v19, that is not vital. Node v19, in addition to Node ≥ v 18.11.0, is now capable of robotically restart a course of when it detects new modifications utilizing the node --watch function, which is at present experimental.

To run a file in watch mode, use the --watch flag:

node --watch index.js

Whenever you edit the index.js file, you will notice that the method robotically restarts and the brand new modifications are mirrored with out stopping the server.

As talked about, this function has additionally been backported to Node.js ≥ v18.11.0, which suggests you don’t have to make use of Node.js v19 if that is the one function you want.

HTTP(S)/1.1 KeepAliveby default

Node.js makes use of an http.globalAgent for outgoing HTTP connections and https.globalAgent for outgoing HTTPS connections. These brokers guarantee TCP connection persistence in addition to that HTTP purchasers can reuse the connections for a number of requests.

You possibly can configure the brokers to reuse connections by setting the HTTP 1.1 keepAlive choice to true; in any other case, set it to false to keep away from reusing connections, which makes issues slower.

For Node.js model ≤18, outgoing connections for HTTP/HTTPS have the keepAlive choice set to fal``se, so connections should not reused for a number of requests, resulting in slower efficiency. With Node.js v19, the keepAlive choice is now set to true, which suggests your outgoing connections will likely be quicker with out doing any configurations.

Let’s confirm this. Assuming you might be utilizing nvm, you may set up Node.js ≤ v18 and briefly swap to it:

nvm set up v18.12.1
node -v
// Output
// v18.12.1

Create a checkHttpAlive.js file and add the next code to examine the http.globalAgent:

const http = require('node:http');
console.log(http.globalAgent);

Your output will look as follows:

// Output
Agent {
  ...
  keepAliveMsecs: 1000,
  keepAlive: false,  // that is the keepAlive choice
  ...
}

Within the output, you’ll discover that keepAlive is about to false by default on Node v18.

Let’s evaluate it with Node.js v19. Change the Node.js model to v19 with nvm:

nvm set up v19.0.1
node -v
// output:
// v19.0.1

Run the checkHttpAlive.js file once more:

node checkHttpAlive.js

The output will match the next:

// output
Agent {
  ...
  keepAliveMsecs: 1000,
  keepAlive: true,
  ...
}

Within the output, you may see the keepAlive choice is about to true by default in Node.js v19.

V8 engine improve to 10.7

The V8 Engine for Node.js v19 has been upgraded to model 10.7. It didn’t ship with a whole lot of options — it solely added the Intl.NumberFormat function to the JavaScript API.

The Intl.NumberFormat internationalizes a quantity as a foreign money. An instance:

> new Intl.NumberFormat('en-US', { fashion: 'foreign money', foreign money: 'GBP' }).format(3392.10)
'£3,392.10'     // output

Conclusion

On this article, we explored cool options in Node.js v18 and v19. First, we regarded on the new options in v18, which embody the inbuilt Fetch API, a brand new take a look at runner and snapshot function, watch mode, and help for the Net Streams API. We then checked out new options in Node v19, which incorporates watch mode, and the HTTP 1.1 keepAlive function.

As thrilling as the brand new Node.js options are, most of those options exist already in Bun and Deno. The runtimes additionally embody helpful options, corresponding to native TypeScript help, net sockets API, and execute quicker than Node.js.

If you’re undecided which Node.js model to make use of, I might advocate v18. Its help will final till 2025, in contrast to Node v19, whose help will finish subsequent 12 months. If you wish to study these options in additional depth, discuss with the documentation web page.