What’s New in Node.js 20? : Explore Features of Node.js New Version

Hardik Thakker

Founder & CEO

Published On: May 04, 2023

Node.js is a popular open-source, cross-platform, server-side runtime environment that allows developers to build fast and scalable applications using JavaScript.

With the latest node version 20, there are several new features and improvements that are worth exploring. In this blog post, we will take a closer look at some of the key updates included in Node.js v20 and how they can benefit developers.

Node.js version 20 has the latest experimental features to enhance debugging and diagnostics tools. It plays a vital role in the life of developers to create better and more efficient applications. So, whether you are a seasoned Node.js developer or just getting started, read more about the exciting new updates in Node.js v20.

Key Takeaways

What is Node.js?

Node.js is a popular runtime environment that lets developers build fast and scalable server-side applications using JavaScript. Originally introduced in 2009 by Ryan Dahl, it uses Google’s V8 engine to convert JavaScript into high-speed machine code, making execution quick and efficient.

What sets Node.js apart is its non-blocking I/O and event-driven architecture. This allows it to manage many requests at once without slowing down—ideal for real-time features like chat apps or live data streaming. Companies often hire Node.js developers to build web application development projects that need performance and real-time interaction.

Thanks to its active community, Node.js offers thousands of ready-to-use modules that speed up development. It’s commonly used to build APIs, web servers, and even tools for the command line. Whether it’s powering social platforms, online games, or real-time dashboards, Node.js is trusted for its reliability and speed.

For developers and businesses alike, Node.js remains a top choice for building modern web solutions efficiently and effectively.

Build Web Apps Using Node.js Development Services

Features Introduced in Node.js 20

Let’s explore the primary features introduced in the latest version of Node.js.

