"space or no space" is the same as "zero or one space", or perhaps "zero or more spaces", I'm not sure exactly what you want.

In the following discussion, I'm going to use <space> to represent a single space, since a single space is hard to see in short code snippets. In the actual regular expression, you must use an actual space character.

zero-or-one-space is represented as a single space followed by a question mark (<space>?). That will match exactly zero or one spaces. If you want to match zero or any number of spaces, replace the ? with * (eg: <space>*)

If by "space" you actually mean "any whitespace character" (for example, a tab), you can use \s which most regular expression engines translate as whitespace. So, zero-or-one of any whitespace character would be \s?, and zero-or-more would be \s*

The document you linked to shows that Microsoft's "regular expressions" aren't really regular expressions at all; they're a bizarre hybrid (bastard child, rather) of shell-style globbing (http://www.tldp.org/LDP/GNU-Linux-Tools-Summary/html/x11655.htm) and true regular expressions.

Since the glob syntax makes use of the * character as a synonym for the regex .*, and Microsoft decided (as mentioned in a comment) to make @ equivalent to the regex quantifier + instead of * (which is stupid since a+ is equivalent to aa* for any atom a, making + unnecessary), it looks like you're out of luck.

My personal opinion is that (1) this is stupid and (2) calling these patterns "regular expressions" is misleading at best, but unfortunately I don't see any way around this except for abandoning Word in favor of a tool that properly supports regex. (Though I suppose in theory you could try to parse the xml-ish format of the docx file itself, extract the text, and then apply your regex....)

You can do:

((?:\d\s*){1,3})

Demo

---

Explanation:

((?:\d\s*)){1,3}
  ^      ^        define a non capturing group
     ^            a single digit
       ^          a space zero or more times
^         ^       capture that group (digit and following space pattern)
           ^      1 to 3 times

You can also do:

 ^(\d\s*\d?\s*\d?\s*)
  ^                 ^     capture group
    ^                     one digit
      ^                   zero or more spaces
         ^                optional digit
            ^             zero or more spaces
               ^  ^       etcetera..... 

Demo

Your sedPattern has some issue with quotes. you are trying to match the same quote twice. Also, + is used for one or more. for 0 or more, use *.
caution: code below is untested, but should get you going.

sedPattern='s/^.*"keyVal"[ ]*:.*\(".*"\).*$/\1/'

I believe you can do something like this:

([ ]*+[0-9A-Za-z]++[ ]*+)+

This is 0 or more spaces, followed by at least 1 alphanum char, followed by 0 or more spaces

^^ that whole thing at least once.

Using Pshemo's idea of possessive quantifiers to speed up the regex.

Try

grep -oP 'mem\s*=\s*\K[0-9]+' file

The \K simply drops everything matched so far, printing only the number.

This alternative to a look-behind assertion (such as (?<=mem=)) bypasses the latter's limitation that Tomalak mentions: look-behind assertions must be fixed-length.

Note: The nonstandard -P option - for PCRE (Perl-Compatible Regular Expression) support - requires GNU grep.

Assuming you only care about spaces in the word, not leading or trailing then you could use this:

@[A-Za-z0-9]* ?[A-Za-z0-9]*

Explanation:

@ Starts with literal @

[A-Za-z0-9] Any letter or number

* Letter or number can be length {0,infinity}

? Space char, 0 or one times

[A-Za-z0-9]* Any number of trailing letters or spaces after the space (if there is one)

@AgaB-Your regular expression is almost correct, but there's a small mistake in it. Instead of using (\s) to match spaces between digits and letters, you should use \s* to match zero or more spaces. Also, you can simplify it a bit. Here's the corrected version:regexCopy code^([0-9]{9})\s*([A-Za-z]{2})\s*([0-9]{4})$ In this expression:^ asserts the start of the string.([0-9]{9}) matches exactly 9 digits.\s* matches zero or more spaces.([A-Za-z]{2}) matches exactly 2 letters, either uppercase or lowercase.\s* matches zero or more spaces.([0-9]{4}) matches exactly 4 digits.$ asserts the end of the string.This should match the pattern you described: 9 digits followed by 2 letters followed by 4 digits, with optional spaces in between.

Your regex should work 'as-is'. Assuming that it is doing what you want it to.

wordA(\s*)wordB(?! wordc)

This means match wordA followed by 0 or more spaces followed by wordB, but do not match if followed by wordc. Note the single space between ?! and wordc which means that wordA wordB wordc will not match, but wordA wordB wordc will.

Here are some example matches and the associated replacement output:

Note that all matches are replaced no matter how many spaces. There are a couple of other points: -

• (?! wordc) is a negative lookahead, so you wont match lines wordA wordB wordc which is assume is intended (and is why the last line is not matched). Currently you are relying on the space after ?! to match the whitespace. You may want to be more precise and use (?!\swordc). If you want to match against more than one space before wordc you can use (?!\s*wordc) for 0 or more spaces or (?!\s*+wordc) for 1 or more spaces depending on what your intention is. Of course, if you do want to match lines with wordc after wordB then you shouldn't use a negative lookahead.

• * will match 0 or more spaces so it will match wordAwordB. You may want to consider + if you want at least one space.

• (\s*) - the brackets indicate a capturing group. Are you capturing the whitespace to a group for a reason? If not you could just remove the brackets, i.e. just use \s.

Update based on comment

Hello the problem is not the expression but the HTML out put   that are not considered as whitespace. it's a Joomla website.

Preserving your original regex you can use:

wordA((?:\s| )*)wordB(?!(?:\s| )wordc)

The only difference is that not the regex matches whitespace OR  . I replaced wordc with \swordc since that is more explicit. Note as I have already pointed out that the negative lookahead ?! will not match when wordB is followed by a single whitespace and wordc. If you want to match multiple whitespaces then see my comments above. I also preserved the capture group around the whitespace, if you don't want this then remove the brackets as already described above.

Example matches: