<p>DynamoDB is a well-known NoSQL database from Amazon Web Services(AWS). It offers a wide variety of features for free in its free tier program.</p>
<p>One can get started with DynamoDB in just a few minutes.&nbsp;But before that, you need to signup for an AWS account. Signing up for an AWS account can be done in a few simple steps, directly from the <em>aws.com</em> site.</p>
<p>Note you need to provide a credit or debit card to complete the signup. You will not be charged any amount until you cross their free tier service, so nothing to worry about 😊.&nbsp;</p>
<p>In the AWS free tier, you will get tonnes of features to use, of which some are limited for the first year and some are free even rest of the years until a certain threshold.</p>
<p>DynamoDB comes under always free service with&nbsp;</p>
<ul>
<li><strong>25</strong> GB&nbsp;of Storage</li>
<li><strong>25&nbsp;</strong>provisioned Write Capacity Units (WCU)</li>
<li><strong>25&nbsp;</strong>provisioned Read Capacity Units (RCU)</li>
</ul>
<p>and is said to handle up to 200M requests per month. If you go beyond that you will be charged the amount as per the extra usage.&nbsp;</p>
<blockquote>
<p>1 WCU = 1 write of up to 1 KB/s.</p>
<p>2 WCUs = 1 transactional write request (one write per second) for items up to 1 KB.</p>
</blockquote>
<blockquote>
<p>1 RCU =&nbsp; 1&nbsp; read of up to 4 KB/s&nbsp;</p>
<p>2 RCUs = 1 transactional read request (one read per second) for items up to 4 KB.</p>
</blockquote>
<p>To understand more about the read and write capacities check these <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html" target="_blank" rel="noopener">aws docs</a>.</p>
<p>Once the AWS account is ready, you can set up the credentials locally for using the AWS services. Linux and Windows users can create <code>.aws</code> directory in the user folder and add the credentials file without any extension with the following details.</p>
<pre class="language-markup"><code>[default]
aws_access_key_id = &lt;YOUR_ACCESS_KEY_ID&gt;
aws_secret_access_key = &lt;YOUR_SECRET_ACCESS_KEY&gt;</code></pre>
<p>If you need more details for setting up the AWS credentials, follow up <a href="https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/loading-node-credentials-shared.html" target="_blank" rel="noopener">this doc</a>.</p>
<p>Now let's get started with the DynamoDB NodeJS crud operations.&nbsp;</p>
<h2 style="text-align: center;">DynamoDB NodeJS CRUD</h2>
<p>Let's create a new directory <code>dynamo-crud</code> and initialize node project(you need to have node installed already).&nbsp;</p>
<pre class="language-bash"><code>mkdir dynamo-crud
cd dynamo-crud
npm init -y</code></pre>
<p>To get started with using AWS services we need <code>aws-sdk</code> package and we can install it using <code>npm</code>. You can learn the <a href="https://devapt.com/npm-commands-list" target="_blank" rel="noopener">npm commands from here</a>.</p>
<pre class="language-bash"><code>npm i aws-sdk</code></pre>
<p>For having unique IDs for our records or items, we can use <code>nanoid</code> package.</p>
<pre class="language-bash"><code>npm i nanoid</code></pre>
<p>Next create the <code>index.js</code>&nbsp;file in the root project directory.</p>
<p>After that configure AWS with your desired region and create DynamoDB instance. Keep in mind that we have already configured our credentials through a local file inside <code>.aws</code> directory.</p>
<pre class="language-javascript"><code>// Inside index.js
import AWS from 'aws-sdk';
import { nanoid } from 'nanoid';

AWS.config.update({ region: 'ap-south-1' });  // you can change region as per your preference

