Home/Blog/Web Development/What is Node.js? A beginner's introduction to JavaScript runtime

What is Node.js? A beginner's introduction to JavaScript runtime

Sep 30, 2020 - 10 min read
Christina Kopecky

Node.js is an open-source, cross-platform, JavaScript runtime environment that executes JavaScript code outside of a web browser. Node.js is a popular, lightweight web framework for beginners, and it is used by many big companies like Netflix and Uber.

When we typically think of JavaScript, our mind tends to go to web development. Until Node.js came along, there was really no way to run JavaScript outside of a browser. When we write a backend server and database, Node.js is a popular choice because we can run our code as a standalone application rather than something that can only be evaluated in a browser environment.

Node.js is an important tool for any JavaScript developer to understand. So, today, we’ll introduce you to Node.js and show you how to get started with a project.

Today, we will cover:

Take your JavaScript skills to then next level.

Explore the inner workings and fundamentals of Node.js. By the end of this course, you will have an in-demand skill to add to your resume.

Learn Node.js: The Complete Course for Beginners

What is Node.js?

Node.js is an open-source, cross-platform JavaScript runtime environment used for executing JavaScript code outside of a web browser.

Node.js is a great web framework for beginners because it works great for data-intensive applications, like streaming and real-time apps, and Node.js makes it easy to start building the back-end.

Node.js allows us to use JavaScript everywhere and on any browser, including MacOS, Linux, and Windows. When we say everywhere, we mean the front-end, the middle-ware, and the back-end. Node.js is, therefore, part of some very popular web development stacks, such as the MERN stack, MEVN stack, and MEAN stack.

svg viewer

There are a number of characteristics that make Node.js what it is:

  • Google Chrome V8 JavaScript Engine: This runtime environment is built on the Google Chrome V8 JavaScript runtime engine. In the same way a Java Virtual Machine translates bytecode, the Chrome V8 JavaScript engine takes JavaScript and makes it readable.
  • Modules/Packages: Node.js has npm, a node package manager, with a library of over 350,000 packages to help get your project or application off the ground with efficiency and ease.
  • Event Driven, Single-Threaded I/O Model: JavaScript relies on user interactions or events to run. In most cases, code is run synchronously. Server requests and other such asynchronous tasks rely on a system of promises or async/await functions to handle these inputs and outputs.

Fundamentals of Node.js

Now that we know what Node.js is, let’s explore the fundamentals of this tool.


The console is a module provided by Node.js that is akin to the JavaScript console in the browser when you inspect a webpage. The console has methods that are available for us to use for debugging purposes.

  • console.log(): Frequently used to log some sort of output.
  • console.warn(): Explicitly delivers a warning to the console.
  • console.error(): Explicitly delivers an error message to the console. You can log an error as a string or as an object. If logged as a new Error(), a traceback will be included as part of the message.
  • console.trace(): Logs a traceback when an error occurs in your code. Gives line number and column number of the file that the error probably occurred.


At its core, the Buffer class in Node.js is a temporary storage solution for file systems. Due to its low-level nature, as web developers we will rarely actually use the Buffer class directly. The main purpose of this class is to allocate memory.

Let’s take a look at a few methods that the Buffer class provides.

const buf1 = Buffer.alloc(10);
const buf2 = Buffer.alloc(5, 15);
const buf3 = Buffer.allocUnsafe(10);
const buf4 = Buffer.from([265, 6.5, -255, '7']);
const buf5 = Buffer.from('Hello world');

File System

The file system (fs) module allows us to interact with files in Node.js. There are synchronous and asynchronous methods that can be used to read or write to a file using the fs module. In contrast to using console or the Buffer class, we need to import the fs module into the file that we would like to use in order to get it to work.

The code example below shows how the readFile, an asynchronous method, works. Notice that the last argument in the method is a callback function whose first argument is an error. By definition this callback will always pass in the error first before the data.

Asynchronous Example:

The asynchronous nature of the readFile method doesn’t block other functions or lines of code from running.

The synchronous method, readFileSync, however, blocks other lines of code from running until the file is finished reading. Here’s an example:

