braces

Espansione delle graffe in stile Bash, implementata in JavaScript. Più sicura di altre librerie di espansione delle graffe, con supporto completo alla specifica delle graffe di Bash 4.3, senza sacrificare la velocità.

Ti invitiamo a seguire l'autore di questo progetto, Jon Schlinkert, e a mettere una stella al progetto per mostrare il tuo ❤️ e il tuo supporto.

Installazione

Installa con npm:

$ npm install --save braces

v3.0.0 Rilasciata!!

Consulta il changelog per i dettagli.

Perché usare braces?

I pattern brace rendono i glob più potenti aggiungendo la capacità di corrispondere a intervalli e sequenze specifiche di caratteri.

Preciso - supporto completo per la specifica Bash 4.3 Brace Expansion (supera tutti i test dei braces di Bash)
veloce e performante - Si avvia rapidamente, viene eseguito velocemente e scala bene man mano che i pattern aumentano in complessità.
Code base organizzata - Il parser e il compilatore sono facili da mantenere e aggiornare quando emergono casi limite.
Ben testato - Migliaia di asserzioni di test, e supera tutti i test unitari di Bash, minimatch e brace-expansion (alla data in cui questo è stato scritto).
Più sicuro - Non dovresti preoccuparti che gli utenti definiscano pattern brace aggressivi o malevoli che possano compromettere la tua applicazione. Braces adotta misure per prevenire regex malevole che possono essere utilizzate per attacchi DDoS (vedi catastrophic backtracking).
Supporta le liste - (dette anche "set") a/{b,c}/d => ['a/b/d', 'a/c/d']
Supporta le sequenze - (dette anche "range") {01..03} => ['01', '02', '03']
Supporta i passi - (detti anche "incrementi") {2..10..2} => ['2', '4', '6', '8', '10']
Supporta l'escaping - Per prevenire la valutazione di caratteri speciali.

Utilizzo

L'export principale è una funzione che accetta uno o più patterns brace e 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']

Espansione delle graffe vs. compilazione

Per impostazione predefinita, i pattern con graffe vengono compilati in stringhe ottimizzate per la creazione di espressioni regolari e il matching.

Compilato

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

Expanded

Abilita l'espansione delle graffe impostando l'opzione expand su true, oppure utilizzando braces.expand() (restituisce un array simile a quello che ti aspetteresti da 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']

Liste

Espandi le liste (come i "set" di 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']

Sequenze

Espandi intervalli di caratteri (come le "sequenze" di 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']

Vedi fill-range per tutte le opzioni di espansione degli intervalli disponibili.

Intervalli a passi

I passi, o incrementi, possono essere utilizzati con gli intervalli:

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

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

Quando viene utilizzato il metodo .optimize, o options.optimize è impostato su true, le sequenze vengono passate a to-regex-range per l'espansione.

Annidamento

I pattern con parentesi graffe possono essere annidati. I risultati di ogni stringa espansa non sono ordinati e l'ordine da sinistra a destra viene preservato.

Parentesi graffe "espanse"

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

Parentesi "ottimizzate"

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

Escaping

Escaping delle parentesi graffe

Un pattern con parentesi graffe non verrà espanso o valutato se la parentesi graffa di apertura o quella di chiusura è sottoposta a escape:

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

Escape delle virgole

Anche le virgole all'interno delle parentesi graffe possono essere sottoposte a escape:

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

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

Elementi singoli

Seguendo le convenzioni di bash, un pattern con parentesi graffe non viene espanso nemmeno quando contiene un singolo carattere:

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

Opzioni

options.maxLength

Tipo: Number

Predefinito: 10,000

Descrizione: Limita la lunghezza della stringa di input. Utile quando la stringa di input è generata o quando l'applicazione consente agli utenti di passare una stringa, eccetera.

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

options.expand

Tipo: Boolean

Predefinito: undefined

Descrizione: Genera un pattern con parentesi graffe "espanso" (in alternativa puoi usare il metodo braces.expand(), che fa la stessa cosa).

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

options.nodupes