Learn the powerful and flexible JavaScript runtime, Node.js.

Introduction to Node.js

In computer science, a _process_ is the instance of a computer program that is being executed. You can open Task Manager if you're on a Windows machine or Activity Monitor from a Mac to see information about the various processes running on your computer right now. Node has a global `process` object with useful methods and information about the current process.

The `process.env` property is an object which stores and controls information about the environment in which the process is currently running. For example, the `process.env` object contains a `PWD` property which holds a string with the directory in which the current process is located. It can be useful to have some `if/else` logic in a program depending on the current environment&mdash; a web application in a development phase might perform different tasks than when it's live to users. We could store this information on the `process.env`. One convention is to add a property to  `process.env` with the key `NODE_ENV` and a value of either `production` or `development`. 
```js
if (process.env.NODE_ENV === 'development'){
  console.log('Testing! Testing! Does everything work?');
}
```

The `process.memoryUsage()` returns information on the CPU demands of the current process. It returns a property that looks similar to this:
```js
{ rss: 26247168,
  heapTotal: 5767168,
  heapUsed: 3573032,
  external: 8772 }
```

_Heap_ can mean different things in different contexts: a heap can refer to <a href="https://en.wikipedia.org/wiki/Heap_(data_structure)" target="_blank" rel="noopener noreferer">a specific data structure</a>, but it can also refer to a block of <a href="https://en.wikipedia.org/wiki/Memory_management 
" target="_blank" rel="noopener noreferer">computer memory</a>. The `process.memoryUsage().heapUsed` method will return a number representing how many bytes of memory the current process is using. 

The `process.argv` property holds an array of command line values provided when the current process was initiated. The first element in the array is the absolute path to Node, which ran the process. The second element in the array is the path to the file that's running. The following elements will be any command line arguments provided when the process was initiated. Command line arguments are separated from one another with spaces.

```bash
node myProgram.js testing several features
``` 
```js
console.log(process.argv[3]); // Prints 'several'
```

We've only covered a few of the properties of the `process` object, so make sure to check out the <a href="https://nodejs.org/api/process.html" target="_blank" rel="noopener noreferer">documentation on the `process` object</a> to learn more about it and explore some of its other methods and properties. 

Let's get some practice using the `process` object! 

The Process Module

