异步编程的直接体现就是回调,处理大量的并发请求
一边读取文件，一边执行其他命令，在文件读取完成后，我们将文件内容作为回调函数的参数返回。这样在执行代码时就没有阻塞或等待文件 I/O 操作

cmd（npm、node.js）

允许用户从NPM服务器下载别人编写的第三方包到本地使用。
允许用户从NPM服务器下载并安装别人编写的命令行程序到本地使用。
允许用户将自己编写的包或命令行程序上传到NPM服务器供别人使用。

1.查看版本

node-v
npm -v

2.npm 命令来升级

sudo npm install npm -g
npm install npm -g

---

在E:\webpack-demo新建文件如webpack-test并进入
cd E:\webpack-demo\webpack-test

3.创建一个新的本地项目目录名为webpack-demo

mkdir webpack-test

4.进入目录

cd webpack-test

5.安装webpack

(安装最新版本) + webpack@4.41.6
npm install --save-dev webpack
(安装你需要的版本)
npm install --save-dev webpack@3.12.0

6.安装webpack-cli + webpack-cli@3.3.11

npm install --save-dev webpack-cli

7.引入依赖（打包）

• 安装一个要打包到生产环境的安装包
  使用 npm install --save
• 安装一个用于开发环境的安装包（例如，linter, 测试库等）
  使用 npm install --save-dev

例子

