关于javascript:nodejs交互工具库-resolve和semver

nodejs 交互工具库系列

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

nodejs 交互工具库 — commander 和 Inquirer

nodejs 交互工具库 — slash, minimist 和 dotenv

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

nodejs 交互工具库 — resolve 和 semver

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