关于node.js:一篇文章搞定什么是nodeJs它和NPM关系与应用

当初前端的入门门槛越来越高了，不再是单纯 html+css+js，各种前端框架 层出不穷，各种 ui 组件库层出不穷。

模块化，打包化，各种工具库层出不穷，前端变成 大前端 ，甚至前端能够搞定整个我的项目，通过node 作为服务端 api，

这里咱们配角就是nodeJs

什么是 nodejs

javaScript 是一门脚本语言，通常被用来编写、执行本地源代码。脚本语言须要一个解析器能力运行，HTML 文件中的 JavaScript 代码由浏览器解析执行。而自行执行 JavaScript 代码则须要 Node.js 解析器能力运行。

每个解析器都是一个运行环境，容许 JavaScript 定义各种数据结构和执行各种计算，同时也容许 JavaScript 调用运行环境提供的内置对象和办法。浏览器环境下，JavaScript 常被用来操作 DOM 等性能，因而浏览器提供了 document 等内置对象；在 Node.js 环境下，JavaScript 通常用来解决磁盘文件和搭建 HTTP 服务器，因而 Node.js 提供了 fs、http 等内置对象。

Node.js 是一个基于 V8 引擎的 JavaScript 运行环境。V8 引擎具备疾速执行 JavaScript 代码的能力，并且性能十分优良。Node.js 专一于优化一些非凡用例，并提供了代替的 API，在非浏览器环境下更好地运行 V8 引擎。

作为一种服务器端 JavaScript 平台，Node.js 可能疾速创立网络应用程序。同时，它也反对前后端 JavaScript 编程，为开发者提供了更高效的零碎设计和一致性。

NodeJS 个性

以下是一些使得 Node.js 成为软件架构师的首选的重要特色：

1. 异步和事件驱动的 Node.js 库 - 所有 API 都是异步非阻塞的，这意味着 Node.js 服务器不用期待 API 返回数据。它能够立刻挪动到下一个 API 调用，利用 Node.js 事件告诉机制来获取从 API 调用取得的响应。这种异步的事件驱动机制，使得服务器能够高效地响应并疾速解决大量申请。
2. 十分快的 Node.js 代码执行 - Node.js 代码在谷歌 Chrome 的 V8 JavaScript 引擎上运行，速度十分快。
3. 单线程但高度可扩大的 Node.js – Node.js 应用事件循环单线程模型，事件机制有助于服务器以非阻塞的形式响应申请，这使得服务器具备高度可扩展性。相比传统服务器应用创立线程等形式来解决申请，Node.js 应用单线程和繁多程序处理形式，可能更好地解决大量申请，并具备更高的可扩展性。例如，Node.js 能够比传统的 Apache HTTP 服务器解决更多申请。
4. 无缓冲的 Node.js 利用 – Node.js 应用程序从来不须要缓冲任何数据。这些应用程序只需输入块中的数据，不须要在内存中缓冲大量数据。

总之，以上特点都让 Node.js 成为软件架构师的首选，因为它能够高效地响应申请并解决大量申请，从而进步零碎的性能和可扩展性。

对立在 Javascript 浏览器之外的实现，CommonJS

自从 Netscape 浏览器问世以来，JavaScript 就始终在摸索本地编程的路。可怜的是，过后服务端 JavaScript 的倒退基本上是借鉴其余服务器端语言的实现，因而不足特色和实用价值。随着 JavaScript 在前端利用的广泛应用以及服务端 JavaScript 的推动，JavaScript 现有的标准变得十分弱，难以满足 JavaScript 在大规模利用方面的需要。在以 JavaScript 为宿主语言的环境中，只有根本的原生对象和类型，其余对象和 API 取决于宿主的提供，因而，JavaScript 不足以下性能：

1. 模块零碎：没有原生反对的闭包作用域或依赖治理。
2. 规范库：除了一些外围库外，没有文件系统 API 和 IO 流 API 等。
3. 标准接口：不足像 Web 服务器或数据库这样的对立接口。
4. 包管理系统：不能主动加载和装置依赖。

