braces

Expansion d'accolades à la Bash, implémentée en JavaScript. Plus sûre que les autres bibliothèques d'expansion d'accolades, avec un support complet de la spécification des accolades de Bash 4.3, sans sacrifier la vitesse.

Pensez à suivre l'auteur de ce projet, Jon Schlinkert, et envisagez de mettre une étoile au projet pour montrer votre ❤️ et votre soutien.

Installation

Installez avec npm:

$ npm install --save braces

v3.0.0 publiée !!

Consultez le changelog pour plus de détails.

Pourquoi utiliser braces ?

Les motifs à accolades rendent les globs plus puissants en ajoutant la capacité de correspondre à des plages et des séquences de caractères spécifiques.

Précis - prise en charge complète de la spécification Bash 4.3 Brace Expansion (réussit tous les tests de accolades de Bash)
rapide et performant - Démarre vite, s'exécute vite et passe bien à l'échelle à mesure que les motifs gagnent en complexité.
Base de code organisée - Le parseur et le compilateur sont faciles à maintenir et à mettre à jour lorsque des cas limites surviennent.
Bien testé - Des milliers d'assertions de test, et réussit tous les tests unitaires de Bash, minimatch et brace-expansion (à la date de rédaction de ce document).
Plus sûr - Vous ne devriez pas avoir à vous soucier des utilisateurs définissant des motifs à accolades agressifs ou malveillants qui pourraient casser votre application. Braces prend des mesures pour empêcher les regex malveillantes pouvant être utilisées pour des attaques DDoS (voir catastrophic backtracking).
Prend en charge les listes - (aussi appelées « ensembles ») a/{b,c}/d => ['a/b/d', 'a/c/d']
Prend en charge les séquences - (aussi appelées « plages ») {01..03} => ['01', '02', '03']
Prend en charge les pas - (aussi appelés « incréments ») {2..10..2} => ['2', '4', '6', '8', '10']
Prend en charge l'échappement - Pour empêcher l'évaluation de caractères spéciaux.

Utilisation

L'export principal est une fonction qui prend un ou plusieurs patterns d'accolades et des 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']

Expansion d'accolades vs. compilation

Par défaut, les motifs d'accolades sont compilés en chaînes optimisées pour créer des expressions régulières et effectuer des correspondances.

Compilé

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

Étendu

Activez l'expansion des accolades en définissant l'option expand sur true, ou en utilisant braces.expand() (renvoie un tableau similaire à ce que vous attendriez de Bash, ou echo {1..5}, ou 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']

Listes

Développer les listes (comme les « 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']

Séquences

Développe des plages de caractères (comme les « séquences » 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']

Voir fill-range pour toutes les options d'expansion de plages disponibles.

Plages avec pas

Des pas, ou incréments, peuvent être utilisés avec les plages :

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

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

Lorsque la méthode .optimize est utilisée, ou que options.optimize est défini sur true, les séquences sont transmises à to-regex-range pour expansion.

Imbrication

Les motifs d'accolades peuvent être imbriqués. Les résultats de chaque chaîne développée ne sont pas triés, et l'ordre de gauche à droite est préservé.

Accolades « développées »

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

Accolades « optimisées »

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

Échappement

Échappement des accolades

Un motif d'accolades ne sera ni développé ni évalué si l'accolade ouvrante ou fermante est échappée :

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

Échappement des virgules

Les virgules à l'intérieur des accolades peuvent également être échappées :

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

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

Éléments uniques

Suivant les conventions de bash, un motif d'accolades n'est pas non plus développé lorsqu'il contient un seul caractère :

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

Options

options.maxLength

Type : Number

Default : 10,000

Description : Limite la longueur de la chaîne d'entrée. Utile lorsque la chaîne d'entrée est générée ou lorsque votre application permet aux utilisateurs de passer une chaîne, etc.

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

options.expand

Type : Boolean

Default : undefined

Description : Génère un motif d'accolades « étendu » (vous pouvez également utiliser la méthode braces.expand(), qui fait la même chose).

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

options.nodupes