node

‎

1. 全局对象
2. 代码执行优先级
3. 模块导入
4. 模块加载
- 4.1. 文件模块优先级
- 4.2. 文件夹加载优先级
  - 4.2.1. 包（文件夹）下的入口文件优先级
  - 4.2.2. 包加载优先级
5. 核心模块的简单使用
- 5.1. events

1 全局对象

global

console.log(global);// Object [global] {
//     global: [Circular],
//         clearInterval: [Function: clearInterval],
//     clearTimeout: [Function: clearTimeout],
//     setInterval: [Function: setInterval],
//     setTimeout: [Function: setTimeout] { [Symbol(util.promisify.custom)]: [Function] },
//     queueMicrotask: [Function: queueMicrotask],
//     clearImmediate: [Function: clearImmediate],
//     setImmediate: [Function: setImmediate] {
//         [Symbol(util.promisify.custom)]: [Function]
//     }
// }

console

console.log(console)// {
//     log: [Function: bound consoleCall],
//     warn: [Function: bound consoleCall],
//     dir: [Function: bound consoleCall],
//     time: [Function: bound consoleCall],
//     timeEnd: [Function: bound consoleCall],
//     timeLog: [Function: bound consoleCall],
//     trace: [Function: bound consoleCall],
//     assert: [Function: bound consoleCall],
//     clear: [Function: bound consoleCall],
//     count: [Function: bound consoleCall],
//     countReset: [Function: bound consoleCall],
//     group: [Function: bound consoleCall],
//     groupEnd: [Function: bound consoleCall],
//     table: [Function: bound consoleCall],
//     debug: [Function: bound consoleCall],
//     info: [Function: bound consoleCall],
//     dirxml: [Function: bound consoleCall],
//     error: [Function: bound consoleCall],
//     groupCollapsed: [Function: bound consoleCall],
//     Console: [Function: Console],
//     profile: [Function: profile],
//     profileEnd: [Function: profileEnd],
//     timeStamp: [Function: timeStamp],
//     context: [Function: context],
//     [Symbol(kBindStreamsEager)]: [Function: bound ],
//     [Symbol(kBindStreamsLazy)]: [Function: bound ],
//     [Symbol(kBindProperties)]: [Function: bound ],
//     [Symbol(kWriteToConsole)]: [Function: bound ],
//     [Symbol(kGetInspectOptions)]: [Function: bound ],
//     [Symbol(kFormatForStdout)]: [Function: bound ],
//     [Symbol(kFormatForStderr)]: [Function: bound ]
// }

exports, require, module, __filename, __dirname（模块参数）

console.log(arguments.callee + '');// function (exports, require, module, __filename, __dirname) {
//     console.log(arguments.callee + '');

2 代码执行优先级

同步代码优先，例子如下

// 代码执行优先级
setTimeout(function () {setTimeout(function () {console.log('time out');}, 0);new Promise(resolve => {setTimeout(function () {console.log('start in Promise');}, 1);console.log('beg');resolve();console.log('end');setTimeout(function () {console.log('end in Promise');}, 0);}).then(() => {console.log('finish');});console.log('不要调皮');
}, 100);// beg
// end
// 不要调皮
// finish
// time out
// start in Promise
// end in Promise

3 模块导入

同步导入，module.exports = exports ==> true

{ test }  » tree                      
.
├── index.js
└── test.js

./index.js

console.log("index.js");

./test.js

require('./index.js');
console.log('test.js');

output: 导入之后才会继续执行代码

index.js
test.js

4 模块加载

4.1 文件模块优先级

这里只考虑 .js .json文件路径加载

文件结构

.
├── a.js
├── a.json
├── b.json
└── test.js

a.js

module.exports = "js文件优先";

a.json

{"s": "json文件优先"
}

b.json

{"main" : "json 文件也支持省略扩展名的方式加载"
}

test.js

// 测试js文件先加载
console.log(require('./a'));
// 证明json也可以加载
console.log(require('./b'));

output

默认文件加载js先于json文件

js文件优先
{ main: 'json 文件也支持省略扩展名的方式加载' }

4.2 文件夹加载优先级

4.2.1 包（文件夹）下的入口文件优先级

文件结构

.
├── a
│   ├── index.js
│   ├── m.js
│   └── package.json
├── b
│   ├── index.js
│   └── package.json
├── c
│   └── index.js
└── test.js

./a

index.js

module.exports = "index.js文件优先";

m.js

module.exports = "package.json文件优先";

package.json

{"name": "a","version": "1.0.0","main" : "m.js"
}

./b

index.js

module.exports = "./b/index.js文件优先";

package.json

{"name": "a","version": "1.0.0"
}

./c

index.js

module.exports = "index.js支持默认加载";

./test.js

// 优先加载packagae.json文件
console.log(require('./a'));
// packagae.json中main属性指定加载某文件
console.log(require('./b'));
// index.js也支持默认加载
console.log(require('./c'));

output

package.json文件中有main优先于index.js文件

package.json文件优先
./b/index.js文件优先
index.js支持默认加载

4.2.2 包加载优先级

路径加载

文件结构

.
├── fs
│   └── index.js
└── test.js

./fs/index.js

module.exports = "路径加载优先级高";

./fs/test.js

// 加载核心模块
console.log(require('fs'));
// 第三方模块
console.log(require('./fs'));

output

路径加载优先级高于核心模块

{appendFile: [Function: appendFile],appendFileSync: [Function: appendFileSync],access: [Function: access],accessSync: [Function: accessSync],chown: [Function: chown],promises: [Getter]..........//还有很多
}
路径加载优先级高

非路径加载

文件结构

.
├── node_modules
│   ├── fs
│   │   └── index.js
│   └── tts
│       └── index.js
└── test.js

./node_nodules./fs/index.js

module.exports = "./node_nodules./fs";

./node_nodules./tts/index.js

module.exports = "./node_nodules./tts";

./test.js

// 判断第三方模块和核心模块的优先级
console.log(require('fs'));
// 第三方模块可以加载
console.log(require('tts'));

output

核心模块加载优先于第三方模块(node_modules)

{appendFile: [Function: appendFile],appendFileSync: [Function: appendFileSync],access: [Function: access],......//很多promises: [Getter]
}
./node_nodules./tts

第三方模块查找过程（非路径查找）

文件结构

.
├── a
│   ├── b
│   │   ├── c
│   │   │   ├── node_modules
│   │   │   │   └── tts1
│   │   │   │       └── index.js
│   │   │   └── t.js
│   │   └── node_modules
│   │       └── tts2
│   │           └── index.js
│   └── node_modules
│       └── tts3
│           └── index.js
└── node_modules└── tts4└── index.js

module.paths 中列表的顺序查找

递归向上级目录查找

['C:\\a\\b\\c\\node_modules','C:\\a\\b\\node_modules','C:\\a\\node_modules','C:\\node_modules'
]

5 核心模块的简单使用

5.1 events

继承了事件类，自身不用实现事件类

const events = require('events');class Teacher extends events {constructor(sec = 2000) {super();this.sec = sec;this.doing();}doing() {let cnt = 0;setInterval(() => {++cnt;this.emit('class', {cnt});}, this.sec);}
}const t = new Teacher();
t.on('class', function (args) {console.log('time to class:', args.cnt);
});