因而，CommonJS（http://www.commonjs.org）标准应运而生，目标是为了构建 JavaScript 在包含 Web 服务器、桌面、命令行工具以及浏览器中的生态系统。

CommonJS 试图定义一套可供一般应用程序应用的 API，以填补 JavaScript 规范库过于简略的有余。其终极目标是制订相似于 C ++ 规范库的标准，使基于 CommonJS API 的应用程序能够在不同的环境下运行，就像应用 C ++ 编写的应用程序能够应用不同的编译器和运行时函数库一样。例如：模块、包、零碎、二进制、控制台、编码、文件系统、套接字、单元测试等等。

Node.js 是 CommonJS 标准最风行的实现之一。Node.js 实现了 require 办法作为其模块引入的办法，同时，NPM 则基于 CommonJS 标准定义的模块标准，实现了依赖治理、模块主动装置等性能。

罕用框架

1. express: 欠缺、呈现早、文档全、社区大
2. koa: 超前，欠缺中
3. hapi：简单，适宜大型项目

NodeJS 下载安装

NodeJS 提供了一些安装程序能够从 nodejs.org 下载安装。

治理 Nodejs 版本

n

n 是一位鼎鼎大名的 TJ Holowaychuk 所写的 Node.js 模块，（鼎鼎大名的 Express 框架作者）旨在提供一个简略、直观的形式来治理 Node.js 版本。正如其名字所示，它谋求的理念就是简洁——无需应用子 Shell、配置文件或臃肿的 API，仅提供简略易用的性能。

n 模块的次要性能是让用户能够轻松地装置、应用和治理不同版本的 Node.js。如果您想要装置 n 模块，能够依照以下步骤进行操作：

npm install n -g

装置实现之后，间接输出 n 后输入以后曾经装置的 node 版本以及正在应用的版本（后面有一个 o），你能够通过挪动高低方向键来抉择要应用的版本，最初按回车失效。

装置最新的版本

n latest

装置稳固版本

n stable

n 前面也能够追随版本号比方：

n v0.10.26

n 0.10.26

删除某个版本

$ n rm 0.10.1

以指定的版本来执行脚本

$ n use 0.10.21 some.js

常用命令

n          # 显示所有已下载版本
n 10.16.0  # 下载指定版本
n lts      # 查看近程所有 LTS Node.js 版本
n run 10.16.0 # 运行指定的 Node.js 版本

  n                              Display downloaded Node.js versions and install selection
  n latest                       Install the latest Node.js release (downloading if necessary)
  n lts                          Install the latest LTS Node.js release (downloading if necessary)
  n <version>                    Install Node.js <version> (downloading if necessary)
  n install <version>            Install Node.js <version> (downloading if necessary)
  n run <version> [args ...]     Execute downloaded Node.js <version> with [args ...]
  n which <version>              Output path for downloaded node <version>
  n exec <vers> <cmd> [args...]  Execute command with modified PATH, so downloaded node <version> and npm first
  n rm <version ...>             Remove the given downloaded version(s)
  n prune                        Remove all downloaded versions except the installed version
  n --latest                     Output the latest Node.js version available
  n --lts                        Output the latest LTS Node.js version available
  n ls                           Output downloaded versions
  n ls-remote [version]          Output matching versions available for download
  n uninstall                    Remove the installed Node.js

n 只实用于 macOS 和 Linux，不适用于 Windows。

nvm

nvm 是一款风行的 Node.js 版本管理工具，能够通过命令行界面实现疾速、简便的 Node.js 版本装置、切换和治理。应用 nvm，您能够轻松地装置和切换不同版本的 Node.js，以适应不同的开发需要和利用场景。同时，nvm 还具备不便的命令行接口和欠缺的文档反对，让用户可能疾速上手并进行高效的开发工作。

nvm 只实用于 macOS 和 Linux 用户的我的项目，如果是 Windows 用户，能够应用 nvm-windows、nodist 或 nvs 替换。

# 形式 1 浏览器关上上面链接下载
https://github.com/nvm-sh/nvm/blob/v0.39.1/install.sh
# 下载实现后，通过命令装置
sh install.sh

