nodejs交互工具库 -- resolve和semver

nodejs交互工具库系列

库	作用
chalk-pipe	使用更简单的样式字符串创建粉笔样式方案
chalk	正确处理终端字符串样式
Commander.js	完整的 node.js 命令行解决方案
Inquirer.js	一组通用的交互式命令行用户界面。
slash	系统路径符处理
minimist	解析参数选项
dotenv	将环境变量从 .env文件加载到process.env中
dotenv-expand	扩展计算机上已经存在的环境变量
hash-sum	非常快的唯一哈希生成器
deepmerge	深度合并两个或多个对象的可枚举属性。
yaml-front-matter	解析yaml或json
resolve	实现node的 require.resolve()算法，这样就可以异步和同步地使用require.resolve()代表文件
semver	npm的语义版本器
leven	测量两字符串之间的差异<br/>最快的JS实现之一
lru cache	删除最近最少使用的项的缓存对象
portfinder	自动寻找 8000至65535内可用端口号
ora	优雅的终端转轮
envinfo	生成故障排除软件问题(如操作系统、二进制版本、浏览器、已安装语言等)时所需的通用详细信息的报告
memfs	内存文件系统与Node's fs API相同实现
execa	针对人类的流程执行
webpack-merge	用于连接数组和合并对象，从而创建一个新对象
webpack-chain	使用链式API去生成简化webpack版本配置的修改
strip-ansi	从字符串中去掉ANSI转义码
address	获取当前机器的IP, MAC和DNS服务器。
default-gateway	通过对OS路由接口的exec调用获得机器的默认网关
joi	JavaScript最强大的模式描述语言和数据验证器。
fs-extra	添加了未包含在原生fs模块中的文件系统方法，并向fs方法添加了promise支持
Acorn	一个小而快速的JavaScript解析器，完全用JavaScript编写。
zlib.js	ZLIB.js是ZLIB(RFC1950)， DEFLATE(RFC1951)， GZIP(RFC1952)和PKZIP在JavaScript实现。

nodejs交互工具库 -- chalk-pipe和chalk

nodejs交互工具库 -- commander和Inquirer

nodejs交互工具库 -- slash, minimist和dotenv, dotenv-expand

nodejs交互工具库 -- hash-sum, deepmerge和yaml-front-matter

nodejs交互工具库 -- resolve和semver

nodejs交互工具库 -- leven, lru cache和portfinder

nodejs交互工具库 -- ora和envinfo

nodejs交互工具库 -- memfs和execa

nodejs交互工具库 -- webpack-merge和webpack-chain

nodejs交互工具库 -- strip-ansi, address, default-gateway和joi

nodejs交互工具库 -- fs-extra, Acorn和zlib

resolve

实现node的 require.resolve()算法，这样就可以异步和同步地使用require.resolve()代表文件

example

异步解析:

var resolve = require('resolve');
resolve('tap', { basedir: __dirname }, function (err, res) {
    if (err) console.error(err);
    else console.log(res);
});

$ node example/async.js
/home/substack/projects/node-resolve/node_modules/tap/lib/main.js

同步解析:

var resolve = require('resolve');
var res = resolve.sync('tap', { basedir: __dirname });
console.log(res);

$ node example/sync.js
/home/substack/projects/node-resolve/node_modules/tap/lib/main.js

methods

var resolve = require('resolve');

对于同步和异步方法，错误可能具有以下任何一种err.code值

• MODULE_NOT_FOUND: 给定的路径字符串 (id) 无法解析到模块
• INVALID_BASEDIR: 指定的 opts.basedir 不存在，或者不是目录
• INVALID_PACKAGE_MAIN: package.json 遇到了一个无效的 main 属性(如。不是一个字符串)

resolve(id, opts={}, cb)

异步解析模块路径字符串 id 进 cb(err, res [, pkg]), pkg(如果定义)是来自的数据 package.json.

选项有:

• opts.basedir - 要开始解析的目录
• opts.package - package.json 能应用被加载模块的数据
• opts.extensions - 要按顺序搜索的文件扩展名数组
• opts.readFile - 如何异步读取文件
• opts.isFile - 函数异步测试文件是否存在
• opts.isDirectory - 函数异步测试文件是否存在，是否为目录
• opts.realpath - 函数异步地解决到其实际路径的潜在符号链接

