Parsing JSON with a single regex

http://blogs.perl.org/users/brian_d_foy/2013/10/parsing-json-with-a-single-regex.html

by kamaal • 13 years ago

37 30 13 years ago

blogs.perl.org

kamaal3• 13 years ago

Here is the original thread on which this talk is based upon : http://www.perlmonks.org/?node_id=995856

Gigablah• 13 years ago

Right, now parse HTML :D

sateesh• 13 years ago

Oh that has already been done too, using perl :) http://stackoverflow.com/questions/4231382/regular-expressio... (Check the answer from tchrist)

pak• 13 years ago

A great example of why you shouldn't, in fact, ever try doing this for JSON parsing within something important.

yeukhon4• 13 years ago

or this: http://stackoverflow.com/questions/827557/how-do-you-validat...

gjm11• 13 years ago

Or for that matter this: http://stackoverflow.com/questions/1732348/regex-match-open-...

(which is what I was expecting yeukhon's link to go to; it comes up in every discussion of abusing regular expressions to parse very non-regular languages, for good reason).

andyidsinga• 13 years ago

..because you can!!

DanWaterworth• 13 years ago

Somebody show this guy a parser combinator library.

meritt• 13 years ago

.. but... JSON isn't regular. And neither is HTML :(

gpvos2• 13 years ago

Did you look at the regex? Perl regexes are also not regular; they're basically grammars.

yeukhon4• 13 years ago

I might be off on this one, but regular expressions are and can be defined by regular grammar. No?

duedl0r• 13 years ago

very ugly presentation....

ot• 13 years ago

To whomever is thinking "but JSON is not regular!", note that that regex is not a regular expression (Perl has a very liberal definition of regexes).

Perl regexes can be recursive: the operator $^R means "match here the whole regex itself", making the matching algorithm a full recursive descent parser. I suspect that parsing speed wouldn't be too bad because JSON is LL(1), so the parser shouldn't backtrack.

I don't think that the author is suggesting to use this in any useful code, he's just showing a cool hack. It kind of resonates well with the Perl aesthetics of short, "clever" code with as little as possible dependencies (and a fascination for regexes).

fulafel• 13 years ago

The original Randal Schwartz post (http://www.perlmonks.org/?node_id=995856) says it was infact code for a customer app.

evandrix• 13 years ago

save disabled by author @ http://www.slideshare.net/brian_d_foy/json-regex

lazyjones2• 13 years ago

Running code in the regex with (?{ ... code ... }) is cheating, because you can just put a whole Perl program in there. It's also one of the many badly implemented features of Perl that could be more useful if the implementation was any good. Using it will cause subtle bugs when you use regexps in the code called from there (even if you just call a sub/function), because the context (of regexp processing) isn't saved.

kamaal3• 13 years ago

>Running code in the regex with (?{ ... code ... }) is cheating, because you can just put a whole Perl program in there.

Would you like to call eval, recursion, macros, closures and many such things cheating?

Sorry but doing things without understanding or knowing the true consequences of what you are actually writing, always causes bugs. And that's true with any programming language.

Perl has many features which are designed to make the language powerful enough, to express solutions to very complex problems that other wise demands piles and piles of code in other languages. That's the whole point of the Perl language as a whole, you should take a really hard problem on a Friday night which you would find very difficult to code up in a weekend and then go to a finished script by Sunday evening.

lazyjones2• 13 years ago

Would you like to call eval, recursion, macros, closures and many such things cheating?

Yes, in the context of "I did this with just a regexp".

Sorry but doing things without understanding or knowing the true consequences of what you are actually writing, always causes bugs. And that's true with any programming language.

That's a cheap excuse for implementing this in a way that is just plain wrong, or too limited to be useful, when it could have been implemented correctly (at least if enough capable programmers still understood Perl's source code to work on it).

Perl has many features which are designed to make the language powerful enough

I never disputed that. I used Perl almost exclusively in the past 14 years or so, so I know what I'm talking about. These broken language features are the biggest PITA about the language. They are useful for some very specific tasks, but useless for others where they could be used if they had been implemented correctly. Adding a feature with more gotchas than useful use cases is not the way to making a language more useful and enjoyale.

viraptor• 13 years ago

Sorry but doing things without understanding or knowing the true consequences of what you are actually writing, always causes bugs. And that's true with any programming language.

I agree with this in general, but not in this situation. Let's say you use a function you verify doesn't contain regex matching. Then someone else changes that function to contain regex - s/he shouldn't need to (and may not be able to) verify every single place where this function is used - introducing a hard to find bug. Who caused a bug here? In my opinion that's the regex engine/language creator who didn't decide to either handle this case correctly in all cases, or explicitly fail in this edge case.

draegtun• 13 years ago

Here's the video for this presentation: http://perltv.org/v/parsing-json-with-a-regex

riffraff• 13 years ago

notice you can _match_ json with systems based on oniguruma/onigmo (ruby, sublime text, textmate, julia etc), and the syntax is quite readable.

Sadly, I couldn't find a way to access the nested matches, so it's quite pointless :)

Parsing JSON with a single regex

Related Stories