1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 引入fs模块
const fs = require('fs')
// 利用fs创建流
const stream = fs.createWriteStream('./big_file.txt')

// 写数据
for (let i = 0; i < 100000; i++) {
    stream.write(`这是第${i}行内容，我们需要很多很多内容\n`)
}
// 关闭流
stream.end()
console.log('done')

//命令行执行
node 1.js

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 引入文件模块
const fs = require('fs')
// 引入http模块
const http = require('http')

// 开启服务器
const server = http.createServer()
server.on('request', (request, response) => {
    // 读取文件
    fs.readFile('./big_file.txt', (error, data) => {
        if (error) throw error
        response.end(data)
        console.log('done')
    })
})
// 开启监听端口
server.listen(8888)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

const http = require('http')
const fs = require('fs')

const server = http.createServer()
server.on('request', (request, response) => {
    // 利用流读取文件
    const stream = fs.createReadStream('./big_file.txt')
    stream.pipe(response)
})
server.listen(8888)

 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

const fs = require('fs')

function writeOneMillionTimes(writer, data) {
    let i = 1000000
    write()

    function write() {
        let ok = true //默认可以写
        do {
            i--
            if (i === 0) {
                // 最后一次写
                writer.write(data)
            } else {
                // 如果i不为0，则说明还继续写
                // 向writer中写数据的同时，把值给ok，进入下一次判断
                ok = writer.write(data)
                if (ok === false) {
                    console.log('不能再写了')
                }
            }
        } while (i > 0 && ok)

        // 如果ok不为true（写不进去值了）
        if (i > 0) {
            // 就监听writer的drain事件
            writer.once('drain', () => {
                console.log('干涸了，可以写了')
                // 如果drain事件触发了，则继续写
                write()
            })
        }
    }
}

const writer = fs.createWriteStream('./big_file.txt')

writeOneMillionTimes(writer, 'hello world')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

const { Writable } = require('stream')

const outStream = new Writable({
    write(chunk, encoding, callback) {
        console.log(chunk.toString())
        callback()
    }
})

// process.stdin是一个用户输入stream
process.stdin.pipe(outStream)
// 用监听事件改写
// process.stdin.on('data', chunk => {
//     outStream.write(chunk)
// })

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

const { Readable } = require('stream')

const inStream = new Readable()

inStream.push("ABCDEFGH")
inStream.push('IJKLMNOP')
inStream.push(null)

// 等同于inStream.pipe(process.stdout)
inStream.on('data', chunk => {
    process.stdout.write(chunk)
    console.log('写了一次数据')
})

// 这个流是先推再读 不管读没读 都推进去了 不推荐 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

const { Readable } = require('stream')

const inStream = new Readable({
    read(size) {
        const char = String.fromCharCode(this.currentCharCode++)
        this.push(char)
        console.log(`推了${char}`)
        if (this.currentCharCode > 90) {// Z
            this.push(null)
        }
    }
})

inStream.currentCharCode = 65 // A

inStream.pipe(process.stdout)// d

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

const { Duplex } = require("stream")

const inoutStream = new Duplex({
	write(chunk, encoding, callback) {
		console.log(chunk.toString());
		callback();
	},
	read(size) {
		this.push(String.fromCharCode(this.currentCharCode++));
		if (this.currentCharCode > 90) {
			this.push(null);
		}
	}
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

const { Transform } = require("stream");

const upperCaseTr = new Transform({
	transform(chunk, encoding, callback) {
		this.push(chunk.toString().toUpperCase());
		callback();
	}
});
// 将用户输入的字符传到transform流中进行大写处理，再打印输出出来
process.stdin.pipe(upperCaseTr).pipe(process.stdout);