My favorite is https://regex101.com/

But I've found all of the following to be useful:

http://regexone.com/

http://www.regexpal.com/

http://www.rexegg.com/

http://regexr.com/

https://www.debuggex.com/

https://regexper.com/

https://www.regular-expressions.info/

http://www.cheatography.com/davechild/cheat-sheets/regular-e...

http://eloquentjavascript.net/09_regexp.html

http://www.smashingmagazine.com/2009/06/essential-guide-to-r...

http://www.smashingmagazine.com/2009/05/introduction-to-adva...

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guid...

http://codylindley.com/techpro/2013_05_14__javascript-regula...

These: regex101.com and regexper.com !

Regexper will render your regular expression as a friggin' railroad diagram!! It's extremely handy when debugging your regex or to understand those super complex, multiline regexes, that someone has posted to Stack Overflow.

Both regular-expressions.info and rexegg.com are incredibly good explanations of Regular Expressions.

regular-expressions.info is even available as a PDF e-book against a tip of your choice.

Here is one for Ruby: https://rubular.com/

Time for a shout-out to Lea Verou's terrific fifty-minute tutorial "Regexplained" and accompanying regex playground:

https://youtu.be/EkluES9Rvak

https://regexplained.com/

And for python this one is nice: https://pythex.org/

Regex101 let's you switch mode, and has a python regex one.

pythex works ok but it's UI/UX is worse than regex101 (which as a friend state, has pythonre capabilities as well.

try regex101 and you won't look back.

Thanks for the list, but are they all the same? Why go to one over the other?

It makes me wonder, is there something about Regex that makes people want to create so many tools for it, even after so many other ones already exist?

Some support other varieties of RegEx, and some have interesting features or different interfaces

Not sure if it's completely comprehensive, but the clearest tutorial/reference of regex's that I've used is in the book "The AWK Programming Language" by Aho, Kernighan, Weinberger.

https://ia902309.us.archive.org/25/items/pdfy-MgN0H1joIoDVoI...

That is a nice introduction indeed. Afterwards, to get a taste for more complex matching, maybe the Perl / PCRE docs.

https://perldoc.perl.org/perlre.html

I especially like debuggex for debugging/teaching purposes, here's an example: https://www.debuggex.com/r/SMLRfiyt0Ag2hXu5

Thank you for posting these links. I'm lost whenever I attempt something with Regex.

Are there any online regex testers for ICU regexes?

I prefer regex101.com because that site assigns different colors to different capture groupings. I made a previous comment on this and why it's helpful: https://news.ycombinator.com/item?id=9581692

(For some reason RegExr.com is submitted to HN much more often than regex101.com. Is there a compelling advantage to RegExr that I've overlooked?)

Although it's overkill when I could have a reference sheet on my computer or on the wall, but I always remember that regexr has its cheat sheet on the side that I can easily get to. I use their cheat sheet more than the actual editor on their page.

It looks like regex101 has it as well, but the regexr one is straight to the point (at least for me). https://i.imgur.com/Hg9jGOa.png

regexr is open source, unlike regex101.

That doesn't make it better.

I prefer regex101 too. I think it has fewer features, but it has the right features and is so easy to approach.

I’m a big fan.

The problem I have with all of these regex websites and tools is that they usually only use the regex dialect of whatever language they’re written in. Or at best, a very incomplete list of dialects. Subtle differences between dialects matter a lot. Personally, I would need at least Perl, Python, GNU utils (with and without -E), BSD utils (or whatever comes with macOS, again with and without-E), and vim with the various settings for “magic”. Ideally, they would also be able to convert between all these dialects.

If you were on Windows, you could try RegexBuddy. It supports regex dialects for: .NET, Boost (C++), Delphi, Groovy, Oracle Database, PowerShell, R, std::regex, VB6, wxWidgets, C#, MySQL, PHP, PostgreSQL, VBScript, Java, Perl, PCRE, JavaScript, Python, Ruby, Tcl ARE, POSIX BRE, POSIX ERE, GNU BRE, GNU ERE, XML Schema, and XPath. It will even generate code snippets for you based on the regex you create with the tool. It can also convert between these dialects and lets you know if features in the target dialect are not available.

I am not associated with this company in any way, just a long time user.

That does look impressive! I'm tempted to check how well this runs in Wine (since I'm not a Windows user)

RegexBuddy is a fantastic piece of software. It also runs fine under Wine.

https://regex101.com/ supports 4 dialects. Certainly not exhaustive, but very handy none-the-less.

Sounds like a fun side project :D

Posted many times but the large threads are:

2017 https://news.ycombinator.com/item?id=13599952

2015 https://news.ycombinator.com/item?id=9581225

2014 https://news.ycombinator.com/item?id=7537189

Already in 2008 the comments were listing others: https://news.ycombinator.com/item?id=277657

I find RegEx's a bit cryptic. Sure, with enough practice one can read them, but I'd like an alternative that can easily break out chunks as named units. One can then reference the named units to compose new named units. Divide-and-Conquer.

I'd like to see experiments in alternatives that provide this. It could help do for RegEx's what SQL's WITH statement did for long SQL statements.