# 形式 2 举荐
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash

# 形式 3
wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash

装置过程中如果遇到一些奇怪的问题，能够查看下 nvm 补充阐明。

常用命令

nvm ls                # 查看版本装置所有版本
nvm ls-remote         # 查看近程所有的 Node.js 版本
nvm install 17.0.0    # 装置指定的 Node.js 版本
nvm use 17.0.0        # 应用指定的 Node.js 版本
nvm alias default 17.0.0  # 设置默认 Node.js 版本
nvm alias dev 17.0.0  # 设置指定版本的别名，如将 17.0.0 版本别名设置为 dev

fnm

fnm 是一款疾速简略 🚀 的 Node.js 版本管理器，应用 Rust 构建。

次要特点包含：

1. 🌎 跨平台反对，包含：macOS、Windows、Linux；
2. ✨ 繁多文件，轻松装置，即时启动；
3. 🚀 以速度为设计理念；
4. 📂 实用于 .node-version 和 .nvmrc 文件；

macOS / Linux 环境：

# bash, zsh and fish shells
curl -fsSL https://fnm.vercel.app/install | bash

Windows 环境：

# 管理员模式关上终端，装置后只能应用管理员模式关上应用

choco install fnm

# 装置实现还须要手动设置环境变量

Linux/macOS/Windows 环境也能够间接下载二进制文件装置，下载地址：https://github.com/Schniz/fnm/releases

常用命令

fnm -h             # 查看帮忙
fnm install 17.0.0 # 装置指定 Node.js 版本
fnm use 17.0.0     # 应用指定 Node.js 版本
fnm default 17.0.0 # 设置默认 Node.js 版本

Node.js 模块零碎

为了让 Node.js 的文件能够互相调用，Node.js 提供了一个简略的模块零碎。
模块是 Node.js 应用程序的根本组成部分，文件和模块是一一对应的。换言之，一个 Node.js 文件就是一个模块，这个文件可能是 JavaScript 代码、JSON 或者编译过的 C /C++ 扩大。

模块化编程

随着网页应用程序的一直倒退，网页的性能越来越相似于桌面程序，须要许多不同的人协同工作并进行进度治理、单元测试等等。因而，软件工程的办法逐步成为网页开发者必不可少的技能。在此情境下，Javascript 模块化编程成为一项迫切的需要。通过模块化编程，开发者只须要专一于实现外围业务逻辑，而其余的工作则能够由其余开发者编写的模块来实现。

模块化编程的劣势在于能够防止常见的问题，比方 命名抵触 和文件依赖。

通过模块化编程，咱们能够防止在代码中呈现 反复的变量名或函数名，从而确保代码的正确性和可维护性。

另外，应用模块化编程还能够解决文件依赖问题，开发者能够轻松地治理代码中的各个模块之间的依赖关系，并确保它们可能正确地加载和运行。这些劣势使得模块化编程成为古代网页开发中不可或缺的一部分。

Node 中模块分类

NodeJS 中模块分为 2 类：原生模块和文件模块。

原生模块即 Node.jsAPI 提供的原声模块，原生模块在启动时曾经被加载。(如：os 模块、http 模块、fs 模块、buffer 模块、path 模块等)

// 调用原生模块不须要指定门路
var http = require('http');

文件模块为动静加载模块，加载文件模块的次要由原生模块 module 来实现和实现。原生模块在启动时曾经被加载，而文件模块则须要通过调用 Node.js 的 require 办法来实现加载。

// 调用文件模块必须指定门路，否则会报错
var sum = require('./sum.js');

模块操作

在编写每个模块时，都有 require、exports、module 三个事后定义好的变量可供使用。

require 加载模块

require 办法承受以下几种参数的传递：

1. http、fs、path 等，原生模块。
2. ./mod 或../mod，相对路径的文件模块。
3. /pathtomodule/mod，绝对路径的文件模块。
4. mod，非原生模块的文件模块。

