How do you regex?

For building & explaining regular expressions, I always use regex101.com/. It's a great tool that really break down how your regular expression will work, which is very useful if it can get complex. It also has multi-language support to match the regex flavors across different major languages & distributions.

For learning regex, I usually just Google and dive through StackOverflow posts similar to what I'm trying to do. If I write a regex that is more complicated than just some alphanumeric grouping, I try to comment it with some human text such as capture the ID from the post slug or something of the sorts...not very in-depth, but 😅

Regular expressions are most commonly used when I am validating string structure, which could be form inputs, hostname information, or CSV data. If I am parsing strings, my first go-to for basic cases is to do some combination of .split() and .join on the resulting array, as its a bit easier to reason about and requires no understanding of regular expressions, just some basic logic. I tend to fall back to regular expressions if the string parsing is more complicated, has more than one match, or requires some more advanced substitution.

I usually work from memory and try to use as many named capturing groups as possible because I find that it serves to provide basic, inline, documentation of the pattern itself, and provides a more expressive way of accessing the groups on the match result:

const regex = /(?<first>[^\-])-(?<second>[^\-])-(?<rest>.+)/

const { groups } = regex.exec("1-2-3-4-5")

groups.first
'1'
groups.second
'2'
groups.rest
'3-4-5'

I just write them down; ,usually they work. I comment more complex RegExp by splitting up the parts of it in a comment, e.g. for a simple example:

// Matches cookies in document.cookie
// $1: key `([^=]+)` one or more not `=`
// separator `=`
// $2: value `([^;]+)` one or more not `;`
// Modifier 'g' (global)
const cookieMatcher = /([^=]+)=([^;]+)/g;

Well I did use regex quite heavily to build a basic JS syntax highlighter (instead of doing it properly with tokenisation)

Other than that I just tend to use them for validation of input!

I like using regexr.com/ to test my regex and make sure it behaves correctly for edge cases. It's a wonderful tool!

These days, I mainly use regex at the editor level (e.g., in VS Code) to mass-replace certain patterns with other patterns when it's not possible to easily rename them using built-in editor shortcuts. For example, in early 2021, I migrated my site from Jekyll to 11ty, and as part of that migration, I had to convert a bunch of my Liquid shortcodes to use a new syntax. Since I had hundreds of matches, I relied on regex to mass-replace them rather than doing it by hand.

More recently, I also learned about the HTML pattern attribute, which accepts any valid regex to validate a form input, and have been using it where appropriate for client-side validation. For example, in a recent project, I used the pattern ^[a-zA-Z0-9-](?:(,\s*)?[a-zA-Z0-9-])*$ to match a comma-separated list of identifiers, with potential spaces after the commas. It seemed difficult to arrive at this solution initially, but then I realized that it was just a more complex case of the slug regex pattern I used here: npmjs.com/package/is-slug.

While I find it easy to compose basic regex patterns, I do think it's harder to read regex, especially for complex patterns like the one above, and especially if I'm reading other people's regex.

For Ruby regex I've always used Rubular as a lightweight reference tool. I do much more from knowledge/memory than I used to, but I'm still mostly a user of search and tools like this for anything complicated.

• Tools? None, most of the times. For most complex regex, I wrote myself a nice "regexp generator" library that allows me to "build" regexp in more readable way.
• Problems? It depends on the language, actually. In Ruby I use them mostly to parse simple line-based text files. In Ada I use them more sparingly, usually when I need some kind of lexical analyzer. The reason for this difference is that in Ruby using regexp is much easier: just write something like /[a-z][0-9]+/, in Ada it is a bit more involved.

1. ask copilot
2. got dumb answer? so $askagain
3. test that! curl_cat_whatever $something | rg -n -w $regex
4. bug? visualize regex as railroad diagram (I'm still searching CLI similar to npeg but for regex while being a stand-alone binary)
5. ditch regex and just use PEG 😂

I wrote(WIP) an article which I shared with my colleagues which explains regex. These colleagues have little to no knowledge on how regex works hence the urge to write and help them get started using it since we're the last people who work on clients' project before giving it back to them. Our work includes making sure the data's clean and consistent. notion.so/vicentereyes/Introductio...

I use Regexr (regexr.com) to quickly test out my regexes. It supports JS style regex. and is very handy since it has features like live preview, and explanation of your regex.

For explaining regex, I mostly try to create simple and small regex, and assign it to some const (or function) to make it understandable.
e.g. I'll never do if (/regex/.test(str)), but always const EMAIL_REGEX = /regex/, and then my code.

For solving problems, I use it to sometimes modify data structures on the fly, and code refactor.
I also recently wrote a post about it: dev.to/admitkard/regexp-cheatsheet...

RegExp Cheatsheet to speed up code editing and refactor

Piyush Kumar Baliyan for AdmitKard ・ Jan 4 ・ 5 min read

#javascript #vscode #regex #webdev