Nodejs中路径处理模块path如何使用？
时间： 16:19:49
&&&& 阅读：192
&&&& 评论：
&&&& 收藏：0
在中，path是个使用频率很高，但却让人又爱又恨的模块。部分因为文档说的不够清晰，部分因为接口的平台差异性。
将path的接口按照用途归类，仔细琢磨琢磨，也就没那么费解了。
/文件名/扩展名
．&获取路径：path.dirname(filepath)
．&获取文件名：path.basename(filepath)
．&获取扩展名：path.extname(filepath)
例子如下：
&path = require(’path’);&filepath = ’/tmp/demo/js/test.js’;
//&输出：/tmp/demo/jsconsole.log( path.dirname(filepath) );
严格意义上来说，path.basename(filepath)&只是输出路径的最后一部分，并不会判断是否文件名。
但大部分时候，我们可以用它来作为简易的“获取文件名“的方法。
&path = require(’path’);
//&输出：test.jsconsole.log( path.basename(’/tmp/demo/js/test.js’) );
//&输出：testconsole.log( path.basename(’/tmp/demo/js/test/’) );
//&输出：testconsole.log( path.basename(’/tmp/demo/js/test’) );
如果只想获取文件名，单不包括文件扩展呢？可以用上第二个参数。
//&输出：test.log( path.basename(’/tmp/demo/js/test.js’, ’.js’) );
简单的例子如下：
&path = require(’path’);&filepath = ’/tmp/demo/js/test.js’;
//&输出：.jsconsole.log( path.extname(filepath) );
更详细的规则是如下：（假设&path.basename(filepath) === B&）
．&从B的最后一个&&开始截取，直到最后一个字符。
．&如果B中不存在&&，或者B的第一个字符就是&&，那么返回空字符串。
直接看&&的例子
.extname(’index.html’)// returns ’.html’
.extname(’index.coffee.md’)// returns ’.md’
.extname(’index.’)// returns ’.’
.extname(’index’)// returns ’’
.extname(’.index’)// returns ’’
． path.join([...paths])
． path.resolve([...paths])
把&&拼起来，然后再normalize一下。这句话反正我自己看着也是莫名其妙，可以参考下面的伪代码定义。
例子如下：
var path =&(’path’);
//&输出&’/foo/bar/baz/asdf’
path.join(’/foo’, ’bar’, ’baz/asdf’, ’quux’, ’..’);
path定义的伪代码如下：
module.exports.join =&(){
&paths = Array.prototye.slice.call(arguments, 0);
&.normalize( paths.join(’/’) );
这个接口的说明有点啰嗦。你可以想象现在你在shell下面，从左到右运行一遍&&命令，最终获取的绝对路径/文件名，就是这个接口所返回的结果了。
比如&&可以看成下面命令的结果
cd /foo/barcd ./baz
更多对比例子如下：
&path = require(’path’);
//&假设当前工作路径是&/Users/a/Documents/git-code/nodejs-learning-guide/examples/-node-path
//&输出&/Users/a/Documents/git-code/nodejs-learning-guide/examples/-node-pathconsole.log( path.resolve(’’) )
//&输出&/Users/a/Documents/git-code/nodejs-learning-guide/examples/-node-pathconsole.log( path.resolve(’.’) )
//&输出&/foo/bar/bazconsole.log( path.resolve(’/foo/bar’, ’./baz’) );
//&输出&/foo/bar/bazconsole.log( path.resolve(’/foo/bar’, ’./baz/’) );
//&输出&/tmp/fileconsole.log( path.resolve(’/foo/bar’, ’/tmp/file/’) );
//&输出&/Users/a/Documents/git-code/nodejs-learning-guide/examples/-node-path/www/js/mod.jsconsole.log( path.resolve(’www’, ’js/upload’, ’../mod.js’) );
path.parse(path)
从官方文档的描述来看，path.normalize(filepath)&应该是比较简单的一个API，不过用起来总是觉得没底。
为什么呢？API说明过于简略了，包括如下：
．&如果路径为空，返回&&，相当于当前的工作路径。
．&将对路径中重复的路径分隔符（比如linux下的&&)合并为一个。
．&对路径中的&&、&&进行处理。（类似于shell里的&&）
．&如果路径最后有&&，那么保留该&&。
感觉stackoverflow上一个兄弟对这个API的解释更实在，&&。
In other words, path.normalize is "What is the shortest path I can take that will take me to the same place as the input"
代码示例如下。建议读者把代码拷贝出来运行下，看下实际效果。
&path = require(’path’);&filepath = ’/tmp/demo/js/test.js’;
&index = 0;
&compare =&(desc, callback){
console.log(’[用例%d]：%s’, ++index, desc);
callback();
console.log(’\\n’);
compare(’路径为空’,&(){
console.log( path.normalize(’’) );
compare(’路径结尾是否带/’,&(){
//&输出&/tmp/demo/js/upload
console.log( path.normalize(’/tmp/demo/js/upload’) );
// /tmp/demo/js/upload/
console.log( path.normalize(’/tmp/demo/js/upload/’) );
compare(’重复的/’,&(){
//&输出&/tmp/demo/js
console.log( path.normalize(’/tmp/demo//js’) );
compare(’路径带..’,&(){
//&输出&/tmp/demo/js
console.log( path.normalize(’/tmp/demo/js/upload/..’) );
compare(’相对路径’,&(){
//&输出&demo/js/upload/
console.log( path.normalize(’./demo/js/upload/’) );
//&输出&demo/js/upload/
console.log( path.normalize(’demo/js/upload/’) );
compare(’不常用边界’,&(){
//&输出&..
console.log( path.normalize(’./..’) );
//&输出&..
console.log( path.normalize(’..’) );
//&输出&../
console.log( path.normalize(’../’) );
console.log( path.normalize(’/../’) );
console.log( path.normalize(’/..’) );
感兴趣的可以看下&path.normalize(filepath)&的node源码如下：&
． path.format(pathObject)：将pathObject的root、dir、base、name、ext属性，按照一定的规则，组合成一个文件路径。
． path.parse(filepath)：path.format()方法的反向操作。
我们先来看看官网对相关属性的说明。
首先是linux下
┌─────────────────────┬────────────┐
│ dir │ base │
├──────┬ ├──────┬─────┤
│ root │ │ name │ ext │" / home/user/dir / file .txt "
└──────┴──────────────┴──────┴─────┘
(&spaces in the "" line should&&ignored -- they are purely&&formatting)
然后是windows下
┌─────────────────────┬────────────┐
│ dir │ base │
├──────┬ ├──────┬─────┤
│ root │ │ name │ ext │" C:\\ path\\dir \\ file .txt "
└──────┴──────────────┴──────┴─────┘
(&spaces in the "" line should&&ignored -- they are purely&&formatting)
阅读相关API文档说明后发现，path.format(pathObject)中，pathObject的配置属性是可以进一步精简的。
根据接口的描述来看，以下两者是等价的。
．&&vs&&：两者可以互相替换，区别在于，路径拼接时，&&后不会自动加&，而&&会。
．&&vs&&：两者可以互相替换。
&path = require(’path’);
&p1 = path.format({
root: ’/tmp/’,
base: ’hello.js’
});console.log( p1 ); //&输出&/tmp/hello.js
&p2 = path.format({
dir: ’/tmp’,
name: ’hello’,
ext: ’.js’
});console.log( p2 ); //&输出&/tmp/hello.js
path.format(pathObject)&的反向操作，直接上官网例子。
四个属性，对于使用者是挺便利的，不过path.format(pathObject)&中也是四个配置属性，就有点容易搞混。
path.parse(’/home/user/dir/file.txt’)// returns// {// root : "/",// dir : "/home/user/dir",// base : "file.txt",// ext : ".txt",// name : "file"// }
接口：path.relative(from, to)
描述：从&&路径，到&&路径的相对路径。
．&如果&&、&&指向同个路径，那么，返回空字符串。
．&如果&&、&&中任一者为空，那么，返回当前工作路径。
&path = require(’path’);
&p1 = path.relative(’/data/orandea/test/aaa’, ’/data/orandea/impl/bbb’);console.log(p1); //&输出&"../../impl/bbb"
&p2 = path.relative(’/data/demo’, ’/data/demo’);console.log(p2); //&输出&""
&p3 = path.relative(’/data/demo’, ’’);console.log(p3); //&输出&"../../Users/a/Documents/git-code/nodejs-learning-guide/examples/-node-path"
以下属性、接口，都跟平台的具体实现相关。也就是说，同样的属性、接口，在不同平台上的表现不同。
． path.posix：path相关属性、接口的linux实现。
． path.win32：path相关属性、接口的win32实现。
． path.sep：路径分隔符。在linux上是&&，在windows上是&&。
． path.delimiter：path设置的分割符。linux上是&&，windows上是&&。
注意，当使用&path.win32&相关接口时，参数同样可以使用&&做分隔符，但接口返回值的分割符只会是&&。
直接来例子更直观。
& path.win32.(’/tmp’, ’fuck’)’\\\\tmp\\\\fuck’
& path.win32.sep’\\\\’
& path.win32.(’\\tmp’, ’demo’)’\\\\tmp\\\\demo’
& path.win32.(’/tmp’, ’demo’)’\\\\tmp\\\\demo’
linux系统例子：
console.log(process.env.PATH)
// ’/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin’
process.env.PATH.split(path.delimiter)
// returns [’/usr/bin’, ’/bin’, ’/usr/sbin’, ’/sbin’, ’/usr/local/bin’]
windows系统例子：
console.log(process.env.PATH)// ’C:\\Windows\\system32;C:\\WC:\\Program Files\\node\\’
process.env.PATH.split(path.delimiter)
// returns [’C:\\\\Windows\\\\system32’, ’C:\\\\Windows’, ’C:\\\\Program Files\\\\node\\\\’]
文章来源：chyingp
加入时间：
&&关注此人&&发短消息
“jiangjie190”关注的人------（）
“jiangjie190”的粉丝们------（）
&&国之画&&&& &&&&chrome插件
版权所有 京ICP备号-2
迷上了代码！NodeJs中通过-g安装的全局模块是怎么回事？ - 知乎4被浏览2721分享邀请回答$ npm -g install the_module_name
而如果一个包是使用在项目里面的话，则使用本地安装，这样避免了不同项目对不同版本的包之间的相互依赖的问题，如下$ npm install the_module_name
52 条评论分享收藏感谢收起12 条评论分享收藏感谢收起与世界分享知识、经验和见解nodejs中组建a/b可以互相调用？ - 知乎5被浏览3334分享邀请回答module.exports = Writer // [1]
var fs = require("graceful-fs")
, inherits = require("inherits")
, rimraf = require("rimraf")
, mkdir = require("mkdirp")
, path = require("path")
, umask = process.platform === "win32" ? 0 : process.umask()
, getType = require("./get-type.js")
, Abstract = require("./abstract.js")
// Must do this *before* loading the child classes
inherits(Writer, Abstract) // [2]
Writer.dirmode = 0777 & (~umask) // [3]
Writer.filemode = 0666 & (~umask) // [4]
var DirWriter = require("./dir-writer.js")
, LinkWriter = require("./link-writer.js")
, FileWriter = require("./file-writer.js") // [5]
, ProxyWriter = require("./proxy-writer.js")
Node.js的执行大概是这样的：第一行 [1] 就定义了exports执行到 [2] 的时候，会让Writer继承所有Abstract的prototype执行到 [5] 的时候，会试图去load file-writer.js，在load file-writer.js的时候，会跑回来load writer.js，也就是在writer.js的exports。writer.js的exports已经在第一行定义了是Writer，那么这时候在file-writer.js拿到的Writer就是writer.js执行到 [5] 这一行时的Writer，这时候Writer就是执行了[2] [3] [4]的样子。Node.js对于circular ref的处理只是很基本的，如果引用失败，会给一个空object，所以要等到真正用的时候才会出错。所以Node.js一般尽量避免circular ref，除非你很清楚自己在做什么(比如Isaac这种大牛)，推荐用dependency injection1添加评论分享收藏感谢收起与世界分享知识、经验和见解给一个本地路径
nodejs 怎么读取这个路径下的所有文件
把这些文件罗列出来 - CNode技术社区
这家伙很懒，什么个性签名都没有留下。
给一个本地路径,nodejs 怎么读取这个路径下的所有文件
,把这些文件罗列出来.
或者用html5 罗列出来。求指导
查 fs 对象下的 API 就好了
诶没办法 ，自己写了一个递归。诶 这
用到了这几个api
var fs1 = require(‘fs’);
stats = fs1.lstatSync(filePath);//查看文件属性
fs1.readdir(）;罗列文件夹下面文件，
需要的可以参考下
var fs = require('fs'),
stdin = process.stdin,
stdout = process.
var stats = [];
fs.readdir(process.cwd(), function(err, files) {
console.log(' ');
if (!files.length) {
return console.log(' \033[31m No files to show!\033[39m\n');
function file(i) {
var filename = files[i];
fs.stat(__dirname + '/' + filename, function(err, stat) {
stats[i] =
if (stat.isDirectory()) {
console.log(' ' + i + ' \033[36m' + filename + '/\033[39m');
console.log(' ' + i + ' \033[90m' + filename + '\033[39m');
if (i == files.length) {
function read() {
console.log(' ');
stdout.write(' \033[33mEnter your choice : \033[39m');
stdin.resume();
stdin.setEncoding('utf8');
stdin.on('data', option);
function option(data) {
var filename = files[Number(data)];
if (!files[Number(data)]) {
stdout.write(' \033[mEnter your choice : \033[39m');
} else if (stats[Number(data)].isDirectory()) {
fs.readdir(__dirname + '/' + filename, function(err, files) {
console.log(' ');
console.log(' (' + files.length + 'files)');
files.forEach(function(file) {
console.log(' - ' + file);
console.log(' ');
stdin.pause();
fs.readFile(__dirname + '/' + filename, 'utf8', function(err, data) {
console.log(' ');
console.log('\033[90m' + data.replace(/(.*) /g, ' $1') + '\033[39m');
《了不起的node.js》 上的代码
这书还不赖
var fs = require(“fs”);
var path = “d:\WinRAR”;
function explorer(path){
fs.readdir(path, function(err,files){
console.log(“error:\n”+err);
files.forEach(function(file){
fs.stat(path+&\&+file+’’,function(err,stat){
console.log(err);
if(stat.isDirectory()){
console.log(path+&\\&+file+&\\&);
explorer(path+&\\&+file);
console.log(path+&\\&+file);
explorer(path);
我自己写的 贴进来格式有点变化，markdown还不太会用
5楼正解~！
这个也不错！
var fs = require(‘fs’),
util = require(‘util’),
path = ‘D:/mp3’;
function explorer(path){
fs.readdir(path, function(err, files){
//err 为错误 , files 文件名列表包含文件夹与文件
console.log('error:\n' + err);
files.forEach(function(file){
fs.stat(path + '/' + file, function(err, stat){
if(err){console.log(err);}
if(stat.isDirectory()){
// 如果是文件夹遍历
explorer(path + '/' + file);
// 读出所有的文件
console.log('文件名:' + path + '/' + file);
explorer(path);
ndir模块做了这件事
fs.readdir
可以参考npm模块的实现,
glob可以使用与shell模式匹配一样的方式遍历文件目录树
var glob = require(&glob&)
// options is optional
glob(&**&, options, function (err, files) {
或者自己用递归的方式实现
const fs = require('fs')
let files = []
function ScanDir(path) {
let that = this
if (fs.statSync(path).isFile()) {
return files.push(path)
fs.readdirSync(path).forEach(function (file) {
ScanDir.call(that, path + '/' + file)
} catch (e) {
ScanDir(process.cwd())
console.log(files)
CNode 社区为国内最专业的 Node.js 开源技术社区，致力于 Node.js 的技术研究。
服务器赞助商为
，存储赞助商为
，由提供应用性能服务。
新手搭建 Node.js 服务器，推荐使用无需备案的Node.js模块加载详解
作者：Jack Yao
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了Node.js模块加载详解,本文讲解了加载核心模块、加载文件模块、加载目录模块、从文件加载模块等内容,需要的朋友可以参考下
JavaScript是世界上使用频率最高的编程语言之一，它是Web世界的通用语言，被所有浏览器所使用。JavaScript的诞生要追溯到Netscape那个时代，它的核心内容被仓促的开发出来，用以对抗Microsoft，参与当时白热化的浏览器大战。由于过早的发布，无可避免的造成了它的一些不太好的特性。
尽管它的开发时间很短，但是JavaScript依然具备了很多强大的特性，不过，每个脚本共享一个全局命名空间这个特性除外。
一旦Web页面加载了JavaScript代码，它就会被注入到全局命名空间，会和其他所有已加载的脚本公用同一个地址空间，这会导致很多安全问题，冲突，以及一些常见问题，让bug即难以跟踪又很难解决。
不过谢天谢地，Node为服务器端JavaScript定了一些规范，还实现了CommonJS的模块标准，在这个标准里，每个模块有自己的上下文，和其他模块相区分。这意味着，模块不会污染全局作用域，因为根本就没有所谓的全局作用域，模块之间也不会相互干扰。
本章，我们将了解几种不同的模块以及如何加载它们。
把代码拆分成一系列定义良好的模块可以帮你掌控你的应用程序，下面我们将学习如何创建和使用你自己的模块。
了解Node如何加载模块
Node里,可以通过文件路径来引用模块，也可以通过模块名引用，如果用名称引用非核心模块，Node最终会把模块名影射到对应的模块文件路径。而那些包含了核心函数的核心模块，会在Node启动时被预先加载。
非核心模块包括使用NPM（Node Package Manager）安装的第三方模块，以及你或你的同事创建的本地模块。
每个被当前脚本导入的模块都会向程序员暴露一组公开API，使用模块前，需要用require函数来导入它，像这样：
var module = require(‘module_name')
上面的代码会导入一个名为module_name的模块，它可能是个核心模块，也可以是用NPM安装的模块，require函数返回一个包含模块所有公共API的对象。随模块的不同，返回的对象可能是任何JavaScript值，可以是一个函数，也可以是个包含了一系列属性（函数，数组或者任何JavaScript对象）的对象。
CommonJS模块系统是Node下文件间共享对象和函数的唯一方式。对于一个很复杂的程序，你应该把一些类，对象或者函数重构成一系列良好定义的可重用模块。对于模块使用者来说，模块仅对外暴露出那些你指定的代码。
在下面的例子里你将会了解到，在Node里文件和模块是一一对应的，我们创建了一个叫circle.js的文件，它仅对外导出了Circle构造函数。
function Circle(x, y, r) {
&&&&&& function r_squared() {
&&&&&&&&&&&&& return Math.pow(r, 2);
&&&&&& function area() {
&&&&&&&&&&&&& return Math.PI * r_squared();
&&&&&& return {area: area};
module.exports = C
代码里最重要的是最后一行，它定义了模块对外导出了什么内容。module是个特殊的变量，它代表当前模块自身，而module.exports是模块对外导出的对象，它可以是任何对象，在这个例子里，我们把Circle的构造函数导出了，这样模块使用者就可以用这个模块来创建Circle实例。
你也可以导出一些复杂的对象，module.exports被初始化成一个空对象，你把任何你想暴露给外界的内容，作为module.exports对象的属性来导出。比如，你设计了一个模块，它对外暴露了一组函数：
&&&&&&&&&&&&&&&&& function printA() {
&&&&&&&& console.log('A');
function printB() {
&&&&&&&& console.log('B');
function printC() {
&&&&&&&& console.log('C');
module.exports.printA = printA;
module.exports.printB = printB;
module.exports.pi = Math.PI;
这个模块导出了两个函数（printA和printB）和一个数字(pi)，调用代码看起来像这样：
var myModule2 = require('./myModule2');
myModule2.printA(); // -& A
myModule2.printB(); // -& B
console.log(myModule2.pi); // -& 3.793
前面提到过，你可以使用require函数来加载模块，不用担心在代码里调用require会影响全局命名空间，因为Node里就没有全局命名空间这个概念。如果模块存在且没有任何语法或初始化错误，require函数就会返回这个模块对象，你还可以这个对象赋值给任何一个局部变量。
模块有几种不同的类型，大概可以分为核心模块，本地模块和通过NPM安装的第三方模块，根据模块的类型，有几种引用模块的方式，下面我们就来了解下这些知识。
加载核心模块
Node有一些被编译到二进制文件里的模块，被称为核心模块，它们不能通过路径来引用，只能用模块名。核心模块拥有最高的加载优先级，即使已经有了一个同名的第三方模块，核心模块也会被优先加载。
比如，如果你想加载和使用http核心模块，可以这样做：
&&&&&&&& var http = require('http');
这将返回一个包含了http模块对象，它包含了Node API文档里定义的那些htpp模块的API。
加载文件模块
你也可以使用绝对路径从文件系统里加载模块：
var myModule = require('/home/pedro/my_modules/my_module');
也可以用一个基于当前文件的相对路径：
var myModule = require('../my_modules/my_module');
var myModule2 = require('./lib/my_module_2');
注意上面的代码，你可以省略文件名的扩展名，如果Node找不到这个文件，会尝试在文件名后加上js后缀再次查找（译者注：其实除了js，还会查找json和node，具体可以看官网文档），因此，如果在当前目录下存在一个叫my_module.js的文件，会有下面两种加载方式：
var myModule = require('./my_module');
var myModule = require('./my_module.js');
加载目录模块
你还可以使用目录的路径来加载模块：
var myModule = require('./myModuleDir');
Node会假定这个目录是个模块包，并尝试在这个目录下搜索包定义文件package.json。
如果没找到，Node会假设包的入口点是index.js文件（译者注：除了index.js还会查找index.node，.node文件是Node的二进制扩展包，具体见官方文档），以上面代码为例，Node会尝试查找./myModuleDir/index.js文件。
反之，如果找到了package.json文件，Node会尝试解析它，并查找包定义里的main属性，然后把main属性的值当作入口点的相对路径。以本例来说，如果package.json定义如下：
&&&&&&&&&&&&&&&&&& {
&&&&&&&&&&&&&&&&&&&&&&&&&&& "name" : "myModule",
&&&&&&&&&&&&&&&&&&&&&&&&&&& "main" : "./lib/myModule.js"
&&&&&&&&&&&&&&&&&& }
Node就会尝试加载./myModuleDir/lib/myModule.js文件
从node_modules目录加载
如果require函数的参数不是相对路径，也不是核心模块名，Node会在当前目录的node_modules子目录下查找，比如下面的代码，Node会尝试查找文件./node_modules/myModule.js:
var myModule = require('myModule.js');
如果没找到，Node会继续在上级目录的node_modules文件夹下查找，如果还没找到就继续向上层目录查找，直到找到对应的模块或者到达根目录。
你可以使用这个特性来管理node_modules目录的内容或模块，不过最好还是把模块的管理任务交给NPM（见第一章），本地node_modules目录是NPM安装模块的默认位置，这个设计把Node和NPM关联在了一起。通常，作为开发人员不必太关心这个特性，你可以简单的使用NPM安装，更新和删除包，它会帮你维护node_modules目录
模块在第一次成功加载后会被缓存起来，就是说，如果模块名被解析到同一个文件路径，那么每次调用require(‘myModule')都确切地会返回同一个模块。
比如，有一个叫my_module.js的模块，包含下面的内容：
console.log('module my_module initializing...');
module.exports = function() {
&&&&&&&& console.log('Hi!');
console.log('my_module initialized.');
然后用下面的代码加载这个模块：
var myModuleInstance1 = require('./my_module');
它会产生下面的输出：
module my_module initializing...
my_module initialized
如果我们两次导入它：
var myModuleInstance1 = require('./my_module');
var myModuleInstance2 = require('./my_module');
输出依然是：
module my_module initializing...
my_module initialized
也就是说，模块的初始化代码仅执行了一次。当你构建自己的模块时，如果模块的初始化代码里含有可能产生副作用的代码，一定要特别注意这个特性。
Node取消了JavaScript的默认全局作用域，转而采用CommonJS模块系统，这样你可以更好的组织你的代码，也因此避免了很多安全问题和bug。可以使用require函数来加载核心模块，第三方模块，或从文件及目录加载你自己的模块
还可以用相对路径或者绝对路径来加载非核心模块，如果把模块放到了node_modules目录下或者对于用NPM安装的模块，你还可以直接使用模块名来加载。
建议读者把官方文档的模块章节阅读一遍，个人感觉比作者讲得更清晰明了，而且还附加了一个非常具有代表性的例子，对理解Node模块加载会很有很大帮助。下面把那个例子也引用过来：
用require(X) 加载路径Y下的模块
1. 如果X是核心模块,
&& a. 加载并返回核心模块
&& b. 结束
2. 如果X以 './' or '/' or '../ 开始'
&& a. LOAD_AS_FILE(Y + X)
&& b. LOAD_AS_DIRECTORY(Y + X)
3. LOAD_NODE_MODULES(X, dirname(Y))
4. 抛出异常："not found"
LOAD_AS_FILE(X)
1. 如果X是个文件，把 X作为JavaScript 脚本加载，加载完毕后结束
2. 如果X.js是个文件，把X.js 作为JavaScript 脚本加载，加载完毕后结束
3. 如果X.node是个文件，把X.node 作为Node二进制插件加载，加载完毕后结束
LOAD_AS_DIRECTORY(X)
1. 如果 X/package.json文件存在,
&& a. 解析X/package.json, 并查找 "main"字段.
&& b. 另M = X + (main字段的值)
&& c. LOAD_AS_FILE(M)
2. 如果X/index.js文件存在，把 X/index.js作为JavaScript 脚本加载，加载完毕后结束
3. 如果X/index.node文件存在，把load X/index.node作为Node二进制插件加载，加载完毕后结束
LOAD_NODE_MODULES(X, START)
1. 另DIRS=NODE_MODULES_PATHS(START)
2. 对DIRS下的每个目录DIR做如下操作:
&& a. LOAD_AS_FILE(DIR/X)
&& b. LOAD_AS_DIRECTORY(DIR/X)
NODE_MODULES_PATHS(START)
1. 另PARTS = path split(START)
2. 另ROOT = index of first instance of "node_modules" in PARTS, or 0
3. 另I = count of PARTS - 1
4. 另DIRS = []
5. while I & ROOT,
&& a. 如果 PARTS[I] = "node_modules" 则继续后续操作，否则下次循环
&& c. DIR = path join(PARTS[0 .. I] + "node_modules")
&& b. DIRS = DIRS + DIR
&& c. 另I = I - 1
6. 返回DIRS
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具