Sunday, March 31, 2024

Studying Setting Variables in Node.js

Must read


Ever puzzled learn how to handle delicate information like API keys, database credentials or configuration settings in your Node.js functions? The reply lies with surroundings variables. This Byte will give a short intro to surroundings variables, why they’re necessary, after which we’ll discover learn how to learn them in Node.js utilizing completely different strategies.

What are Setting Variables

Setting variables are name-value pairs that may have an effect on the best way working processes behave on a pc. They exist in each working system, and are used to make sure info globally obtainable to all working processes. Within the context of Node.js, surroundings variables are primarily used to set process-level variables which might be international to the applying.

console.log(course of.env);

Operating the above code in Node.js will output an object containing your surroundings variables. It would look one thing like this:

  TERM: 'xterm-256color',
  SHELL: '/usr/native/bin/bash',
  USER: 'username',
  PATH: '...',
  PWD: '/',
  EDITOR: 'vim',
  SHLVL: '1',
  HOME: '/house/username',
  LOGNAME: 'username',
  _: '/usr/native/bin/node'

We’ll take a look at course of.env extra later on this Byte.

Why Use Setting Variables

However why must you use surroundings variables in your Node.js functions? Properly, there are a number of causes:

  • Safety: Setting variables assist you to conceal or separate delicate information out of your utility code. That is significantly helpful once you’re coping with passwords, API keys, or another delicate information that you do not wish to expose in your code. Preserving these keys separate out of your code means it will not get checked right into a Git repo after which shared with everybody.

Safeguard your keys! By accident checking in AWS entry keys into public Git repos is so frequent that there are bots that look ahead to these keys. When discovered, the bots will arrange crypto mining software program in your AWS account, doubtlessly costing you hundreds of {dollars} in compute prices.

  • Portability: With surroundings variables, you possibly can configure your utility to work in numerous environments. That is helpful when you might want to change between completely different settings for improvement, testing, and manufacturing environments – and even between working techniques!

  • Ease of use: Setting variables are straightforward to make use of and could be accessed from wherever in your utility. They supply a easy approach to retailer and retrieve configuration settings and generally used all through all forms of software program.

How one can Learn Setting Variables in Node.js

There are two most important methods to learn surroundings variables in Node.js: utilizing the course of.env international object, and utilizing the dotenv module.

Utilizing course of.env

The course of.env international object is a straightforward approach to entry your surroundings variables. It is obtainable globally in your utility, and also you needn’t import any further modules to make use of it.

Here is an instance of how one can learn an surroundings variable utilizing course of.env:

console.log(course of.env.USER);

Operating this code will output the worth of the USER surroundings variable:


Nevertheless, whereas course of.env is easy and straightforward to make use of, it has its limitations. For example, it does not present a approach to load variables from a file, which you’d then should set by specifying them on the command that launches your app. However what when you have plenty of variables to set? That is the place the dotenv module turns out to be useful.

Notice: It is a good follow to prefix your customized surroundings variables with a selected key phrase associated to your app or firm. This helps keep away from potential conflicts with system-level surroundings variables.

Utilizing dotenv Module

The dotenv module is a third-party module that permits you to load surroundings variables from a .env file into course of.env. That is significantly helpful when you’ve gotten numerous surroundings variables, or once you wish to simply change between completely different environments (i.e. dev, staging, prod, and so forth).

Here is how you should utilize dotenv to learn surroundings variables:

First, set up the dotenv module utilizing npm:

$ npm set up dotenv

Subsequent, create a .env file within the root of your undertaking and add some variables:


Lastly, you possibly can load the variables from the .env file into course of.env utilizing dotenv:


console.log(course of.env.DB_HOST);
console.log(course of.env.DB_USER);
console.log(course of.env.DB_PASS);

Operating this code will output the values of the DB_HOST, DB_USER, and DB_PASS surroundings variables:


And there you’ve gotten it! You now know learn how to learn surroundings variables in Node.js utilizing each course of.env and the dotenv module.

Frequent Errors and How one can Repair Them

Whereas studying surroundings variables in Node.js is usually fairly straightforward, and thus pretty error-free, you would possibly encounter a number of hiccups alongside the best way. Listed here are a few frequent points to look out for:

  • undefined values: If course of.env.YOUR_VARIABLE returns undefined, it means the surroundings variable YOUR_VARIABLE wasn’t set earlier than the method began. Ensure that the variable is about and exported in your surroundings, or loaded from the .env file. An undefined worth might be an indicator of one other drawback.

  • Dotenv does not load variables: When you’re utilizing dotenv and your variables aren’t loaded, be certain that the .env file is in your undertaking root and that you simply’re calling dotenv.config() earlier than making an attempt to entry the variables.

    In case your env file isn’t being loaded as a result of it has a distinct title, you possibly can both rename it to the usual .env title or use the path setting to specify a distinct title:

    require('dotenv').config({ path: './.env-dev' })

Notice: When utilizing dotenv, do not forget that it does not overwrite present surroundings variables. So when you have an surroundings variable set in your surroundings and a distinct worth for a similar variable in your .env file, course of.env will comprise the worth out of your surroundings.

Use Instances

Setting variables are utilized in tons of software program initiatives and have plenty of use-cases, a number of of which we’ll contact on right here.

Storing Delicate Data

Take into account a situation: You are engaged on a undertaking that interacts with a database. Naturally, you will have to retailer the database credentials. However, is it a good suggestion to hardcode these values into your Node.js utility? Nope!

Storing delicate info reminiscent of database credentials, API keys, or another secret information immediately in your code can result in severe safety points. This information could be simply uncovered in case your codebase is publicly accessible, say, on a GitHub repository.

That is the place surroundings variables come in useful. By storing delicate info in surroundings variables, you are guaranteeing that this information is not uncovered in your codebase.

Notice: At all times keep in mind so as to add your .env file to your .gitignore file to forestall it from being tracked by Git and uncovered on platforms like GitHub.

Configuration Administration

Ever puzzled how one can handle completely different configurations for improvement, testing, and manufacturing environments in your Node.js utility? Setting variables to the rescue, once more!

Managing configurations with surroundings variables is a typical follow. It permits you to outline completely different values in your variables relying on the surroundings your utility is working in.

For example, you would possibly wish to use a distinct database for improvement and manufacturing. You’ll be able to handle this by setting an surroundings variable, say DB_HOST. In your improvement surroundings, DB_HOST could be set to the URL of your improvement database. Equally, in manufacturing, DB_HOST can level to your manufacturing database.

This fashion, you possibly can simply change between completely different configurations with out altering any code in your utility.


On this Byte, we have explored the significance of surroundings variables in Node.js functions. We have seen how they might help safe delicate information and handle completely different configurations for varied environments.

However, there’s extra to surroundings variables than simply storing secrets and techniques and managing configurations. They may also be used for characteristic flagging, setting application-level constants, and extra.

Supply hyperlink

More articles


Please enter your comment!
Please enter your name here

Latest article