How To Install Node Modules From Package Json

At that place are ii principal methods of arranging JavaScript lawmaking – via a library structure or through a framework. But if y'all go deeper, you'll find that the code is oftentimes constructed in a manner that results in a module.

A module is a functionality that tin can exist imported or exported. Sometimes it comes along in the form of 3rd party libraries. Sometimes it comes bundled with the framework you're using.

Modules can exist used in various parts of an application, bundled into or excluded in builds. However they are used and implemented, a module is essentially one of the many lego-like bricks that brand up the pre-congenital functionalities of your application.

What are node modules and how do you use them?

Node.js is a server runtime environs that runs JavaScript outside of a browser. Despite popular belief, node.js itself is not a framework. Rather, it'southward the thing that allows frameworks and libraries to run.

For frontend applications, you lot tin can run a JavaScript application without a server by but opening the browser, in addition to a lot of transmission configuration. Backend apps need a runtime environment to run.

Backend apps without an interface often come in the grade of APIs or collaborate with the database.

So, what exactly are modules?

Modules are clusters of code that are grouped based on functionality. They are highly self-contained, making them highly reusable and independent from one another.

When it comes to lawmaking, a way to import modules into your project is to utilize the crave() part.

For example, to implement the third-party HTTP server module express, you can practice so via your console. The node_modules folder is the default folder where all your 3rd-party libraries are downloaded to and served from.

To install, merely npm it.

npm install express

To import, create a const and call it in via require()

const limited = crave('limited');

To reference and employ limited, you tin can exercise and so by initializing it.

const app = express()  app.get('/', function(req, res) {     res.ship('Hullo TabNine')  })  app.listen(3000)

The functionality of package.json

Earlier nosotros talk about the purpose and functionality of parcel.json, we need to have a clear agreement of npm.

npm is one of those things we use just may non actually know exactly what it does.

So what is npm?

npm is a packet manager.

A package managing director is a piece of software that automates the installation, upgrading, configuring and removing things from the space information technology covers. For npm, this means installing, upgrading, configuring and removing libraries and frameworks, in addition to kickstarting runtimes like node.js via npm commands.

It saves yous from manually having to lawmaking in all the dissimilar pathways and dependencies requires to brand your JavaScript awarding run.

Where does parcel.json come up in?

package.json is a json file that npm uses by default to identify the project and handle all the declared dependencies. Information technology is used as a starting betoken past npm and the information contained in this file to fetch and coordinate the various JavaScript libraries (packages) required by an application to run.

You can create a package.json file via the console using npm init

When y'all run this command, it will give y'all a series of questions to answer via the console and generate a json file that contains a name, version, description, main (the entry point of your application), whatsoever scripts, the author, and license blazon.

If yous decided non to respond the questions in the console and come back to it later, your package.json file should look something like this:

{   "proper noun": "tabnine",   "version": "i.0.0",   "description": "",   "main": "index.js",   "scripts": {     "test": "echo \"Error: no test specified\" && exit 1"   },   "author": "",   "license": "ISC" }

By default, index.js is prepare as the main, just you can have information technology be whatever you want.

How to add node modules into package.json

To add third-party modules into packet.json automatically, run the --save flag when you install the module.

For example, in the above example, nosotros used installed limited for our projection using npm. To have it added to our package.json, add the --salve flag at the cease.

npm install limited --save

The --save flag essentially tells npm to salvage limited as a dependency. If it doesn't exist, it will create a new dependencies object in your package.json file that looks something like this:

"dependencies": {     "express": "^4.17.i"   }

Otherwise, npm will simply add together it to the dependencies object. By default, npm volition look to your node_module folder to find the dependencies.

Y'all tin can also use --salve-dev to brand a particular module only available in the development environment. When y'all use --salvage-dev, it will create or add together to the devDependencies object, in the aforementioned style as it did with dependencies and --save.

Why is this important?

The dependencies object makes information technology possible to share code in an elegant and efficient manner. npm plays a pivotal part in keeping track of dependencies and version used. When you push button and share code in a team setting via git, yous're merely making the code created by your team bachelor.

This saves you download and upload time, and coordinating betwixt transmission updates. To install and instantiate a working project on your local machine, you only need to pull the code and run npm install.

The package manager will use the meta-data inside package.json and effigy out the residuum for you lot.

npm, even so, is not the only package manager bachelor. In 2022, Facebook announced the release of Yarn, a package direction client that runs of the npm registry.

The npm registry is a free and public registry for JavaScript modules. Since and so, Yarn has become another major and widely used bundle manager. Yarn is astern uniform and follows the conventions set by npm for the package.json file.

This means you don't accept to worry if the dependencies object is called something else.

What about putting your node modules in a different folder?

There are times where you may not desire the modules to download into the node_module folder. Whatever the reason, there is no manner to alter it in npm as it is part of node.js' core module loading system. If y'all were to change it globally, it may cause your packages to break.

However, yarn gives yous the option to configure it. To exercise this, run the following command:

yarn install --modules-folder <path>

The package manager volition practice the heavy lifting required to make everything work smoothly. Alternatively, if yous don't want to continue specifying the path every time, yous tin create a file called .yarnrc with the following as a configuration.

# ./.yarnrc

--modules-folder lib

When you run yarn install, it volition create a lib folder and install packages to information technology instead of node_modules.

Conclusion

Modules are foundational to building robust and reusable code.

Most major frameworks have a command-line interface that y'all can install via npm to scaffold out a barebone application such as the Angular CLI and Vue CLI. These generators volition automatically create a package.json for you lot with the required dependencies to make things run smoothly.

For this reason, a lot of new developers tend to miss out on learning the importance of bundle.json and how it functions. Generators often have away the complexity of setting upwardly and make the task of app development faster and more robust past generating scaffold lawmaking that'due south modeled on an accepted standard.

package.json is a simple file that has the potential to plough complex equally it grows. The dependencies object is only a minor portion of what it can do and covers the telescopic of this article.

In theory, you tin can manually add each dependency yourself but using a bundle manager such as npm and yarn just makes your development flow a lot faster and easier. It likewise cuts down the potential for mistakes and errors.