Node.js

目录

1.Node.js的模块系统
2.Node.js 异步编程
3.Node.js常用核心模块

Node.js的模块系统

1.module和exports

export.A === module.exports.A

错误：export = "Hello world!"

上述错误将不会导出Hello world

原因：不能对export赋值，会导致export的指向被改变

正确：module.export = 'Hello world！'

export.A=''

2.require

require接受一个js模块，没有该模块会抛出异常

加载规则：

  1. 以’ / ‘开头：绝对路径
  2. 以’ ./ ‘开头：相对路径
  3. 若不以1.2.两方式开头则为核心模块或当前工作目录中node_modules模块
  4. 如果没找到，js会自动添加.js .json .node去寻找
  5. 如果传入目录，会自动寻找package.json 中的 main字段加载入口文件，若还是没有则会尝试加载index.js或index.node

3.自定义模块例子

Node.js 异步编程

1.回调函数

1
2
3
4
5
6
7
function test(callback){
    callback(1);
}

test(function(data){
    console.log(1);
})

以上是回调函数但是不是异步的

读取桌面data.txt文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 回调函数

// 读取桌面的txt文件

const fs = require('fs')
fs.readFile('./data.txt', function(err, data) {
    if (err) {
        console.log('读取出错', err)
        return
    }
    console.log(data)
})

// 返回<Buffer 31 3e 0d 0a 6c 6a 6c 0d 0a 32 3e 0d 0a 63 63 79>
// 将console.log(data)改为console.log(data.toString('UTF-8'))可以读取出内容

链式调用

bad

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//链式调用bad
const fs = require('fs');

fs.readFile('./data.txt', function(err, data) {
    if (err) {
        console.log('读取data出错', err)
        return
    }
    console.log('data读取成功', data.toString('utf8'))
    fs.readFile('./data2.txt', function(err, data2) {
        if (err) {
            console.log('读取data2出错', err)
            return
        }
        console.log('data2读取成功', data2.toString('utf8'))
    })
})

这种写法可读性和可维护性差

good

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//链式调用good
const fs = require('fs')

function readFileAsync(path) {
    return new Promise(function(resolve, reject) {
        fs.readFile(path, function(err, data) {
            if (err) {
                reject(err)
                return
            }
            resolve(data)
        })
    })
}

readFileAsync('./data.txt')
    .then(function(data) {
        console.log('读取data成功', data.toString('utf-8'));
        return readFileAsync('./data2.txt') //返回Promise
    }).then(function(data2) {
        console.log('读取data2成功', data2.toString('utf-8'))
    }).catch(function(err) {
        console.log('读取失败', err)
    })

链式调用中只要有一个出错就会调用catch函数

Promise其他操作

1
2
console.log('Promise.resolve(true):', Promise.resolve(true)) //Promise { true }
console.log(Promise.resolve(Promise.resolve(true))) //Promise { true }

.reject(reason)

.all(promises)

.race(promises)

async/await

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
//async.js
const fs = require('fs')

function readFileAsync(path) {
    return new Promise(function(resolve, reject) {
        fs.readFile(path, function(err, data) {
            if (err) {
                reject(err)
                return
            }
            resolve(data)

        })
    })
}

//依次提取文件
async function readFiles() {
    try {
        const data1 = await readFileAsync('./data.txt')
        const data2 = await readFileAsync('./data2.txt')
        console.log("data1:\n", data1.toString('utf-8'))
        console.log("data2:\n", data2.toString('utf-8'))
    } catch (e) {
        console.log('fail', e)
    }
}

readFiles()

看似是同步编程，实则是异步

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
async function dosome(a, b) {
    return a + b;
}

const dosome2 = async(a, b) => {
    return a + b;
}

class demo {
    async test(a, b) {
        return a + b
    }
}

console.log('1:', dosome(1, 2))
dosome(1, 2).then(function(res) {
    console.log('2:', res)
})

// 1: Promise { 3 }
// 2: 3

asfnc函数一定返回的是Promise，需要将结果交给then

await

只能在async函数中使用

Node.js常用核心模块

1.events

基本使用

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
const EventEmitter = require('events');
// 实例化事件监听器
const emitter = new EventEmitter();