• opts.packageFilter(pkg, pkgfile, dir) - 在查看“main”字段之前先转换已解析的package.json内容

  • pkg - package 数据
  • pkgfile - package.json路径
  • dir - 目录包含package.json

• opts.pathFilter(pkg, path, relativePath) - 转换包中的路径

  • pkg - package 数据
  • path -要解析的路径
  • relativePath - 相对于package.json的位置
  • returns - 连接package.json位置的相对路径

• opts.paths - require.paths数组使用，如果没有找到正常 node_modules 递归遍历(可能不用这个)

  对于高级用户, paths 也可以是 opts.paths(request, start, opts) 函数

  • request - 正在解析的导入说明符
  • start - 查找路径
  • getNodeModulesDirs - 一个thunk(无参数函数)，使用标准返回路径 node_modules 解决方案
  • opts - 解决方案选项

• opts.packageIterator(request, start, opts) - 返回可以找到包源的候选路径列表(可能不使用这个)

  • request - 正在解析的导入说明符
  • start - 查找路径
  • getPackageCandidates - 一个thunk(无参数函数)，使用标准返回路径 node_modules 解决方案
  • opts - 解决方案选项
• opts.moduleDirectory - 在其中递归查找模块的目录(或多个目录)。默认的: "node_modules"
• opts.preserveSymlinks - 如果为真，则在解析之前不说basedir解析为实际路径。当使用。执行时，这就是Node解析依赖项的方式 --preserve-symlinks 标记.

默认 opts 值:

{
    paths: [],
    basedir: __dirname,
    extensions: ['.js'],
    readFile: fs.readFile,
    isFile: function isFile(file, cb) {
        fs.stat(file, function (err, stat) {
            if (!err) {
                return cb(null, stat.isFile() || stat.isFIFO());
            }
            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
            return cb(err);
        });
    },
    isDirectory: function isDirectory(dir, cb) {
        fs.stat(dir, function (err, stat) {
            if (!err) {
                return cb(null, stat.isDirectory());
            }
            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
            return cb(err);
        });
    },
    realpath: function realpath(file, cb) {
        var realpath = typeof fs.realpath.native === 'function' ? fs.realpath.native : fs.realpath;
        realpath(file, function (realPathErr, realPath) {
            if (realPathErr && realPathErr.code !== 'ENOENT') cb(realPathErr);
            else cb(null, realPathErr ? file : realPath);
        });
    },
    moduleDirectory: 'node_modules',
    preserveSymlinks: false
}

resolve.sync(id, opts)

同步解析模块路径字符串id，返回结果并在id无法解析时抛出错误。

选项有:

• opts.basedir - 要开始解析的目录
• opts.extensions - 要按顺序搜索的文件扩展名数组
• opts.readFile - 如何同步读取文件
• opts.isFile - 函数同步测试文件是否存在
• opts.isDirectory - 函数同步测试文件是否存在且是否是目录
• opts.realpathSync - 函数同步解析到其实际路径的潜在符号链接

• opts.packageFilter(pkg, pkgfile, dir) - 转换解析后package.json内容，然后查看“main”字段

  • pkg - package 数据
  • pkgfile - package.json路径
  • dir - 目录包含package.json

• opts.pathFilter(pkg, path, relativePath) - 转换包中的路径

  • pkg - package 数据
  • path - 要解析的路径
  • relativePath - 相对于package.json的位置
  • returns - 连接package.json位置的相对路径

• opts.paths - require.paths数组使用，如果没有找到正常 node_modules 递归遍历(可能不用这个)

  对于高级用户, paths 也可以是 opts.paths(request, start, opts) 函数

  • request - 正在解析的导入说明符
  • start - 查找路径
  • getNodeModulesDirs - 一个thunk(无参数函数)，使用标准返回路径 node_modules 解决方案
  • opts - 解决方案选项

• opts.packageIterator(request, start, opts) - 返回可以找到包源的候选路径列表(可能不使用这个)

  • request - 正在解析的导入说明符
  • start - 查找路径
  • getPackageCandidates - 一个thunk(无参数函数)，使用标准返回路径 node_modules 解决方案
  • opts - 解决方案选项
• opts.moduleDirectory - 在其中递归查找模块的目录(或多个目录)。默认的: "node_modules"
• opts.preserveSymlinks - 如果为真，则在解析之前不说basedir解析为实际路径。当使用。执行时，这就是Node解析依赖项的方式 --preserve-symlinks 标记.

default opts values:

