4 Very Useful Built-In Node.js Modules

nancy

11 min readNov 15, 2020

Source: Unsplash

Second part:

3 Pretty Cool Built-In Node.js Modules

Let’s read user input, execute terminal commands & run a virtual machine for JS — using Node.js!

medium.com

What Are Built-In Modules?

Node.js has some so-called built-in modules. This means that although these modules work like other modules that we can install, e.g., via npm and then include using the require or import syntax, as the name suggests, built-in modules are already installed and, therefore, always available.

And of course, they are maintained by the development team behind Node.js, so everything is always up to date and we can use the modules without worries.

Features of the modules that are deprecated can be recognized as such in the official documentation.

So, all good reasons to have a look at some of these modules and to use them in our next project.

1. Performance Timing API (perf_hooks)

In this module, we are provided with various features to examine the performance of our Node.js app.

The API, which is also implemented in modern browsers, provides very precise results and is therefore perfectly suited to be the first choice for analyzing your own app.

Let’s take a look at an example where we examine the time it takes to read a large file and compare it to reading a small file. The large file contains about 3000 lines of Lorem Ipsum, the small file only 20 lines of Lorem Ipsum.

If you run the Node app a few times, you should see that it takes on average much longer to read the large file with the readFileSync function.

Our Node app to measure the reading duration

We use the performance.mark functions for this purpose by surrounding the actual code whose execution we want to examine with these markers.

So, we always set a start and an endpoint, and with the performance.measure function, we can then store the whole thing in the performance timeline so that we can give out the results with the PerformanceObserver.

The first parameter of the measure function is just the name, the other two are the names of the start and endpoints.

The results should look like this:

Of course, the times will depend on your machine.

2. The File System Module (fs)

I think everyone already knows the fs module, which stands for file system, and allows access to the file system. As the name says.

Most of you should already know it from when you first used Node.js, and the basic functions of fs modules work similarly in almost all programming languages.

But there are some cool features that are not so well-known, which I will introduce to you now.

Check whether it is a folder

const fs = require(‘fs’)// will return false, no directory
fs.statSync(‘./index.html’).isDirectory()

Print all the files in a directory

fs.readdir(‘./test-dir’, (err, files) => {
  files.forEach(file => {
    console.log(file)
  })
})

Watch a directory for changes and give out the type of change

fs.watch(‘./test-dir’, (eventType, filename) => {
  if (filename) console.log(filename, eventType)
})

The basic features of the fs module

Read the file and print out the content of it

fs.readFile(‘./note.txt’, ‘utf8’, (err, data) => {
  console.log(data)
})

If you leave out the parameter for the decoding, in our example, “utf8”, by default, the content will be given out as a buffer.

Add something to the file

fs.appendFile(‘./note.txt’, ‘This is new!’, err => {
  if (err) throw err
  console.log(‘file changed’)
})

Create a new file, write something into it/clear file

fs.writeFile(‘./note.txt’, ‘’, err => {
  if (err) throw err
  console.log(‘file cleared’)
})

The second parameter of this function is the content that should be written to the file. In our example, we left this empty so if the given file exists, it will be made completely empty.

If it does not exist, it will be created, but will also remain empty. So, this function is not suitable for adding content to files, because it overwrites everything that has been added before.

3. The Operating System Module (os)

This module can output all kinds of information about the system on which Node.js is currently running. For example, it can be used to monitor the performance of a server.

Here are a few useful functions whose output I have converted directly so that they are more understandable for us.

By dividing the value for os.totalmem() three times, which gives the exact size of RAM, a nice smooth number should be output. In my case, on my MacBook Pro, exactly “16”, since it has 16 gigabytes of RAM.

To confirm that os.freemem() works fine, you can open a few Chrome tabs, run the script, and close them again, and then run the script again. You will see a difference.

4. The URL Module (url)

Since Node.js is often used for the back end of web applications, working with URLs is virtually unavoidable.

The built-in module presented here can make our work easier by providing standard functions for processing URLs.

Split the URL into all important information, such as host, protocol, and port

const url = require("url")url.parse(‘https://medium.com/@louispetrik')

Result:

Url {
 protocol: ‘https:’,
 slashes: true,
 auth: null,
 host: ‘medium.com’,
 port: null,
 hostname: ‘medium.com’,
 hash: null,
 search: null,
 query: null,
 pathname: ‘/@louispetrik’,
 path: ‘/@louispetrik’,
 href: ‘https://medium.com/@louispetrik'
}

Merge base URL and an exact path into one correct URL

url.resolve(‘https://medium.com/', ‘/@louispetrik’)

Result: https://medium.com/@louispetrik

Output the value of the search parameter of the URL

let SearchURL = new URL(‘https://example.org/?product=car')
console.log(SearchURL.searchParams.get(‘product’))

Result: car

Conclusion

That’s it for today, I hope you learned something new and useful. Thanks for reading!