Renamer allows you to rename and number many files at once. If you’ve every tried to rename a large set of files by hand and thought “There must be an easier way”, then Renamer is for you. This includes graphic designers, photographers, developers, system administrators, artists, writers, Web designers, network administrators, and pretty much everybody who uses their Mac on a professional basis.
Version: 4.0.2 Release Date: 6-15-2007 Notes: Added support for 'Regular' version key. File Renamer - Regular is now available for only $10. This is great for people who would like to support the continued development of the File Renamer product but don't need some of the extras of the full File Renamer Deluxe.
Stunning user interface – We redesigned our user interface to make renaming files even easier. And that in an elegantly simple, simply elegant look
Optimize your files for the web – You want to publish images, photos and documents on the Internet? Prepare them for the Web in just a few clicks
Rename quickly from Finder – Renamer is all about saving you time working with files. Now you can perform common rename tasks conveniently from Finder with our new system menu
Powerful chain feature – Tired of running the same sequence of renames? Link up rename tasks into a single tasks to gain the ultimate renaming flexibility
Work faster with Presets – Save even more time by storing your common rename tasks as presets and accessing them later with just a single click
Change file extensions – Your files have the wrong endings? With Renamer you can change file extensions in seconds
Undo – Renamer allows you to undo all your file renames, so you can focus on your work without having to worry about making mistakes
Live feedback – See immediately how your renamed files look with Renamer’s live feedback. Great for catching errors early and fine-tuning your results
Regular expressions – For power users Renamer offers to find and replace filenames with regular expressions
Shareware: $19.99
Free Download: Renamer 6.0.6
Regular Expressions (RegEx) is a syntax for specifying patterns of text to search for. Special metacharacters allow you to specify, for instance, that a particular string you are looking for occurs at the beginning or end of a line, or contains N recurrences of a certain character.
Metacharacters, such as $ . ^ { [ ( | ) * + ? are interpreted according to their individual meaning, instead of finding a literal match for them.
In this document, RegEx patterns are shown in bold orange. The subject text which is checked against a RegEx pattern for a possible match is shown in bold black. Parts of the subject text are color-coded to provide a clue as to why a certain part matches (green color), or does not match (red color).
When the search string does not contain any metacharacters, the RegEx engine works like 'normal' search. (it tries to find an exact copy of the search string.) (This is also known as 'literal match').
If you want to find a literal match for a metacharacter, put a backslash before it. (The character is called 'escape character', because it lets the metacharacter escape from its special duty, and lets it act as a normal character. Its combination with a metacharacter is called 'escape sequence').
For example, metacharacter ^ matches the beginning of string, but ^ matches the character ^.
Note that the RegEx pattern matches the character .
| RegEx pattern | Matches | Remarks |
|---|---|---|
| This RegEx pattern does not contain any metacharacters; so all characters are matched literally. | ||
| The ^ escape sequence searches for the character ^literally . |
We already saw one use of escape sequence (above).
Specific escape sequences are interpreted as special conditions, as listed below.
| RegEx pattern | matches |
|---|---|
| Character represented by the hex code nn | |
| two bytes char with hex code nnnn (unicode) | |
| tab (HT/TAB), same as x09 (Hex 09) | |
| new line (NL), same as x0a (Hex 0a) | |
| carriage return (CR), same as x0d (Hex 0d) | |
| form feed (FF), same as x0c (Hex 0c) | |
| matches foo bar (note the space in the middle), but does not match foobar | |
| matches foobar preceded by a tab (the tab is needed for the match) |
Note that the tab, new line, carriage return, and form feed are known as 'white spaces'. But RegEx can distinguish between them. This allows you to make high-precision searches.
A character class is a list of characters surrounded by square brackets '[' and ']', which will match any one (and only one) character from the list.
Note that:
| RegEx Pattern | Remarks |
|---|---|
| Matches a, b, c, d, e, or f (only one character), but no other characters | |
| Matches any one (and only one) of the small alphabetical characters, from c to m | |
| Matches any one (and only one) of the capital alphabetical characters from G to J | |
| Matches any one (and only one) of the alphabetical characters (capital or small) | |
| Matches any one (and only one) of numerical characters from 5 to 8 | |
Matches any one (and only one) of characters with their ordinal value in range from #10 (n) to #31 (x1F), which in ASCII character table correspond to some non-printable characters. Note the use of escape sequences inside of this example. |
Awesome screenshot 1 2 – capture annotate and share screenshots. There are some special conditions:
| RegEx Pattern | Remarks |
|---|---|
| matches a, z, and - (since – is put at the beginning, the escape sequence is not needed) | |
| matches a, z, and - (since – is not at the beginning/end, the escape sequence is needed) | |
| matches any non-digit character | |
| matches any character from ] to a. (since ] is at the beginning, the escape sequence is not needed) | |
| Matches with foobar, foober, etc. but not foobbr, foobcr, etc. | |
| Matches with foobbr, foobcr etc. but not foobar, foober, etc. |
Ithoughtsx 3 11 download free. Some of the character classes are used so often that RegEx has predefined escape sequences to represent them.
| RegEx Pattern | Remarks |
|---|---|
| an alphanumeric character, including an underscore (_) | |
| a non-alphanumeric character | |
| a numeric character | |
| a non-numeric character | |
| any space (same as the [ tnrf] class) | |
| a non space | |
| any character in line (the symbol is just a dot) |
Notice that the capitalized letter is used to negate (for example, compare w with W)
A word boundary b matches a position between a word character w and a non-word character W. For the purpose of a word boundary position, the start and end of text will be treated as non-word characters W. These markers are commonly used for matching patterns as whole words, while ignoring occurrences within words.
| RegEx Pattern | Remarks |
|---|---|
| word boundary | |
| not word boundary | |
| start of text (^ is an alternative) | |
| end of text ($ is an alternative) |
For example, bhisb will search for a whole word his, but will ignore this, history or whistle.
Iterators (quantifiers) are meta-characters that specify how many times the preceding expression has to repeat. For example, finding a numeric sequence exactly 3 to 5 digits long.
Iterators can be 'Greedy' or 'Non-Greedy'. Greedy means the expression grabs as much matching text as possible. In contrast, the non-greedy expression tries to match as little as possible.
All iterators are greedy by default. Adding ? (question mark) at the end of an iterator makes it non-greedy.
For example:
| RegEx pattern | Remarks | Greedy? | Remarks |
|---|---|---|---|
| zero or more | equivalent to {0,} | ||
| one or more | equivalent to {1,} | ||
| zero or one | equivalent to {0,1} | ||
| exactly n times | |||
| at least n times | |||
| at least n but not more than m times | |||
| zero or more | equivalent to {0,}? | ||
| one or more | equivalent to {1,}? | ||
| zero or one | equivalent to {0,1}? | ||
| exactly n times | |||
| at least n times | |||
| at least n but not more than m times |
Let us see some examples:
| RegEx pattern | Remarks |
|---|---|
| matches foobar, foobalkjdflkj9r and foobr | |
| matches foobar, foobalkjdflkj9r but not foobr | |
| matches foobar,foobbr and foobr but not foobalkj9r | |
| matches foobaar | |
| matches foobaar,foobaaar, foobaaaar etc. but not foobar | |
| matches foobaar, or foobaaar but not foobaaaar or foobar |
A RegEx expression can have multiple alternative characters or subexpressions. The metacharacter | is used to separate the alternatives.
For example, fee|fie|foe will match with fee, fie, or foe in the target string.
It is difficult to understand where each alternative starts and ends. This is why it is a common practice to include alternatives in parentheses, to make it easier to understand.
For example, fee|fie|foe can be written as f(e|i|o)e, to make it easier to understand.
Alternatives are tried from left to right, so the first alternative found for which the entire expression matches, is the one that is chosen. For example, when matching foo|foot against barefoot, only the foo part will match, because that is the first alternative tried, and it successfully matches the target string. (This is important when you are capturing matched text using parentheses.)
| RegEx Pattern | Remarks |
|---|---|
| foo(bar|foo) | matches foobar or foofoo |
Also remember that alternatives cannot be used inside a character class (square brackets), because | is interpreted as a literal within []. That means [fee|fie|foe] is same as [feio|]. (The other characters are treated as duplicates, and ignored).
Parts of any RegEx pattern can be enclosed in brackets (), just like using brackets in a mathematics formula. Each part that is enclosed in brackets is called a 'subexpression'.
The brackets serve two main purposes:
Let us see some examples:
| RegEx Pattern | Remarks |
|---|---|
| Much better readability than the equivalent RegEx pattern fee|fie|foe. | |
| Matches with the entire enclosed string foobar repeated 2 or 3 times. (i.e., matches with foobarfoobar or foobarfoobarfoobar) | |
| Matches with fooba followed by the character r repeated 2 or 3 times. (i.e., matches with foobarr or foobarrr) (The iterator acts only on the last character.) | |
| foob([0-9]|a+)r | matches only the character foob0r, foob1r, foobar, foobaar, foobaaaar, etc. (The subexpression is evaluated first.) |
You must have told (or heard-) jokes like this one:
'Two guys walk in a bar. The first guy says. Then the second guy replies.'.
Then you are already familiar with backreferences!
A 'backreference' is a numbered reference to a previously mentioned thing.
RegEx also has backreferences. Let us understand how backreferences are defined in RegEx.
The RegEx engine tries to find text that matches the whole When is legacy of the void release. RegEx pattern. If a matching text is found, the RegEx engine identifies the matching text for each of the subexpressions in the pattern.
At this stage, the RegEx engine gives numbers to these matching parts:
Now we use those numbers to refer to the entire pattern and/or subexpressions. (That is why these numbers are called 'backreference'.)
The backreference to the nth subexpression is written as n.
The backreferences can be used to compose the RegEx pattern itself, as shown below:
| matches aaaa and cc (any single character that is repeated twice or more) | |
| matches aaaa, cc, abababab, 123123 Book collector 20 0 2 download free. (a set of one or more characters, repeated twice or more) (The character-sets are alternately colored blue and pink for easy identification. Observe how a RegEx pattern can match quite different text!) |
The backreferences are also used in find-and-replace operations, to re-assemble new text from old.
The replacement text is typically a combination of-
Note that the RegEx pattern may have some parts that are not enclosed in (). (In other words, it may have parts that are not subexpressions.) Such parts are not used in the replacement text.
Here are some 'find-and-replace' examples:
| Expression | Replace | Description |
|---|---|---|
| Switch two words around and put a comma after the resulting first word. Example: if input string is 'John Smith', then output will be 'Smith, John'. Notice that the replacement text also has additional literal text in the middle (comma and space). | ||
| Find date sequences in dd-mm-yyyy format and reverse them into yyyy-mm-dd format. (e.g. 25-10-2007 is converted to 2007-10-25). Note: This is not a very robust example, because d can represent any digit in range of 0-9. That means sequences like 99-99-9999 also will match this pattern, resulting in a problem. This in fact shows that you need to be careful with RegEx patterns! | ||
| Remove the contents of the [.] (square brackets), and the brackets too. (Replace with nothing means deleting.) |
Backreferences can also be used to adjust the case of a certain patterns or fragments, which cannot be easily achieved with generic case manipulation rules. Hypnospace outlaw 1 0 download free.
| Flag | Description |
|---|---|
| L | Convert all characters to lowercase. |
| l | Convert only the first character to lowercase (that's a lower case L). |
| U | Convert all characters to uppercase. |
| u | Convert only the first character to uppercase. |
These flags can be used together with the backreferences in the replace pattern to adjust the case of text inserted by backreferences.
For example, we can do the following manipulations:
| Input | Find | Replace | Result |
|---|---|---|---|
| test ExAmple | (.+) (.+) | $1 $2 | test ExAmple |
| test ExAmple | (.+) (.+) | U$1 $2 | TEST ExAmple |
| test ExAmple | (.+) (.+) | $1 L$2 | test example |
| test ExAmple | (.+) (.+) | u$1 L$2 | Test example |
Note: Case manipulation features were added in v5.72.4 Beta. This feature is less common and may not exist in other RegEx engines.
One of the known limitation of RegEx engine when working with binary data is that the input string is not searched beyond the first occurrence of NULL character (x00). This would not affect file names because there are simply no NULL characters in them, but may affect parsing of binary content of files when working in Pascal Script for example.
0 
Star