{
    paths: [],
    basedir: __dirname,
    extensions: ['.js'],
    readFileSync: fs.readFileSync,
    isFile: function isFile(file) {
        try {
            var stat = fs.statSync(file);
        } catch (e) {
            if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
            throw e;
        }
        return stat.isFile() || stat.isFIFO();
    },
    isDirectory: function isDirectory(dir) {
        try {
            var stat = fs.statSync(dir);
        } catch (e) {
            if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
            throw e;
        }
        return stat.isDirectory();
    },
    realpathSync: function realpathSync(file) {
        try {
            var realpath = typeof fs.realpathSync.native === 'function' ? fs.realpathSync.native : fs.realpathSync;
            return realpath(file);
        } catch (realPathErr) {
            if (realPathErr.code !== 'ENOENT') {
                throw realPathErr;
            }
        }
        return file;
    },
    moduleDirectory: 'node_modules',
    preserveSymlinks: false
}

install

yarn add resolve

参考

基本常用的方法场景就这些了,更完整的用法可以直接查阅文档

resolve

semver

npm的语义版本器

Install

yarn add semver

Usage

作为node模块

const semver = require('semver')

semver.valid('1.2.3') // '1.2.3'
semver.valid('a.b.c') // null
semver.clean('  =v1.2.3   ') // '1.2.3'
semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true
semver.gt('1.2.3', '9.8.7') // false
semver.lt('1.2.3', '9.8.7') // true
semver.minVersion('>=1.0.0') // '1.0.0'
semver.valid(semver.coerce('v2')) // '2.0.0'
semver.valid(semver.coerce('42.6.7.9.3-alpha')) // '42.6.7'

如果希望最小化内存占用，还可以为所关心的函数加载模块。

// load the whole API at once in a single object
const semver = require('semver')

// or just load the bits you need
// all of them listed here, just pick and choose what you want

// classes
const SemVer = require('semver/classes/semver')
const Comparator = require('semver/classes/comparator')
const Range = require('semver/classes/range')

// functions for working with versions
const semverParse = require('semver/functions/parse')
const semverValid = require('semver/functions/valid')
const semverClean = require('semver/functions/clean')
const semverInc = require('semver/functions/inc')
const semverDiff = require('semver/functions/diff')
const semverMajor = require('semver/functions/major')
const semverMinor = require('semver/functions/minor')
const semverPatch = require('semver/functions/patch')
const semverPrerelease = require('semver/functions/prerelease')
const semverCompare = require('semver/functions/compare')
const semverRcompare = require('semver/functions/rcompare')
const semverCompareLoose = require('semver/functions/compare-loose')
const semverCompareBuild = require('semver/functions/compare-build')
const semverSort = require('semver/functions/sort')
const semverRsort = require('semver/functions/rsort')

// low-level comparators between versions
const semverGt = require('semver/functions/gt')
const semverLt = require('semver/functions/lt')
const semverEq = require('semver/functions/eq')
const semverNeq = require('semver/functions/neq')
const semverGte = require('semver/functions/gte')
const semverLte = require('semver/functions/lte')
const semverCmp = require('semver/functions/cmp')
const semverCoerce = require('semver/functions/coerce')

// working with ranges
const semverSatisfies = require('semver/functions/satisfies')
const semverMaxSatisfying = require('semver/ranges/max-satisfying')
const semverMinSatisfying = require('semver/ranges/min-satisfying')
const semverToComparators = require('semver/ranges/to-comparators')
const semverMinVersion = require('semver/ranges/min-version')
const semverValidRange = require('semver/ranges/valid')
const semverOutside = require('semver/ranges/outside')
const semverGtr = require('semver/ranges/gtr')
const semverLtr = require('semver/ranges/ltr')
const semverIntersects = require('semver/ranges/intersects')
const simplifyRange = require('semver/ranges/simplify')
const rangeSubset = require('semver/ranges/subset')

作为命令行工具:

$ semver -h

A JavaScript implementation of the https://semver.org/ specification
Copyright Isaac Z. Schlueter

Usage: semver [options] <version> [<version> [...]]
Prints valid versions sorted by SemVer precedence

Options:
-r --range <range>
        Print versions that match the specified range.

-i --increment [<level>]
        Increment a version by the specified level.  Level can
        be one of: major, minor, patch, premajor, preminor,
        prepatch, or prerelease.  Default level is 'patch'.
        Only one version may be specified.