const DynamoDB = new AWS.DynamoDB(); // instance of DynamoDB</code></pre>
<h3>Creating table in DynamoDB NodeJS</h3>
<p>Now let's create a table named <code>Posts</code>. While creating the table we need to mention the unique key for querying the data.</p>
<p>In DynamoDB there are two key parameters, one is <strong><em>partition</em></strong> key and the other is <em><strong>sort</strong></em> key.</p>
<p>The primary key can be created using only the partition key or the combination of partition and sort key, known as composite primary key.</p>
<p>Having a sort key helps in sorting the data based on that sort key.</p>
<blockquote>
<p>In DynamoDB, tables, items, and attributes are the core components to work with. A <em>table</em>&nbsp;is a collection of&nbsp;<em>items</em>, and each item is a collection of&nbsp;<em>attributes</em>. DynamoDB uses primary keys to uniquely identify each item in a table and secondary indexes to provide more querying flexibility.</p>
</blockquote>
<p>We'll make a function for each operation so that it will be easier to use or reuse it and keep all related lines of code together.&nbsp;</p>
<pre class="language-javascript"><code>// Creating the table with parition key as the primary key
const createTable = () =&gt; {
  const params = {
    TableName: 'Posts',
    KeySchema: [{ AttributeName: 'postId', KeyType: 'HASH' }], // using partition key only
    AttributeDefinitions: [{ AttributeName: 'postId', AttributeType: 'S' }], // S for string
    ProvisionedThroughput: {
      ReadCapacityUnits: 5,
      WriteCapacityUnits: 5,
    },
  };

  DynamoDB.createTable(params, function (err, data) {
    if (err) {
      console.error('Unable to create table', err);
    } else {
      console.log('Created table', data);
    }
  });
};</code></pre>
<p>In the above code, we have created a table with name <code>Posts</code> and primary key <code>postId</code>. We have provisioned the capacity units 5 each RCU and WCU.&nbsp;</p>
<p>In <code>DynamoDB</code> instance by using <code>createTable</code> method we can pass the <code>params</code> and a callback with <code>err</code> and <code>data</code> arguments to create the table.</p>
<p>Calling the <code>creatTable()</code> function will run all the code inside it and will create the <code>Posts</code> table in the AWS DynamoDB space.</p>
<h3>Creating items/records in DynamoDB</h3>
<p>We'll create a function named <code>insertPost</code> that takes <code>postId</code>, <code>title</code> and <code>content</code> as arguments for creating the item with three key-value pairs.</p>
<p>We need <code>documentClient</code> instance for doing CRUD operations in the Dynamo database. With the following code snippet, we can create the instance of the <code>documentClient</code>.</p>
<pre class="language-javascript"><code>const documentClient = new AWS.DynamoDB.DocumentClient();</code></pre>
<p>Now initialize the function <code>insertPost</code> for inserting the items. We are going to use <code>put</code> method of <code>documentClient</code> for inserting the items.</p>
<pre class="language-javascript"><code>// Function to insert the post into Posts table/document
const insertPost = async (postId, title, content) =&gt; {
  const params = {
    TableName: 'Posts',
    Item: {
      postId,
      title,
      content,
    },
  };
  try {
    const data = await documentClient.put(params).promise();
    console.log('Post inserted', data);
  } catch (err) {
    console.log(err);
  }
};</code></pre>
<p>So we can now insert posts by calling the <code>insertPost</code> function with the data.&nbsp;</p>
<pre class="language-javascript"><code>// Inserting two posts
insertPost(
  nanoid(),
  'How to do CRUD operations in Dynamo?',
  'It is not that hard to do CRUD operations in DynamoDB.'
);
insertPost(
  nanoid(),
  'Sample title that can be deleted',
  'Sample description for the sample post'
);</code></pre>
<h3>Reading items/records in DynamoDB</h3>
<p>For reading the items we're going to create two functions, <code>getAllPosts</code> and <code>getSinglePost</code> functions.</p>
<p><code>scan</code> method of <code>documentClient</code> is used to get all the items in the table. <code>get</code> method is used to get a single item by using the primary key, nothing but the <code>postId</code> here.</p>
<pre class="language-javascript"><code>// Function to get all the posts
const getAllPosts = async (table) =&gt; {
  const params = {
    TableName: table,
  };
  try {
    const data = await documentClient.scan(params).promise();
    console.log(data);
    return data;
  } catch (err) {
    console.log(err);
  }
};

getAllPosts('Posts');