require 函数在以后模块中被应用以加载其余模块。传入模块名后，将返回一个蕴含导出对象的模块。模块名能够是相对路径（以./ 结尾）或绝对路径（以 / 或 C: 这样的盘符结尾）。此外，模块名中的.js 扩展名能够省略。以下是一个示例：

var foo1 = require('./foo');
var foo2 = require('./foo.js');
var foo3 = require('/home/user/foo');
var foo4 = require('/home/user/foo.js');
//foo1 ~ foo4 中保留的是同一个模块的导出对象。

// 加载 node 外围模块
var fs = require('fs');
var http = require('http');
var os = require('os');
var path = require('path');

加载和应用 json 文件

var data = require('./data.json');

exports 创立模块

exports 对象是以后模块的导出对象，用于导出模块私有办法和属性。别的模块通过 require 函数应用以后模块时失去的就是以后模块的 exports 对象。以下例子中导出了一个私有办法。

//sum.js
exports.sum = function(a,b){return a+b;}

//main.js
var m = require("./sum");
var num = m.sum(10,20);
console.log(num);

module

通过 module 对象能够拜访到以后模块的一些相干信息，但最多的用处是替换以后模块导出对象。例如模块默认导出对象默认是一个一般对象，如果想改为一个函数能够通过如下形式：导出一个一般函数：

//sum.js
function sum(a,b){return a+b;}
module.exports= sum;
//main.js
var sum = require('./sum');
sum(10,20);// 30

导出一个构造函数：

//hello.js
function hello(){
    this.name ="你的名字";
    this.setName = function(name){this.name = name;}
    this.sayName = function(){alert(this.name);
    }
}
module.exports= hello;

//main.js
var hello = require('./hello.js');
var o = new hello();
o.setName('张三');
o.sayName(); // 张三

模块初始化

一个模块中的 JS 代码仅在模块第一次被应用时执行一次，并在执行过程中初始化模块的导出对象。之后，缓存起来的导出对象被反复利用。

模块加载优先级

模块加载优先级：曾经缓存模块 > 原生模块 > 文件模块 > 从文件加载

Node.js 的 require 办法中的文件查找策略如下：因为 Node.js 中存在 4 类模块（原生模块和 3 种文件模块），只管 require 办法极其简略，然而外部的加载却是十分复杂的，其加载优先级也各自不同。如下图所

模块门路解析规定

1. 内置模块
   如果传递给 require 函数的是 NodeJS 内置模块名称，不做门路解析，间接返回外部模块的导出对象，例如 require(‘fs’)。
2. node_modules 目录
   NodeJS 定义了一个非凡的 node_modules 目录用于寄存模块。例如某个模块的绝对路径是 /home/user/hello.js，在该模块中应用 require(‘foo/bar’) 形式加载模块时，则 NodeJS 顺次尝试应用以下门路。

/home/user/node_modules/foo/bar
/home/node_modules/foo/bar
/node_modules/foo/bar

主模块

通过命令行参数传递给 NodeJS 以启动程序的模块被称为主模块。主模块负责调度组成整个程序的其它模块实现工作。例如通过以下命令启动程序时，main.js 就是主模块。

NPM 利用

什么是 NPM

Node 胜利的次要因素之一是它广受欢迎的软件包管理器——npm，因为 npm 使 JavaScript 开发人员能够疾速不便地共享软件包

npm（“Node 包管理器”）是 JavaScript 运行时 Node.js 的默认程序包管理器。
Node Packaged Modules 简称

Node 自身提供了一些根本 API 模块，然而这些根本模块难以满足开发者需要。Node 须要通过应用 NPM 来治理开发者自我研发的一些模块，并使其可能共用与其余开发者

npm 由两个次要局部组成:

. 用于公布和下载程序包的 CLI（命令行界面）工具

. 托管 JavaScript 程序包的 在线存储库

为了更直观地解释，咱们能够将存储库 npmjs.com 视为一个物流集散中心，该核心从卖方（npm 包裹的作者）那里接管货物的包裹，并将这些货物分发给买方（npm 包裹的用户）。

为了促成此过程，npmjs.com 物流集散中心雇用了一群勤奋的袋熊（npm CLI），他们将被调配给每个 npmjs.com 用户作为私人助理。因而，dependencies（依赖项）会如下传递给 JavaScript 开发人员：