--preid <identifier>
        Identifier to be used to prefix premajor, preminor,
        prepatch or prerelease version increments.

-l --loose
        Interpret versions and ranges loosely

-p --include-prerelease
        Always include prerelease versions in range matching

-c --coerce
        Coerce a string into SemVer if possible
        (does not imply --loose)

--rtl
        Coerce version strings right to left

--ltr
        Coerce version strings left to right (default)

如果任何有效版本满足所有提供的范围，程序将成功退出，并打印所有满足的版本。
如果没有找到满意的版本，则退出失败。
版本是按升序打印的，因此向实用程序提供多个版本只是对它们进行排序。

Versions

“version”由在https://semver.org/找到的v2.0...。

开头的 “=”或“v”字符被删除并忽略。

Ranges

version range 是一套 comparators 指定满足范围的版本。

comparator由operator和 version组成。原始运算符集合为:

• < 小于
• <= 小于或等于
• > 大于
• >= 大于或等于
• = 平等的。如果没有指定操作符，则假定相等，因此该操作符是可选的，但可以包含其中。

例如, comparator >=1.2.7 将匹配版本1.2.7, 1.2.8, 2.5.3, 和1.3.9, 但不是版本 1.2.6 或1.1.0.

Comparators可以用空格连接成 comparator set,这是由它所包含的所有比较器的交点所满足的。

一个范围由一个或多个比较器集合组成，并由||连接起来。 当且仅当至少一个||分离的比较器集合中的每个比较器的版本满足时，版本匹配一个范围。

例如，范围 >=1.2.7 <1.3.0 将匹配版本 1.2.7, 1.2.8, 和1.2.99, 但不是版本 1.2.6, 1.3.0, 或1.1.0.

范围 1.2.7 || >=1.2.9 <2.0.0 将匹配版本 1.2.7, 1.2.9, 和 1.4.6, 但不是版本 1.2.8 或2.0.0.

Prerelease Tags

如果一个版本有prerelease标签(例如, 1.2.3-alpha.3)，那么只有当至少一个具有相同元组的[major, minor, patch]的comparator也有prerelease标签时，才允许它满足comparator集。

例如，范围 >1.2.3-alpha.3将被允许与版本1.2.3-alpha.7匹配，但它不会满足3.4.5-alpha.9，尽管是3.4.5 alpha.9在技术上“大于”1.2.3-alpha.3根据SemVer排序规则。版本范围只接受 1.2.3版本的预发行标签。版本3.4.5将满足这个范围，因为它没有prerelease标志，而且 3.4.5大于1.2.3-alpha.7。

这种行为的目的是双重的。首先，预发行版本经常更新得非常快，并且包含了许多(根据作者的设计)还不适合公众使用的破坏性更改。因此，默认情况下，它们被排除在范围匹配语义之外。

第二，选择使用预发行版本的用户已经明确表示了使用特定的alpha/beta/rc版本集的意图。通过在范围内包含prerelease标签，用户表明他们意识到了风险。然而，假设他们在下一组预发行版本中选择承担类似的风险仍然是不恰当的。

注意，可以通过将options对象上的 includePrerelease标记设置为执行范围匹配的任何函数来抑制此行为(将所有prerelease版本视为正常版本，以便进行范围匹配)。

Prerelease Identifiers

.inc方法有一个附加的identifier字符串参数，它将附加字符串的值作为预发布标识符:

semver.inc('1.2.3', 'prerelease', 'beta')
// '1.2.4-beta.0'

命令行示例:

$ semver 1.2.3 -i prerelease --preid beta
1.2.4-beta.0

可用于进一步增加:

$ semver 1.2.4-beta.0 -i prerelease
1.2.4-beta.1

Advanced Range Syntax

高级范围语法以确定的方式转换为基本比较器。

高级范围可以像原始比较器一样使用空格或 ||组合。

Hyphen Ranges X.Y.Z - A.B.C

指定包含集。

• 1.2.3 - 2.3.4 := >=1.2.3 <=2.3.4

如果提供的部分版本是包含范围内的第一个版本，那么丢失的部分将被替换为零。