// Output:
// {
//   Items: [
//     {
//       content: 'Sample description for the sample post',
//       postId: 'FPbCFAvNoKWinPadsNBoW',
//       title: 'Sample title that can be deleted'
//     },
//     {
//       content: 'Follow this to learn about DyanamoDB',
//       postId: 'j6uv_RKuZg5XZll1AkAWx',
//       title: 'Learn to use DyanamoDB'
//     }
//   ],
//   Count: 2,
//   ScannedCount: 2
// }
</code></pre>
<p>By calling <code>getAllPosts('Posts')</code> with the table name we get all the posts.&nbsp;</p>
<pre class="language-javascript"><code>// Function to get single post from the table/document
const getSinglePost = async (table, keyObj) =&gt; {
  const params = {
    TableName: table,
    Key: keyObj,
  };
  try {
    const data = await documentClient.get(params).promise();
    console.log(data);
    return data;
  } catch (err) {
    console.log(err);
  }
};

getSinglePost('Posts', { postId: 'FPbCFAvNoKWinPadsNBoW' }); // gets single post</code></pre>
<p>By calling <code>getSinglePost(...)</code> with the table name and keyObj gets the single post.&nbsp;</p>
<h3>Updating items in DynamoDB&nbsp;</h3>
<p>For updating the items we're going to create <code>updatePost</code> function.</p>
<p><code>put</code> method of <code>documentClient</code> is used for inserting and updating the item based on the primary key. If there's an item already existing then it will update else insert the item into the table.</p>
<pre class="language-javascript"><code>// Function to update the post based on postId
const updatePost = async (postId, title, content) =&gt; {
  const params = {
    TableName: 'Posts',
    Item: {
      postId,
      title,
      content,
    }
  };
  try {
    const data = await documentClient.put(params).promise();
    console.log('Post updated', data);
  } catch (err) {
    console.log(err);
  }
};
updatePost(
  'FPbCFAvNoKWinPadsNBoW',
  'Update sample post title',
  'Updated content'
);</code></pre>
<p>By calling <code>updatePost(...)</code> with <code>postId</code>, <code>title</code> and <code>content</code> will update that particular post.&nbsp;</p>
<h3>Deleting item in DynamoDB</h3>
<p>For deleting the item we're going to create <code>deletePost</code> function.</p>
<p><code>delete</code> method of <code>documentClient</code> is used for deleting the item based on the primary key.&nbsp;</p>
<pre class="language-javascript"><code>// Function to delete the post from posts table/document by postId
const deletePost = async (postId) =&gt; {
  const params = {
    TableName: 'Posts',
    Key: {
      postId,
    }
  };
  try {
    const data = await documentClient.delete(params).promise();
    console.log('Post deleted', data);
  } catch (err) {
    console.log(err);
  }
};
deletePost('FPbCFAvNoKWinPadsNBoW');</code></pre>
<p>By calling <code>deletePost(...)</code> function with <code>postId</code>, deletes the item from the <code>Posts</code> table.</p>
<p>That's the basic CRUD(Create, Read, Update, Delete) in DynamoDB using NodeJS. There are other methods and ways for querying data based on different conditions in AWS dynamodb. You can find the detailed documentation in these <a href="https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html" target="_blank" rel="noopener">docs</a>.</p>
<p>You can find all the above-discussed codes in this <a href="https://github.com/Basharath/dynamodb-crud" target="_blank" rel="noopener">dynamodb-crud git repository</a>.</p>

AWS DynamoDB is a well-known NoSQL database. Here are the DynamoDB NodeJS CRUD operations with examples to help you get started using this NoSQL database.

Sample excerpt

Getting started with AWS DynamoDB NodeJS CRUD operations

