模块化
什么是模块化
模块化是指解决一个复杂问题时,自顶向下 逐层把系统 拆解 成若干 模块 的过程。
对于整个系统来说,模块是可组合、分解和更换的单元。
编程领域中的模块化
编程领域中的模块化,就是遵守固定的规则,把一个大文件拆成独立并互相依赖的多个小模块。
把代码进行模块化拆分的好处:
- 提高了代码的复用性
- 提高了代码的可维护性
- 可以实现按需加载
更多精彩内容,请微信搜索“前端爱好者
“, 戳我 查看 。
模块化规范
模块化规范就是对代码进行模块化的拆分与组合时,需要遵守的那些规则。
例如:
使用什么样的语法格式来引用模块
在模块中使用什么样的语法格式向外暴露成员
模块化规范的好处:大家都遵守同样的模块化规范写代码,降低了沟通的成本,极大方便了各个模块之间的相互调用,利人利己。
模块化实例 -- nodejs
模块 -- a.js
function strParse(str) {
console.log(str)
}
module.exports = strParse
引用模块 index.js
var strParse = require('./a')
strParse('hello world!')
Node.js 中的模块化
Node.js 中根据模块来源的不同,将模块分为了 3 大类,分别是:
- 全局模块:全局对象和全局变量
- 核心模块:NodeJs自带的系统模块
- 自定义模块:用户创建的每个 .js 文件,都是自定义模块
全局模块
定义:随时随地都可以访问,不需要引用还包含全局对象和全局变量。
核心模块
定义:不需要单独下载,可以直接使用 require() 引入的模块。
常见的核心模块
- path模块
- fs模块
- http模块
自定义模块
定义:自己封装的模块,可以直接使用 require() 引入。
Node.js 常见的核心模块
path模块
地址:https://nodejs.cn/api/path.html
API归纳:
- 路径相关
- 文件相关
- 路径解析
路径相关
- normalize:用于规范化给定的path
- join:将所有给定的path片段连接在一起
- resolve:解析为绝对路径
- isAbsolute:检查当前path是否为绝对路径
path.normalize(path)
地址:https://nodejs.cn/api/path.html#pathnormalizepath
path.normalize() 方法规范化给定的 path,解析 '..' 和 '.' 片段。
- path
<string>
- 返回: <boolean>
当找到多个连续的路径片段分隔符(例如 POSIX 上的 / 和 Windows 上的 \ 或 /)时,则它们将被平台特定路径片段分隔符(POSIX 上的 / 和 Windows 上的 \)的单个实例替换。 保留尾随的分隔符。
如果 path 是零长度字符串,则返回 '.',表示当前工作目录。
例如,在 POSIX 上:
path.normalize('/foo/bar//baz/asdf/quux/..');
// Returns: '/foo/bar/baz/asdf'
在 Windows 上:
path.normalize('C:\\temp\\\\foo\\bar\\..\\');
// Returns: 'C:\\temp\\foo\\'
var path = require('path');
var pathStr = path.normalize("a/b//c///d\\\e")
console.log(pathStr) // a\b\c\d\e
path.join([...paths])
地址:https://nodejs.cn/api/path.html#pathjoinpaths
path.join() 方法使用特定于平台的分隔符作为定界符将所有给定的 path 片段连接在一起,然后规范化生成的路径。
- ...paths
<string>
路径或路径片段的序列 - 返回: <string>
零长度的 path 片段被忽略。 如果连接的路径字符串是零长度字符串,则将返回 '.',表示当前工作目录。
var {join} = require('path')
console.log(join('a','b','/c','//d')) // a\b\c\d
console.log(join('a','/b','../c','/d')) //a\c\d
或者
path.join('/foo', 'bar', 'baz/asdf', 'quux', '..');
// Returns: '/foo/bar/baz/asdf'
path.join('foo', {}, 'bar');
// Throws 'TypeError: Path must be a string. Received {}'
如果任何路径片段不是字符串,则抛出 TypeError。
path.resolve([...paths])
path.resolve() 方法将路径或路径片段的序列解析为绝对路径。
- ...paths
<string>
路径或路径片段的序列 - 返回:
<string>
给定的路径序列从右到左处理,每个后续的 path 会被追加到前面,直到构建绝对路径。 例如,给定路径段的顺序: /foo、/bar、baz,调用 path.resolve('/foo', '/bar', 'baz') 将返回 /bar/baz,因为 'baz' 不是绝对路径,但 '/bar' + '/' + 'baz' 是。
如果在处理完所有给定的 path 片段之后,还没有生成绝对路径,则使用当前工作目录。
生成的路径被规范化,并删除尾部斜杠(除非路径解析为根目录)。
零长度的 path 片段被忽略。
如果没有传入 path 片段,则 path.resolve() 将返回当前工作目录的绝对路径。
var {resolve} = require('path')
console.log(resolve('a/b/c'))
或者
path.resolve('/foo/bar', './baz');
// Returns: '/foo/bar/baz'
path.resolve('/foo/bar', '/tmp/file/');
// Returns: '/tmp/file'
path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif');
// If the current working directory is /home/myself/node,
// this returns '/home/myself/node/wwwroot/static_files/gif/image.gif'
path.isAbsolute(path)
地址:https://nodejs.cn/api/path.html#pathisabsolutepath
path.isAbsolute() 方法确定 path 是否为绝对路径。
- path
<string>
- 返回: <boolean>
如果给定的 path 是零长度字符串,则将返回 false。
例如,在 POSIX 上:
var {isAbsolute} = require('path')
console.log(isAbsolute('./a/b/c'))
console.log(isAbsolute('/a/b/c'))
或者
path.isAbsolute('/foo/bar'); // true
path.isAbsolute('/baz/..'); // true
path.isAbsolute('qux/'); // false
path.isAbsolute('.'); // false
文件相关
- basename:返回路径中最后一部分的文件名
- extname:返回路径最后文件名的扩展名
- dirname:返回path路径中的目录名
path.basename(path[, suffix])
地址:https://nodejs.cn/api/path.html#pathbasenamepath-suffix
path.basename() 方法返回 path 的最后一部分,类似于 Unix basename 命令。 忽略尾随 目录分隔符。
- path
<string>
- suffix
<string>
要删除的可选后缀 - 返回:
<string>
path.basename('/foo/bar/baz/asdf/quux.html');
// Returns: 'quux.html'
path.basename('/foo/bar/baz/asdf/quux.html', '.html');
// Returns: 'quux'
var {basename} = require('path')
console.log(basename("/a/b/c.txt")) // c.txt
path.extname(path)
地址:https://nodejs.cn/api/path.html#pathextnamepath
path.extname() 方法返回 path 的扩展名,即 path 的最后一部分中从最后一次出现的 .(句点)字符到字符串的结尾。 如果 path 的最后一部分中没有 .,或者除了 path 的基本名称(参见 path.basename())的第一个字符之外没有 . 个字符,则返回空字符串。
- path
<string>
- 返回:
<string>
path.extname('index.html');
// Returns: '.html'
path.extname('index.coffee.md');
// Returns: '.md'
path.extname('index.');
// Returns: '.'
path.extname('index');
// Returns: ''
path.extname('.index');
// Returns: ''
path.extname('.index.md');
// Returns: '.md'
var {extname} = require('path')
console.log(extname("/a/b/c.txt.exe")) // .exe
path.dirname(path)
地址:https://nodejs.cn/api/path.html#pathdirnamepath
path.dirname() 方法返回 path 的目录名,类似于 Unix dirname 命令。 尾随的目录分隔符被忽略,见 path.sep。
- path
<string>
- 返回:
<string>
path.dirname('/foo/bar/baz/asdf/quux');
// Returns: '/foo/bar/baz/asdf'
var {dirname} = require('path')
console.log(dirname('/a/b/c.txt')) // /a/b
路径解析
- parse:返回一个对象,其属性表示 path 的有效元素
- format:把对象转为一个路径字符串
path.parse(path)
地址:https://nodejs.cn/api/path.html#pathparsepath
path.parse() 方法返回一个对象,其属性表示 path 的重要元素。 尾随的目录分隔符被忽略,见 path.sep。
返回的对象将具有以下属性:
- dir
<string>
- root
<string>
- base
<string>
- name
<string>
- ext
<string>
path.parse('/home/user/dir/file.txt');
// Returns:
// { root: '/',
// dir: '/home/user/dir',
// base: 'file.txt',
// ext: '.txt',
// name: 'file' }
var {parse} = require('path')
console.log(parse('/a/b/c.txt')) // { root: '/', dir: '/a/b', base: 'c.txt', ext: '.txt', name: 'c' }
如果 path 不是字符串,则抛出 TypeError。
path.format(pathObject)
地址:https://nodejs.cn/api/path.html#pathformatpathobject
path.format() 方法从对象返回路径字符串。 这与 path.parse() 相反。
pathObject <Object>
任何具有以下属性的 JavaScript 对象:
- dir
<string>
- root
<string>
- base
<string>
- name
<string>
- ext
<string>
- 返回:
<string>
当向 pathObject 提供属性时,存在一个属性优先于另一个属性的组合:
- 如果提供 pathObject.dir,则忽略 pathObject.root
- 如果 pathObject.base 存在,则忽略 pathObject.ext 和 pathObject.name
// If `dir`, `root` and `base` are provided,
// `${dir}${path.sep}${base}`
// will be returned. `root` is ignored.
path.format({
root: '/ignored',
dir: '/home/user/dir',
base: 'file.txt',
});
// Returns: '/home/user/dir/file.txt'
// `root` will be used if `dir` is not specified.
// If only `root` is provided or `dir` is equal to `root` then the
// platform separator will not be included. `ext` will be ignored.
path.format({
root: '/',
base: 'file.txt',
ext: 'ignored',
});
// Returns: '/file.txt'
// `name` + `ext` will be used if `base` is not specified.
path.format({
root: '/',
name: 'file',
ext: '.txt',
});
// Returns: '/file.txt'
// The dot will be added if it is not specified in `ext`.
path.format({
root: '/',
name: 'file',
ext: 'txt',
});
// Returns: '/file.txt'
var {format} = require("path")
var pathObj = {
root: '/',
dir: '/hello/world',
base: 'demo.txt',
ext: '.txt',
name: 'demo'
}
console.log(format(pathObj)) ///hello/world\demo.txt
参考文档
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用
。你还可以使用@
来通知其他用户。