模块化

什么是模块化

模块化是指解决一个简单问题时，自顶向下 逐层把零碎 拆解 成若干 模块 的过程。

对于整个零碎来说，模块是可组合、合成和更换的单元。

编程畛域中的模块化

编程畛域中的模块化，就是恪守固定的规定，把一个大文件拆成独立并相互依赖的多个小模块。

把代码进行模块化拆分的益处：

  • 进步了代码的复用性
  • 进步了代码的可维护性
  • 能够实现按需加载

更多精彩内容，请微信搜寻“前端爱好者“， 戳我 查看 。

模块化标准

模块化标准就是对代码进行模块化的拆分与组合时，须要恪守的那些规定。

例如：

应用什么样的语法格局来援用模块

在模块中应用什么样的语法格局向外裸露成员

模块化标准的益处：大家都恪守同样的模块化标准写代码，升高了沟通的老本，极大不便了各个模块之间的互相调用，利人利己。

模块化实例 -- nodejs

模块 -- a.js

function strParse(str) {    console.log(str)}module.exports = strParse

援用模块 index.js

var strParse = require('./a') strParse('hello world!')

Node.js 中的模块化

官网地址：https://nodejs.cn/api/

Node.js 中依据模块起源的不同，将模块分为了 3 大类，别离是：

  • 全局模块：全局对象和全局变量
  • 外围模块：NodeJs自带的零碎模块
  • 自定义模块：用户创立的每个 .js 文件，都是自定义模块

全局模块

定义：随时随地都能够拜访，不须要援用还蕴含全局对象和全局变量。

外围模块

定义：不须要独自下载，能够间接应用 require() 引入的模块。

常见的外围模块

  • path模块
  • fs模块
  • http模块

自定义模块

定义：本人封装的模块，能够间接应用 require() 引入。

Node.js 常见的外围模块

官网地址：https://nodejs.cn/api/

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'); // truepath.isAbsolute('/baz/..');  // truepath.isAbsolute('qux/');     // falsepath.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

参考文档

  • https://blog.csdn.net/m0_52177571/article/details/124258165
  • https://nodejs.cn/api/documentation.html