Regular Expression Recipes: A Problem-Solution Approach [Paperback]

This is the cookbook approach to regular expressions. Nathan gives a bunch of common scenarios (parsing filenames, CSV, validating emails and SSNs) and gives us the expression in Perl. Followed by a discussion of the code, and further examples in PHP, shell script, VIM and others.

There is a small section at the beginning to teach you the fundamentals. But there is nothing at the level of Mastering Regular Expressions (O'Reilly), the classic work in the field.

This book is a good reference for those more interested in simply getting the job done, than in understanding how or why the pattern works. There are some bad examples. In particular the Spam filter example is almost worthless. But most of the examples are well written.

If you spend time working writing applications that have to do pattern matches and/or replacements, you know about some of the intricacies of regular expressions. For many people they can be an arcane hodgepodge of odd characters, but they don't have enough time (or interest) to really understand how to code them. Nathan A. Good has written <cite>Regular Expression Recipes: A Problem-Solution Approach</cite> for those people. In its relatively slim 289 pages, he offers 100 regular expressions in a cookbook format, tailored to solve problems in one of six broad categories (Words and Text, URLs and Paths, CSV and Tab-Delimited Files, Formatting and Validating, HTML and XML, and Coding and Using Commands).

Regular expressions are not restricted to just the Perl or shell environments, so Nathan offers variations for Python, PHP, and VIM as well. In most cases the translation is relatively straight-forward, but in a few cases a different environment may have (or lack) additional facilities, prompting a different expression to do the same task.

Before you even read chapter 1, Nathan provides a quick summary course on regular expressions, with detail given to each of the five environments you might utilize. He has written the syntax overview in a highly-readable format, making it easy to understand the gobbledy-gook of the most bizarre concoctions you might encounter.

In each chapter, Nathan gives examples of how to find single words, multiple words, and repeated words, along with examples of how to replace various detected strings with others. In each case he gives an example of its use for each platform, followed by a bit-by-bit breakdown of how it works. Not every environment is given on every example, and in many cases the "How It Works" section refers to the first one, as most REs are identical between the platforms.

First, I must admit that there are a number of useful solutions provided, especially for someone who is concerned with application and web development. However, I did feel a little cheated by the fact that several chapters covered essentially the same task, with only minor variations. It almost seemed as though the author was trying to pad out the solution count to the magic number 100. A simple example: three solutions in chapter one cover (a) replacing smart quotes with straight quotes, (b) replacing copyright symbols with the (c) tri-graph, and (c) replacing trademark symbols with the (tm) sequence. Did we really need three separate chapters for that? I don't think so.

Another quibble revolves around some of the coding of the expressions. Nathan has made liberal use of the non-capturing groups to insure only the items that needed replacement were captured. While a worthy idea, in some cases the expression may have been simplified for understanding. Another issue is a slight error in searching for letters. In a number of expressions, Nathan uses [A-z] to capture all letters. Unfortunately, the special characters [, \, ], ^, _, and ` occur between upper-case Z and lower-case a, making it match too much. Either [[:alpha:]] or [A-Za-z] should have been used.

Despite a couple of quibbles, <cite>Regular Expression Recipes</cite> does provide a useful compendium of solutions for common problems developers face. Presenting the information in a cookbook fashion, along with insuring that those using something other than Perl don't have to sweat translating the expressions to their target language, makes this a handy book to have. I wouldn't hesitate to recommend it.

In "Regular Expression Recipes" the author does a good job of cutting away the sometimes tedious and at sometimes overwhelming job of teaching the reader every in and out of regular expessions and instead focuses on providing practical, real-world examples that the reader can try in a variety of languages and see instant results.

No doubt, one of the strengths of this book is that is takes Regular Expressions and demonstrates them not in just one language but in several (Perl, Python, PHP, grep, sed and Vim). In this way, a reader who is familiar with any of these languages can catch on and understand what is happening without having to learn yet another syntax just to understand the basics of regular expressions.

The book itself is categorized into different topics with an index system that makes it easy to jump to right what you are most interested in. When the author covers a topic, such as Reformatting Last Names, he also cross-references other useful, related regular expressions that the reader may also have an interest in given the topic.

Of particular interest to those new to the Regular Expression field, the author does a good job of explaining in everyday terms how an expression works. One of the drawbacks of many RegEx books is that often you cannot grasp exactly why a certain syntax works because of the complexity of the problem.

The only lacking spot in this book is that it does not include any "real" output of running the regular expressions; however given the content and ease-of-use of the book, this is but a small caveat that should not impact most readers.

Overall, a wonderful reference that explains Regular Expressions in terms that most beginning and intermediate users will enjoy and learn from.