Node.js vs Deno: What You Need to Know

Deno has attracted widespread attention from the JavaScript community since its release. As a JavaScript runtime designed by Node creators, you might expect a lot of similarities between these two projects, and that's true. However, they also have important differences, which means you can't simply replace the other with one.

This article will explore Deno's relationship with its "old senior" Node.js to help understand what they are in common and different. (If you want to learn about Deno's core content first, you can check out our recent introduction article.)

Key Points

• Deno and Node.js are both JavaScript runtimes, but they have significant differences. Deno provides top-notch support for TypeScript, which means it works out of the box without the need for extra tools to convert code to JavaScript. However, Node.js requires the code to be compiled into JavaScript code that the V8 engine can execute.
• Deno's API is designed to take advantage of modern JavaScript capabilities, return a promise for all asynchronous methods and support top-level await. On the other hand, Node.js' API still requires callbacks to maintain backward compatibility. Deno also provides a safer sandbox environment for code execution, limiting access to file systems, networks, and environment variables unless permissions are explicitly granted.
• Node.js has a large and diverse ecosystem with over one million packages available on the npm registry. Deno is designed to avoid using package managers or registries, allowing scripts to import modules directly from any public URL. However, as of this writing, Deno has listed only 707 compatible third-party modules.

Language Support

Both projects are JavaScript runtimes, allowing JavaScript code to be executed on a computer (outside a web browser). Let's look at their comparison in language support.

Node.js

The current LTS version of Node (v12.18.1 as of this writing) supports modern JavaScript syntax and features. It also supports approximately 75% of the ES2020 specification. The ECMAScript module is also supported, but is currently only classified as experimental: you need to use the .mjs file extension, or add the property "type": "module" to the project's package.json file.

In order to run TypeScript (or any other language) on Node, the code needs to be compiled into JavaScript code that the V8 engine can execute. There are several different ways to do this, each with its pros and cons, so getting up and running means having to choose one of them and following the necessary setup process.

Deno

I didn't find any mention of the JavaScript specification supported by Deno, but since it also uses V8 in the background, I assume it's similar to Node's support level. My own tests show that Deno supports ES2020 features such as Promise.allSettled() and globalThis keywords. The ECMAScript module is default and the CommonJS module is not supported unless you use the Node compatibility library (more on this later).

TypeScript is supported as a first-class language in Deno, which means it can be used out of the box: no need to install additional tools to convert to JavaScript first. Of course, the V8 engine itself does not natively support TypeScript, so Deno still converts code in the background, but this is completely seamless and transparent for you as a developer.

I also can't find information about which version of TypeScript to use for Deno v1.0.1, but it supports optional chaining and null value merging (but not private class fields), which can be positioned as TS 3.7.

API

Deno and Node both expose their own APIs to developers, allowing us to write programs that can perform useful operations such as reading and writing files, and sending and receiving network requests.

Node.js

When Node was first released, there was no built-in support for Promise. Therefore, most of the APIs for asynchronous operations are written using error-first callbacks:

const fs = require('fs');
fs.readFile('readme.txt', (err, data) => {
  if (err) {
    // 处理错误
  }
  // 否则处理数据
});

Even if Node developers can now use Promise and async/await syntax, the API still requires callbacks to maintain backward compatibility.

Deno

Deno's API is designed to take advantage of modern JavaScript capabilities. All asynchronous methods return Promise. Deno also supports top-level await, which means you can use await in the main script without wrapping it in an async function.

try {
  const data = await Deno.readFile('readme.txt');
  // 处理数据
} catch (e) {
  // 处理错误
}

The development team also decided to use the web standards where possible, which means they implemented the browser API when practical. Deno provides global window objects and APIs such as addEventListener and fetch. Accessing fetch is especially good because in Node, you have to use polyfill or third-party libraries for this.

Compatibility Module

Deno provides a compatibility layer designed to allow you to reuse existing Node packages. It's not done yet, but it currently supports loading CommonJS modules via require(), among other features.

Brand Management

Package management is an area where Deno and Node work very differently. Since Deno is still in its early stages, it remains to be seen whether its approach will prove advantageous.

Node.js

You may know that Node comes with a package manager called npm for installing and managing third-party packages. npm is mainly used with the online npm registry, and most of the available third-party packages are listed in it.

When you install the package into your project using npm, the package.json file is used to specify the package name and acceptable version range. The package itself (and any package it depends on) will then be downloaded into the node_modules folder inside the project.

Deno

Deno completely eliminates the need for package managers. Instead, the package is directly linked via the URL:

import { Response } from "https://deno.land/std@0.53.0/http/server.ts";

The first time you run your code, Deno gets and compiles all dependencies. They will then be cached in the file system, separate from your project, so subsequent runs will be faster.

Similar to npm's package-lock.json file, Deno allows you to specify a lock file that will be used to ensure that only dependencies match the exact version you originally imported are used.