<p><code>yarn</code> is an alternative package manager for Javascript and the Javascript runtime environment(Node) which claims to provide speed, consistency, stability, and security.&nbsp;</p>
<p><code>yarn</code> was created in order to overcome some of the problems faced in dealing with packages for large codebases by Facebook in collaboration with Google and a few other companies.&nbsp;</p>
<p>Yarn stands for <strong>Yet Another Resource Negotiator</strong>.</p>
<h2 style="text-align: center;">How to install yarn?</h2>
<p>Yarn can be installed in various methods based on your operating system. With yarn version 2, a lot of things have changed compared to v1. But as of now installing process remains the same and to even use v2, we need to first install the latest v1.&nbsp;</p>
<h3>Install yarn using npm&nbsp;</h3>
<p>Yes, using npm we can install yarn as a global package, for this, you need to have npm already installed. This works for all types of operating systems.</p>
<pre class="language-bash"><code>npm install -g yarn</code></pre>
<p>If you face any issues with installation or running yarn installed using npm, then you can follow up the OS-specific method for installing yarn.</p>
<h3>Yarn installation for Mac users</h3>
<p>Mac users can use homebrew for installing the yarn package manager.</p>
<pre class="language-bash"><code>brew install yarn</code></pre>
<p>For other ways of installation, you can visit this yarn official <a href="https://classic.yarnpkg.com/lang/en/docs/install/#mac-stable" target="_blank" rel="noopener">link</a> and under alternatives dropdown select macOS and you'll see different ways of installing yarn in mac.</p>
<p><img style="display: block; margin-left: auto; margin-right: auto;" src="https://res.cloudinary.com/cloudtale/image/upload/v1641227823/devapt/yarn-macos.jpg" alt="yarn-install-macos" width="450" /></p>
<h3>Yarn installation for Windows users</h3>
<p>Windows users can download the latest yarn <code>.msi</code> file from this <a href="https://classic.yarnpkg.com/lang/en/docs/install/#windows-stable" target="_blank" rel="noopener">link</a> and run it for installing the yarn. By using chocolatey and scoop package managers also yarn can be installed.</p>
<p>After the installation is completed you can confirm it by running the below command</p>
<pre class="language-bash"><code>yarn --version</code></pre>
<p>If you see the version number without any errors then you've successfully installed yarn.</p>
<p><code>yarn</code> is a CLI tool using which we can manage the packages from the npm registry.</p>
<p>Let's see the different yarn commands to manage npmjs packages.</p>
<p>There are a lot of yarn commands for dealing with npm packages but our main focus will be on the commands related to consuming the packages not creating or publishing those.</p>
<p>Note: We'll be seeing all commands from yarn v1 and a few updated commands of v2.</p>
<h2 style="text-align: center;">Essential yarn commands</h2>
<h3>To check the yarn version</h3>
<pre class="language-javascript"><code>yarn --version(or -v) // To see your yarn version</code></pre>
<h3>To initialize</h3>
<pre class="language-javascript"><code>yarn init
or 
yarn init -y // To autocomplete the details</code></pre>
<h3>For installing packages</h3>
<pre class="language-javascript"><code>yarn add  &lt;package&gt; // To save in dependencies list
yarn add --dev(or -D) &lt;package&gt; // To save in dev dependencies list

// To install a particular version of the package
yarn add &lt;package&gt;@2.1.1 // version as per the need, 2.1.1 is a sample version

// To install all the packages from package.json
yarn 
or
yarn install

// To install a global package accessible to all the projects
yarn global add &lt;package&gt;</code></pre>
<h3>For listing or checking packages</h3>
<pre class="language-javascript"><code>yarn list // By default lists all the packages and their dependencies
yarn list --depth=0 // To restrict the depth of the dependencies use depth flag

// To list global packages just use global before list command
yarn global list // Lists all globally installed packages and their dependencies
yarn global list --depth=0 // Lists all global packages with zero level dependencies
</code></pre>
<h3>For updating packages</h3>
<pre class="language-javascript"><code>// For updating a single package (semver contraints will be respected)
yarn upgrade &lt;package&gt; // Updates package to the latest version in the current project
yarn global upgrade &lt;package&gt; // Updates global package to the latest version

// For updating all packages
yarn upgrade  // Updates all packages to their latest versions respecting their semver constraints
yarn global upgrade // Updates all global packages to their latest versions respecting semver constraints

// To check the outdated packages instead of directly updating
yarn outdated // Lists the outdated packages in the current project directory
yarn upgrade-interactive // Before updating the packages it shows a list of outdated packages to select

