regex match upto some character

Conditions updated

There is often a situation where you want to extract a substring upto (immediately before) certain characters. For example, suppose you have a text that:

• Does not start with a semicolon or a period,
• Contains several sentences,
• Does not contain any "\n", and
• Ends with a period,

and you want to extract the sequence from the start up开发者_开发知识库to the closest semicolon or period. Two strategies come to mind:

1. /[^;.]*/
2. /.*?[;.]/

I do either of these quite randomly, with slight preference to the second strategy, and also see both ways in other people's code. Which is the better way? Is there a clear reason to prefer one over the other, or are there better ways? I personally feel, efficiency aside, that negating something (as with [^]) is conceptually more complex than not doing it. But efficiency may also be a good reason to chose one over the other.

I came up with my answer. The two regexes in my question were actually not expressing the same thing. And the better approach depends on what you want.

1. If you want a match up to and including a certain character, then using

   /.*?[;.]/

is simpler.

1. If you want a match up to right before (excluding) a certain character, then you should use:

   /[^;.]*/

Well, the first way is probably more efficient, not that it's likely to matter. By the way, \z in a character class does not mean "end of input"--in fact, it's a syntax error in every flavor I know of. /[^;.]*/ is all you need anyway.

I personally prefer the first one because it does exactly as you would expect. Get all characters except ...

But it's mostly a matter of preference. There are nearly always multiple ways to write a regular expression and it's mostly style that matters.

For example... do you prefer [0-9], [:digit:] or \d? They all do exactly^* the same.

^* In case of unicode the [:digit:] and \d classes match some other characters too.

you left out one other strategy. string split?

"my sentence; blahblah".split(/[;.]/,2)[0] 

I think that it is mostly a matter of opinion as to which regular expression you use. On the note of efficiency, though, I think that adding \A to the beginning of a regular expression in this case would make the process faster because well designed regular expression engines should only try to match once in that case. For example:

/\A[^.;]/m

Note the m option; it indicates that newline characters can also be matched. This is just a technicality I would add for generic examples, but may not apply to you.

Although adding more to the solution might be viewed as increasing complexity, it can also serve to clarify meaning.