In word processors, the Search feature is considered an editing tool. You can certainly use it just that way while writing in Studio, but the extended search capabilities make it a powerful tool to update site content.
You can find and replace alphanumeric strings (including regular expressions) across folders and projects and choose how tags are processed by the search engine.
Studio provides both basic and extended levels of search and replace to help you maintain your Web pages.
![]() |
To search the current document: |
If you highlight text in the editor, it displays in the Find what box.
![]() |
To replace text in the current document: |
In addition to the Up and Down Direction options, you can restrict the search to just a part of the document by highlighting a block of text in the editor and picking Selection.
The last 10 items are saved in the Find what and Replace what dropdown lists.
For more complex operations across multiple documents, use the Extended Find or Extended Replace commands. These commands offer a number of options to refine your search:
The Results pane displays a list of locations where the matched string was replaced. Double-click on a match in the list to highlight it in the document. Right-click in the Results pane to clear the pane or close it.
Note | The Extended Replace command skips read-only files. |
Use the Search > Replace Special Characters command to either replace extended characters with their HTML equivalents, or replace HTML tags with the equivalent extended characters. This command works only in the current document.
Because of the way different operating systems treat carriage returns, text files saved on UNIX or Macintosh systems may become double-spaced when opened in Studio. Use the Search > Replace Double Spacing with Single Spacing command to collapse double-spaced lines to single-spaced lines in the current document.
Studio supports searching with regular expressions (or RegExp) to match patterns in character strings in the Extended Find and Replace commands. Regular expressions allow you to specify all the possible variants in a search and to precisely control replacements. Ordinary characters are combined with special characters to define the pattern for the search. The RegExp parser evaluates the selected files and returns each matching pattern.
In the Find command, the matching pattern is added to the find list. In the Replace operation, it triggers insertion of the replacement string. When replacing a string, it is just as important to ensure what is not found as what is. Simple regular expressions can be concatenated into complex search criteria. Note that enabling the Regular expressions option in the Extended dialog boxes disables the Skip tags while searching option.
Thanks to Team Allaire member Christopher Bradford for his ongoing support of RegExp issues in the ColdFusion Support Forum at http://forums.allaire.com/DevConf/index.cfm.
Note | The rules listed in this section are for creating regular expressions in ColdFusion. The rules used by other RegExp parsers may differ. |
Studio's RegExp engine processes the entire document, it does not parse on a line-by-line basis. This affects the way the characters such the asterisk (*), carat (^) and dollar sign ($) should be used.
Because special characters are the operators in regular expressions, in order to represent a special character as an ordinary one, you need to precede it with a backslash. To represent a backslash, for instance, use a double backslash (\\).
This section describes the rules for creating regular expressions. You can use regular expressions in the Search > Extended Find and Replace commands to match complex string patterns.
The following rules govern one-character RegExp that match a single character:
+ * ? . [ ^ $ ( ) { | \
You can specify a character by using one of the POSIX character classes. You enclose the character class name inside two square brackets, as in this Replace example:
"Allaire's Web Site","[[:space:]]","*","ALL")
This code replaces all the spaces with *, producing this string:
Allaire's*Web*Site
The following table shows the POSIX character classes that Studio supports.
Supported Character Classes | |
---|---|
Character Class | Matches |
alpha | Matches any letter. Same as [A-Za-z]. |
upper | Matches any upper-case letter. Same as [A-Z]. |
lower | Matches any lower-case letter. Same as [a-z]. |
digit | Matches any digit. Same as [0-9]. |
alnum | Matches any alphanumeric character. Same as [A-Za-z0-9]. |
xdigit | Matches any hexadecimal digit. Same as [0-9A-Fa-f]. |
space | Matches a tab, new line, vertical tab, form feed, carriage return, or space. |
Matches any printable character. | |
punct | Matches any punctuation character, that is, one of ! ` # S % & ` ( ) * + , - . / : ; < = > ? @ [ / ] ^ _ { | } ~ |
graph | Matches any of the characters defined as a printable character except those defined to be part of the space character class. |
cntrl | Matches any character not part of the character classes [:upper:], [:lower:], [:alpha:], [:digit:], [:punct:], [:graph:], [:print:], or [:xdigit:]. |
You can use the following rules to build a multi-character regular expressions:
Studio supports backreferencing, which allows you to match text in previously matched sets of parentheses. A slash followed by a digit n (\n) is used to refer to the nth parenthesized sub-expression.
One example of how backreferencing can be used is searching for doubled words -- for example, to find instances of `the the' or `is is' in text. The following example shows the syntax you use for backreferencing in regular expressions:
("There is is coffee in the the kitchen", "([A-Za-z]+)[ ]+\1","*","ALL")
This code searches for words that are all letters ([A-Za-z]+) followed by one or more spaces [ ]+ followed by the first matched sub-expression in parentheses. The parser detects the two occurrences of is as well as the two occurrences of the and replaces them with an asterisk, resulting in the following text:
There * coffee in * kitchen
All or part of a regular expression can be anchored to either the beginning or end of the string being searched:
The following examples show some regular expressions and describe what they match.
Regular Expression Examples | |
---|---|
Expression | Description |
[\?&]value= | A URL parameter value in a URL. |
[A-Z]:(\\[A-Z0-9_]+)+ | An uppercase DOS/Windows full path that (a) is not the root of a drive, and (b) has only letters, numbers, and underscores in its text. |
[A-Za-z][A-Za-z0-9_]* | A ColdFusion variable with no qualifier. |
([A-Za-z][A-Za-z0-9_]*)(\.[A-Za-z][A-Za- z0-9_]*)? | A ColdFusion variable with no more than one qualifier, for example, Form.VarName, but not Form.Image.VarName. |
(\+|-)?[1-9][0-9]* | An integer that does not begin with a zero and has an optional sign. |
(\+|-)?[1-9][0-9]*(\.[0-9]*)? | A real number. |
(\+|-)?[1-9]\.[0-9]*E(\+|-)?[0-9]+ | A real number in engineering notation. |
a{2,4} | Two to four occurrences of 'a': aa, aaa, aaaa. |
(ba){3,} | At least three 'ba' pairs: bababa, babababa, ... |
An excellent reference on regular expressions is Mastering Regular Expressions by Jeffrey E.F. Friedl, published by O'Reilly & Associates, Inc.