要在 index.js 中打包 lodash 依赖，我们需要在本地安装 library：
(注意更改package.json不要有//之类的注释)
npm install --save lodash

8.更新 index.html 文件

现在，由于通过打包来合成脚本，我们必须更新 index.html 文件。
因为现在是通过 import 引入 lodash，所以将 lodash <script> 删除，
然后修改另一个 <script> 标签来加载 bundle，而不是原始的 /src 文件：

9.将我们的脚本作为入口起点

npx webpack
然后输出为 main.js

10.删除

1.删除全局webpack-cli
npm uninstall -g webpack-cli
2.删除全局webpack
npm uninstall -g webpack
3.删除本地（局部）webpack-cli
npm uninstall webpack-cli
4.删除本地webpack
npm un webpack
5.检查webpack残余文件
rm -rf node_modules package-lock.json package.json

---

1.创建package.json文件

//1.手动输  
npm init  
//2.自动建立package.json(-y 的含义:在init的时候省去了敲回车的步骤，少用)  
npm init -y
会出现warn警告1：
No description: 这个警告是说这个项目的描述为空
会出现warn警告2：
No repository field：这个警告就是说git仓库字段没有设置
可以添加
{...."scripts": {"test": "echo \"Error: no test specified\" && exit 1"},"private": true, #加这个声明私有"author": "xxxx",....
}

Package.json属性说明:位于 node_modules/express/package.json 内容

name            包名。
version         包的版本号。
description     包的描述。
homepage        包的官网 url 。
author          包的作者姓名。
contributors    包的其他贡献者姓名。
dependencies    依赖包列表。如果依赖包没有安装，npm 会自动将依赖包安装在 node_module目录下。
repository      包代码存放的地方的类型，可以是 git 或 svn，git 可在 Github 上。
main            指定了程序的主入口文件，require('moduleName') 就会加载这个文件。这个字段的默认值是模块根目录下面的 index.js。
keywords        关键字

2.安装模块【可以通过 require() 来引入本地安装的包】

npm install <Module Name模块名> (本地安装)
npm install <Module Name模块名> -g (全局安装)
//express 包就放在了工程目录下的 node_modules 目录中
安装：npm install express
调用：var express = require(‘express’);

注：

我自己在项目的本地总共安装了这些
npm install express             //路由、HTTP帮助程序（重定向，缓存等）
npm install fs                  		//文件
npm install http               	 	//开发HTTP服务器程序
npm install url                		 //解析URL
npm install path                	//处理本地文件目录
npm install http-server
npm install crypto              	//提供通用的加密和哈希算法
npm install stream              //提供的仅在服务区端可用的模块,支持“流”这种数据结构
npm install steam

3.查看、卸载、更新、搜索模块

（以express模块举例）
查看所有全局安装的模块：
npm list -g
查看某个模块的版本号：
npm list express
卸载模块
npm uninstall express
卸载后，你可以到 /node_modules/ 目录下查看包是否还存在
npm ls
更新模块
npm update express
搜索模块
npm search express
启动模块
npm start xxx
停止模块
npm stop xxx

创建自己的模块

在 npm 资源库中注册用户（使用邮箱注册）
npm adduser
发布模块
npm publish
然后就可以安装自己的模块
npm install xxxxx

3.创建 Node.js 应用

• 引入 required 模块，将实例化的 HTTP 赋值给变量 http

  var http = require(“http”);

• 创建HTTP服务器

  http.createServer(function (request, response) {
  // 发送 HTTP 头部 （HTTP 状态值: 200 : OK 和 内容类型: text/plain）
  response.writeHead(200, {‘Content-Type’: ‘text/plain’});
  // 发送响应数据 “Hello World”
  response.end(‘Hello World\n’);
  }).listen(8888);

• 终端打印如下信息

  console.log(‘Server running at http://127.0.0.1:8888/’);

如下：
server.js

var http = require('http');
http.createServer(function (request, response) {response.writeHead(200, {'Content-Type': 'text/plain'});response.end('Hello World\n');
}).listen(8888);
console.log('Server running at http://127.0.0.1:8888/');

4. node 命令

node server.js
再打开http://127.0.0.1:8888/，即可看到Hello World

---

Node.js REPL(交互式解释器)

1.启动 Node 的终端
node

2.使用 var 关键字的变量可以使用 console.log() 来输出变量

$ node
> x = 10
10
> var y = 10
undefined

3.使用下划线(_)获取上一个表达式的运算结果

> x + y
30
> var sum = _
undefined

ctrl + c                退出当前终端。
ctrl + c 按下两次        退出 Node REPL。
ctrl + d                退出 Node REPL.

回调函数

回调函数callbak一般作为函数的最后一个参数出现
function foo1(name, age, callback) { }
function foo2(value, callback1, callback2) { }

基本模块

在Node环境中，一个.js文件就称之为一个模块

$\color{red}1.自定义模块$

• 一个模块想要对外暴露变量（函数也是变量）
  module.exports = variable;
• 一个模块要引用其他模块暴露的变量
  var ref = require(‘module_name模块名’); 或
  var ref = require(‘path_name相对目录名’);
• 原理：支持闭包。
  • 如果我们把一段JavaScript代码用一个函数包装起来，这段代码的所有“全局”变量就变成了函数内部的局部变量

实例：

hello.js

'use strict';
var s = 'Hello';
function greet(name) {console.log(s + ', ' + name + '!');
}
module.exports = greet;   //对外暴露变量(greet函数名)

main.js

'use strict';
// 引入hello模块,引入的模块作为变量保存在greet变量中
var greet = require('./hello');  
var s = 'world';
greet(s); // s使用hello.js内的函数，输出Hello, world!

$\color{red}2.fs模块$

fs模块就是文件系统模块，负责读写文件。同时提供了异步和同步的方法

1.异步读文本文件

'use strict';               //js的严格模式
var fs = require('fs');
fs.readFile('sample.txt', 'utf-8', function (err, data) {if (err) {console.log(err);} else {console.log(data);}
});

注：

• sample.txt文件必须在当前目录下，且文件编码为utf-8
• 当正常读取时，err参数为null，data参数为读取到的String
• 当读取发生错误时，err参数代表一个错误对象，data为undefined

2.异步读二进制文件（图片）

'use strict';
var fs = require('fs');
fs.readFile('sample.png', function (err, data) {if (err) {console.log(err);} else {console.log(data);console.log(data.length + ' bytes');}
});

注：

• 回调函数的data参数将返回一个Buffer对象，是一个包含零个或任意个字节的数组（注意和Array不同）
• Buffer对象转换成String

  // Buffer -> String
  var text = data.toString(‘utf-8’);
  console.log(text);

• String转换成Buffer

  // String -> Buffer
  var buf = Buffer.from(text, ‘utf-8’);
  console.log(buf);

3.同步读文件(少用)
多了一个Sync后缀，并且不接收回调函数，函数直接返回结果

'use strict';
var fs = require('fs');
try {var data = fs.readFileSync('sample.txt', 'utf-8');console.log(data);
} catch (err) {// 出错了
}

4.异步写文件

'use strict';
var fs = require('fs');
var data = 'Hello, Node.js';
fs.writeFile('output.txt', data, function (err) {if (err) {console.log(err);} else {console.log('ok.');}
});

注：

• 参数依次为文件名、数据和回调函数
• 回调函数由于只关心成功与否，因此只需要一个err参数

5.异步写文件（忽略）

6.获取文件大小，创建时间等信息

'use strict';
var fs = require('fs');
fs.stat('sample.txt', function (err, stat) {if (err) {console.log(err);} else {// 是否是文件:console.log('isFile: ' + stat.isFile());// 是否是目录:console.log('isDirectory: ' + stat.isDirectory());if (stat.isFile()) {// 文件大小:console.log('size: ' + stat.size);// 创建时间, Date对象:console.log('birth time: ' + stat.birthtime);// 修改时间, Date对象:console.log('modified time: ' + stat.mtime);}}
});

注：使用fs.stat()，它返回一个Stat对象，能告诉我们文件或目录的详细信息

$\color{red}3.stream模块（主要是fs模块）$

标准输出流（stdout）。
流的特点是数据是有序的，而且必须依次读取，或者依次写入，不能像Array那样随机定位.
流也是一个对象

• data事件表示流的数据已经可以读取
  • data事件可能会有多次，每次传递的chunk是流的一部分数据
• end事件表示这个流已经到末尾了
• error事件表示出错了
• 所有可以读取数据的流都继承自stream.Readable
• 所有可以写入数据的流都继承自stream.Writable
• 一个Readable流和一个Writable流串起来后，所有的数据自动从Readable流进入Writable流，这种操作为pipe()方法

1.文件流读取文本

'use strict';
var fs = require('fs');
// 打开一个流:
var rs = fs.createReadStream('sample.txt', 'utf-8');
rs.on('data', function (chunk) {console.log('DATA:')console.log(chunk);
});
rs.on('end', function () {console.log('END');
});
rs.on('error', function (err) {console.log('ERROR: ' + err);
});

2.文件流写入文本，不断调用write()方法，最后以end()结束

'use strict';
var fs = require('fs');var ws1 = fs.createWriteStream('output1.txt', 'utf-8');
ws1.write('使用Stream写入文本数据...\n');
ws1.write('END.');
ws1.end();var ws2 = fs.createWriteStream('output2.txt');
ws2.write(new Buffer('使用Stream写入二进制数据...\n', 'utf-8'));
ws2.write(new Buffer('END.', 'utf-8'));
ws2.end();

3.读取源文件的所有数据都自动写入到目标文件

'use strict';
var fs = require('fs');var rs = fs.createReadStream('sample.txt');
var ws = fs.createWriteStream('copied.txt');rs.pipe(ws);

$\color{red}4.http模块（包含path、url模块）$

提供的request和response对象

• request对象封装了HTTP请求，调用request对象属性和方法可以拿到所有HTTP请求信息
• response对象封装了HTTP响应，操作response对象方法，可以把HTTP响应返回给浏览器

1.Web程序

hello.js'use strict';
var http = require('http');
// 创建http server，并传入回调函数:
var server = http.createServer(function (request, response) {// 回调函数接收request和response对象,// 获得HTTP请求的method和url:console.log(request.method + ': ' + request.url);// 将HTTP响应200写入response, 同时设置Content-Type: text/html:response.writeHead(200, {'Content-Type': 'text/html'});// 将HTTP响应的HTML内容写入response:response.end('<h1>Hello world!</h1>');
});
server.listen(8080);           // 让服务器监听8080端口:
console.log('Server is running at http://127.0.0.1:8080/');再node hello.js 输出

2.文件服务器(url和path模块)

将一个字符串解析为一个Url对象：

'use strict';
var url = require('url');
console.log(url.parse('http://user:pass@host.com:8080/path/to/file?query=string#hash'));

构造目录：
这样，我们就不关心怎么拼接路径了

'use strict';
var path = require('path');
var workDir = path.resolve('.'); // 解析当前目录:为'/Users/michael'
// 组合完整文件路径:当前目录+'pub'+'index.html':为'/Users/michael/pub/index.html'
var filePath = path.join(workDir, 'pub', 'index.html');

实现一个文件服务器：

'use strict';
varfs = require('fs'),url = require('url'),path = require('path'),http = require('http');
// 从命令行参数获取root目录，默认是当前目录:
var root = path.resolve(process.argv[2] || '.');
console.log('静态根目录: ' + root);
// 创建服务器:
var server = http.createServer(function (request, response) {// 获得URL的path，类似 '/css/bootstrap.css':var pathname = url.parse(request.url).pathname;// 获得对应的本地文件路径，类似 '/srv/www/css/bootstrap.css':var filepath = path.join(root, pathname);// 获取文件状态:fs.stat(filepath, function (err, stats) {if (!err && stats.isFile()) {console.log('200 ' + request.url);              // 没有出错并且文件存在:response.writeHead(200);                        // 发送200响应:fs.createReadStream(filepath).pipe(response);   // 将文件流导向response:} else {console.log('404 ' + request.url);              // 出错了或者文件不存在:response.writeHead(404);                        // 发送404响应:response.end('404 Not Found');}});
});
server.listen(8080);
console.log('Server is running at http://127.0.0.1:8080/');

注：运行node file_server.js /path/to/dir，把/path/to/dir改成你本地的一个有效的目录，然后在浏览器中输入http://localhost:8080/index.html，只要当前目录下存在文件index.html，服务器就可以把文件内容发送给浏览器。

$\color{red}5.crypto模块$

。。。。

---

这是我的学习笔记，待续（详见廖雪峰的官方网站）