• 1.2 - 2.3.4 := `>=1.2.0 <=2.3.4

如果提供的部分版本作为包含范围中的第二个版本，则接受以提供的元组部件开始的所有版本，但不接受大于提供的元组部件的版本。

• 1.2.3 - 2.3 := >=1.2.3 <2.4.0-0
• 1.2.3 - 2 := >=1.2.3 <3.0.0-0

X-Ranges 1.2.x 1.X 1.2.* *

任何 X、x 或*都可用于“代入”其中一个数值 [major, minor, patch] 元组.

• * := >=0.0.0 (Any version satisfies)
• 1.x := >=1.0.0 <2.0.0-0 (Matching major version)
• 1.2.x := >=1.2.0 <1.3.0-0 (Matching major and minor versions)

部分版本范围被视为x范围，因此特殊字符实际上是可选的。

• "" (empty string) := * := >=0.0.0
• 1 := 1.x.x := >=1.0.0 <2.0.0-0
• 1.2 := 1.2.x := >=1.2.0 <1.3.0-0

Tilde Ranges ~1.2.3 ~1.2 ~1

如果在比较器上指定了次要版本，则允许补丁级更改。如果不允许，允许小级别更改。

• ~1.2.3 := >=1.2.3 <1.(2+1).0 := >=1.2.3 <1.3.0-0
• ~1.2 := >=1.2.0 <1.(2+1).0 := >=1.2.0 <1.3.0-0 (Same as 1.2.x)
• ~1 := >=1.0.0 <(1+1).0.0 := >=1.0.0 <2.0.0-0 (Same as 1.x)
• ~0.2.3 := >=0.2.3 <0.(2+1).0 := >=0.2.3 <0.3.0-0
• ~0.2 := >=0.2.0 <0.(2+1).0 := >=0.2.0 <0.3.0-0 (Same as 0.2.x)
• ~0 := >=0.0.0 <(0+1).0.0 := >=0.0.0 <1.0.0-0 (Same as 0.x)
• ~1.2.3-beta.2 := >=1.2.3-beta.2 <1.3.0-0 注意，1.2.3版本中的prerelease将被允许，如果它们大于或等于beta.2。所以,1.2.3-beta.4是允许的，但1.2.4-beta.2不会，因为它是一个不同 [major, minor, patch]元组的预发行。

Caret Ranges ^1.2.3 ^0.2.5 ^0.0.4

允许不修改 [major, minor, patch] 元组属性中最左边的非零元素更改. 换句话说，这允许 1.0.0及以上版本的补丁和小更新, 0.X >=0.1.0版本的补丁更新, 0.0.X版本没有更新.

许多作者对待0.x就好像 x是主要的“中断-更改”指示器。

当作者可能进行中断更改时，在 0.2.4 和0.3.0 发布管理之间插入符号范围是理想的, 这是一种常见的做法. However, 它假定 0.2.4 和 0.2.5两者之间不会有中断变化. 根据通常观察到的实践，它允许假定是附加的(但不会破坏)更改。

• ^1.2.3 := >=1.2.3 <2.0.0-0
• ^0.2.3 := >=0.2.3 <0.3.0-0
• ^0.0.3 := >=0.0.3 <0.0.4-0
• ^1.2.3-beta.2 := >=1.2.3-beta.2 <2.0.0-0 Note that prereleases in the 1.2.3 version will be allowed, if they are greater than or equal to beta.2. So, 1.2.3-beta.4 would be allowed, but 1.2.4-beta.2 would not, because it is a prerelease of a different [major, minor, patch] tuple.
• ^0.0.3-beta := >=0.0.3-beta <0.0.4-0 Note that prereleases in the 0.0.3 version only will be allowed, if they are greater than or equal to beta. So, 0.0.3-pr.2 would be allowed.

在解析插入符号范围时，缺失的patch值将退化为0，但允许在该值内保持灵活性，即使主版本和次版本都为0。

• ^1.2.x := >=1.2.0 <2.0.0-0
• ^0.0.x := >=0.0.0 <0.1.0-0
• ^0.0 := >=0.0.0 <0.1.0-0

缺失的 minor 和patch 值将退化为零，但也允许在这些值中保持灵活性，即使主版本为零。

• ^1.x := >=1.0.0 <2.0.0-0
• ^0.x := >=0.0.0 <1.0.0-0

Range Grammar

把所有这些放在一起，下面是一个用于范围的Backus-Naur语法，以方便解析器作者:

range-set  ::= range ( logical-or range ) *
logical-or ::= ( ' ' ) * '||' ( ' ' ) *
range      ::= hyphen | simple ( ' ' simple ) * | ''
hyphen     ::= partial ' - ' partial
simple     ::= primitive | partial | tilde | caret
primitive  ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
partial    ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
xr         ::= 'x' | 'X' | '*' | nr
nr         ::= '0' | ['1'-'9'] ( ['0'-'9'] ) *
tilde      ::= '~' partial
caret      ::= '^' partial
qualifier  ::= ( '-' pre )? ( '+' build )?
pre        ::= parts
build      ::= parts
parts      ::= part ( '.' part ) *
part       ::= nr | [-0-9A-Za-z]+

Functions

所有方法和类都采用最终的options对象参数。此对象中的所有选项默认为 false。支持的选项有:

• loose 对不完全有效的semver字符串更加宽容。(当然，任何结果输出都是100%严格兼容的。)由于向后兼容性的原因，如果options参数是一个布尔值而不是一个对象，它将被解释为松散参数。
• includePrerelease设置为禁止从范围中排除预先标记的版本的默认行为，除非它们被显式地选择。

严格模式比较器和范围对于解析的SemVer字符串是严格的。

• valid(v): 返回解析后的版本，如果无效则返回null

• inc(v, release): 返回按发布类型递增的版本 (major, premajor, minor, preminor, patch, prepatch, 或者prerelease), 或null，如果它无效

  • premajor 在一个调用中会将版本提升到下一个主版本并降低到主版本的预发行版. preminor, 和prepatch 以同样的方式工作。
  • 如果从非预发行版本调用 , prerelease 和 prepatch一样的运作. 它增加补丁版本，然后制作预发行版。如果输入的版本已经是预发行版本，它就会增加它。
• prerelease(v): 返回预发行组件的数组，如果不存在，则返回null. 例如: prerelease('1.2.3-alpha.1') -> ['alpha', 1]
• major(v): 返回主版本号。
• minor(v): 返回副版本号。
• patch(v): 返回补丁版本号。
• intersects(r1, r2, loose): 如果两个提供的范围或比较器相交，则返回true。
• parse(v): 尝试将字符串解析为语义版本，返回 SemVer 对象或者 null.

Comparison

• gt(v1, v2): v1 > v2
• gte(v1, v2): v1 >= v2
• lt(v1, v2): v1 < v2
• lte(v1, v2): v1 <= v2
• eq(v1, v2): v1 == v2 如果它们在逻辑上是等价的，即使它们不是完全相同的字符串。您已经知道如何比较字符串。
• neq(v1, v2): v1 != v2 eq的反面.
• cmp(v1, comparator, v2): 传入一个比较字符串，它将调用上面对应的函数. "===" 和 "!==" 做简单的字符串比较，但是为了完整起见，这里包含了。如果提供了无效的比较字符串，则引发。
• compare(v1, v2): 如果v1 == v2返回0，如果v1大于1，如果v2大于-1。如果传递给Array.sort()，则按升序排序。
• rcompare(v1, v2): 是compare的反义词。传递到的版本数组按降序排序 Array.sort().
• compareBuild(v1, v2): 与比较相同，但在两个版本相同时考虑构建。如果传递给Array.sort()，则按升序排序。v2更大。如果传递给 Array.sort()，则按升序排序。
• diff(v1, v2): 按发布类型返回两个版本之间的差异 (major, premajor, minor, preminor, patch, prepatch, 或者prerelease), 或如果版本相同，则为null。

Comparators

• intersects(comparator): 如果比较器相交，返回true

Ranges

• validRange(range): 返回有效范围，如果无效则返回null
• satisfies(version, range): 如果版本满足范围，则返回true。
• maxSatisfying(versions, range): 返回列表中满足范围的最高版本，如果没有一个版本满足范围，则返回null
• minSatisfying(versions, range): 返回列表中满足范围的最低版本，如果没有一个版本满足范围，则返回null。
• minVersion(range): 返回可能与给定范围匹配的最低版本。
• gtr(version, range): 如果版本大于范围内所有可能的版本，则返回true。
• ltr(version, range): 如果版本小于范围内所有可能的版本，则返回true。
• outside(version, range, hilo): 如果版本在高方向或低方向超出范围的范围，则返回true。hilo参数必须是字符串 '>'或'<'。(这是gtr和ltr调用的函数。)
• intersects(range): 如果任何一个范围比较器相交，返回true
• simplifyRange(versions, range): 返回一个“简化”范围，该范围匹配版本列表中指定的相同项。注意，它并不保证在所有情况下都匹配相同的版本，只对提供的一组版本进行匹配。这在通过编程方式将多个版本与||结合在一起生成范围时非常有用，可以为用户提供一些更符合人体工程学的东西。如果提供的范围的字符串长度小于生成的范围，则返回该范围。
• subset(subRange, superRange): 如果子程序范围完全包含在超范围范围内，则返回true。

注意，由于范围可能是非连续的，版本可能不大于范围、小于范围或满足范围!例如,范围 1.2 <1.2.9 || >2.0.0从1.2.9到2.0.0会有一个洞,所以 1.2.10版本不会大于范围(因为2.0.1满足,较高),也不到范围(因为1.2.8满足,这是低),而且它也不满足。

如果您想知道某个版本是否满足某个范围，可以使用satisfies(version, range)函数。

Coercion

• coerce(version, options): 如果可能，强制字符串semver

这样做的目的是提供一个非常宽容的非semver字符串到semver的转换。它查找字符串中的第一个数字，并消耗至少满足部分分配器的所有其余字符(例如., 1, 1.2, 1.2.3) 最大允许长度(256个字符)。较长的版本被简单地截断 (4.6.3.9.2-alpha2 变成4.6.3). 所有周围的文本都被忽略了 (v3.4 replaces v3.3.1 变成3.4.0). 只有缺少数字的文本不能强制 (version one 无效). 考虑强制的任何semver组件的最大长度是16个字符;较长的组件将被忽略 (10000000000000000.4.7.4 变成4.7.4). 任何semver组件的最大值为 Number.MAX_SAFE_INTEGER || (2**53 - 1); 更高值组件无效 (9999999999999999.4.7.4 可能是无效的).

如果 options.rtl标记已经设置了, 然后coerce 返回最右端的可压缩性元组，不与更长的可压缩性元组共享结束索引. 例如, 1.2.3.4 会返回 2.3.4 在 rtl 模式, 而不是4.0.0. 1.2.3/4 会返回 4.0.0, 因为4不是任何其他重叠的SemVer元组的一部分。

Clean

• clean(version): 如果可能的话，将字符串清除为有效的semver

这将返回一个干净和修剪过的semver版本。如果提供的版本无效，将返回null。这对范围不适用。

ex.

• s.clean(' = v 2.1.5foo'): null
• s.clean(' = v 2.1.5foo', { loose: true }): '2.1.5-foo'
• s.clean(' = v 2.1.5-foo'): null
• s.clean(' = v 2.1.5-foo', { loose: true }): '2.1.5-foo'
• s.clean('=v2.1.5'): '2.1.5'
• s.clean(' =v2.1.5'): 2.1.5
• s.clean(' 2.1.5 '): '2.1.5'
• s.clean('~1.0.0'): null

Exported Modules

如果您对打包和树抖动问题很敏感，那么可以只使用这个semver实用程序的一部分。主要的require('semver')导出使用getter函数惰性地加载所使用的API的部分。

以下模块可供选择:

• require('semver')
• require('semver/classes')
• require('semver/classes/comparator')
• require('semver/classes/range')
• require('semver/classes/semver')
• require('semver/functions/clean')
• require('semver/functions/cmp')
• require('semver/functions/coerce')
• require('semver/functions/compare')
• require('semver/functions/compare-build')
• require('semver/functions/compare-loose')
• require('semver/functions/diff')
• require('semver/functions/eq')
• require('semver/functions/gt')
• require('semver/functions/gte')
• require('semver/functions/inc')
• require('semver/functions/lt')
• require('semver/functions/lte')
• require('semver/functions/major')
• require('semver/functions/minor')
• require('semver/functions/neq')
• require('semver/functions/parse')
• require('semver/functions/patch')
• require('semver/functions/prerelease')
• require('semver/functions/rcompare')
• require('semver/functions/rsort')
• require('semver/functions/satisfies')
• require('semver/functions/sort')
• require('semver/functions/valid')
• require('semver/ranges/gtr')
• require('semver/ranges/intersects')
• require('semver/ranges/ltr')
• require('semver/ranges/max-satisfying')
• require('semver/ranges/min-satisfying')
• require('semver/ranges/min-version')
• require('semver/ranges/outside')
• require('semver/ranges/to-comparators')
• require('semver/ranges/valid')

参考

基本常用的方法场景就这些了,更完整的用法可以直接查阅文档

node-semver