braces

Expansión de llaves al estilo Bash, implementada en JavaScript. Más segura que otras librerías de expansión de llaves, con soporte completo para la especificación de llaves de Bash 4.3, sin sacrificar velocidad.

Considera seguir al autor de este proyecto, Jon Schlinkert, y considera darle una estrella al proyecto para mostrar tu ❤️ y apoyo.

Instalación

Instalar con npm:

$ npm install --save braces

¡¡Lanzada la v3.0.0!!

Consulta el registro de cambios para más detalles.

¿Por qué usar braces?

Los patrones de llaves hacen que los globs sean más potentes al añadir la capacidad de coincidir con rangos y secuencias específicas de caracteres.

• Preciso - compatibilidad completa con la especificación de Bash 4.3 Brace Expansion (supera todas las pruebas de llaves de Bash)
• rápido y eficiente - Arranca rápido, se ejecuta rápido y escala bien a medida que los patrones aumentan en complejidad.
• Base de código organizada - El analizador y el compilador son fáciles de mantener y actualizar cuando surgen casos límite.
• Bien probado - Miles de aserciones de prueba, y supera todas las pruebas unitarias de Bash, minimatch y brace-expansion (a la fecha en que se escribió esto).
• Más seguro - No deberías tener que preocuparte por que los usuarios definan patrones de llaves agresivos o maliciosos que puedan romper tu aplicación. Braces toma medidas para prevenir expresiones regulares maliciosas que puedan usarse para ataques DDoS (consulta catastrophic backtracking).
• Admite listas - (también conocidas como "conjuntos") a/{b,c}/d => ['a/b/d', 'a/c/d']
• Admite secuencias - (también conocidas como "rangos") {01..03} => ['01', '02', '03']
• Admite pasos - (también conocidos como "incrementos") {2..10..2} => ['2', '4', '6', '8', '10']
• Admite escape - Para evitar la evaluación de caracteres especiales.

Uso

La exportación principal es una función que toma uno o más patterns de llaves y 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']

Expansión de llaves vs. compilación

Por defecto, los patrones de llaves se compilan en cadenas que están optimizadas para crear expresiones regulares y realizar coincidencias.

Compilado

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' ]

Expandido

Habilite la expansión de llaves estableciendo la opción expand en true, o usando braces.expand() (devuelve un array similar a lo que esperaría de Bash, o echo {1..5}, o 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']

Listas

Expandir listas (como los "sets" de Bash):

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']

Secuencias

Expande rangos de caracteres (como las "secuencias" de Bash):

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']

Consulta fill-range para ver todas las opciones disponibles de expansión de rangos.

Rangos con pasos

Los pasos, o incrementos, pueden usarse con rangos:

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

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

Cuando se usa el método .optimize, o options.optimize se establece en true, las secuencias se pasan a to-regex-range para su expansión.

Anidamiento

Los patrones de llaves pueden estar anidados. Los resultados de cada cadena expandida no se ordenan, y se preserva el orden de izquierda a derecha.

Llaves "expandidas"

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']

Llaves "optimizadas"

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']

Escape

Escapar llaves

Un patrón de llaves no se expandirá ni evaluará si se escapa la llave de apertura o la de cierre:

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']

Escapando comas

Las comas dentro de llaves también pueden escaparse:

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

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

Elementos individuales

Siguiendo las convenciones de bash, un patrón de llaves tampoco se expande cuando contiene un solo carácter:

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

Opciones

options.maxLength

Tipo: Number

Predeterminado: 10,000

Descripción: Limita la longitud de la cadena de entrada. Útil cuando la cadena de entrada se genera o cuando tu aplicación permite a los usuarios pasar una cadena, etcétera.

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

options.expand

Tipo: Boolean

Predeterminado: undefined

Descripción: Genera un patrón de llaves "expandido" (alternativamente puedes usar el método braces.expand(), que hace lo mismo).

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

options.nodupes

Tipo: Boolean

Predeterminado: undefined

Descripción: Elimina los duplicados del array devuelto.

options.rangeLimit

Tipo: Number

Predeterminado: 1000

Descripción: Para evitar que los usuarios pasen patrones maliciosos, se lanza un error cuando se usa braces.expand() o cuando options.expand es true y el rango generado excederá el rangeLimit.

Puedes personalizar options.rangeLimit o establecerlo en Inifinity para deshabilitar esto por completo.

Ejemplos