公布 JS 软件包的过程如下：

NPM 应用

NPM 是伴随 NodeJS 一起装置的包管理工具，能解决 NodeJS 代码部署上的很多问题，常见的应用场景有以下几种：

1. 容许用户从 NPM 服务器下载他人编写的第三方包到本地应用。
2. 容许用户从 NPM 服务器下载并装置他人编写的命令行程序到本地应用。

3. 容许用户将本人编写的包或命令行程序上传到 NPM 服务器供他人应用。

   因为新版的 nodejs 曾经集成了 npm，所以之前 npm 也一并装置好了。同样能够通过输出

    npm -v

   来测试是否胜利装置。命令如下，呈现版本提醒示意装置胜利:

$ npm -version
9.5.1

降级更新 NPM

$ sudo npm install npm -g

应用 NPM 装置模块

有一个简略装置任何 Node.js 模块，语法如下：

$ npm install <Module Name>

例如，上面是装置一个驰名的 Node.jsweb 框架模块的命令叫 express:

$ npm install express

当初，你能够在 js 文件中应用此模块如下：

var express = require('express');

全局装置 VS 本地装置

本地装置 默认状况下，NPM 装置指定包默认会装置到本地。本地装置指的是包装置在当前目录中 node_modules 文件夹中。本地装置的包都能够通过 require()办法进行拜访。例如咱们装置 Express 模块:

$ npm install express

列出所有本地装置的模块

$ npm ls

全局装置 全局安装包都存储在系统目录中。咱们能够在 nodejs 的 CLI(命令行界面)应用，然而不能间接应用 require()办法进行拜访。例如装置 http-server 包：

// 全局装置 -g
$ npm install -g http-server
// 应用 node CLI  
$ http-server

卸载模块

应用上面的命令卸载 Node.js 模块

npm uninstall express

更新模块

npm update express

搜寻模块

搜寻应用 NPM 包名

npm search express

下载三方包

NPM 建设了一个 NodeJS 生态圈，NodeJS 开发者和用户能够在里边互通有无。

当你须要下载第三方包时, 首先要晓得有哪些包可用。npmjs.com 提供了能够依据包名来搜寻的平台，然而如果不晓得包名能够百度一下。晓得了包名后，就能够应用命令去装置了，例如：Express

npm install express

下载实现之后，express 包就放在了工程目录下的 node_modules 目录中，在代码中只须要通过 reuqire(‘express’)的形式去援用，无需指定包门路。
以上命令默认下载最新版本第三方包，如果要下载指定版本，能够在包名前面追加 @<version>, 例如通过如下命令能够下载 0.0.1 版本的 express。

npm install express@0.0.1

如果应用到的第三方包比拟多，在终端下一个包一条命令的装置十分不不便，因而 NPM 对 package.json 的字段做了扩大，容许在其中增加三方包依赖。

{
    "name":"test",
    "main":"./lib/main.js",
    "dependencies":{"http-server":"3.2.1"}
}

这样解决后，在工程目录下就能够应用 npm install 命令批量装置三包了。最重要的是，当当前吧 test 我的项目上传到了 NPM 服务器，他人下载这个包时，NPM 会依据包中申明的三方依赖包进行主动下载依赖。这样用户只须要关怀要应用的包，不必管其依赖的三方包。

给 NPM 服务器公布本人的包

第一次应用 NPM 公布本人的包须要在 npmjs.com 注册一个账号

npm 的常用命令

npm -v          #显示版本，查看 npm 是否正确装置。npm install express   #装置 express 模块

npm install -g express  #全局装置 express 模块

npm list         #列出已装置模块

npm show express     #显示模块详情

npm update        #降级当前目录下的我的项目的所有模块

npm update express    #降级当前目录下的我的项目的指定模块

npm update -g express  #降级全局装置的 express 模块

npm uninstall express  #删除指定的模块

NPM 我的项目中使用

package.json