1. New Permission Model in Node.js Version 20

   Node.js 20 introduces a new permission model that provides better control over what resources an application can access. This new model is designed to address some of the security concerns that have been raised about Node.js development services in the past, particularly with regards to the risk of malicious code executing with elevated privileges.

   The new Node.js permission model is based on the principle of least privilege. This means that by default, Node.js applications are only granted access to the specific resources they need to function, and no more. If an application needs access to additional resources, it must explicitly request them.

   The new permission model is implemented using a set of new APIs that allow applications to request access to resources such as files, network interfaces, and environment variables. These APIs are organized into modules based on the type of specific resources being accessed.

   For example, there is a fs.promises module for accessing the file system, a net module for network access, and a process module for environment variables.

   Each module has its own set of methods for requesting access to resources. For example, the fs.promises module has methods such as access(), read(), and write() that allow applications to request read or write access to specific files or directories.

   When an application requests access to a resource, Node.js checks to see if the requested access is allowed based on the permissions currently granted to the application.

   If the access is allowed, the application is granted the necessary permissions and can proceed with its operation. If the access is not allowed, the application is denied access and an error is returned.

   The new (experimental) mechanism named Node.js Permission Model restrict access the usage of traditional script. You just have to push the command –experimental-permission flag your node command line followed by:

   –allow-fs-read to grant read-access to files.

   In addition, you can can set the limit read-access to:

   • specific directories: –allow-fs-read=/tmp/
   • specific files: –allow-fs-read=/path-to-data/.json
   • or wildcard file patterns: –allow-fs-read=/path-to-data/*.json
   • writing permission: Grant writing permission to files with matching directory, file, or wildcard patterns by using the –allow-fs-write option.
   • Child Process: Enabling the –allow-child-process option allows a child process, including running other scripts that may have been written in different programming languages.
   • Allow Worker Option: Enabling the –allow-worker option allows the use of worker threads, which can execute Node.js code concurrently with the main processing and dedicated main thread.

   In the following example, somescript.js can read files in the /path-to-data/ directory:

   node –experimental-permission –allow-fs-read=/path-to-data/ somescript.js

   Any attempt to write a file, execute another process, or launch a web worker raises a ERR_ACCESS_DENIED error.

   The new process.permission object enables you to examine authorizations within your application. To illustrate, the following is a way to verify if the script has the ability to create files.

   Deno initially introduced permission management for JavaScript, which provides detailed regulation over access to multiple functionalities such as files, environment variables, time measurement, operating system information, network, dynamically-loaded libraries, and child processes.

   Copy

   process.permission.has('fs.write');
   
   Here’s how to check if the script can write to a specific file:
   
   if ( !process.permission.has('fs.write', '/path-to-data/mydata.json') ) {
     console.error('Cannot write to file');
   }
   

   Node.js is insecure by default unless you add the –experimental-permission flag. This is less effective, but ensures existing scripts continue to run without modification.

   The new permission model is designed to be flexible and extensible, allowing JS team to define their own custom permissions and access control policies if needed.

   With the help of its long-term support, it makes it possible to create highly secure applications that are tailored to the specific needs of the organization or use case.

2. Native Test Runner

   The Native Test Runner in Node.js is a built-in tool introduced to simplify the testing process. Traditionally, developers needed to rely on third-party libraries like Mocha or Jest for testing their code. While these tools are powerful, choosing and managing them often added extra steps and complexity.

   Starting with Node.js 18, an experimental test runner was introduced, and by Node.js 20, it became stable. This means developers now have a built-in, reliable option to write and run tests without adding external dependencies.

   Similar to other modern runtimes like Deno or Go that include native testing tools, Node.js now gives its development community a streamlined way to write tests directly within the runtime environment. This update helps improve workflow consistency, reduces setup time, and ensures a more standardized development experience.

   For teams looking to write efficient, maintainable code, the native test runner makes it easier to test applications using tools already integrated into Node.js.

   • in your project’s /test/ directory
   • by naming the file test.js, mytestfile.mjs, or test.cjs
   • using test- at the beginning of the filename — such as test-mycode.js
   • using test at the end of the filename with preceding period (.), hyphen (-) or underscore (_) — such as mycode-test.js, mycode_test.cjs, or mycode.mytestfile.mjs

   You can then import node:test and node:assert and write testing functions:

   Copy

   / mytestfile.mjs
   import { test, mock } from 'node:test';
   import assert from 'node:assert';
   import fs from 'node:fs';
   
   test('my first test', (t) => {
     assert.strictEqual(1, 1);
   });
   
   test('my second test', (t) => {
     assert.strictEqual(1, 2);
   });
   
   / asynchronous test with mocking
   mock.method(fs, 'readFile', async () => 'Node.js test');
   test('my third test', async (t) => {
     assert.strictEqual( await fs.readFile('anyfile'), 'Node.js test' );
   });
   
   

   Run the tests with node –test mytestfile.mjs and examine the output:

   ✔ my first test (0.9792ms)
   ✖ my second test (1.2304ms)
   AssertionError: Expected values to be strictly equal:1 !== 2

   at TestContext. (mytestfile.mjs:10:10)
   at Test.runInAsyncScope (node:async_hooks:203:9)
   at Test.run (node:internal/test_runner/test:547:25)
   at Test.processPendingSubtests (node:internal/test_runner/test:300:27)
   at Test.postRun (node:internal/test_runner/test:637:19)
   at Test.run (node:internal/test_runner/test:575:10)
   at async startSubtest (node:internal/test_runner/harness:190:3)

   Copy

   {
       generatedMessage: false,
       code: 'ERR_ASSERTION',
       actual: 1,
       expected: 2,
       operator: 'strictEqual'
     }
   
   

   ✔ my third test (0.1882ms)
   ℹ tests 3
   ℹ pass 2
   ℹ fail 1
   ℹ cancelled 0
   ℹ skipped 0
   ℹ todo 0
   ℹ duration_ms 72.6767

   For any file changes, you have an option to add a –watch flag to automatically re-run tests when the file system changes:

   For example, node –test –watch mytestfile.mjs

   With the help of the command: node –test, it becomes easier for you to run all tests found in the project:

   The inclusion of native testing in the Node.js runtime is a positive development. It reduces the need to familiarize oneself with various third-party APIs and eliminates any excuses for neglecting to add tests to smaller projects.

   Related Post: Best NodeJS Frameworks

3. Compiling a Single Executable Application

   In the context of Node.js 20, compiling single executable apps refers to the process of bundling all the necessary dependencies, modules, and code into a single executable app file system that can be run on any system without the need for additional installations or configurations.

   Before Node.js 20, creating a single executable file for a Node.js application was a challenging task that required the use of third-party tools and libraries. However, with the last major release of Node.js 20, this process has become much more straightforward and has a separate scope of development.

   The new pkg module, included with Node.js 20, allows developers to create self-contained executable files for their Node.js applications. The pkg module compiles the entire Node.js application, including its dependencies, into a single binary file that can be executed on any system without requiring additional installations.

   To create an executable file using the pkg module, developers simply need to install the module, configure their application’s entry point and any necessary flags, and run the pkg command. The resulting binary file of a single executable app can be distributed and run on any system, making it a convenient and practical way to package and distribute Node.js applications.

   The ability to compile a single executable file for a Node.js application simplifies the deployment process and makes it easier for developers to distribute their applications across different platforms and other Javascript environments.

   In Node Version 20, an experimental feature enables the creation of a Single Executable Application (SEA) that can be deployed without dependencies. To create a SEA, your project must have a single entry script that uses CommonJS instead of ES Modules in your SEA config file.

   Generate a JSON config file that can be utilized to assemble your script into a blob that executes within the runtime.

   For example, sea-config.json:

   Copy

   {
     "main": "myscript.js",
     "output": "sea-prep.blob"
   }
   
   

   To create the blob, run the command “node –experimental-sea-config sea-config.json”, and depending on your operating system, you will need to perform additional steps such as copying the node executable, removing the binary’s signature, injecting the blob into the binary, re-signing it, and testing the application.

   However, this approach has some limitations, such as only being able to target the same OS as the one being used and being restricted to older CommonJS projects.

   On the other hand, the Deno compiler is more advanced and can generate an executable for any platform with a single command from JavaScript or TypeScript source files. It is expected that the process of generating single executable applications with Node.js application code will improve.

4. Updated V8 JavaScript Engine

   The newest version of the V8 engine is incorporated in Node.js 20 and offers several JavaScript frameworks features, such as:

   • String.prototype.isWellFormed(): returns a boolean value indicating whether a string is well-formed and does not include lone (unpaired) surrogate characters.
   • String.prototype.toWellFormed(): returns a well-formed string that resolves lone surrogate character problems.

   A new regular expression v flag that addresses issues related to the casing of Unicode characters.

   Hire Node.JS Developers To Create a Robust Back-End Solution

   Our team of talented Nodejs developers are proficient in working with Node.js version 20 for all your project requirements.

   Hire Node.JS Developers Now

5. Application Performance

   Application performance refers to how efficiently a software application runs, especially in handling tasks, user requests, and system resources. In the context of Node.js v20, performance improvements were a key part of the release.

   This version introduced optimizations that help applications run faster and handle more users at once with lower latency. These enhancements benefit developers building high-traffic or real-time systems by reducing delays and increasing responsiveness.

   Improving application performance in Node.js not only leads to a smoother user experience but also supports scalable, reliable software that performs well under pressure.

   Here are some of the highlights:

   • Improved startup time: The V8 engine, the JavaScript engine used by Node.js, now starts up faster due to changes in how it loads code. This can lead to faster startup times for Node.js applications.
   • Improved garbage collection: Garbage collection is the process of freeing up memory no longer being used by an application. The V8 engine in the latest version of Node.js now uses a more efficient garbage collection algorithm that can reduce the impact on application performance.
   • Improved performance for HTTP/2: HTTP/2 is a newer version of the HTTP protocol that can improve website performance. Node.js now includes better official support for HTTP/2, which can lead to faster and more efficient web applications.
   • Improved diagnostics: The latest version of Node.js now includes better tools for diagnosing application performance issues. The new diagnostics capabilities include better tracing and profiling tools, as well as improved official support for debugging.

   The improvements in Node.js v20 can help developers build faster and more efficient applications, with better tools for diagnosing and resolving performance issues.

   Related Post: Node.js Best Practices in 2023

6. Regular Updates on Web Assembly System Interface (WASI)

   The Node.js project is still implementing Web Assembly System Interface, and some noteworthy progress has been made.

   One significant advancement is that, although still experimental, WASI can now be enabled without needing a command line option, making it more accessible.

   In anticipation of preview 2, the WASI team has made a few changes to prepare for the future, such as adding a version option when calling new WASI(). Starting with the 20.x release, the version is mandatory. It has no default value, which is crucial to ensure that applications do not default to an obsolete version as new versions are supported.

   However, it does mean that any code that relied on the default version will need to be updated to specify a particular version.

7. Web Crypto API

   The Web Crypto API is a built-in interface in modern web browsers that allows developers to perform cryptographic operations like hashing, encryption, and key generation directly in JavaScript. It plays a key role in securing data for web applications, without needing external libraries.

   In recent updates, such as Node.js 20, the Web Crypto API has improved to match WebIDL standards more closely. This means its functions now validate and coerce arguments consistently, ensuring better compatibility across different environments.

   These changes enhance the interoperability of Web Crypto API implementations, offering a more stable and trusted foundation for secure web application development. It’s a reliable tool for developers working on projects that require secure data handling in browsers and server-side platforms alike.

   Conclusion

   Node.js v20 introduces several new language features and improvements that can help developers build faster and more efficient applications.

   The update includes application performance enhancements, faster startup times, improved garbage collection, and better support for HTTP/2. Node.js v20 also includes better tools for diagnosing performance issues, with improved tracing and profiling capabilities and enhanced debugging support.

   These updates can help developers create better and more efficient applications, making Node.js an even more valuable tool for building server-side applications.

   Node.js v20 is a significant update that should be of interest to any developer working with Node.js, and we recommend giving it a try to such future releases and experiencing the new language features of this Node.js 20 release post and improvements firsthand.