Thanks for support to Ovg
=================
DEUTSCH/German
=================
BEISPIEL
=================
Beispiel, Datum umsortieren und nach vorne stellen
VON, altem Dateinamen:
Unnamed road, Near Stuttgart - 16-11-2015 12-41-09.gpx
Track 203 - 16-11-2015 12-42-33.gpx
Cerevicka Skela - Cerevicka Skela - 15-11-2015 18-09-21.gpx
ZU, gewünschtem Dateinamen:
151116 12-41-09 Unnamed road, Near Stuttgart.gpx
151116 12-42-33 Track 203.gpx
151115 18-09-21 Cerevicka Skela - Cerevicka Skela.gpx
REGEL:
Finde und speichere alles bis zum nächsten 'Finde'-Ausdruck in RegEx-Backrefernce $1
Die Backrefernce gibt das zurück, was mit dem RE-Ausdruck zwischen den Klammern gefunden wurde, hier zB: "Unnamed road, Near Stuttgart"
Was tatsächlich gefunden wurde, hängt von der Zusammenstellung des verwendeten Ausdruck ab. Hier muss die Syntax der verwendeten RegEx-Engine gelesen werden.
Finde Leerzeichen-Bindestrich-Leerzeichen: " - "
Finde und speichere zwei Ziffern (Tag) in $2: "16"
Finde Bindestrich
Finde und speichere zwei Ziffern (Monat) in $3: "11"
Finde Bindestrich gefolgt von '20'
Finde und speichere zwei Ziffern (Jahr) in $4: "2015"
Finde Leerzeichen
Finde und speichere den Rest (Uhrzeit) in $5 "18-09-21"
Benutze MUT (Multi Umbenennungs Tool):
Name: [N]
Erweiterung: [E]
Find: ^(.+) - (\d\d)-(\d\d)-20(\d\d) (.+)$
Replace: $4$3$2 $5 $1
[x]RegEx
[_]E
Erklärung:
$4$3$2 $5 $1
2015+11+16+Leerzeichen+18-09-21+Leerzeichen+Unnamed road, Near Stuttgart
Beispiel, Dateinamen auftrennen nach Großbuchstaben
VON:
IchBinEinDateiName.txt
ZU:
Ich Bin Ein Datei Name.txt.
Suche: ([a-z])([A-Z0-9])
Ersetze: $1 $2
[X] ^_ "Groß-/Kleinschreibung beachten"
[X] RegEx
Beispiel, Namen umsortieren, Teile austauschen, Umdrehen
VON:
Christ, Karl - Römische Kaiserzeit.ext
NACH:
Römische Kaiserzeit - Christ, Karl.ext
Suchen nach: (.+) - (.+)\.
Ersetzen durch: $2 - $1.
[X] RegEx
Beispiel, Namen umsortieren, Teile austauschen, Umdrehen, komplexer
VON:
01. Dancing In The Dark - Bruce Springsteen (blaster mix).mp3
ZU:
01. Bruce Springsteen - Dancing In The Dark (Blaster Mix).mp3
ERKLÄRUNG:
Finde am Anfang drei Zeichen "^.{3}" und speichere diese in Gruppe 1 : "^(.{3})"
Finde danach alles von Leerzeichen bis zu einem Leerzeichen/Bindestrich "( .+ )-" und speichere in Gruppe 2
Danach alles vom Leerzeichen bis zu einem Leerzeichen, gefolgt von einer öffnenden Klammer "( .+ )" >> Gruppe 3
Danach alles in der Klammer "(\(.+\))" >> Gruppe 4
Finde: ^(.{3})( .+ )-( .+ )(\(.+\))
Ersetze: durch umordnen der gefunden Stellen: $1$3-$2$4
[_]E
[X]RegEx
[Erster pro Wort Groß]
Beispiel, Ordnern aus selektierten Dateien ( https://ghisler.ch/board/viewtopic.php?t=73447#p406442 )
VON:
C:\Temp\YYYY-MM-DD_@usernamen_19stellige Indexnummern.mp4
ZU:
C:\Temp\usernamen\YYYY-MM-DD_@usernamen_19stellige Indexnummern.mp4
Erklärung:
^ ... starte die Suche am Anfang
.+ ...suche als nächstes ein beliebiges Zeichen (.) und das ein-oder-mehrmals (+)
@ ... suche als nächstes ein tatsächliches Zeichen (literal) "@"
(.*) ... suche als nächstes ein beliebiges Zeichen (.) und das null-oder-mehrmals (*), also da kann etwas sein oder auch nicht (usernamen) als $1
_ ... suche als nächstes ein tatsächliches Zeichen (literal) "_"
Dabei wird jeder Teilausdruck nur solange gesucht, bis die Suche auf den nächsten Ausdruck trifft.
Die RegEx-Engine sucht also immer Vorwärts und geht dann bei Fund wieder ein Schritt zurück.
Im Ersetzen-Teil können dann diese Gruppen wiederverwendet werden, also hier nur $1
und dann noch $0, was für den gesamten Ursprungsstring steht.
Suchen nach: ^.+@(.*)_
Ersetzen durch: $1\\$0
[_]E
[X]RegEx
ANLEITUNGEN:
=================
http://www.regenechsen.de/phpwcms/index.php?regex_allg
https://danielfett.de/de/tutorials/tutorial-regulare-ausdrucke/
TC-Hilfe > Bedienung > Reguläre Ausdrücke
http://www.ghisler.ch/wikide/index.php/Reguläre_Ausdrücke
Total Commander verwendet die freie Delphi-Bibliothek TRegExpr von Andrey V. Sorokin:
http://regexpstudio.com/TRegExpr/Help/regexp_syntax.html
(https://github.com/andgineer/TRegExpr >> "http://regexpstudio.com expired and moved to regex.sorokin.engineer")
https://regex.sorokin.engineer/de/latest/index.html
oder http://mp3bookhelper.sourceforge.net/help/TagEditing/SyntaxOfRegularExpressions.html
oder http://www.den4b.com/wiki/ReNamer:Regular_Expressions
======================================
Note: die RegEx-Engine unterstützt kein 'lookaround' (look ahead / look behind regular expressions funktionieren nicht)
https://regex.sorokin.engineer/de/latest/regular_expressions.html#lookahead , auch ein Workaround ist beschrieben.
https://www.regular-expressions.info/lookaround.html
Negative LookAhead: (?!EXP)
Positive LookAhead: (?=EXP)
Negative LookBehind: (?<!EXP)
Positive LookBehind: (?<=EXP)
======================================
Original-Dokumentation des vom TC verwendeten Moduls für Reguläre Ausdrücke
(Gekürtzte Fassung, nicht nur für TC-Anwendung mit Dateinamen, sondern auch für Textdokumente, somit ist nicht alles für TC relevant)
Code: Select all
TRegExpr v.0.947 - Delphi Regularen Ausdrucken
Einfache Treffer
Jedes einzelne Zeichen findet sich selbst, ausser es sei ein Metazeichen mit einer speziellen Bedeutung (siehe weiter unten).
Eine Sequenz von Zeichen findet genau dieses Sequenz im zu durchsuchenden String (Zielstring). Also findet das Muster (= reguläre Ausdruck) "bluh" genau die Sequenz "bluh'' irgendwo im Zielstring. Ganz einfach, nicht wahr?
Damit Du Zeichen, die üblicherweise als Metazeichen oder Escape-Sequenzen dienen, als ganz normale Zeichen ohne jede Bedeutung finden kannst, stelle so einem Zeichen einen "\" voran. Diese Techninik nennt man Escaping. Ein Beispiel: das Metazeichen "^" findet den Anfang des Zielstrings, aber "\^" findet das Zeichen "^" (Circumflex), "\\" findet also "\" etc.
Beispiele:
foobar findet den String 'foobar'
\^FooBarPtr findet den String '^FooBarPtr'
Escape-Sequenzen
Zeichen könenn auch angeben werden mittels einer Escape-Sequenz, in der Syntax ähnlich derer, die in C oder Perl benutzt wird: "\n'' findet eine neue Zeile, "\t'' einen Tabulator etc. Etwas allgemeiner: \xnn, wobei nn ein String aus hexadezimalen Ziffern ist, findet das Zeichen, dessen ASCII Code gleich nn ist. Falls Du Unicode-Zeichen (16 Bit breit kodierte Zeichen) angeben möchtest, dann benutze '\x{nnnn}', wobei 'nnnn' – eine oder mehrere hexadezimale Ziffern sind.
\xnn Zeichen mit dem Hex-Code nn (ASCII-Text)
\x{nnnn} Zeichen mit dem Hex-Code nnnn (ein Byte für ASCII-Text und zwei Bytes für Unicode -Zeichen
\t ein Tabulator (HT/TAB), gleichbedeutend wie \x09
\n Zeilenvorschub (NL), gleichbedeutend wie \x0a
\r Wagenrücklauf (CR), gleichbedeutend wie \x0d
\f Seitenvorschub (FF), gleichbedeutend wie \x0c
\a Alarm (bell) (BEL), gleichbedeutend wie \x07
\e Escape (ESC), gleichbedeutend wie \x1b
Beispiele:
foo\x20bar findet 'foo bar' (beachte den Leerschlag in der Mitte)
\tfoobar findet 'foobar', dem unmittelbar ein Tabulator vorangeht
Zeichenklassen
Du kannst sogenannte Zeichenklassen definieren, indem Du eine Liste von Zeichen, eingeschlossen in eckige Klammern [], angibst. So eine Zeichenklasse findet genau eines der aufgelisteten Zeichen Zeichen im Zielstring.
Falls das erste aufgelistete Zeichen, das direkt nach dem "[", ein "^" ist, findet die Zeichenklasse jedes Zeichen ausser denjenigen in der Liste.
Beispiele:
foob[aeiou]r findet die Strings 'foobar', 'foober' etc. aber nicht 'foobbr', 'foobcr' etc.
foob[^aeiou]r findet die Strings 'foobbr', 'foobcr' etc. aber nicht 'foobar', 'foober' etc.
Innerhalb der Liste kann das Zeichen "-" benutzt werden, um einen Bereich oder eine Menge von Zeichen zu definieren. So definiert a-z alle Zeichen zwischen "a" and "z" inklusive.
Falls das Zeichen "-" selbst ein Mitglied der Zeichenklasse sein soll, dann setze es als erstes oder letztes Zeichen in die Liste oder schütze es mit einem vorangestellten "\" (escaping). Wenn das Zeichen "]" ebenfalls Mitglied der Zeichenklasse sein soll, dann setze es als erstes Zeichen in die Liste oder escape es.
Beispiele:
[-az] findet 'a', 'z' und '-'
[az-] findet 'a', 'z' und '-'
[a\-z] findet 'a', 'z' und '-'
[a-z] findet alle 26 Kleinbuchstaben von 'a' bis 'z'
[\n-\x0D] findet eines der Zeichen #10, #11, #12 oder #13.
[\d-t] findet irgendeine Ziffer, '-' oder 't'.
[]-a] findet irgendein Zeichen von ']'..'a'.
Metazeichen
Metazeichen sind Zeichen mit speziellen Bedeutungen. Sie sind die Essenz der regulären Ausdrücke. Es gibt verschiedene Arten von Metazeichen wie unten beschrieben.
Metazeichen - Zeilenseparatoren
^ Beginn einer Zeile ( Beim TC: am Anfang des Namens )
$ Ende einer Zeile ( Beim TC: am Ende des Namens )
\A start of text
\Z end of text
. irgendein beliebiges Zeichen
Beispiele:
^foobar findet den String 'foobar' nur, wenn es am Zeilenanfang vorkommt
foobar$ findet den String 'foobar' nur, wenn es am Zeilenende vorkommt
^foobar$ findet den String 'foobar' nur, wenn er der einzige String in der Zeile ist
foob.r findet Strings wie 'foobar', 'foobbr', 'foob1r' etc.
Metazeichen – vordefinierte Klassen
\w ein alphanumerisches Zeichen inklusive "_"
\W kein alphanumerisches Zeichen, auch kein "_"
\d ein numerisches Zeichen
\D kein numerisches Zeichen
\s irgendein wörtertrennendes Zeichen (entspricht [ \t\n\r\f])
\S kein wörtertrennendes Zeichen
Du kannst \w, \d und \s innerhalb Deiner selbstdefinierten Zeichenklassen benutzen.
Beispiele:
foob\dr findet Strings wie 'foob1r', ''foob6r' etc., aber not 'foobar', 'foobbr' etc.
foob[\w\s]r findet Strings wie 'foobar', 'foob r', 'foobbr' etc., aber nicht 'foob1r', 'foob=r' etc.
Metazeichen – Wortgrenzen
\b findet eine Wortgrenze
\B findet alles ausser einer Wortgrenze
Eine Wortgrenze (\b) is der Ort zwischen zwei Zeichen, welcher ein \w auf der einen und ein \W auf der anderen Seite hat bzw. umgekehrt. \b bezeichnet alle Zeichen des \w bis vor das erste Zeichen des \W bzw. umgekehrt.
Metazeichen - Iteratoren
Jeder Teil eines regulären Ausdruckes kann gefolgt werden von einer anderen Art von Metazeichen – den Iteratoren. Dank dieser Metazeichen kannst Du die Häufigkeit des Auftretens des Suchmusters im Zielstring definieren. Dies gilt jeweils für das vor diesem Metazeichen stehenden Zeichen, das Metazeichen oder den Teilausdruck.
* kein- oder mehrmaliges Vorkommen ("gierig"), gleichbedeutend wie {0,}
+ ein- oder mehrmaliges Vorkommen ("gierig"), gleichbedeutend wie {1,}
? kein- oder einmaliges Vorkommen ("gierig"), gleichbedeutend wie {0,1}
{n} genau n-maliges Vorkommen ("gierig")
{n,} mindestens n-maliges Vorkommen ("gierig")
{n,m} mindestens n-, aber höchstens m-maliges Vorkommen ("gierig")
*? kein- oder mehrmaliges Vorkommen ("genügsam"), gleichbedeutend wie {0,}?
+? ein oder mehrmaliges Vorkommen ("genügsam"), gleichbedeutend wie {1,}?
?? kein- oder einmaliges Vorkommen ("genügsam"), gleichbedeutend wie {0,1}?
{n}? genau n-maliges Vorkommen ("genügsam")
{n,}? Mindestens n-maliges Vorkommen ("genügsam")
{n,m}? mindestens n-, aber höchstens m-maliges Vorkommen ("genügsam")
Also, die Ziffern in den geshcweiften Klammern in der Form {n,m} geben an, wieviele Male das Suchmuster im Zielstring gefunden muss, um einen Treffer zu ergeben. Die Angabe {n} ist gleichbedeutend wie {n,n} und findet genau n Vorkommen. Die Form {n,} findet n oder mehre Vorkommen. Es gibt keine Limiten für die Zahlen n und m. Aber je grösser sie sind, desto mehr Speicher und Zeit wird benötigt, um den regulären Ausdruck auszuwerten.
Falls eine geschweifte Klammer in einem anderen als dem eben vorgestellten Kontext vorkommt, wird es wie ein normales Zeichen behandelt.
Beispiele:
foob.*r findet Strings wie 'foobar', 'foobalkjdflkj9r' und 'foobr'
foob.+r findet Strings wie 'foobar', 'foobalkjdflkj9r', aber nicht 'foobr'
foob.?r findet Strings wie 'foobar', 'foobbr' und 'foobr', aber nicht 'foobalkj9r'
fooba{2}r findet den String 'foobaar'
fooba{2,}r findet Strings wie 'foobaar', 'foobaaar', 'foobaaaar' etc.
fooba{2,3}r findet Strings wie 'foobaar', or 'foobaaar', aber nicht 'foobaaaar'
Eine kleine Erklärung zum Thema "gierig" oder "genügsam". "Gierig" nimmt soviel wie möglich, wohingegen "genügsam" bereits mit dem ersten Erfüllen des Suchmusters zufrieden ist. Beispiel: 'b+' und 'b*' angewandut auf den Zielstring 'abbbbc' findet 'bbbb', 'b+?' findet 'b', 'b*?' findet den leeren String, 'b{2,3}?' findet 'bb', 'b{2,3}' findet 'bbb'.
Metazeichen - Alternativen
Du kannst eine Serie von Alternativen für eine Suchmuster angeben, indem Du diese mit einem "|'' trennst. Auf diese Art findet das Suchmuster fee|fie|foe eines von "fee", "fie", oder "foe" im Zielstring – dies würde auch mit f(e|i|o)e ereicht.
Die erste Alternative beinhaltet alles vom letzten Muster-Limiter ("(", "[" oder natürlich der Anfang des Suchmusters) bis zum ersten "|". Die letzte Alternative beinhaltet alles vom letzten "|" bis zum nächsten Muster-Limiter. Aus diesem Grunde ist es allgemein eine gute Gewohnheit, die Alternativen in Klammern anzugeben, um möglichen Missverständnissen darüber vorzubeugen, wo die Alternativen beginnen und enden.
Alternativen werden von links nach rechts geprüft, so dass der Treffer im Zielstring zusammengesetzt ist aus den jeweils zuerst passenden Alternativen. Das bedeutet, dass Alternativen nicht notwendigerweise "gierig" sind. Ein Beispiel: Wenn man mit "(foo|foot)" im Zielstring "barefoot" sucht, so passt bereits die erste Variante. Diese Tatsache mag nicht besonders wichtig erscheinen, aber es ist natürlich wichtig, wenn der gefundene Text weiterverwendet wird. Im Beispiel zuvor würde der Benutzer nicht "foot" erhalten, wie er eventuell beabsichtigt hatte, sondern nur "foo".
Erinnere Dich auch daran, dass das "|" innerhalb von eckigen Klammern wie ein normales Zeichen behandelt wird, so dass [fee|fie|foe] dasselbe bedeutet wie [feio|].
Beispiele:
foo(bar|foo) findet die Strings 'foobar' oder 'foofoo'.
Metazeichen - Teilausdrücke
Das KLammernkonstrukt (...) wird auch dazu benutzt, reguläre Teilausdrücke zu definieren (nach dem Parsen findest Du Positionen, Längen und effektive Inhalte der regulären Teilausdrücke in den TRegExpr-Eigenschaften MatchPos, MatchLen und Match und kannst sie ersetzen mit den Template-Strings in TRegExpr.Substitute ).
Teilausdrücke werden nummeriert von links nach recht, jeweils in der Reihenfolge ihrer öffnenden Klammer. Der erste Teilausdruck hat die Nummer 1, der gesamte reguläre Ausdruck hat die Nummer 0
Beispiele:
(foobar){8,10} findet Strings, die 8, 9 oder 10 Vorkommen von 'foobar' beinhalten
foob([0-9]|a+)r findet 'foob0r', 'foob1r' , 'foobar', 'foobaar', 'foobaar' etc.
Metazeichen - Rückwärtsreferenzen
Die Metacharacters \1 bis \9 ( Im TC: $1 bis $9 ) werden in Suchmustern interpretiert als Rückwärtsreferenzen. \<n> findet einen zuvor bereits gefundenen Teilausdruck #<n>.
Beispiele:
(.)\1+ findet 'aaaa' und 'cc'.
(.+)\1+ findet auch 'abab' und '123123'
(['"]?)(\d+)\1 findet "13" (innerhalb ") , oder '4' (innerhalb ') oder auch 77, etc.
ONLINE TESTER
=================
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ENGLISH/Englisch
=================
Total Commander is using the free TRegExp engine by Andrey V. Sorokin:
http://regexpstudio.com/TRegExpr/Help/regexp_syntax.html
(https://github.com/andgineer/TRegExpr >> "http://regexpstudio.com expired and moved to regex.sorokin.engineer")
https://regex.sorokin.engineer/en/latest/
or http://mp3bookhelper.sourceforge.net/help/TagEditing/SyntaxOfRegularExpressions.html
or http://www.den4b.com/wiki/ReNamer:Regular_Expressions
======================================
Note: the RegEx engine doesn't support 'lookaround' (look ahead / look behind regular expressions don't work)
https://regex.sorokin.engineer/en/latest/regular_expressions.html#lookahead , also read about an work around.
https://www.regular-expressions.info/lookaround.html
Negative LookAhead: (?!EXP)
Positive LookAhead: (?=EXP)
Negative LookBehind: (?<!EXP)
Positive LookBehind: (?<=EXP)
======================================
EXAMPLE
=================
TUTORIALS:
=================
http://www.regular-expressions.info/
http://rexegg.com/
TC-Help > Operations > Regular expressions
http://www.ghisler.ch/wiki/index.php/Regular_Expressions
My RegEx hints: (Not only for file names like with TC, but for text documents also, so not everything may fit within TC)
=================
Expression:
Code: Select all
. --> one piece of a sign (char, digit, sign, blank)
a --> the char "a" itself literally
abc --> the string "abc" literally itself
(aa|bb) --> one of the alternatives "aa" or "bb", what ever is found first
(aa|bb|cc)--> one of the alternatives "aa" or "bb" or "cc", what ever is found first
[ab3-] --> one from list ("a" or "b" or "3" or "-") NOTE: the hyphen must be at the very begin, or at the end. NOT in between!
[^ab3-] --> one sign but none from the ones from this list (no "a", no "b", no "3" and no hyphen)
[^-] --> one sign (char, digit, whitespace, punctuation) but not a hyphen
[a-z] --> one lower case char from the range "a", "b", "c", "d".... till "z"
[A-Z] --> the same, but match upper case letters.
[a-d] --> one from the range "a", "b", "c" or "d"
[A-D] --> the same, but match upper case letters.
Note: all this A-Za-z thinggy will only match plain 7-bit ASCII chars (english alphabet), no umlauts or ascents or such.
3 --> the digit "3"
2013 --> the number "2013" literally
[6-9] --> one piece of any digit from the range "6", "7", "8" and "9"
[^6-9] --> one piece of any sign (char, digit, whitespace, punctuation) but not a "6", "7", "8" or "9"
\w --> one any letter, digit or underscore
\d --> one any digit from the range "0", "1", "2", "3" till "9"
\s --> one blank
- --> one hyphen literally
_ --> one underscore,
\. --> one dot literally (the dot has to be "escaped" with an backslash, because it is a RegEx MetaChar (see above))
\\ --> one backslash literally (the backslash has to be "escaped" with an backslash, because it is a RegEx MetaChar)
(...) --> group an expression to apply operators or for backreference. Instead of the three dots write your expression.
(Note: those groups are counted from left to right and can be nested too)
\W, \D, \S, --> opposite of lower case \w \d \s
\W, \D, \S means: match one of ANY sign, but NOT if it is a sign of the character class \w or \d or \s
\W --> match one sign but NOT a word sign, \D --> match one sign but NOT a digit, \S --> match one sign but NOT a whitespace
Note: all of the above match only one single piece of a sign!
To match more than one piece, just double them:
aa --> match two 'a' literally
aaa --> match three 'a' literally
aaaa --> match four 'a' literally
\d\d\d\d --> match exactly four single digits like '1962' or '2013'
... --> (three dots) match three of any (maybe different) signs
\s\s --> match two blanks
or use a another meta sign as quantifier.Quantifier:
Code: Select all
* --> match greedy zero or more times the previous expression
+ --> match greedy one or more times the previous expression
{3} --> match exactly 3 times the previous expression
{3,} --> match greedy but at least 3 times the previous expression
{,5} --> match greedy zero-or-more up to 5 times the previous expression
{3,5} --> match greedy 5, or 4, or 3 times the previous expression
? --> behind * or + or {,} will limit the match to as few as (non-greedy)
? --> behind an expression matches on zero or one occurrenceExample:
Code: Select all
\d+ --> match one-or-two-or-three-or....-or-as-may-as-possible pieces of any digit. Like '3', or '42', or '123', or '5782332'
\d* --> match zero(none)-or-one-or-two-or....-or-as-many-as-possible pieces of any digit. Like ' ', or '3', or '42', or '123', or '5782332'
\d{4}--> match exactly four of any digits. Like '1962' or '2013' or '1234'
\d{2,4} --> match two, or three, or four of any digits. Like '08' or '2013' or '123'. Works greedy, will get you rather '2013' than '08'
\d{2}|\d{4) --> match exactly two or four digit. But tries to match two first and then stops, even on '2013' it will get you only '20' and will never try to match four digits
a{4} --> match four 'a' s
(Ho){3} --> match three times 'Ho' >>> 'HoHoHo'
(the ){2} --> match doubled 'the 'Code: Select all
\b --> Match at word boundary. Example: "\bfun\b" on "my fun function" will match 'fun' only.
\A or ^ --> at start of file name. Example: "^fun" on "fun function" will match first 'fun' only.
\Z or $ --> at end of file name. Example: "on$" on "onto my fun function" will match last 'on' only.Meta signs:
Code: Select all
\ --> use the escape character "\" in front of an meta sign, to match an meta sign itself
Meta signs are: ., \, (, ), [, {, }, +, *, ?, |, ^, $
Example:
\. --> one dot literally
\\ --> one backslash literallyOrigin:
1.1.ps1
1.2.ps1
Wanted:
1.01.ps1
1.02.ps1
Search: \.(\d)
Replace: .0$1
[_]E
[X]RegEx
Second Meta signs Example; escape parenthesis:
Origin : askdhfads (2017).ext
Wanted: 2017 askdhfads.ext
Search: (.+) \((\d\d\d\d)\)
Replace: $2 $1
[_]E
[X]RegEx
backreference on replacement:
Code: Select all
\1 or $1 - insert here what was matched by first (...)-group
\2 or $2 - insert here what was matched by second (...)-group
\3 ... \9 or $3 ... $9 - insert what was matched by third, fourth, fifth,... till ninth group
(Note: some flavours use $1 syntax instead of \1)
(Note: those backreference groups are counted from left to right and can be nested too)
(1 ... (2 ... (3... ))) (4 ... ) (5 ... ) (6 ... (7 ... ) ) Origin : Straight Shooter - Bad Company.mp3
Wanted: Bad Company - Straight Shooter.mp3
Search: (.+) - (.+)
Replace: $2 - $1
[_]E
[X]RegEx
Some RegEx implementation allow additional rules like:
Code: Select all
- Named groups: (?<abc>pattern) >> (?P<my_description-here>pattern)
- Non-capturing group: (?:pattern)
- Comments: (?#comment)
- Positive lookahead: (?=pattern)
- Negative lookahead: (?!pattern)
- Positive lookbehind: (?<=pattern)
- Negative lookbehind: (?<!pattern)
(and many more > http://www.regular-expressions.info/refadv.html)ONLINE TESTER
=================
http://regexr.com/
https://regex101.com/
http://rereplace.com/
http://www.regextester.com/
http://www.regexlib.com/RETester.aspx
Find more information:
http://www.regular-expressions.info/reference.html
http://www.autohotkey.com/docs/misc/RegEx-QuickRef.htm
http://www.rexegg.com/
http://www.debuggex.com/
www.regular-expressions.info
www.regexlib.com/
www.regexlib.com/CheatSheet.aspx
A collection of awesome Regex libraries, tools, frameworks and software:
http://github.com/aloisdg/awesome-regex
.