// To manually update any package to any version
yarn upgrade &lt;package&gt;@version
yarn global upgrade &lt;package&gt;@version</code></pre>
<p>Semver means <strong>semantic versioning</strong>. For the dependencies in the package.json, besides version number, a small hat(<code>^</code>) or tilde(<code>~</code>) is prefixed for some dependencies. It means those dependencies can be updated to the latest minor version when it is prefixed with (<code>^</code>) and to the latest patch version when it is prefixed with (<code>~</code>).&nbsp;</p>
<p>So <code>yarn upgrade</code> command when updating such dependencies considers semver prefixes without breaking the project or that dependency.&nbsp;</p>
<p>There's a whole site dedicated for <a href="https://semver.org/" target="_blank" rel="noopener">semver</a> to learn more about it.</p>
<h3>For uninstalling packages</h3>
<pre class="language-javascript"><code>yarn remove &lt;package&gt; // To uninstall the package installed locally
yarn global remove &lt;package&gt; // To uninstall the globally installed package
</code></pre>
<h3>For getting package details</h3>
<pre class="language-javascript"><code>yarn info &lt;package&gt; // Shows details about that particular package 
yarn info &lt;package&gt;@version // To see specific package version details
// To see the details of the package it need not be installed locally
</code></pre>
<h3>For auditing packages</h3>
<pre class="language-javascript"><code>yarn audit // To scan all dependencies and list all the vulnerabilities 
yarn audit --json // To audit and list the details in a JSON format</code></pre>
<h3>Miscellaneous commands</h3>
<pre class="language-javascript"><code>yarn run &lt;command&gt; // Any script/command listed in the scripts in package.json
yarn run // Lists all the scripts available to run
yarn import // To generate yarn.lock from an npm package-lock.json while migration
</code></pre>
<p>Note all the commands are as per yarn v1 and in v2 lot of new commands are added. Once everyone starts using v2, these commands will be updated.&nbsp;</p>
<p>So that is all about the most important yarn commands to know for getting started using the yarn package manager.</p>

Here is the guide to install yarn and all the essential yarn commands to know to get started with yarn effectively. Yarn provides speed and consistency.

Guide to install yarn and essential yarn commands to know

<p><code>npm</code> is a package manager for Javascript and the Javascript runtime(Node). Often npm is considered as an acronym for Node Package Manager but in reality, it is not. <code>pm</code> in <code>npm</code> stands for <strong>pkgmakeinst</strong> as per the <a href="https://github.com/npm/cli#is-npm-an-acronym-for-node-package-manager" target="_blank" rel="noopener">npm docs</a>.</p>
<p>npm has a command-line client which is called npm CLI or just <code>npm</code>. npm comes installed with the Node. npmjs is the site where npm packages can be browsed and searched.&nbsp;</p>
<p>Here we are going to see the npm commands in CLI to install, update and manage various packages from the npm registry.</p>
<p>There are a lot of npm commands for dealing with npm packages but our main focus will be on the commands related to consuming the packages not creating or publishing those.</p>
<h2 style="text-align: center;">Essential npm commands</h2>
<h3>To check the npm version</h3>
<pre class="language-javascript"><code>npm --version(or -v) // To see your npm version</code></pre>
<h3>To initialize</h3>
<pre class="language-javascript"><code>npm init
or 
npm init -y // To autocomplete the details</code></pre>
<h3>For installing packages</h3>
<pre class="language-javascript"><code>npm i --save(or -S) &lt;package&gt; // To save in dependencies list
npm i --save-dev(or -D) &lt;package&gt; // To save in dev dependencies list

// Shorthand commands for the above
npm i &lt;package&gt; // By default packages get added to dependencies
npm i -D &lt;package&gt; // To add to dev dependencies

// To install a particular version of the package
npm i &lt;package&gt;@5.1.1 // version as per the need, 5.1.1 is a sample version

// To install all the packages from package.json
npm install 
or
npm i

// To install global package accessible to all the projects
npm install -g &lt;package&gt;
or 
npm i -g &lt;package&gt;</code></pre>
<h3>For listing or checking packages</h3>
<pre class="language-javascript"><code>// From npm v7.x, list command by default lists only the installed package names, not their dependencies
npm list(or ls or la or ll) // Lists all the packages installed in the current project
npm list --all // Lists all the packages with dependencies in a tree structure

// To list global packages just use -g flag
npm list -g // Lists all globally installed packages
npm list -g --all // Lista all global packages with dependencies

// Shorthand for --all is -a
// ls, la, ll are all aliases for list, any of those shorthands can be used</code></pre>
<h3>For updating packages</h3>
<pre class="language-javascript"><code>// For updating a single package(semver contraints will be respected)
npm update &lt;package&gt; // Updates package to the latest version in the current project
npm update -g &lt;package&gt; // Updates global project to the latest version

// For updating all packages
npm update  // Updates all packages to their latest versions respecting their semver contraints
npm update -g // Updates all global packages to their latest versions respecting semver contraints

