Node.js(一)

1. 初识Node.js

Node.js 是一种建立在Google Chrome’s v8 engine上的 non-blocking (非阻塞）, event-driven （基于事件的）I/O平台。

Node.js平台使用的开发语言是JavaScript，平台提供了操作系统低层的API，方便做服务器端编程，具体包括文件操作、进程操作、通信操作等系统模块

2. Node.js可以用来做什么？

  • 具有复杂逻辑的动态网站
  • WebSocket服务器
  • 命令行工具
  • 带有图形界面的本地应用程序
  • ……

3. Node.js开发环境准备

1、普通安装方式官方网站

2、多版本安装方式

1
2
3
4
5
6
7
8
9
10
11
2.1	卸载已有的Node.js
2.2	下载[nvm](https://github.com/coreybutler/nvm-windows)
2.3	在C盘创建目录dev
2.4	在dev目中中创建两个子目录nvm和nodejs
2.5	并且把nvm包解压进去nvm目录中
2.6	在install.cmd文件上面右键选择【以管理员身份运行】
2.7	打开的cmd窗口直接回车会生成一个settings.txt文件，修改文件中配置信息
2.8	配置nvm和Node.js环境变量
  2.8.1     NVM_HOME:C:\dev\nvm
  2.8.2     NVM_SYMLINK:C:\dev\nodejs
2.9	把配置好的两个环境变量加到Path中%NVM_HOME%;%NVM_SYMLINK%;

4. nvm常用的命令

  • nvm list 查看当前安装的Node.js所有版本
  • nvm install 版本号 安装指定版本的Node.js
  • nvm uninstall 版本号 卸载指定版本的Node.js
  • nvm use 版本号 选择指定版本的Node.js

5. Node.js之HelloWorld

5.1 命令行方式REPL

REPL read-eval-print-loop 读取代码-执行-打印结果-循环这个过程

在REPL环境中，_表示最后一次执行结果; .exit 可以退出REPL环境

image-20200709142204833

5.2 运行文件方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/*
    初识Node.js
*/
console.log('hello tom and jerry');

function sum(n) {
    var result = 0;
    for (var i = 0; i <= n; i++) {
        result += i;
    }
    return result;
}

var ret = sum(100);
console.log(ret);

image-20200709142641865

6. 全局对象概览

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
    全局成员概述
*/

// 1.   包含文件名称的全路径
console.log(__filename);
// 2.   文件的路径（不包含文件名称）
console.log(__dirname);

// 3.   定时函数，用法与浏览器中的定时函数类似
var timer = setTimeout(function () {
    console.log(123);
}, 1000);

setTimeout(function () {
    clearTimeout(timer);
}, 2000);

// 4.   在Node.js中没有window对象，但是有一个类似的对象global，访问全局成员的时候可以省略global
global.console.log(123456);

// 5.   argv是一个数组，默认情况下，前两项数据分别是：Node.js环境的路径、当前执行的js文件的全路径
// 从第三个参数开始表示命令行参数
console.log(process.argv);
// 6.   打印当前系统的架构（64位或者32位）
console.log(process.arch);

image-20200709144913210

7. 模块化开发

7.1 模块化规范与实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
传统非模块化开发有如下的缺点：
1、命名冲突
2、文件依赖

前端标准的模块化规范：
1、AMD - requirejs
2、CMD - seajs

服务器端的模块化规范：
1、CommonJS - Node.js

模块化相关的规则：
1、如何定义模块：一个js文件就是一个模块，模块内部的成员都是相互独立
2、模块成员的导出和引入

模块成员的导出最终以module.exports为准

7.2 模块导出与引入

7.2.1 导出方式一：

03.js

1
2
3
4
5
6
var sum = function(a,b){
    return parseInt(a) + parseInt(b);
}

// 导出模块成员
exports.sum = sum;

04.js

1
2
3
4
5
//引入模块
var module = require('./03.js');

var ret = module.sum(12,13);
console.log(ret);

7.2.2 导出方式二：

03.js

1
2
3
4
5
6
var sum = function(a,b){
    return parseInt(a) + parseInt(b);
}

// 导出模块成员
module.exports = sum;

04.js

1
2
3
4
5
//引入模块
var module = require('./03.js');

var ret = module(12,13);
console.log(ret);

7.2.3 两种导出方式区别

如果要导出单个的成员或者比较少的成员，一般我们使用exports导出；如果要导出的成员比较多，一般我们使用module.exports的方式。

这两种方式不能同时使用，exports与module的关系：
module.exports = exports = {};

7.3 模块导出机制分析

05.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
    四则运算-成员导出方式分析
*/
var sum = function (a, b) {
    return parseInt(a) + parseInt(b);
}
var subtract = function (a, b) {
    return parseInt(a) - parseInt(b);
}
var multiply = function (a, b) {
    return parseInt(a) * parseInt(b);
}
var divide = function (a, b) {
    return parseInt(a) / parseInt(b);
}

// 导出成员
// exports.sum = sum;
// exports.subtract = subtract;

module.exports = {
    sum: sum,
    subtract: subtract,
    multiply: multiply,
    divide: divide
}

06.js

1
2
3
4
5
6
7
8
/*
    测试导出
*/

var m = require('./05.js');
var ret = m.sum(1, 2);
var ret1 = m.subtract(1, 2);
console.log(ret, ret1);

7.4 模块成员导出：global

07.js

1
2
var flag = 123;
global.flag = flag;

08.js

1
2
require('./07.js');
console.log(global.flag);

7.5 模块加载规则

已经加载的模块会缓存

模块文件的后缀3种情况：.js .json .node

上述三种模块的加载优先级(不加文件后缀时的优先级)：.js -> .json -> .node

data.json

1
2
3
4
{
    "username":"张三",
    "age":"12"
}

data.js

1
2
3
exports.showInfo = function(){
    console.log('nihao');
}

08.js

1
2
var m = require('./data');
var ret = m.showInfo();

7.6 模块分类

  1. 自定义模块
  2. 系统核心模块
    • fs 文件操作
    • http 网络操作
    • path 路径操作
    • querystring 查询参数解析
    • url url解析
    • ……

8. Buffer基本操作

Buffer对象是Node处理二进制数据的一个接口。它是Node原生提供的全局对象，可以直接使用，不需要require(‘buffer’)。Buffer本质上就是字节数组。

8.1 实例化

  • Buffer.from(array)
  • Buffer.from(string)
  • Buffer.alloc(size)
1
2
3
4
5
6
7
8
9
let buf = new Buffer(5);//不推荐
let buf = Buffer.alloc(5);
console.log(buf); -><Buffer 00 00 00 00 00>

let buf = Buffer.from('hello', 'utf8');
console.log(buf); -><Buffer 68 65 6c 6c 6f>

let buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
console.log(buf.toString()); ->buffer

8.2 功能方法

  • Buffer.isEncoding() 判断是否支持该编码
  • Buffer.isBuffer() 判断是否为Buffer
  • Buffer.byteLength() 返回指定编码的字节长度，默认utf8
  • Buffer.concat() 将一组Buffer对象合并为一个Buffer对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
console.log(Buffer.isEncoding('utf8')); ->true
console.log(Buffer.isEncoding('gbk')); ->false

let buf = Buffer.from('hello');
console.log(Buffer.isBuffer(buf)); ->true
console.log(Buffer.isBuffer({})); ->false

let buf = Buffer.from('中国', 'ascii');
console.log(Buffer.byteLength(buf)); ->2
console.log(buf.toString());

let buf1 = Buffer.alloc(3);
let buf2 = Buffer.alloc(5);
let buf3 = Buffer.concat([buf1, buf2]);
console.log(Buffer.byteLength(buf3)); ->8

let buf1 = Buffer.from('tom');
let buf2 = Buffer.from('jerry');
let buf3 = Buffer.concat([buf1, buf2]);
console.log(Buffer.byteLength(buf3)); ->8
console.log(buf3.toString()); ->tomjerry

8.3 实例方法

  • write() 向buffer对象中写入内容
  • slice() 截取新的buffer对象
  • toString() 把buf对象转成字符串
  • toJson() 把buf对象转成json形式的字符串
1
2
3
4
5
6
7
8
9
10
11
12
13
14
let buf = Buffer.alloc(5);
buf.write('hello', 2, 2);
console.log(buf); -><Buffer 00 00 68 65 00>      空格空格he空格

let buf = Buffer.from('hello');
let buf1 = buf.slice(2, 3);
console.log(buf === buf1);//false
console.log(buf1.toString()); ->l

// toJSON方法不需要显式调用，当JSON.stringify方法调用的时候会自动调用toJSON方法
const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]); ->{"type":"Buffer","data":[1,2,3,4,5]}
const buf = Buffer.from('hello'); ->{"type":"Buffer","data":[104,101,108,108,111]}
const json = JSON.stringify(buf);
console.log(json);

