Regular Expressions - Revision history

Admin at 16:34, 28 May 2011

2011-05-28T16:34:43Z

← Older revision		Revision as of 16:34, 28 May 2011
Line 223:		Line 223:
	* http://www.regular-expressions.info/characters.html		* http://www.regular-expressions.info/characters.html
	* http://vim.runpaint.org/searching/creating-regular-expressions/		* http://vim.runpaint.org/searching/creating-regular-expressions/


			{{Programs}}
			{{Languages}}

Admin: /* Extracting Links from an HTML Page */

2011-05-01T02:53:58Z

Extracting Links from an HTML Page

← Older revision		Revision as of 02:53, 1 May 2011
Line 212:		Line 212:
	\|image=none		\|image=none
	\|type=delete		\|type=delete
	\|The final command used was:		\|text=The final command used was:

	<pre>		<pre>

Admin: /* Surrounding Variable with Quotes */

2011-05-01T02:53:37Z

Surrounding Variable with Quotes

← Older revision		Revision as of 02:53, 1 May 2011
Line 167:		Line 167:
	\|image=none		\|image=none
	\|type=delete		\|type=delete
	\|The final Vim search command was:		\|text=The final Vim search command was:

	<pre>		<pre>

Admin at 02:53, 1 May 2011

2011-05-01T02:53:09Z