Backus–Naur Form could act as a starting point, but it needs some syntactic adjustments to make it more compact and practical, in my opinion. Partial example:

     Side = VarFunc + Segment*;
     Segment = 
         ":" + Varfunc
      | (":" + VarFunc)[0..1] + "{" + "}"
      | (":" + Varfunc)[0..1] + "{" + Base + (";" + Base)* + "}";
     Letter = ('a'..'z'|'A'..'Z');
     ForbiddenChar = $anyChr("/?#%");
     /*
     Legend:
       [x..y] = quantity of repeats (substitute letters with integers)
       [0..n] = zero, one, or multiple
       * = shorthand for [0..n]
       | = "or"
       + = concatenation, ignores white-space
       ++ = concatenation, excludes white space
       +w+ = concatenation, must have white-space between
       'x'..'y' = character falls within range
       $x() = special function or constant, where "x" is a name.
     */

It sounds like you would like https://en.wikipedia.org/wiki/SNOBOL.

Though if you had to do enough work with text, my bet is that you'd eventually figure out why regexes won. They are simple, straightforward, and just enough to tackle the occasional matching problem on your way to doing something else.

Have you tried Parsing Expression Grammars (PEGs)? Most implementations allow use to name arbitrary sub-parsers, often using the programming language's native variables.

See for example Peg.js, LPEG (lua), etc. However, PEGs don't natively permit left recursion (note: some PEG implementations do add that on). If that's a problem, Earley parsers are a nice alternative.

Example of a calculator using Peg.js:

  start
    = additive

  additive
    = left:multiplicative "+" right:additive { return left + right; }
    / multiplicative

  multiplicative
    = left:primary "*" right:multiplicative { return left * right; }
    / primary

  primary
    = integer
    / "(" additive:additive ")" { return additive; }

  integer "integer"
    = digits:[0-9]+ { return parseInt(digits.join(""), 10); }

I wrote a very crude library like this in VimL to make writing syntax plugins a bit easier: https://github.com/b0o/builder.vim

You can see it in use here: https://github.com/b0o/quicktemplate.vim/blob/master/syntax/...

PCRE has the DEFINE keyword. Here's an example: https://regex101.com/library/gJ7pU0

(not to be confused with named capture groups)

There is a concept of named capturing groups:

https://www.regular-expressions.info/named.html

https://regexper.com will render your regex as railroad diagram. Maybe a help...

Look at perl6 grammars.

It looks extensive, but perhaps may be overkill for a common regex alternative. Thanks for the tip, though. A standard or semi-standard would have to start simple.

I usually prefer https://regexper.com/. Especially when trying to make sense of regexes I come across in code I didn't write.

I've been using this website for years. It's been so long now that I can't even remember when Grant Skinner, the former Flash/ActionScript guru, released it. Nice to see it shared here.

Why is there a sudden explosion of posts about regex in the last few days? Did something newsworthy happen that I missed, or is it more of a "I saw the post last week and then found this cool related thing" bandwagon effect?

I thinks it’s the latter.

If there is a major news item involving regular expressions, we’re all ready to pounce, ala: https://xkcd.com/208/

This is nice, but my go to tool is: https://www.debuggex.com/

Not only does it tell you what everything means, but it visually displays it in a way that just makes sense.

This is always the one I forget about and have a hard time finding. It's not really great for editing but it's probably the best display I've seen in regards to debugging large regex.

I can highly recommend the following tool: Mastering Regular Expressions by Jeffrey Friedl http://shop.oreilly.com/product/9780596528126.do

I found the pacing to be excellent, with complimentary exercises and that it was educational as both a cheatsheet and a coherent text. Learned a lot from it, despite being experienced from the outset.

For ruby regex, I use https://rubular.com/

Actually I use it for all platforms, and it works most of the time. If I notice that something is odd because the regex engine is different, then I'll use something else. But I really value Rubular's UI simplicity.

Beautiful! I tried it with a particularly nasty regex from a codebase I had and it did a fantastic job explaining what it would target. It's similar to regex101.com in a lot of ways, but the UI might be a little more easy to read and understand.

Something I can recommend to both experienced and "new developers" alike is https://regexper.com.

It generates clear graphs from regular expressions making immediately clear what they do.

I love this tool. I have customized Emacs keybindings that open RegExr in a xwidget-webkit instance, type in regexes, and exit RegExr with the regex inserted at the cursor.

Great for reading monstrous regexes or sharpening my regex skills.

This is always my go-to tool when I'm trying out RegEx!

Same, I'm a big fan.

One thing that's always perplexed me is the variants of regex and their differences - is there any write up that defines the majority of them?

Been using RegExr for years!

Me too! I have to admit I'm really bad at it and can never remember how the heck regular expressions work, but whenever I have to come up with something I just fiddle around in RegExr until it works. Documentation in the sidebar is super handy too.

regex101.com lets me have client-side validation without requiring a network connection, so it's way more useful to me than regexr (although the regexr UI is nice and I like their github repo).

doesnt support POSIX character classes.

this should be preferred over `a-z` as the latter relies on users locale.