9. 核心模块API

9.1 路径操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
//引入path模块
const path = require('path');

// 1. 获取路径的最后一部分
console.log(path.basename('/foo/bar/baz/asdf/quux.html')); ->quux.html
console.log(path.basename('/foo/bar/baz/asdf/quux.html', '.html')); ->quux

// 2. 获取路径
console.log(__dirname);->D:\02-code
console.log(path.dirname('/abc/qqq/www/abc')); ->/abc/qqq/www

// 3. 获取扩展名称
console.log(path.extname('index.html')); ->.html

// 4. 路径的格式化处理
// path.format() obj->string
// path.parse()  string->obj

let obj = path.parse(__filename);
console.log(obj.base);
/*
{ root: 'D:\\', 文件的跟路径
  dir: 'D:\\02-code',文件的全路径
  base: '02.js',文件的名称
  ext: '.js',扩展名
  name: '02' 文件名称
}
*/
let objpath = {
    root: 'd:\\',
    dir: 'd:\\qqq\\www',
    base: 'abc.txt',
    ext: '.txt',
    name: 'abc'
};
let strpath = path.format(objpath);
console.log(strpath); ->d:\qqq\www\abc.txt

// 5. 判断是否为绝对路径
console.log(path.isAbsolute('/foo/bar')); ->true
console.log(path.isAbsolute('C:/foo/..')); ->true