Third-party package

The prosperity of a language depends on the vitality of its ecosystem, because productivity depends on not having to reinvent the wheel! Here, Node seems to have the advantage at the moment.

Node.js

Node has a huge and diverse library and package ecosystem. Over one million packages have been registered on the npm registry in the 11 years since its release. Of course, quality may vary widely, and many packages are no longer actively maintained, but this is still a big advantage for Node developers.

Deno

As we saw in the previous section, Deno is actively trying to avoid the need for a package manager or registry, allowing scripts to import modules directly from any public URL. Of course, it's hard to import packages if you don't know what's there, so the Deno website maintains a list of compatible third-party modules. As of this writing, there are 707 modules on the list.

Deno's standard library

Deno One way to try to improve the developer experience is to provide a standard library with helper programs and utilities for common tasks. All modules are reviewed by core developers to ensure high-quality, reliable code. There are modules for handling command line parameters and shading terminal outputs—both are available only as third-party packages for Node.

Safety

Perhaps one of the most touted improvements of Deno over Node is the permission system. Let's see why.

Node.js

Node runtime is very loose, allowing code to fully access the computer's network and file system. If unchecked, third-party code can cause damage to your system.

Deno

Improving the security model is something Ryan Dahl particularly wanted to do when designing Deno. By default, all code is executed in a secure sandbox environment. This prevents code from accessing content like file system, network, and environment variables unless access is explicitly granted using command line parameters.

const fs = require('fs');
fs.readFile('readme.txt', (err, data) => {
  if (err) {
    // 处理错误
  }
  // 否则处理数据
});

Better yet, you can provide a whitelist when allowing reading or writing to the file system or accessing the network. This means you can limit read/write access to the Deno program to the data folder of the project, for example, limiting any potential malicious corruption.

Deno: comes with its own battery

Before the end, I want to talk about one more thing. If you browse the tool section of the manual, you will notice that Deno has provided us with some nice "extra features"! Here are the built-in tools that can make the development experience better:

• bundler: Bundler the specified script and its dependencies into a single file
• debugger: Allows debugging of Deno programs using Chrome Devtools, VS Code, and other tools (Note: Node also comes with a debugger)
• dependent inspector: Running this command on the ES module will list the tree structure of all dependencies
• documentation generator: parses JSDoc comments in a given file and outputs the document
• formatter: Automatically format JavaScript and TypeScript code
• test runner: You can use this to test your JS and TS code and combine it with the assertions module in the standard library
• linter: A code linter (currently unstable) that can help discover potential problems in the program

Conclusion

The purpose of this article is not to promote Node or Deno, but to compare and compare the two. You should now understand the similarities between these two runtimes and, perhaps more importantly, the differences between them.

Deno provides developers with some special advantages, including a strong permission system and top-notch TypeScript support. Design decisions and additional built-in tools are designed to provide an efficient environment and a good developer experience.

On the other hand, Node has a huge and complete ecosystem that has been developing for more than a decade. This combined with a lot of documentation and tutorials may make Node.js a safe choice for some time to come.

Deno Basics

Learn about Deno quickly. Our Deno Basics series will help you take your first step into the Deno world and we are constantly adding content. We will provide the tutorials you need to become a professional. You can always refer to our index after updating our Deno profile:

➤ Deno Basics

Node.js and Deno FAQs

What is Node.js? Node.js is an open source cross-platform JavaScript runtime built on Chrome's V8 JavaScript engine. It allows developers to execute server-side JavaScript, allowing them to build scalable and high-performance web applications.

What is Deno? Deno is a secure runtime for JavaScript and TypeScript built on the V8 engine. It was created by the same person (Ryan Dahl) who originally developed Node.js. Deno aims to solve some design flaws and security issues in Node.js.

What is the difference between Node.js and Deno in terms of architecture? Node.js uses a callback-based asynchronous model, while Deno uses modern features such as async/await to make asynchronous code easier to read and maintain. Compared to Node.js, Deno also has a more modular and decentralized architecture.

What are the main security differences between Node.js and Deno? Deno takes a security-first approach, meaning it limits access to file systems, networks, and other potentially dangerous operations by default. Instead, Node.js adopts a looser model, and developers need to manually manage security settings.

Can Deno run the Node.js module? Deno is designed to be compatible with the web platform and it has its own module system. While it can run some modified Node.js modules, it is generally recommended to use Deno native modules for better compatibility and security.

How does Node.js and Deno support TypeScript? Both Node.js and Deno support TypeScript. In Node.js, developers usually need to set up a separate TypeScript compilation step, while Deno natively supports TypeScript, allowing you to run TypeScript code directly without additional configuration.

The above is the detailed content of Node.js vs Deno: What You Need to Know. For more information, please follow other related articles on the PHP Chinese website!