braces

Bash-ähnliche Brace-Expansion, implementiert in JavaScript. Sicherer als andere Brace-Expansion-Bibliotheken, mit vollständiger Unterstützung der Bash-4.3-Braces-Spezifikation, ohne Geschwindigkeitseinbußen.

Bitte erwägen Sie, dem Autor dieses Projekts, Jon Schlinkert, zu folgen, und geben Sie dem Projekt einen Stern, um Ihr ❤️ zu zeigen und es zu unterstützen.

Installation

Installation mit npm:

$ npm install --save braces

v3.0.0 veröffentlicht!!

Details finden Sie im Changelog.

Warum braces verwenden?

Brace-Muster machen Globs leistungsfähiger, indem sie die Möglichkeit hinzufügen, bestimmte Bereiche und Zeichenfolgen abzugleichen.

Präzise – vollständige Unterstützung der Spezifikation Bash 4.3 Brace Expansion (besteht alle Bash-Brace-Tests)
schnell und leistungsfähig – startet schnell, läuft schnell und skaliert gut, wenn Muster komplexer werden.
Organisierte Codebasis – Parser und Compiler sind einfach zu warten und zu aktualisieren, wenn Sonderfälle auftreten.
Gut getestet – Tausende von Test-Assertions und besteht alle Unit-Tests von Bash, minimatch und brace-expansion (Stand zum Zeitpunkt der Erstellung dieses Textes).
Sicherer – Sie sollten sich keine Sorgen machen müssen, dass Benutzer aggressive oder bösartige Brace-Muster definieren, die Ihre Anwendung beschädigen können. Braces ergreift Maßnahmen, um bösartige Regex zu verhindern, die für DDoS-Angriffe genutzt werden können (siehe katastrophales Backtracking).
Unterstützt Listen – (auch „Sets“ genannt) a/{b,c}/d => ['a/b/d', 'a/c/d']
Unterstützt Sequenzen – (auch „Bereiche“ genannt) {01..03} => ['01', '02', '03']
Unterstützt Schritte – (auch „Inkremente“ genannt) {2..10..2} => ['2', '4', '6', '8', '10']
Unterstützt Escaping – um die Auswertung von Sonderzeichen zu verhindern.

Verwendung

Der Haupteexport ist eine Funktion, die ein oder mehrere Brace-patterns und options entgegennimmt.

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

Brace-Expansion vs. Kompilierung

Standardmäßig werden Brace-Muster in Strings kompiliert, die für die Erstellung regulärer Ausdrücke und das Matching optimiert sind.

Kompiliert

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

Erweitert

Aktiviere die Klammererweiterung, indem du die Option expand auf true setzt oder braces.expand() verwendest (gibt ein Array zurück, ähnlich dem, was du von Bash erwarten würdest, oder echo {1..5}, oder 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']

Listen

Listen erweitern (wie Bash-„Sets"):

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

Sequenzen

Erweitert Zeichenbereiche (wie Bash-„Sequenzen"):

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

Siehe fill-range für alle verfügbaren Optionen zur Bereichserweiterung.

Schrittweise Bereiche

Schritte oder Inkremente können mit Bereichen verwendet werden:

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

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

Wenn die Methode .optimize verwendet wird oder options.optimize auf true gesetzt ist, werden Sequenzen zur Erweiterung an to-regex-range übergeben.

Verschachtelung

Brace-Muster können verschachtelt werden. Die Ergebnisse jedes erweiterten Strings werden nicht sortiert, und die Reihenfolge von links nach rechts bleibt erhalten.

"Erweiterte" Braces

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

„Optimierte“ geschweifte Klammern

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 von geschweiften Klammern

Ein Klammernmuster wird nicht expandiert oder ausgewertet, wenn entweder die öffnende oder die schließende Klammer escaped ist:

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

Kommas escapen

Kommas innerhalb von geschweiften Klammern können ebenfalls escaped werden:

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

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

Einzelne Elemente

Den Bash-Konventionen folgend wird ein Klammernmuster auch dann nicht expandiert, wenn es ein einzelnes Zeichen enthält:

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

Optionen

options.maxLength

Typ: Number

Standard: 10,000

Beschreibung: Begrenzt die Länge der Eingabezeichenkette. Nützlich, wenn die Eingabezeichenkette generiert wird oder Ihre Anwendung es Benutzern erlaubt, eine Zeichenkette zu übergeben, usw.

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

options.expand

Typ: Boolean

Standard: undefined

Beschreibung: Erzeugt ein „erweitertes“ Brace-Muster (alternativ können Sie die Methode braces.expand() verwenden, die dasselbe bewirkt).

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

options.nodupes