{"result":{"depiction_url":null,"edges":{},"id":1601,"is_a":["text","documentation","cookbook"],"links":[{"rel":"self","target":"https:\/\/zotonic.com\/.zotonic\/websub\/topic\/1601"},{"rel":"hub","target":"https:\/\/zotonic.com\/.zotonic\/websub"}],"medium":null,"medium_url":null,"name":"doc_cookbook_justenough_re","page_url":{"en":"https:\/\/zotonic.com\/cookbook\/1601\/just-enough-regular-expressions-in-erlang","x-default":"https:\/\/zotonic.com\/cookbook\/1601\/just-enough-regular-expressions-in-erlang"},"preview_url":null,"resource":{"body":"
\n \n
\n\n

Learn how to manipulate string data with the re<\/span><\/code> module.<\/p>\n

Lloyd R. Prentice August 31, 2011<\/cite><\/p>\n

\n

WHY<\/h2>\n

The Erlang standard library re provides a powerful suite of functions\nto excute regular expressions to find, replace, and manipulate\nsubstrings within a string or Erlang binary.<\/p>\n

Re<\/cite> functions are particularly useful for form validation,\ndecomposing and modifying urls, e-mail addresses, and other common web\nelements represented as strings or binaries.<\/p>\n

They are found throughout Zotonic source files.<\/p>\n

See: http:\/\/www.erlang.org\/doc\/man\/re.html<\/a><\/p>\n<\/div>\n

\n

ASSUMPTIONS<\/h2>\n

You have a current version of Erlang installed on your system.<\/p>\n

Examples have been tested on Ubuntu 11.04.<\/p>\n<\/div>\n

\n

HOW<\/h2>\n

Bring up an Erlang terminal:<\/p>\n

<\/span>$ erl\nErlang R14B03 (<\/span>erts-5.8.4)<\/span> [<\/span>source]<\/span> [<\/span>64<\/span>-bit]<\/span> [<\/span>smp:3:3]<\/span> [<\/span>rq:3]<\/span> [<\/span>async-threads:0]<\/span> [<\/span>kernel-poll:false]<\/span>\n\nEshell V5.8.4  (<\/span>abort with ^G)<\/span>\n1<\/span>>\n<\/pre><\/div>\n<\/div>\n
and follow along with the following examples. Modify and re-execute\neach example until you feel comfortable with what’s going on.<\/p>\n
\n
What is a regular expression?<\/h3>\n
A regular expression is a pattern that is matched against a subject\nstring from left to right.<\/p>\n
The power of regular expressions comes from the ability to include\nalternatives and repetitions in the pattern. These are encoded in the\npattern by the use of metacharacters.<\/p>\n<\/div>\n
\n
What is a pattern?<\/h3>\n
Most characters stand for themselves in a pattern.<\/p>\n
The pattern “ick”, for instance, would match the first occurence of\n“ick” in the string “The quick brown fox.”<\/p>\n
We’ll use re:run\/2<\/span><\/code> to illustrate. This function checks a string agains a regular expression: run(Subject,RE)<\/span> -><\/span> {match,<\/span> Captured}<\/span> |<\/span> nomatch<\/span><\/code>.<\/p>\n
Example:<\/p>\n
<\/span>6<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"The quick brown fox."<\/span>,<\/span>"ick"<\/span>).<\/span>\n{<\/span>match<\/span>,[{<\/span>6<\/span>,<\/span>3<\/span>}]}<\/span>\n<\/pre><\/div>\n<\/div>\n
The atom “match” is self-explanatory. The tuple {6,3} in the list provides the start position and length of the pattern in the subject string.<\/p>\n
<\/span>7<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"The brown fox."<\/span>,<\/span>"ick"<\/span>).<\/span>\nnomatch<\/span>\n<\/pre><\/div>\n<\/div>\n
re:run\/2 will also work with a binary:<\/p>\n
<\/span>8<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span><<<\/span>"The quick brown fox."<\/span>>><\/span>,<\/span>"ick"<\/span>).<\/span>\n{<\/span>match<\/span>,[{<\/span>6<\/span>,<\/span>3<\/span>}]}<\/span>\n<\/pre><\/div>\n<\/div>\n
If we wish to find all instances of “ick” in a string, we need to use\nre:run\/3, run(Subject,RE,Options)<\/span> -><\/span> {match,<\/span> Captured}<\/span> |<\/span> match<\/span> |<\/span> nomatch<\/span><\/code>.<\/p>\n
Example:<\/p>\n
<\/span>9<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"The sick quick brown fox."<\/span>,<\/span> "ick"<\/span>,<\/span> [<\/span>global<\/span>]).<\/span>\n{<\/span>match<\/span>,[[{<\/span>5<\/span>,<\/span>3<\/span>}],[{<\/span>11<\/span>,<\/span>3<\/span>}]]}<\/span>\n<\/pre><\/div>\n<\/div>\n
For documentation of re:run\/3 options, see http:\/\/www.erlang.org\/doc\/man\/re.html<\/p>\n<\/div>\n
\n
How can I replace a substring in a string?<\/h3>\n
Use re:replace\/3<\/span><\/code>: replace(Subject,<\/span> RE,<\/span> Replacement)<\/span> -><\/span> iodata()<\/span> |<\/span> unicode:charlist()<\/span><\/code>.<\/p>\n
Example:<\/p>\n
<\/span>10<\/span>><\/span> re<\/span>:<\/span>replace<\/span>(<\/span>"The quick brown fox."<\/span>,<\/span> "brown"<\/span>,<\/span> "red"<\/span>).<\/span>\n[<\/span><<<\/span>"The quick "<\/span>>><\/span>,<\/span><<<\/span>"red"<\/span>>><\/span>|<\/span><<<\/span>" fox."<\/span>>><\/span>]<\/span>\n<\/pre><\/div>\n<\/div>\n
Hmmm… re:replace\/3 returns an odd-looking binary, which is called an\niolist<\/cite>: an efficient data structure, used like this to prevent\ncopying of data in memory.<\/p>\n
But, let’s use re:replace\/4 to provide an option: replace(Subject,<\/span> RE,<\/span> Replacement,<\/span> Options)<\/span> -><\/span> iodata()<\/span> |<\/span> unicode:charlist()<\/span><\/code>:<\/p>\n
<\/span>11<\/span>><\/span> re<\/span>:<\/span>replace<\/span>(<\/span>"The quick brown fox."<\/span>,<\/span> "brown"<\/span>,<\/span> "red"<\/span>,<\/span> [{<\/span>return<\/span>,<\/span> list<\/span>}]).<\/span>\n"The quick red fox."<\/span>\n<\/pre><\/div>\n<\/div>\n
The {return,<\/span> list}<\/span><\/code> does the trick of returning a “regular”\nstring. Erlang documentation is generally thorough, but often not that\neasy to follow. That’s why I created this Cookbook item. I wanted to\nlearn this stuff myself.<\/p>\n
Regular expressions can deliver much much more, however, with shrewd\nuse of metacharacters.<\/p>\n<\/div>\n
\n
What is a metacharacter?<\/h3>\n
Metacharacters are interpreted in special ways. For instance, the\nmetacharacter . matches the first instance of any character in a\nstring except newline.<\/p>\n
Example:<\/p>\n
<\/span>13<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"The quick brown fox."<\/span>,<\/span> "."<\/span>).<\/span>\n{<\/span>match<\/span>,[{<\/span>0<\/span>,<\/span>1<\/span>}]}<\/span>\n<\/pre><\/div>\n<\/div>\n
You’d usually use . in a more elaborate pattern:<\/p>\n
<\/span>14<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"The quick brown fox."<\/span>,<\/span> "qu."<\/span>).<\/span>\n{<\/span>match<\/span>,[{<\/span>4<\/span>,<\/span>3<\/span>}]}<\/span>\n\n15<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"The quack brown fox."<\/span>,<\/span> "qu."<\/span>).<\/span>\n{<\/span>match<\/span>,[{<\/span>4<\/span>,<\/span>3<\/span>}]}<\/span>\n<\/pre><\/div>\n<\/div>\n
The metachacter ^ asserts start of string.<\/p>\n
Examples:<\/p>\n
<\/span>16<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"The quack brown fox."<\/span>,<\/span> "^The"<\/span>).<\/span>\n{<\/span>match<\/span>,[{<\/span>0<\/span>,<\/span>3<\/span>}]}<\/span>\n\n17<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"The quack brown fox."<\/span>,<\/span> "^qua"<\/span>).<\/span>\nnomatch<\/span>\n<\/pre><\/div>\n<\/div>\n
Similarly, the metacharacter $ asserts the end of a line:<\/p>\n
<\/span>18<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"The quick brown fox is sick."<\/span>,<\/span> "ick.$"<\/span>).<\/span>\n{<\/span>match<\/span>,[{<\/span>24<\/span>,<\/span>4<\/span>}]}<\/span>\n<\/pre><\/div>\n<\/div>\n
The metacharacter * matches zero or more characters.<\/p>\n
Examples:<\/p>\n
<\/span>19<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"The quick brown fox."<\/span>,<\/span> "i*"<\/span>).<\/span>\n{<\/span>match<\/span>,[{<\/span>0<\/span>,<\/span>0<\/span>}]}<\/span>\n\n20<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"The quick brown fox."<\/span>,<\/span> "T*"<\/span>).<\/span>\n{<\/span>match<\/span>,[{<\/span>0<\/span>,<\/span>1<\/span>}]}<\/span>\n\n21<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"TTTTThe quick brown fox."<\/span>,<\/span> "T*"<\/span>).<\/span>\n{<\/span>match<\/span>,[{<\/span>0<\/span>,<\/span>5<\/span>}]}<\/span>\n<\/pre><\/div>\n<\/div>\n
The metacharacter + matches one or more characters:<\/p>\n
<\/span>22<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"TTTTThe quick brown fox."<\/span>,<\/span> "z+"<\/span>).<\/span>\nnomatch<\/span>\n\n23<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"TTTTThe quick brown fox."<\/span>,<\/span> "T+"<\/span>).<\/span>\n{<\/span>match<\/span>,[{<\/span>0<\/span>,<\/span>5<\/span>}]}<\/span>\n<\/pre><\/div>\n<\/div>\n
The metacharacter | alternate patterns. Think of it as “or”:<\/p>\n
<\/span>24<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"The quick brown fox."<\/span>,<\/span> "fox|pig"<\/span>).<\/span>\n{<\/span>match<\/span>,[{<\/span>16<\/span>,<\/span>3<\/span>}]}<\/span>\n\n25<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"The quick brown pig."<\/span>,<\/span> "fox|pig"<\/span>).<\/span>\n{<\/span>match<\/span>,[{<\/span>16<\/span>,<\/span>3<\/span>}]}<\/span>\n<\/pre><\/div>\n<\/div>\n
You can also match generic character types. s, for instance matches\nany whitespace character.<\/p>\n
Examples:<\/p>\n
<\/span>26<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"The quick brown fox"<\/span>,<\/span>"<\/span>\\s<\/span>"<\/span>,[<\/span>global<\/span>]).<\/span>\n{<\/span>match<\/span>,[[{<\/span>3<\/span>,<\/span>1<\/span>}],[{<\/span>9<\/span>,<\/span>1<\/span>}],[{<\/span>15<\/span>,<\/span>1<\/span>}]]}<\/span>\n<\/pre><\/div>\n<\/div>\n<\/div>\n
\n
How can I match non-printing characters?<\/h3>\n
See: Non-printing characters http:\/\/www.erlang.org\/doc\/man\/re.html<\/a><\/p>\n
Note that the metacharacters [ and ] have special meaning, they\nenclose “character classes.”  A character class is the set of\ncharacters in a character class match, if any found, one character in\nthe subject string.<\/p>\n
Examples:<\/p>\n
<\/span>24<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"The quick brown fox."<\/span>,<\/span> "[qui]"<\/span>).<\/span>\n{<\/span>match<\/span>,[{<\/span>4<\/span>,<\/span>1<\/span>}]}<\/span>\n\n25<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"The quick brown fox."<\/span>,<\/span> "[ui]"<\/span>).<\/span>\n{<\/span>match<\/span>,[{<\/span>5<\/span>,<\/span>1<\/span>}]}<\/span>\n\n26<\/span>><\/span> re<\/span>:<\/span>run<\/span>(<\/span>"The quick brown fox."<\/span>,<\/span> "[qui]"<\/span>,<\/span> [<\/span>global<\/span>]).<\/span>\n{<\/span>match<\/span>,[[{<\/span>4<\/span>,<\/span>1<\/span>}],[{<\/span>5<\/span>,<\/span>1<\/span>}],[{<\/span>6<\/span>,<\/span>1<\/span>}]]}<\/span>\n<\/pre><\/div>\n<\/div>\n
You can combine characters, meta-characters, and other regular\nexpression elements into extended patterns that can search, match, and\nreplace nearly any substrings you can imagine.<\/p>\n
Example:<\/p>\n
<\/span>27<\/span>> re:run(<\/span>"E-mail: xyz@pdq.com"<\/span>, "[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[a-z]{2,3}"<\/span>)<\/span>.\n{<\/span>match,[{<\/span>8<\/span>,11}]}<\/span>\n<\/pre><\/div>\n<\/div>\n
Note: DO NOT use this pattern in production. It needs more refinement and much more testing.<\/p>\n
What other goodies does re<\/span><\/code> offer?<\/p>\n
split(Subject,<\/span> RE)<\/span> -><\/span> SplitList<\/span><\/code> and split(Subject,<\/span> RE,<\/span> Options)<\/span> -><\/span> SplitList<\/span><\/code>.<\/p>\n
Examples:<\/p>\n
<\/span>28<\/span>><\/span> re<\/span>:<\/span>split<\/span>(<\/span>"this\/is\/my\/path"<\/span>,<\/span>"\/"<\/span>).<\/span>\n[<\/span><<<\/span>"this"<\/span>>><\/span>,<\/span><<<\/span>"is"<\/span>>><\/span>,<\/span><<<\/span>"my"<\/span>>><\/span>,<\/span><<<\/span>"path"<\/span>>><\/span>]<\/span>\n<\/pre><\/div>\n<\/div>\n
If you wish to use a pattern multiple times and boost perfomance, you\ncan compile it with re:compile\/1<\/span><\/code>.<\/p>\n
Example:<\/p>\n
<\/span>29>  {_, P} = re:compile("[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[a-z]{2,3}").\n{ok,{re_pattern,0,0,\n              <<69,82,67,80,164,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,64,\n                ...>>}}\n30> re:run("E-mail: xyz@pdq.com", P).\n{match,[{8,11}]}\n<\/pre><\/div>\n<\/div>\n
How are regular expressions used in Zotonic source?<\/p>\n
For one of many examples, look at zotonic\/src\/markdown\/get_url\/1<\/span><\/code>:<\/p>\n
<\/span>get_url<\/span>(<\/span>String<\/span>)<\/span> -><\/span>\n  HTTP_regex<\/span> =<\/span> "^(H|h)(T|t)(T|t)(P|p)(S|s)*:\/\/"<\/span>,<\/span>\n  case<\/span> re<\/span>:<\/span>run<\/span>(<\/span>String<\/span>,<\/span> HTTP_regex<\/span>)<\/span> of<\/span>\n      nomatch<\/span>    -><\/span> not_url<\/span>;<\/span>\n      {<\/span>match<\/span>,<\/span> _}<\/span> -><\/span> get_url1<\/span>(<\/span>String<\/span>,<\/span> [])<\/span>\n  end<\/span>.<\/span>\n<\/pre><\/div>\n<\/div>\n
Where can I go from here?<\/p>\n
Study and experiment with all the metacharacters and other regular\nexpression constructs in:<\/p>\n
http:\/\/www.erlang.org\/doc\/man\/re.html<\/a><\/p>\n
Do further research on the web. Everytime you see an interesting\nregular expression, test it in re:run\/2. You may well have to edit to\nget it to run on re:run\/2. But if you understand the basics, it won’t\nbe difficult.<\/p>\n<\/div>\n<\/div>\n
\n
TROUBLESHOOTING<\/h2>\n
CAUTION: Complex regular expression patterns are hard to read and\nerror prone. Break them down into short segments and test each\nsegment. Then build them back up.<\/p>\n
The hard part is confirming that your pattern will match all possible\ninstances of the string segments you’re interested in.<\/p>\n<\/div>\n
\n
RESOURCES<\/h2>\n
http:\/\/www.erlang.org\/doc\/man\/re.html<\/a>\nhttp:\/\/langref.org\/erlang\/pattern-matching<\/a>\nhttp:\/\/www.regular-expressions.info\/examples.html<\/a><\/p>\n<\/div>\n<\/div>\n\n\n           <\/div>","category_id":{"id":318,"is_a":["meta","category"],"name":"cookbook","title":{"_type":"trans","tr":{"en":"Cookbook"}},"uri":"https:\/\/test.zotonic.com\/id\/318"},"content_group_id":{"id":339,"is_a":["meta","content_group"],"name":"default_content_group","title":{"_type":"trans","tr":{"en":"Default Content Group"}},"uri":"https:\/\/zotonic.com\/id\/default_content_group"},"created":"2020-05-30T05:47:27Z","creator_id":{"id":336,"is_a":["person","robot"],"name":"gitbot","title":"Git","uri":"https:\/\/zotonic.com\/id\/336"},"github_url":"https:\/\/github.com\/zotonic\/zotonic\/tree\/master\/doc\/cookbook\/justenough-re.rst","is_authoritative":true,"is_dependent":false,"is_featured":false,"is_protected":false,"is_published":true,"is_unfindable":false,"language":["en"],"modified":"2022-02-15T10:01:41Z","modifier_id":{"id":336,"is_a":["person","robot"],"name":"gitbot","title":"Git","uri":"https:\/\/zotonic.com\/id\/336"},"name":"doc_cookbook_justenough_re","pivot_geocode":null,"pivot_location_lat":null,"pivot_location_lng":null,"privacy":0,"publication_end":"9999-06-01T00:00:00Z","publication_start":"2022-02-15T10:01:41Z","slug":"just-enough-regular-expressions-in-erlang","title":"Just Enough Regular Expressions (in Erlang)","title_slug":"just-enough-regular-expressions-in-erlang","tz":"UTC","uri":null,"version":18,"visible_for":0},"uri":"https:\/\/zotonic.com\/id\/1601","uri_template":"https:\/\/zotonic.com\/id\/:id","websub":{"hub":"https:\/\/zotonic.com\/.zotonic\/websub","topic":"https:\/\/zotonic.com\/.zotonic\/websub\/topic\/1601"}},"status":"ok"}