const fs = require('fs')
fs.readFile('data.txt', 'utf-8', (err, data) => {
if (err) {
let array = data.split('\n')
//props are id, first_name, last_name, email, gender and ip_address
let mapped = array.map(person => {
let new_person = person.split(',');
return new Object({
id: new_person[0],
first_name: new_person[1],
last_name: new_person[2],
email: new_person[3],
gender: new_person[4],
ip: new_person[5]

Synchronous Example:


Try placing a console.log(“Hit!”) after the function to see when the console is actually logged. Is there a difference between the two functions? What is it?

The readFile function will start the function and then immediately move to the rest of the code before the function completes and prints out the contents of our array. So you should see something like:

   id: '1',
   first_name: 'Annabell',
   last_name: 'Cicconetti',
   email: 'acicconetti0@example.com',
   gender: 'Female',
   ip: ''

In contrast, the console.log(“Hit!”) won’t run until after the readFileSync function is finished:

   id: '37',
   first_name: 'Arnoldo',
   last_name: 'Eakly',
   email: 'aeakly10@live.com',
   gender: 'Male',
   ip: ''
   id: '38',
   first_name: 'Janis',
   last_name: 'Didball',
   email: 'jdidball11@shinystat.com',
   gender: 'Female',
   ip: ''

Writing to files is done in a very similar fashion, but the functions are called writeFile() and writeFileSync().

With Node.js, dealing with files is fairly simple to do with the fs module.

Keep the learning going.

Learn Node.js without scrubbing through videos or documentation. Educative’s text-based courses are easy to skim and feature live coding environments, making learning quick and efficient.

Learn Node.js: The Complete Course for Beginners

Event Loop

Much of Node.js is built to be event-driven. When a user clicks on an interface or types in a form, an event is triggered to happen and then something occurs as a result. To attach a function or set of functions to a specific event is emitting an event.

These functions, called event listeners, are one part of an overall journey called the Event Loop. Take this example:

const EventEmitter = require('events');
const emitter = new EventEmitter();
const handleEvent = (str) => {
console.log(`================ ${str}`);
console.log("handleEvent fired! An event has happened!");
console.log("end of event")
emitter.on('load event', () => handleEvent("load"));
emitter.on('hello event', () => handleEvent("hello"));
emitter.emit('load event');
emitter.emit('hello event')

In this code example, we are importing the events module. Next, we create a new EventEmitter and assign it to the variable emitter. In this particular example, we created a handleEvent function that will serve as a callback function that will console.log some things.

The EventEmitter class has several methods we can use. One method that is run when an event is emitted is the EventEmitter.on() function.

This particular method will fire when an event is emitted. The first argument passed into the function is the name of the event and the second is the callback function that tells us how to handle the event.

In this particular example, there are two events being emitted. When we run the code above, we should get:

================ load
handleEvent fired! An event has happened!
end of event
================ hello
handleEvent fired! An event has happened!
end of event

The emit method triggers the on method which then invokes the handleEvent callback function.


Global objects are available in every module, so they can be used without importing a specific module. The Buffer class, for example, class is defined as a global in Node.js. Some other common global objects are:

  • The console object is used to print to stdout and stderr.
  • Timers, such as setImmediate, setInterval, and setTimeout, are also globals.
  • The process object is also global.

In a browser, the top-level scope is the global scope. But in Node.js, the top-level scope is not the global scope.

In Node.js, the global object can be used to see whatever is available in the global scope. Run the code below to see an example.


How to build a basic Node.js project

Let’s learn how to get started with Node.js by creating a simply Node.js file.In this example, we will be setting up our computer to work as a server!

If you would like to learn how to create a Node.js app, please see Educative’s beginner course.

Install Node.js and NPM

First, you need to Go to the site Node.js site and download the files.

Follow the installation prompts and restart your machine for best results.

Another way you can install Node.js is to use a package manager.

Then, test that it’s working by printing the version using the following command:

> node -v

You should also test npm by printing the version using the following command:

> npm -v

Create a file

Once you have installed Node.js properly, create a Node.js file. In this example, we have named it named “first.js”. We then add the following code and save the file on your computer like so: C:\Users\Your Name\first.js

var http = require('http');

http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/html'});
  res.end('Hello World!');

This code is essentially telling the computer to print “Hello World!” when accessed on port 8080.

Command line interface

Node.js files must be initiated in your computer’s “Command Line Interface” program. Navigate to the folder that contains the file “first.js”.

C:\Users\Your Name>_

Initiate your file

This file needs to then be initiated by Node.js. Do this by starting your command line interface, writing node first.js, and clicking enter:

C:\Users\Your Name>node myfirst.js

Awesome! Now your computer is set up as a server, so when you accesses the computer on port 8080, the"Hello World!" message will print.

To see this in real time, open your browser, and type: http://localhost:8080

What to learn next

Congrats! You know the basics of Node.js, its fundamental tools, and how to start a Node.js file. The next steps are to master Node.js modules, the HTTP Modules, File system, and NPM dependencies.

A good next step would be to learn the following concepts of Node.js:

  • Node.js and OS
  • Node.js REPL
  • Packages
  • How to publish a package
  • How to build a functing app
  • Node.js and MySQL

To get started with these advanced topics, check out Educative’s course Learn Node.js: The Complete Course For Beginners, which covers all these topics and more in detail. You’ll explore advanced concepts like modules, events, and packages. At the end of this course, you will get hands-on with Node.js and create your own food delivery web application.

Happy learning!

Continue reading about Node.js and JavaScript

WRITTEN BYChristina Kopecky

Join a community of 1.7 million readers. Enjoy a FREE, weekly newsletter rounding up Educative's most popular learning resources, coding tips, and career advice.