// Shorthand commands for the above
npm up &lt;package&gt;
npm up -g &lt;package&gt;
npm up
npm up -g

// To check the outdated packages instead of directly updating
npm outdated // Lists the outdated packages in the current project directory
npm -g outdated // Lists the outdated global packages

// To manually update any package to any version
npm i &lt;package&gt;@version
npm i -g &lt;package&gt;@version</code></pre>
<p>Semver means semantic versioning. For the dependencies in the package.json, besides version number, a small hat(^) or tilde(~) is prefixed for some dependencies. It means those dependencies can be updated to the latest minor version when it is prefixed with (^) and to the latest patch version when it is prefixed with (~).&nbsp;</p>
<p>So <code>npm up</code> command when updating such dependencies considers semver prefixes without breaking the project or that dependency.&nbsp;</p>
<p>There's a whole site dedicated for <a href="https://semver.org/" target="_blank" rel="noopener">semver</a> to learn more about it.</p>
<h3>For uninstalling packages</h3>
<pre class="language-javascript"><code>npm uninstall &lt;package&gt; // To uninstall the current project package
npm uninstall -g &lt;package&gt; // To uninstall the globally installed package

// Shorthand commands for the above
npm un &lt;package&gt;
npm un -g &lt;package&gt;</code></pre>
<h3>For viewing package details</h3>
<pre class="language-javascript"><code>npm view &lt;package&gt; // Shows details about that particular package 
npm view -g &lt;package&gt; // To see details for the globally installed package

// info, show, v are the aliases for view
// To see particular version details use @version</code></pre>
<h3>For searching packages&nbsp;</h3>
<pre class="language-javascript"><code>npm search &lt;keyword(s)&gt; // List all the packages matching the keyword

// s, se, find are the aliases for search</code></pre>
<h3>For auditing packages</h3>
<pre class="language-javascript"><code>npm audit // To scan project and list all the vulnerabilities without fixing anything
npm audit --json // To audit and list the details in a JSON format
npm audit fix // To scan the project for vulnerabilities and automatically install compatible updates to vulnerable dependencies
npm audit --dry-run --json // To get an idea of what audit fix will do, and output the information in JSON format</code></pre>
<h3>Miscellaneous commands</h3>
<pre class="language-javascript"><code>npm ci // To do a clean install by removing the existing node_modules
npm prune // To remove extraneous packages not listed on the parent package's dependencies list
npm start // To run the scripts mentioned with start key in the package.json scripts
npm run &lt;command&gt; // Any script/command listed in the scripts other than start
npm test // To run the test script if there's any
npx &lt;command&gt; // Used to run any command from npm package (from locally installed or remotely fetched)</code></pre>
<p>Note that npm version 7.x is considered when listing all the above commands. Certain commands may differ with lower or higher major versions.&nbsp;</p>
<p>So those are all the most essential npm commands every Javascript developer should know. A nice dedicated cheatsheet for the above commands will be released soon.</p>

Here are all the essential npm commands you need to know to use the npm CLI effectively. You can search, update, view any package right from your CLI.

Essential npm commands every JS developer should know

