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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
|
'use strict';
const common = require('../common');
const assert = require('assert');
const stream = require('stream');
let state = 0;
/*
What you do
const stream = new stream.Transform({
transform: function transformCallback(chunk, _, next) {
// part 1
this.push(chunk);
//part 2
next();
},
final: function endCallback(done) {
// part 1
process.nextTick(function () {
// part 2
done();
});
},
flush: function flushCallback(done) {
// part 1
process.nextTick(function () {
// part 2
done();
});
}
});
t.on('data', dataListener);
t.on('end', endListener);
t.on('finish', finishListener);
t.write(1);
t.write(4);
t.end(7, endMethodCallback);
The order things are called
1. transformCallback part 1
2. dataListener
3. transformCallback part 2
4. transformCallback part 1
5. dataListener
6. transformCallback part 2
7. transformCallback part 1
8. dataListener
9. transformCallback part 2
10. finalCallback part 1
11. finalCallback part 2
12. flushCallback part 1
13. finishListener
14. endMethodCallback
15. flushCallback part 2
16. endListener
*/
const t = new stream.Transform({
objectMode: true,
transform: common.mustCall(function(chunk, _, next) {
// transformCallback part 1
assert.strictEqual(++state, chunk);
this.push(state);
// transformCallback part 2
assert.strictEqual(++state, chunk + 2);
process.nextTick(next);
}, 3),
final: common.mustCall(function(done) {
state++;
// finalCallback part 1
assert.strictEqual(state, 10);
state++;
// finalCallback part 2
assert.strictEqual(state, 11);
done();
}, 1),
flush: common.mustCall(function(done) {
state++;
// fluchCallback part 1
assert.strictEqual(state, 12);
process.nextTick(function() {
state++;
// fluchCallback part 2
assert.strictEqual(state, 15);
done();
});
}, 1)
});
t.on('finish', common.mustCall(function() {
state++;
// finishListener
assert.strictEqual(state, 13);
}, 1));
t.on('end', common.mustCall(function() {
state++;
// endEvent
assert.strictEqual(state, 16);
}, 1));
t.on('data', common.mustCall(function(d) {
// dataListener
assert.strictEqual(++state, d + 1);
}, 3));
t.write(1);
t.write(4);
t.end(7, common.mustCall(function() {
state++;
// endMethodCallback
assert.strictEqual(state, 14);
}, 1));
|