每个 JavaScript 我的项目（无论是 Node.js 还是浏览器应用程序）都能够被当作 npm 软件包，并且通过 package.json 来形容我的项目和软件包信息。

咱们能够将 package.json 视为快递盒子上的运输信息。

当运行 npm init 初始化 JavaScript/Node.js 我的项目时，将生成 package.json 文件，文件内的内容 (根本元数据) 由开发人员提供：

. name：JavaScript 我的项目或库的名称。

. version：我的项目的版本。通常，在利用程序开发中，因为没有必要对开源库进行版本控制，因而常常疏忽这一块。然而，仍能够用它来定义版本。

. description：我的项目的形容。

. license：我的项目的许可证。

npm scripts

package.json 还反对一个 scripts 属性，能够把它当作在我的项目本地运行的命令行工具。例如，一个 npm 我的项目的 scripts 局部可能看起来像这样：

{
  "scripts": {
    "build": "tsc",
    "format": "prettier --write **/*.ts",
    "format-check": "prettier --check **/*.ts",
    "lint": "eslint src/**/*.ts",
    "pack": "ncc build",
    "test": "jest",
    "all": "npm run build && npm run format && npm run lint && npm run pack && npm test"
  }
}

eslint，prettier，ncc，jest 不是装置为全局可执行文件，而是装置在我的项目本地的 node_modules/.bin/ 中。

最新引入的 npx 使咱们能够像在全局安装程序一样运行这些 node_modules 我的项目作用域命令，办法是在其后面加上 npx …（即 npx prettier –write * / 。ts）。

dependencies vs devDependencies

这两个以键值对象的模式呈现，其中 npm 库的名称为键，其语义格局版本为值。大家能够看看 Github 的 TypeScript 操作模板中的示例：

{
  "dependencies": {
    "@actions/core": "^1.2.3",
    "@actions/github": "^2.1.1"
  },
  "devDependencies": {
    "@types/jest": "^25.1.4",
    "@types/node": "^13.9.0",
    "@typescript-eslint/parser": "^2.22.0",
    "@zeit/ncc": "^0.21.1",
    "eslint": "^6.8.0",
    "eslint-plugin-github": "^3.4.1",
    "eslint-plugin-jest": "^23.8.2",
    "jest": "^25.1.0",
    "jest-circus": "^25.1.0",
    "js-yaml": "^3.13.1",
    "prettier": "^1.19.1",
    "ts-jest": "^25.2.1",
    "typescript": "^3.8.3"
  }
}

这些依赖通过带有 –save 或 –save-dev 标记的 npm install 命令装置。它们别离用于生产和开发 / 测试环境

. ^：示意最新的次版本，例如，^1.0.4 可能会装置主版本系列 1 的最新次版本 1.3.0。

. 〜：示意最新的补丁程序版本，与 ^ 相似，〜1.0.4 可能会装置次版本系列 1.0 的最新次版本 1.0.7。

所有这些确切的软件包版本都将记录在 package-lock.json 文件中。

package-lock.json

该文件形容了 npm JavaScript 我的项目中应用的依赖项的确切版本。如果 package.json 是通用的描述性标签，则 package-lock.json 是成分表。

就像咱们通常不会读取食品包装袋上的成分表（除非你太无聊或须要晓得）一样，package-lock.json 并不会被开发人员一行一行进行读取。

package-lock.json 通常是由 npm install 命令生成的，也能够由咱们的 NPM CLI 工具读取，以确保应用 npm ci 复制我的项目的构建环境。

各种前端我的项目构建 build 工具

Node, NPM, Grunt, Gulp, Bower, Webpack, Browserify, Yeoman, Brunch…… 前端目前有很多很多名词，看着这些感觉永远也学不完。不要被这些名词吓唬住，这些工具呈现的目标是让咱们的工作更加简略。

疾速把握 build 工具秘诀

疾速把握这些工具，抓住几个外围概念：

1. 帮忙你装置

2. 帮忙你做事

当你接触到一个新的开发工具的时候，你首先须要搞清楚一个货色：“这个工具的目标是帮我装置货色，还是帮我做事？”

装置类的工具