// 6. 拼接路径（..表示上层路径；.表示当前路径）,在连接路径的时候会格式化路径
console.log(path.join('/foo', 'bar', 'baz/asdf', 'quux', '../../')); ->\foo\bar\baz\

// 7. 规范化路径
console.log(path.normalize('/foo/bar//baz/asdf/quux/..')); ->\foo\bar\baz\asdf
console.log(path.normalize('C:\\temp\\\\foo\\bar\\..\\')); ->C:\temp\foo\

// 8. 计算相对路径
console.log(path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb')); ->..\..\impl\bbb
console.log(path.relative('C:\\orandea\\test\\aaa', 'C:\\orandea\\impl\\bbb')); ->..\..\impl\bbb

// 9. 解析路径
console.log(path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif')); ->D:\02-code\wwwroot\static_files\gif\image.gif

// 10. 两个特殊属性
console.log(path.delimiter);//环境变量分隔符(windows中使用; linux中使用:) ->;
console.log(path.sep);//表示路径分隔符（windows是\ Linux是/）->\

9.2 文件操作

9.2.1 文件信息获取

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
const fs = require('fs');
console.log(1);
fs.stat('./data.txt', (err, stat) => {
    // 一般回调函数的第一个参数是错误对象，如果err为null,表示没有错误，否则表示报错了
    if (err) return;
    if (stat.isFile()) {
        console.log('文件');
    } else if (stat.isDirectory()) {
        console.log('目录');
    }
    console.log(stat);
    /*
    atime 文件访问时间
    ctime 文件的状态信息发生变化的时间（比如文件的权限）
    mtime 文件数据发生变化的时间
    birthtime 文件创建的时间
    */
    console.log(2);
});
console.log(3);
----------------------------------------------------

// 同步操作
console.log(1);
let ret = fs.statSync('./data.txt');
console.log(ret);
console.log(2);

image-20200709210340377

9.2.2 读文件操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
const fs = require('fs');
const path = require('path');

let strpath = path.join(__dirname, 'data.txt');
fs.readFile(strpath, (err, data) => {
    if (err) return;
    console.log(data.toString());
});

// 如果有第二个参数并且是编码，那么回调函数获取到的数据就是字符串
// 如果没有第二个参数，那么得到的就是Buffer实例对象
fs.readFile(strpath, 'utf8', (err, data) => {
    if (err) return;
    // console.log(data.toString());
    console.log(data);
});

// 同步操作
let ret = fs.readFileSync(strpath, 'utf8');
console.log(ret);

9.2.3 写文件操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
const fs = require('fs');
const path = require('path');

let strpath = path.join(__dirname,'data.txt');
fs.writeFile(strpath,'hello nihao','utf8',(err)=>{
    if(!err){
        console.log('文件写入成功');
    }
});

let buf = Buffer.from('hi');
fs.writeFile(strpath, buf, 'utf8', (err) => {
    if (!err) {
        console.log('文件写入成功');
    }
});

// 同步操作
fs.writeFileSync(strpath,'tom and jerry');
----------------------------------------------------------

// 大文件操作（流式操作）
const path = require('path');
const fs = require('fs');

let spath = path.join(__dirname,'../03-source','file.zip');
let dpath = path.join('C:\\Users\\www\\Desktop','file.zip');

let readStream = fs.createReadStream(spath);
let writeStream = fs.createWriteStream(dpath);

// 基于事件的处理方式
let num = 1;
readStream.on('data',(chunk)=>{
    num++;
    writeStream.write(chunk);
});

readStream.on('end',()=>{
    console.log('文件处理完成'+num);
});

// pipe的作用直接把输入流和输出流
// readStream.pipe(writeStream);
fs.createReadStream(spath).pipe(fs.createWriteStream(dpath));

9.2.4 目录操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/*
    目录操作
    1、创建目录
    fs.mkdir(path[, mode], callback)
    fs.mkdirSync(path[, mode])
    2、读取目录
    fs.readdir(path[, options], callback)
    fs.readdirSync(path[, options])
    3、删除目录
    fs.rmdir(path, callback)
    fs.rmdirSync(path)
*/

const path = require('path');
const fs = require('fs');
// 1. 创建目录
fs.mkdir(path.join(__dirname,'abc'),(err)=>{
    console.log(err);
});

fs.mkdirSync(path.join(__dirname,'hello'));
--------------------------------

// 2. 读取目录
fs.readdir(__dirname,(err,files)=>{
    files.forEach((item,index)=>{
        fs.stat(path.join(__dirname,item),(err,stat)=>{
            if(stat.isFile()){
                console.log(item,'文件');
            }else if(stat.isDirectory()){
                console.log(item,'目录');
            }
        });
    });
});

let files = fs.readdirSync(__dirname);
files.forEach((item,index)=>{
    fs.stat(path.join(__dirname,item),(err,stat)=>{
        if(stat.isFile()){
            console.log(item,'文件');
        }else if(stat.isDirectory()){
            console.log(item,'目录');
        }
    });
});
------------------------------

// 3. 删除目录
fs.rmdir(path.join(__dirname, 'abc'), (err) => {
    console.log(err);
});

fs.rmdirSync(path.join(__dirname,'qqq'));

10. 包

多个模块可以形成包，不过要满足特定的规则才能形成规范的包

10.1 npm

NPM （node.js package management）全球最大的模块生态系统，里面所有的模块都是开源免费的；也是Node.js的包管理工具。官方网站

10.2 npm包安装方式

  • 本地安装

    本地安装的包在当前目录下的node_modules里面，本地安装的包一般用于实际的开发工作

  • 全局安装-g

    全局安装的包位于Node.js环境的node_modules目录下，全局安装的包一般用于命令行工具

10.3 解决npm安装包被墙的问题

10.3.1 –registry

1
npm config set registry=https//registry.npm.taobao.org

10.3.2 cnpm

淘宝NPM镜像,与官方NPM的同步频率目前为10分钟一次
官网: http://npm.taobao.org/ 

1
2
npm install -g cnpm –registry=https//registry.npm.taobao.org 
使用cnpm安装包: cnpm install 包名

10.3.3 nrm

作用：修改镜像源

项目地址：https://www.npmjs.com/package/nrm 

1
2
3
4
5
安装：npm install -g nrm

使用nrm ls 查看当前所有可用的镜像源地址以及当前所使用的镜像源地址。

使用nrm use npm 或 nrm use taobao 切换不同的镜像源地址；

10.4 npm常用命令

1
2
3
4
5
6
7
8
9
10
11
开发环境（平时开发使用的环境）
生产环境（项目部署上线之后的服务器环境）

--save 向生产环境添加依赖 dependencies
--save-dev 向开发环境添加依赖 DevDependencies 

npm install --production 只会安装生产的依赖包（去掉--production安装所有的依赖包）

npm cache clean -f 清除缓存

npm config set proxy http://127.0.0.1:61235/ 设置代理

10.4.1 安装包

1
2
3
4
5
6
// 1. 如果没有指定版本号，那么安装最新版本
npm install -g 包名称 (全局安装)
npm install 包名称 (本地安装)

// 2. 安装包的时候可以指定版本
npm install -g 包名称@版本号

10.4.2 更新包

1
2
3
// 更新到最新版本
npm update -g 包名
//注：更新包update不一定生效，可用install重新安装最新版

10.4.3 卸载包

1
npm uninstall -g 包名

10.5 yarn基本使用

类比npm基本使用

yrm：yarn地址管理工具，类似nrm

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
安装yarn工具：npm install -g yarn

1、初始化包
    npm init
    yarn init
2、安装包
    npm install xxx --save
    yarn add xxx
3、移除包
    npm uninstall xxx
    yarn remove xxx
4、更新包
    npm update xxx
    yarn upgrade xxx
5、安装开发依赖的包
    npm install xxx --save-dev
    yarn add xxx --dev
6、全局安装
    npm install -g xxx
    yarn global add xxx
7、设置下载镜像的地址
    npm config set registry url
    yarn config set registry url
8、安装所有依赖
    npm install
    yarn install
9、执行包
    npm run
    yarn run

11. 自定义包

11.1 包的规范

  • package.json必须在包的顶层目录下
  • 二进制文件应该在bin目录下
  • JavaScript代码应该在lib目录下
  • 文档应该在doc目录下
  • 单元测试应该在test目录下

11.2 package.json字段分析

  • name：包的名称，必须是唯一的，由小写英文字母、数字和下划线组成，不能包含空格
  • description：包的简要说明
  • version：符合语义化版本识别规范的版本字符串
  • keywords：关键字数组，通常用于搜索
  • maintainers：维护者数组，每个元素要包含name、email（可选）、web（可选）字段
  • contributors：贡献者数组，格式与maintainers相同。包的作者应该是贡献者数组的第一- 个元素
  • bugs：提交bug的地址，可以是网站或者电子邮件地址
  • licenses：许可证数组，每个元素要包含type（许可证名称）和url（链接到许可证文本的- 地址）字段
  • repositories：仓库托管地址数组，每个元素要包含type（仓库类型，如git）、url（仓- 库的地址）和path（相对于仓库的路径，可选）字段
  • dependencies：生产环境包的依赖，一个关联数组，由包的名称和版本号组成
  • devDependencies：开发环境包的依赖，一个关联数组，由包的名称和版本号组成

11.3 自定义包案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
  "name": "hello",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "node index.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {},
  "devDependencies": {}
}


-------------本文结束感谢您的阅读-------------



本文作者： Wgy
本文标题： Node.js(一)
本文链接： https://wgy1993.gitee.io/archives/fb0fa11b.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 进行许可。转载请注明出处！
知识共享许可协议
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

本站总访问量:

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

程序员的一天