<p><code>path</code> is the inbuilt module in <a href="https://nodejs.org/docs/latest-v14.x/api/path.html" target="_blank" rel="noopener">NodeJs</a>. It is often used to generate absolute paths for files or resources. <code>join</code> and <code>resolve</code> are the quite commonly and interchangeably used methods of the <code>path</code> module.&nbsp;</p>
<p>In most of the cases the way join and resolve methods used by us lead to the same result but there's a notable difference between those methods, understanding which can help us to use the <code>path</code> module effectively.&nbsp;</p>
<pre class="language-javascript"><code>path.join(__dirname, 'public/logo.png'); // /home/user/project_dir/public/log.png
path.resolve(__dirname, 'public/logo.png'); // /home/user/project_dir/public/log.png</code></pre>
<p>In the above code snippet <code>__dirnname</code> is a global variable that gives the absolute path of your project directory.</p>
<pre class="language-javascript"><code>console.log(__dirname); // /home/user/project_dir</code></pre>
<p>To quickly get an idea of the difference between <code>path.join</code> and <code>path.resolve</code>, just remove the <code>__dirname</code> from both the methods in the above codes and observe the results.</p>
<pre class="language-javascript"><code>path.join('public/logo.png'); // public/log.png
path.resolve('public/logo.png'); // /home/user/project_dir/public/log.png</code></pre>
<p>So it should have given some idea of how <code>join</code> and <code>resolve</code> methods are working. Let's dive into more details and differences between these two methods.</p>
<h2>Difference between path join vs resolve</h2>
<h3>Understanding <code>path.join</code> method</h3>
<p><code>join</code> method takes path segments as arguments and joins them together using the platform-specific separator(<code>/</code> in Linux and <code>\</code> in Windows) as a delimiter and then normalizes the resulting path.</p>
<p>So <code>path.join</code> simply joins the paths that are given to it. Let's have different scenarios below.</p>
<pre class="language-javascript"><code>path.join('a', 'b', 'c'); // a/b/c
path.join('a', '/b', 'c'); // a/b/c
path.join('a', 'b', '../c'); // a/c -&gt; normalized
path.join(''); // .
path.join(); // -&gt; No result because zero length path segments are ignored
path.join(__dirname, 'public/logo.png'); // /home/user/project_dir/public/log.png</code></pre>
<p>The path segment for <code>__dirname</code> as seen earlier is <code>/home/user/project_dir</code> so joining that with <code>public/logo.png</code> gives&nbsp;</p>
<pre class="language-markup"><code>/home/user/project_dir/public/log.png</code></pre>
<p>Make a note that <code>path.join</code> takes only valid strings as path segments else it will throw an error.</p>
<p>Now let's understand path.resolve.</p>
<h3>Understanding <code>path.resolve</code> method</h3>
<p><code>resolve</code> method takes path segments as arguments just like the <code>join</code> method but it resolves or returns an absolute path always with normalization(which means ../.. such paths get resolved) and that's the main difference between <code>join</code> and <code>resolve</code>.</p>
<p>But few things need to be taken care of to get the correct absolute path from the <code>path.resolve</code>. For instance, the given sequence of paths or path segments are processed from right to left, with each subsequent <code>path</code> prepended until an absolute path is constructed.&nbsp;</p>
<p>Let's see various <code>path.resolve</code> scenarios to understand it better.</p>
<pre class="language-javascript"><code>path.resolve('a', 'b', 'c'); // /home/user/project_dir/a/b/c
path.resolve('a', '/b', 'c'); // /b/c -&gt; from right to left until it encounters '/' is considered for absolute path
path.resolve('a', 'b', '../c'); // /home/user/project_dir/a/c -&gt; normalized
path.resolve(''); // /home/user/project_dir/
path.resolve(); // /home/user/project_dir/
</code></pre>
<p>Just like <code>path.join</code>, <code>resolve</code> also takes only the valid path segments as arguments else it will throw an error.</p>
<p>So it should be clear by now that <code>join</code> just joins the path segments given as arguments where as <code>resolve</code> joins or resolves the path segments with the absolute path of the root directory or the absolute path that is given as an argument to the <code>path.resolve</code>.&nbsp;</p>
<p>From this understanding of these methods, we can avoid <code>path.join</code> most of the times to obtain an absolute path using <code>__dirname</code>, because <code>path.resolve</code> actually takes into account the absolute path of the root directory while resolving the path segments.</p>
<pre class="language-javascript"><code>__dirname === path.resolve() // true</code></pre>
<pre class="language-javascript"><code>// Instead of this
path.join(__dirname, 'public/logo.png'); // /home/user/project_dir/public/log.png

// You can use this to get the absolute path
path.resolve('public/logo.png'); // /home/user/project_dir/public/log.png</code></pre>
<blockquote>
<p>Keep in mind that whenever <code>path.resolve</code> encounters <code>/</code> for the first time from right to left it ends the path until there as the absolute path.&nbsp;</p>
</blockquote>
<p>And that is all about path join vs resolve details. Hope this article has clarified and given you a clear understanding of the differences between these two methods.&nbsp;</p>

Here is the clear insight about the path join vs resolve in NodeJS. Understand when to use what based on different scenarios.

NodeJs Articles

Getting started with AWS DynamoDB NodeJS CRUD operations

Guide to install yarn and essential yarn commands to know

Essential npm commands every JS developer should know

Everything about path.join vs path.resolve in NodeJS