牙套

类似bash的大括号展开，在JavaScript中实现。比其他大括号扩展库更安全，完全支持Bash 4.3大括号规范，而不牺牲速度。

请考虑跟随这个项目的作者， Jon Schlinkert,并考虑主演该项目，以展示您的: 心: 和支持。

安装

安装与 npm：

$ npm install --save braces

v3.0.0发布! !

看到 更新日志 获取详细信息。

为什么要用大括号？

大括号模式通过添加匹配特定范围和字符序列的能力，使globs更加强大。

• 准确的 -完全支持 Bash 4.3扩展括号 规范（通过所有Bash大括号测试）
• 快速高效 -开始快，跑得快 良好的可扩展性 随着模式复杂性的增加。
• 有组织的代码库 解析器和编译器在出现边缘情况时易于维护和更新。
• 经过良好测试的 -数以千计的测试断言，并通过所有的Bash， minimatch，和 brace-expansion 单元测试（截至撰写本文的日期）。
• 更安全的 -你不应该担心用户定义攻击性或恶意的大括号模式，这会破坏你的应用程序。brace采取措施防止恶意的regex被用于DDoS攻击(参见 灾难性的回溯）.
• 支持列表 -（又名“集合”） a/{b,c}/d = > ['a/b/d', 'a/c/d']
• 支持序列 -（又名“ranges”） {01..03} = > ['01', '02', '03']
• 支持措施 -（又名“增量”） {2..10..2} = > ['2', '4', '6', '8', '10']
• 支持转义 -防止特殊字符的求值。

用法

主导出是一个接受一个或多个大括号的函数 patterns 和 options。

const braces = require('braces');
// braces(patterns[, options]);

console.log(braces(['{01..05}', '{a..e}']));
//=> ['(0[1-5])', '([a-e])']

console.log(braces(['{01..05}', '{a..e}'], { expand: true }));
//=> ['01', '02', '03', '04', '05', 'a', 'b', 'c', 'd', 'e']

大括号展开与编译

默认情况下，大括号模式被编译成针对创建正则表达式和匹配进行优化的字符串。

编译

console.log(braces('a/{x,y,z}/b'));
//=> ['a/(x|y|z)/b']
console.log(braces(['a/{01..20}/b', 'a/{1..5}/b']));
//=> [ 'a/(0[1-9]|1[0-9]|20)/b', 'a/([1-5])/b' ]

扩大

来启用大括号展开 expand 选项设置为true，或使用 braces.expand () (返回与Bash类似的数组，或者 echo {1..5},或 minimatch）：

console.log(braces('a/{x,y,z}/b', { expand: true }));
//=> ['a/x/b', 'a/y/b', 'a/z/b']

console.log(braces.expand('{01..10}'));
//=> ['01','02','03','04','05','06','07','08','09','10']

列表

展开列表（像Bash的“set”）：

console.log(braces('a/{foo,bar,baz}/*.js'));
//=> ['a/(foo|bar|baz)/*.js']

console.log(braces.expand('a/{foo,bar,baz}/*.js'));
//=> ['a/foo/*.js', 'a/bar/*.js', 'a/baz/*.js']

序列

扩展字符范围（如Bash "sequences"）：

console.log(braces.expand('{1..3}')); // ['1', '2', '3']
console.log(braces.expand('a/{1..3}/b')); // ['a/1/b', 'a/2/b', 'a/3/b']
console.log(braces('{a..c}', { expand: true })); // ['a', 'b', 'c']
console.log(braces('foo/{a..c}', { expand: true })); // ['foo/a', 'foo/b', 'foo/c']

// supports zero-padded ranges
console.log(braces('a/{01..03}/b')); //=> ['a/(0[1-3])/b']
console.log(braces('a/{001..300}/b')); //=> ['a/(0{2}[1-9]|0[1-9][0-9]|[12][0-9]{2}|300)/b']

看到 fill-range 对于所有可用的范围扩展选项。

Steppped范围

步进或增量可以与范围一起使用：

console.log(braces.expand('{2..10..2}'));
//=> ['2', '4', '6', '8', '10']

console.log(braces('{2..10..2}'));
//=> ['(2|4|6|8|10)']

当 .optimize 方法，或 options.optimize 设置为true，则将序列传递给 到正则表达式范围 为扩张。

嵌套

大括号模式可以嵌套。每个扩展字符串的结果不排序，并保持从左到右的顺序。

“扩大”括号

console.log(braces.expand('a{b,c,/{x,y}}/e'));
//=> ['ab/e', 'ac/e', 'a/x/e', 'a/y/e']

console.log(braces.expand('a/{x,{1..5},y}/c'));
//=> ['a/x/c', 'a/1/c', 'a/2/c', 'a/3/c', 'a/4/c', 'a/5/c', 'a/y/c']

“优化”括号

console.log(braces('a{b,c,/{x,y}}/e'));
//=> ['a(b|c|/(x|y))/e']

console.log(braces('a/{x,{1..5},y}/c'));
//=> ['a/(x|([1-5])|y)/c']

逃离

逃离括号

如果出现以下情况，则不会展开或计算大括号模式 左括号或右括号被转义：

console.log(braces.expand('a\\{d,c,b}e'));
//=> ['a{d,c,b}e']

console.log(braces.expand('a{d,c,b\\}e'));
//=> ['a{d,c,b}e']

逃离逗号

大括号内的逗号也可以转义：

console.log(braces.expand('a{b\\,c}d'));
//=> ['a{b,c}d']

console.log(braces.expand('a{d\\,c,b}e'));
//=> ['ad,ce', 'abe']

单项

遵循bash约定，大括号模式在包含单个字符时也不会展开：

console.log(braces.expand('a{b}c'));
//=> ['a{b}c']

选项

options.maxLength

类型： Number

默认的： 10,000

描述限制输入字符串的长度。当输入字符串被生成或者你的应用程序允许用户传递一个字符串时很有用，等等。

console.log(braces('a/{b,c}/d', { maxLength: 3 })); //=> throws an error

options.expand

类型： Boolean

默认的： undefined

描述：生成一个“展开的”大括号模式(或者你可以使用 braces.expand() 方法，它做同样的事情)。

console.log(braces('a/{b,c}/d', { expand: true }));
//=> [ 'a/b/d', 'a/c/d' ]

options.nodupes

类型： Boolean

默认的： undefined

描述：从返回的数组中移除重复项。

options.rangeLimit

类型： Number

默认的： 1000

描述：为防止用户传递恶意模式，当 braces.expand() 是用来或 options.expand 为true，生成的范围将超过 rangeLimit。

你可以自定义 options.rangeLimit 或者设置为 Inifinity 完全禁用它。

例子

// pattern exceeds the "rangeLimit", so it's optimized automatically
console.log(braces.expand('{1..1000}'));
//=> ['([1-9]|[1-9][0-9]{1,2}|1000)']

// pattern does not exceed "rangeLimit", so it's NOT optimized
console.log(braces.expand('{1..100}'));
//=> ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '90', '91', '92', '93', '94', '95', '96', '97', '98', '99', '100']

options.transform

类型： Function

默认的： undefined

描述：自定义范围扩展。

示例：转换非数值

const alpha = braces.expand('x/{a..e}/y', {
  transform(value, index) {
    // When non-numeric values are passed, "value" is a character code.
    return 'foo/' + String.fromCharCode(value) + '-' + index;
  },
});
console.log(alpha);
//=> [ 'x/foo/a-0/y', 'x/foo/b-1/y', 'x/foo/c-2/y', 'x/foo/d-3/y', 'x/foo/e-4/y' ]

示例：转换数值

const numeric = braces.expand('{1..5}', {
  transform(value) {
    // when numeric values are passed, "value" is a number
    return 'foo/' + value * 2;
  },
});
console.log(numeric);
//=> [ 'foo/2', 'foo/4', 'foo/6', 'foo/8', 'foo/10' ]

options.quantifiers

类型： Boolean

默认的： undefined

描述：在正则表达式中，可以使用限定词来指定一个标记可以重复多少次。例如, a{1,3} 将与字母匹配 a 一到三次。

不幸的是，正则表达式量词恰好与 Bash列表

这个 quantifiers 选项告诉大括号何时检测 regex量词 在给定模式中定义的，而不是试图将它们展开为列表。

例子

const braces = require('braces');
console.log(braces('a/b{1,3}/{x,y,z}'));
//=> [ 'a/b(1|3)/(x|y|z)' ]
console.log(braces('a/b{1,3}/{x,y,z}', { quantifiers: true }));
//=> [ 'a/b{1,3}/(x|y|z)' ]
console.log(braces('a/b{1,3}/{x,y,z}', { quantifiers: true, expand: true }));
//=> [ 'a/b{1,3}/x', 'a/b{1,3}/y', 'a/b{1,3}/z' ]

options.keepEscaping

类型： Boolean

默认的： undefined

描述：不要从结果中去掉用于转义的反斜杠。

什么是“支撑扩张”？

大括号展开是unix shell中流行的一种参数展开，用于生成字符串列表，以及与通配符（globs）一起使用时的类正则表达式匹配。

除了“展开”，大括号也用于匹配。换句话说：

• 支架扩张 是为了生成新的列表
• 括号匹配 用于过滤现有列表

{a,b,c}       => a b c
{a,b,c}{1,2}  => a1 a2 b1 b2 c1 c2

{1..9}        => 1 2 3 4 5 6 7 8 9
{4..-4}       => 4 3 2 1 0 -1 -2 -3 -4
{1..20..3}    => 1 4 7 10 13 16 19
{a..j}        => a b c d e f g h i j
{j..a}        => j i h g f e d c b a
{a..z..3}     => a d g j m p s v y

{a,b,c}{1..3}   => a1 a2 a3 b1 b2 b3 c1 c2 c3
foo/{a,b,c}/bar => foo/a/bar foo/b/bar foo/c/bar

foo/1/bar
foo/2/bar
foo/3/bar

baz/1/qux
baz/2/qux
baz/3/qux

foo/1/bar
foo/2/bar
foo/3/bar
baz/1/qux
baz/2/qux
baz/3/qux

{1,2}{3,4}      => (2X2)    => 13 14 23 24
{1,2}{3,4}{5,6} => (2X2X2)  => 135 136 145 146 235 236 245 246

{1,2,3}{4,5,6}{7,8,9} => (3X3X3) => 147 148 149 157 158 159 167 168 169 247 248
                                    249 257 258 259 267 268 269 347 348 349 357
                                    358 359 367 368 369

{1..100}{1..100}         => (100X100)     => 10,000 elements (38.4 kB)
{1..100}{1..100}{1..100} => (100X100X100) => 1,000,000 elements (5.76 MB)

表演

大括号不仅速度快，而且比其他大括号扩展库更准确。

更好的算法

幸运的是，有一个解决方案 “支撑炸弹”问题： 当使用大括号模式进行匹配时，不要将其展开为数组。

相反，将模式转换为优化的正则表达式。这说起来容易做起来难，而且目前只有大括号库能做到这一点。

数字就是证据

随着模式复杂性的增加，Minimatch的速度会呈指数级增长，而大括号则不会。生成以下结果 braces() 和 minimatch.braceExpand(),分别。

更快的算法

当您需要展开时，大括号仍然快得多。

生成以下结果 braces.expand() 和 minimatch.braceExpand()分别)

如果你想自己进行比较，看看 测试/支持/ generate.js。

基准

运行基准测试

安装开发依赖项：

npm i -d && npm benchmark

最新的结果

在不牺牲性能的情况下，牙套更加精确。

● expand - range (expanded)
     braces x 53,167 ops/sec ±0.12% (102 runs sampled)
  minimatch x 11,378 ops/sec ±0.10% (102 runs sampled)
● expand - range (optimized for regex)
     braces x 373,442 ops/sec ±0.04% (100 runs sampled)
  minimatch x 3,262 ops/sec ±0.18% (100 runs sampled)
● expand - nested ranges (expanded)
     braces x 33,921 ops/sec ±0.09% (99 runs sampled)
  minimatch x 10,855 ops/sec ±0.28% (100 runs sampled)
● expand - nested ranges (optimized for regex)
     braces x 287,479 ops/sec ±0.52% (98 runs sampled)
  minimatch x 3,219 ops/sec ±0.28% (101 runs sampled)
● expand - set (expanded)
     braces x 238,243 ops/sec ±0.19% (97 runs sampled)
  minimatch x 538,268 ops/sec ±0.31% (96 runs sampled)
● expand - set (optimized for regex)
     braces x 321,844 ops/sec ±0.10% (97 runs sampled)
  minimatch x 140,600 ops/sec ±0.15% (100 runs sampled)
● expand - nested sets (expanded)
     braces x 165,371 ops/sec ±0.42% (96 runs sampled)
  minimatch x 337,720 ops/sec ±0.28% (100 runs sampled)
● expand - nested sets (optimized for regex)
     braces x 242,948 ops/sec ±0.12% (99 runs sampled)
  minimatch x 87,403 ops/sec ±0.79% (96 runs sampled)

关于

$ npm install && npm test

$ npm install -g verbose/verb#dev verb-generate-readme && verb

贡献者

作者

Jon Schlinkert

• GitHub概要
• Twitter
• LinkedIn的资料

许可证

版权所有©2019 Jon Schlinkert。 根据 麻省理工学院的许可。

该文件由 动词-生成-自述文件， v0.8.0，于2019年4月8日发布。