//注册事件
emitter.on('click', function(paraml) {
    console.log('触发了点击', paraml);
});

//触发事件
emitter.emit('click', 'demo');
emitter.emit('click', 'demo');
//触发了点击 demo
//触发了点击 demo


//一次性监听
emitter.once('click1', function(paraml) {
    console.log('触发了点击1', paraml);
});

emitter.emit('click1', 'demo');
emitter.emit('click1', 'demo');
//触发了点击1 demo

2.fs

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
//文件操作
const fs = require('fs');
//读取文件
fs.readFile('./3.5-node异步编程/data.txt', 'utf8', (err, data) => {
    if (err) {
        console.log('fail', err)
        return;
    }
    console.log('success', data)
})

// 写入文件
// (new Date()).toString()
// fs.writeFile('./3.5-node异步编程/data.txt', '写入文件', { encoding: 'utf-8' }, (err) => {
//         if (err) {
//             console.log('fail', err);
//             return;
//         }
//         console.log('success')
//     })
// fs.readFile('./3.5-node异步编程/data.txt', 'utf8', (err, data) => {
//     if (err) {
//         console.log('fail', err)
//         return;
//     }
//     console.log('success', data)
// })

//追加内容
// fs.appendFile('./3.5-node异步编程/data.txt', '  追加内容', { encoding: 'utf-8' }, (err) => {
//     if (err) {
//         console.log('fail');
//         return;
//     }
//     console.log('追加成功');
// });
// fs.readFile('./3.5-node异步编程/data.txt', 'utf8', (err, data) => {
//     if (err) {
//         console.log('fail', err)
//         return;
//     }
//     console.log('success', data)
// })

//删除内容
// fs.unlink('./1.txt', (err) => {
//     if (err) {
//         console.log('fail', err);
//         return;
//     }
//     console.log('success')
// })

//创建文件夹
// fs.mkdir('./wjj/wjjj', { recursive: true }, (err) => {
//     if (err) {
//         console.log('fail', err);
//         return;
//     }
//     console.log('success')
// })

//读取文件夹
// fs.readdir('./', (err, files) => {
//     if (err) {
//         console.log('fail', err);
//         return;
//     }
//     console.log(files)
// })

//删除文件夹
fs.rmdir('./wjj', (err) => {
    if (err) {
        console.log('fail', err);
        return;
    }
    console.log('success')
})

注意

读取文件夹内容返回一个文件名字和后缀组成的数组

3.stream接口

1.通过流的方式读取文件

优点

内存占用小

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

let data = '';
const stream = fs.createReadStream('./3.6-fs.js', { encoding: 'utf-8' });

stream.on('data', (chunk) => { //chunk是读取到的数据
    data += chunk;
});

stream.on('end', () => { //读取文件完毕
    console.log(data);
});

stream.on('error', (err) => {
    console.log('fail', err);
});

console.log('finish');

2.写入流

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
const fs = require('fs');

const readStream = fs.createReadStream('./3.6-fs.js', { encoding: 'utf-8' });
const writeStream = fs.createWriteStream('./b.js', { encoding: 'utf-8' });

readStream.on('data', (chunk) => {
    writeStream.write(chunk);
});

readStream.on('end', () => {
    writeStream.end();
    console.log('success');
});

writeStream.on('finish', () => {
    console.log('finish')
});

readStream.on('error', (err) => {
    console.log('读取错误', err);
});

writeStream.on('error', (err) => {
    console.log('写入错误', err);
});

3.管道流

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//管道流
const fs = require('fs');


//创建读取流
const readStream = fs.createReadStream('./b.js', { encoding: 'utf-8' });

//创建写入流
const writeStream = fs.createWriteStream('./c.js', { encoding: 'utf-8' });

//管道操作
readStream.pipe(writeStream);

writeStream.on('finish', () => {
    console.log('success')
})

4.数据转换流

1
2
3
4
5
6
7
8
9
//数据装换流
var fs = require('fs');
var zlib = require('zlib');

fs.createReadStream('./c.js')
    .pipe(zlib.createGzip())
    .pipe(fs.createWriteStream('./d.js.gz'));

console.log('finish')
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

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