Awesome work! You've learned a lot about some fundamental Node.js concepts and modules. Let's take a moment to review what we learned:
+ Node.js is a JavaScript _runtime_, an environment that allows us to execute our JavaScript code by converting it into something a computer can understand.
+ REPLs are processes that **r**ead, **e**valuate, **p**rint, and repeat (**l**oop), and Node.js comes with its own REPL we can access in our terminal with the `node` command.
+ We run JavaScript programs with Node in the terminal by typing `node` followed by the file name (if we're in the same directory) or the absolute path of the file. 
+ Code can be organized into separate files, modules, and combined through _requiring_ them where needed using the `require()` function.
+ Core modules are built into the Node.js environment to efficiently perform common tasks.
+ The `console` module exports a global `console` object allowing the terminal to act as a debugging console, similar to the JavaScript `console` object provided by web browsers.
+ The `process` module is a global module that gives access to information about the Node.js runtime environment.
+ The `os` module provides methods to retrieve information about the computer, operating system, and network interfaces.
+ The `util` module contains methods used to maintain and debug your code.

You learned some of the key core modules built into Node.js, but as you know, there are many more. You can even create your own modules, as well as use third-party modules built by other developers. But don't worry! A good thing to remember when learning Node is that it's not necessary to memorize every module, method, or other specific aspects of the environment. The best way to get comfortable with Node is to practice making things with it. Your imagination is the limit! So keep going to learn how to [download Node on your local machine](https://www.codecademy.com/articles/setting-up-node-locally). 

Great work! We're excited to see what you build! 

Review

_Modularity_ is a software design technique where one program has distinct parts, each providing a single piece of the overall functionality. These separate _modules_ come together to build a cohesive whole. Modularity is essential for creating scalable programs which incorporate libraries and frameworks and separate the program's concerns into manageable chunks. Essentially, a module is a collection of code located in a file. Instead of having an entire program located in a single file, code is organized into separate files based on the concerns they address. These files can then be included in other files by using the `require()` function. 

To save developers from reinventing the wheel each time, Node.js has several built-in modules to perform common tasks efficiently. These are known as the _core modules_. The core modules are defined within Node.js's source code and are located in the **lib/** folder. Core modules can be required by passing a string with the name of the module into the `require()` function:

```js
// Require in the 'events' core module:
const events = require('events');
```

The example above shows how the `events` module is required into a file and stored in an `events` variable. Understanding the specifics of this module isn't necessary at this point, but the `events` module is a Node.js core module that provides key functions for working with, well... events. You'll learn more about it in a later lesson. 

Some core modules are actually used inside other core modules. For instance, the `util` module can be used in the `console` module to format messages. We'll cover these two modules in this lesson, as well as two other commonly used core modules: `process` and `os`.
  
Node.js has several core modules, far too many to cover in this lesson. We'll learn how to get the full list and then dive deeper into the aforementioned modules throughout the next few exercises.

Core Modules

<a href="https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop" target="_blank" rel="noopener noreferer">REPL</a> is an abbreviation for **r**ead–**e**val–**p**rint **l**oop. It's a program that **l**oops, or repeatedly cycles, through three different states: a **r**ead state where the program **r**eads input from a user, the **e**val state where the program **e**valuates the user's input, and the **p**rint state where the program **p**rints out its evaluation to a console. Then it **l**oops through these states again. 

When you install Node, it comes with a built-in JavaScript REPL. You can access the REPL by typing the command `node` (with nothing after it) into the terminal and hitting <kbd>enter</kbd>. A `>` character will show up in the terminal, indicating the REPL is running and prompting your input. The Node REPL will evaluate your input line by line. 

By default, you indicate the input is ready for eval when you hit <kbd>enter</kbd>. If you'd like to type multiple lines and then have them evaluated at once, you can type `.editor` while in the REPL. Once in "editor" mode, you can type <kbd>control</kbd> + <kbd>d</kbd> when you're ready for the input to be evaluated. Each session of the REPL has a single shared memory; you can access any variables or functions you define until you exit the REPL.

A REPL can be extremely useful for performing calculations, learning a language, and developing code. It's a place where you can explore language features and try things out while receiving immediate feedback. 
Figuring out how to do this outside of the browser or a website can be really empowering. 

The Node environment contains a number of Node-specific global elements in addition to those <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
" target="_blank" rel="noopener noreferer">built into the JavaScript language</a>. Every Node-specific global property sits inside the <a href="https://nodejs.org/api/globals.html" target="_blank" rel="noopener noreferer">the Node `global` object</a>. This object contains a number of useful properties and methods that are available anywhere in the Node environment. 

Let's try out the Node REPL. This will be a good way for you to explore the Node `global` object!

The Node REPL

When developing or debugging an app, it can be helpful to have information about the computer, operating system, and network on which the program is running. Before Node, this information could not be retrieved using JavaScript due to the language being confined to the browser. However, Node.js is a JavaScript runtime, which means it can execute code outside of the browser, and we're able to get access to much of this information through the `os` core module. 

Unlike `process` and `console`, the `os` module is not global and needs to be included into the file in order to gain access to its methods. You can include the `os` module into your file by typing:

```js
const os = require('os');
```

With the `os` module saved to the `os` variable, you can call methods like:

* `os.type()` &mdash; to return the computer's operating system.
* `os.arch()` &mdash; to return the operating system CPU architecture.
* `os.networkInterfaces()` &mdash; to return information about the network interfaces of the computer, such as IP and MAC address.
* `os.homedir()` &mdash; to return the current user's home directory.
* `os.hostname()` &mdash; to return the hostname of the operating system.
* `os.uptime()` &mdash; to return the system uptime, in seconds.

Let's take a look at an example:

```js
const os = require('os');

const local = {  
  'Home Directory': os.homedir(),    
  'Operating System': os.type(),
  'Last Reboot': os.uptime()
}
```

In the above example code, we first require the `os` module and store it in a variable, `os`. Below that, we have an object, `local`, that will hold some information about the user's computer: the name of the home directory, the type of operating system, and the time since the computer was last rebooted.

```bash
  {
    'Home Directory': '/Users/luca',
    'Operating System': 'Darwin',
    'Time since reboot': 86997
  }
```

When we run the program, the `local` object stores all the requested information: 
* the user's home directory &mdash; `'/Users/luca'`, 
* the operating system &mdash; `'Darwin'` ([Darwin](https://en.wikipedia.org/wiki/Darwin_(operating_system)) is the underlying operating system of macOS.), 
* and the time since the computer was last rebooted &mdash; 86997 seconds. 

Feel free to try running some of the `os` module methods on your own computer to get more information about the hardware, OS, and network you're on! 

Note that in the exercises below, the `os` module will return information from the learning environment hosted by Codecademy, and not your local computer.

The OS Module

Developers sometimes classify outlier functions used to maintain code and debug certain aspects of a program's functionality as _utility functions_. Utility functions don't necessarily create new functionality in a program, but you can think of them as internal tools used to maintain and debug your code. The Node.js `util` core module contains methods specifically designed for these purposes. The `util` module can be required into the file using:

```js
const util = require('util');
```

Once required, you have access to many useful objects and methods within the `util` module. One important object is `types`, which provides methods for runtime type checking in Node.

```js
const util = require('util');

const today = new Date();
const earthDay = 'April 22, 2022';

console.log(util.types.isDate(today));
console.log(util.types.isDate(earthDay));
```

In the above example, we first require in the `util` module. Next, we declare two variables: `today` stores today's date as an instance of the `Date` object, and `earthDay` stores the date of Earth Day as a string. We then log the results of type checking each variable using `util.types.isDate()`. The `types.isDate()` method checks for `Date` objects and returns a boolean value, giving us:

```bash
true
false
```

Since `today` is a `Date` object, it returns `true`, and since `earthDay` is a string, it returns `false`!

Another important `util` method is `.promisify()`, which turns [callback functions](https://www.codecademy.com/learn/introduction-to-javascript/modules/learn-javascript-iterators/cheatsheet#:~:text=Callback%20Functions,can%20be%20passed%20as%20arguments.) into [promises](https://www.codecademy.com/learn/introduction-to-javascript/modules/javascript-promises/cheatsheet). As you know, [asynchronous programming is essential to Node.js](https://www.codecademy.com/content-items/9abb26ac5476a0967d2675d03fce444c). In the beginning, this asynchrony was achieved using error-first callback functions, which are still very prevalent in the Node ecosystem today. But since promises are often preferred over callbacks [and especially nested callbacks](http://callbackhell.com/), Node offers a way to turn these into promises. Let's take a look:

```js
function getUser (id, callback) {
  return setTimeout(() => {
    if (id === 5) {
      callback(null, { nickname: 'Teddy' })
    } else {
      callback(new Error('User not found'))
    }
  }, 1000)
}

function callback (error, user) {
  if (error) {
    console.error(error.message)
    process.exit(1)
  }

  console.log(`User found! Their nickname is: ${user.nickname}`)
}

getUser(1, callback) // -> `User not found`
getUser(5, callback) // -> `User found! Their nickname is: Teddy`
```

Here we have a function that queries a database for a specified user ID. `getUser` methods are very common in back-end applications, and most will also support error-first callbacks. Since a database query typically takes longer to run than other operations, we simulate the query with a `setTimeout()` method that executes a callback function after 1000 milliseconds (or 1 second). If the user with the specified ID is found, the callback function is executed with `null` passed in as the argument for the `error` parameter, and an object containing the returned user information is passed in as an argument for the `user` parameter. If the user is not found, the callback function is executed, passing in a new `Error` as the argument for the `error` parameter. A second argument for `user` is not necessary since the function will end in the case of an error.

This way of handling this function may seem a bit convoluted these days, but with `.promisify()`, we can easily change it into a modern, cleaner, and more maintainable version of itself:

```js
const getUserPromise = util.promisify(getUser);

getUserPromise(id)
  .then((user) => {
      console.log(`User found! Their nickname is: ${user.nickname}`);
  })
  .catch((error) => {
      console.log('User not found', error);
  });

getUser(1) // -> `User not found`
getUser(5) // -> `User found! Their nickname is: Teddy`
```

We declare a `getUserPromise` variable that stores the `getUser` method turned into a promise using the `.promisify()` method. With that in place, we're able to use `getUserPromise` with `.then()` and `.catch()` methods (or we could also use the `async...await` syntax here) to resolve the promise returned or catch any errors.

Now, this is an extremely simplified example, but it's helpful to recognize how to use this important tool when you start working with more complex callback functions.

The Util Module

For a long time, the browser was the only place JavaScript code could be executed. Web developers had to use a different programming language on the front-end than the back-end. It also meant that, even as JavaScript evolved into a more robust and powerful language, it remained a front-end only language. 

Though multiple attempts to create off-browser JavaScript environments have been attempted, <a href="https://nodejs.org/en/" target="_blank" rel="noopener noreferer">Node.js</a>, invented by Ryan Dahl in 2009, found unprecedented popularity and is currently being used by numerous top-tier companies including Netflix, Uber, Paypal, and eBay. Node.js is a JavaScript _runtime_, or an environment that allows us to execute JavaScript code outside of the browser. A “runtime” converts code written in a _high-level_, human-readable, programming language and compiles it down to code the computer can execute.

Though Node was created with the goal of building web servers and web applications in JavaScript, it can also be used for creating command-line applications or desktop applications. In this lesson, we'll explore some features of Node so you start to feel comfortable with running JavaScript in the Node environment and gain some familiarity with features unique to Node. For more advanced development, Node can be combined with any number of robust frameworks like the <a href="https://expressjs.com/" target="_blank" rel="noopener noreferer">Express.js framework</a> for creating effective web application back-ends.  
 
There's more to learn about Node than we could ever fit in one lesson. We'll try to point to great resources like <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript" target="_blank" rel="noopener noreferer">MDN</a> and the <a href="https://nodejs.org/api/" target="_blank" rel="noopener noreferer">Node.js documentation</a>. Take your time exploring and use the documentation.

Introduction

Node was designed with server-side web development in mind and has a lot of thoughtful functionality towards that end. At its most simple, however, it provides the ability to run JavaScript programs on our own computers instead of just in the browser's console or embedded in HTML. 

In this lesson, we'll explore some of the functionality and properties specific to the Node environment, but first, let's see how we run a program. 

We'll need to create a file with a `.js` extension. We'll call ours **myProgram.js**. Next, we'll open that file with a text editor and add our code:
```js
// Inside myProgram.js
console.log('Hello World');
```
Our code is complete! Now, we want to execute it. We'll open our terminal and navigate to the directory that contains **myProgram.js**. Finally, we'll type the command `node myProgram.js` into our terminal. 
```
$ node myProgram.js
```
The results of our program will print to the terminal. 
```
Hello World
```
Let's write a program and run it in Node. 


Running a Program with Node

One of the most commonly used Node.js core modules is the `console` module. In Node.js, the terminal is used to send and receive text feedback to and from a program, often for debugging purposes. This may sound familiar to how we use the console in the web browser. That's because in Node.js, the built-in `console` module exports a global `console` object that gives the terminal similar functionality. The `console` object provides many of the same familiar methods such as:
*  `.log()` &mdash; to print messages to the terminal.
*  `.assert()` &mdash; to print a message to the terminal if the value is falsy.
*  `.table()` &mdash; to print out a table in the terminal from an object or array.

Since `console` is a global module, its methods can be accessed from anywhere, and the `require()` function is not necessary.