npm、Bower 和 Yeoman 简直什么货色都能装，它们能够用来装置前端库，例如 Angular.js 或是 React.js。它们还能够为你的开发环境装置服务器。它们能够装置测试库。它们甚至能够帮你装置其余的前端开发工具。

做事类的工具

Grunt、Webpack、Require.js、Brunchu 和 Gulp 则更加简单一点。这类工具的指标，是在 web 开发中帮你实现自动化。有的时候，这类工具所做的事件，被称为“工作（task）”

为了实现这些工作，这类工具常常须要本人的包和插件生态。每一个工具都会应用不同的形式来实现工作。这些工具所做的事件也不尽相同。一些工具，善于解决那些你所指定的工作，例如 Grunt 和 Gulp 等工具。还有一些工具，只只专一于一件事件，例如解决 JavaScript 的依赖，例如 Browserify 和 Require.js 等工具。

build 工具的“祖宗”是 Node 和 npm

Node 和 npm 负责装置和运行所有这些工具，因而你的所有我的项目中都会有它们的身影。因为这个起因，很多开发者在装置新的工具之前，都会尽可能的尝试应用这两个工具解决问题。

它们两个一个负责装置，一个负责帮你做事件。

. Node 是做事工具

. npm 则是装置工具

npm 能够装置 Angular.js 和 React.js 等库。它还能够装置服务器，让你的利用在开发阶段能够在本地运行。它还能够装置很多其余工具，帮你实现很多事件，例如简化代码。

而 Node，则是帮你实现事件的，例如运行 JavaScript 文件，以及服务器等。

如果你刚刚开始学习，那么 Node 和 npm 都是必学的货色。随着你的我的项目不断丰富，你将会逐步晓得这两个工具的极限能力。当它们无奈满足你的须要的时候，就是你须要开始装置其余工具的时候了。

build 其实就是 production-ready 版本的利用

开发者常常会把 JavaScript 和 CSS 拆分成独立的文件。

独立文件的益处，是让你能够专一于编写针对性较强的代码，让每一部分代码只针对一个问题，免得日后代码多到让你本人都难以治理。然而当你的利用筹备好被推向市场的时候，我的项目内存在多个 JavaScript 或是 CSS 文件并不是一个好主见。当用户拜访你的网站的时候，每一个文件都须要独立的 HTTP 申请，这会让站点加载速度降落。

解决办法就是，给我的项目创立“build”，它要将所有 CSS 文件合并成一个文件，而后再合并 JavaScript 文件。这样一来，你就能够将文件实现最小化。要想创立这个 build，你须要应用 build 工具。

最正确工具组合”这么个货色不存在

应用哪些工具，齐全是你本人说了算的事件。

你也能够抉择什么工具都不必。然而要记住，随着我的项目的倒退，复制、黏贴、整合、开启服务器等事件会让你缓缓慌手慌脚起来。

你也能够只应用 Node 和 npm，其余工具一律不必。对于老手来说，这种形式很好，然而和上一条一样，缓缓你会开始感到力不从心。

或者，除了 Node 和 npm 之外，你也能够应用少数几个其余工具。那么，你的开发过程将会以 Node 和 npm 为外围，而后搭配 Grunt 和 Bower，或是 Webpack 或是 Gulp 和 Bower。

应用正确的工具，可能帮你将很多繁琐的事件实现自动化。然而应用工具的代价，就是你须要付出学习老本。

build 工具学习老本较高，因而你只须要学习你用的上的工具

我的项目开发自身就曾经很简单了，你可能要应用新的语言或是框架。你可能须要应酬简单的业务逻辑。而引入新的工具，只会让你的学习老本变得更高。

对此，我的倡议是，只学习那些你用的上的工具，其余的就先缓一缓吧。

学习任何一种新货色，最好的形式就是进行实际。例如，不要为了学习 Grunt 而去学习，你能够在你的我的项目中去尝试使用。

如果你感觉对您有帮忙关注公众号，程序员三时 我会给大家不定期分享热门技术，做开源我的项目，技术交换，面试，学习，分享本人入行多年一些感触和教训

参考

什么是 npm