← Older revision		Revision as of 02:53, 1 May 2011
Line 119:		Line 119:

	=Grouping Symbols=		=Grouping Symbols=

			=Examples=

			==Surrounding Variable with Quotes==

			I needed to find all instances of the following four patterns in a file:

			<pre>
			${X1},${X1},${X1}

			${X2},${X2},${X2}

			${X3},${X3},${X3}

			${X4},${X4},${X4}
			</pre>

			and replace them with the same thing, but just surrounded by single quotes:

			<pre>
			'${X1},${X1},${X1}'

			'${X2},${X2},${X2}'

			'${X3},${X3},${X3}'

			'${X4},${X4},${X4}'
			</pre>

			I wanted to construct one search using [[Vim]] (or using [[Sed]]) that would do this. It is:

			<pre>
			:%s/$\${X[1-4]},\${X[1-4]},\${X[1-4]}$/'\1'/g
			</pre>

			Breaking this down:

			<pre>
			:%s/$...$/'\1'/g
			</pre>

			this will take whatever is in between <code>$</code> and <code>$</code>, and will replace it with the same thing, hence the <code>\1</code>, but surrounded by single quotes, hence <code>'\1'</code>.

			Next, the stuff going between <code>$</code> and <code>$</code> has to match all instances above, so it needs to use regexp to match a digit between 1 and 4, hence the <code>[1-4]</code>.

			{{Ambox
			\|image=none
			\|type=delete
			\|The final Vim search command was:

			<pre>
			:%s/$\${X[1-4]},\${X[1-4]},\${X[1-4]}$/'\1'/g
			</pre>
			}}

			==Extracting Links from an HTML Page==

			I wanted to write a regular expression that would extract links from several HTML pages I had. To do this, I used sed. Given HTML source code:

			<pre>
			<h1>Some html junk</h1>
			<p>This is a bunch of junk. The thing I really want is the <a href="http://www.yournamehere.com">link location</a>.
			</pre>

			I wanted to pull out all the HTML links, like <code>http://www.yournamehere.com</code>.

			To start with, I ran the sed script on the output from an echo command:

			<pre>
			$ echo '<a href="as:df/qw.er/ty"><img src="">' \| sed ...
			</pre>

			This way, I could test the sed script, then run it on the full HTML source code when I was done.

			The sed script I used was:

			<pre>
			sed -n 's/.href="$[^"]\{1,\}$./\1/p'
			</pre>

			First, the <code>-n</code> flag tells sed not to print the result of the sed processing (this will be done manually).

			Next, the search pattern consists of an arbitrary number of characters <code>.*</code>, followed by <code>href="</code>, followed by the link text itself (what we're interested in getting).

			The link text is, first, put between <code>$</code> and <code>$</code> because whatever is between these, as in the previous example, can be printed out using <code>\1</code>.

			The link text is matcehd using <code>[^"]</code>, which matches any character not a double-quote, followed by <code>\{1,\}</code>, which means 1 or more. The problem with using a simpler pattern like <code>href="$.*$"</code> is that the <code><a></a></code> tags could be followed by other tags, like <code><img src="..." /></code>, which would incorrectly match the link location, plus the closing of the <code><a></code> tag, plus the opening of the image tag, up to <code>src=</code>. That's bad news.

			Using <code>[^"]</code> is smarter because it will guarantee you only get the link text. This can create problems if, say, a double-quote is escaped in a link location, so it appears as <code>\"</code> in the link location, but this would be straightforward to correct.

			{{Ambox
			\|image=none
			\|type=delete
			\|The final command used was:

			<pre>
			/bin/grep -h "href" .html \| sed -n 's/.href="$[^"]\{1,\}$.*/\1/p'
			</pre>
			}}

	=References=		=References=

Admin: /* References */

2011-04-29T01:05:46Z

References

← Older revision		Revision as of 01:05, 29 April 2011
Line 123:		Line 123:

	* http://www.regular-expressions.info/characters.html		* http://www.regular-expressions.info/characters.html
			* http://vim.runpaint.org/searching/creating-regular-expressions/

Admin: /* Grouping Symbols */

2011-04-29T01:04:54Z

Grouping Symbols

← Older revision		Revision as of 01:04, 29 April 2011
Line 119:		Line 119:

	=Grouping Symbols=		=Grouping Symbols=

			=References=

			* http://www.regular-expressions.info/characters.html

Admin: /* Character Classes */

2011-04-28T08:28:07Z

Character Classes

← Older revision		Revision as of 08:28, 28 April 2011
Line 80:		Line 80:
	</pre>		</pre>

			==Repeating Sets==

			You can add a plus sign to the end of a set to indicate that it repeats multiple times:

			<pre>
			[A-Z]+
			</pre>

			will match any longer-than-one sequence of capital letters.

			If you want to match repetitions where the ''same character'' is repeated, rather than just any character in the set being matched multiple times, you can indicate you want only the first character matched to be repeated:

			<pre>
			([0-9])\1+
			</pre>

			will match 666 but not 123.

	=Anchors=		=Anchors=

Admin: /* Anchors */

2011-04-28T08:24:16Z

Anchors

@@ Line 83: / Line 83: @@
 =Anchors=
 =Repetition Symbols=
 =Grouping Symbols=

Admin: Created page with "=Intro= Regular expressions provide a way of searching for, and matching, text patterns. They allow for very fine control over pattern-matching, and are useful in many programs..."

2011-04-28T08:23:02Z

Created page with "=Intro= Regular expressions provide a way of searching for, and matching, text patterns. They allow for very fine control over pattern-matching, and are useful in many programs..."

New page

=Intro=

Regular expressions provide a way of searching for, and matching, text patterns. They allow for very fine control over pattern-matching, and are useful in many programs, like [[Awk]], [[Sed]], [[Vim]], [[Grep]], [[PHP]], [[Perl]], and other programming languages.

Regular expressions have several special groups of symbols:
* Literal characters - these mean exactly what they say
* Special characters - characters with special meaning in regular expressions (e.g. brackets and parentheses)
* Character sets - these symbols represent a set of characters
* Anchors - these match locations in a line, such as the beginning or end, or the boundary between words
* Repetition symbols - these allow you to locate patterns with repetition in them
* Grouping symbols - these provide a way to group terms

=Literal Characters=

=Special Characters=

=Character Sets=

In regular expressions, you can use expressions to match entire sets of characters, instead of individual characters. These are typically several (or a range of) characters surrounded by brackets.

Character sets can be inclusive (meaning, include a list of characters in the expression being searched for) or exclusive (meaning, excluding a list of characters from the expressions being searched for).

==Inclusive Sets==

Inclusive sets are straightforward: just put the characters you're searching for in between brackets. For example,

<pre>
[aeiou]
</pre>

will match any vowel. So searching for a pattern like:

<pre>
gr[ae]y
</pre>

will match gray or grey.

==Exclusive Sets==

If the

==Character Set Special Characters==

The only characters with special meaning in character sets are the backslash, the hyphen, the caret, and the close-bracket. These are usually escaped with a backslash.

Special characters don't always have to be escaped (this makes the regular expression more readable).

'''Backslash''': the backslash always needs to be escaped

'''Caret''': the caret can go unescaped anywhere EXCEPT right after the opening bracket

'''Closing bracket''': the closing bracket can go right after the opening bracket or right after the negating caret. For example:

<pre>
[^]a
</pre>

matches any character that is not a closing bracket or an "a".

'''Hyphen''': this can go right after the opening bracket or right before the closing bracket. For example:

<pre>
[-abcdefg]
[abcdefg-]
</pre>

These will both match the first 6 letters of the alphabet, or a hyphen.

==Character Classes==

Character classes can be used to match a pre-defined set of characters, e.g. all numbers or all non-whitespace characters:

<pre>
\d - matches [0-9]
\w - matches [A-Za-z0-9_]
\s - matches [ \t\r\n]
</pre>

=Anchors=

=Repetition Symbols=

=Grouping Symbols=