Instead of focusing on what 2 spaces isn't, use a negative look ahead for what it is:

^(?!.*  ).+

Or if the 1st and last must be non-spaces (not stated):

^\S((?!.*  ).*\S)?$

Which also allows exactly 1 non-space as the entire input.

The primary thing that makes this work is this expression ^(?!.* ), which a negative look-ahead (?!.* ) anchored to start of input by ^. It asserts, without consuming input, that the text that follows the current point does not match the given expression, in this case ".* " (quotes added for clarity), which is "anything then two spaces". In other words "two spaces do not appear at any point after here".

The second option could have been written ^\S(?!.* ).*\S$ - that same as the first but with \S at either end, but that would require different characters at each end because \S consumes input, so it wouldn't match a single letter eg "X". My making all characters other than the first optional, it allows the single character to pass (as per your requirements), while retaining the prevention of two spaces.

What you want to use interactively is this: \s-\{2\}, not this: \s-\\{2\\}.

That works for me, for both C-M-s (isearch-forward-regexp) and C-M-% (query-replace-regexp).

You edited your question, changing \s-\\{2\\} to \s-\{2\}. But I don't see a problem with the latter. It does not match more than two consecutive space chars, for me. And it does match two for query-replace also, for me.

(It can be confusing to go back and forth between entering a regexp interactively and using a regexp in Lisp code. Interactively you typically do not use \\.)

Given that you also want to cover tabs, newlines, etc, just replace \s\s+ with ' ':

string = string.replace(/\s\s+/g, ' ');

If you really want to cover only spaces (and thus not tabs, newlines, etc), do so:

string = string.replace(/  +/g, ' ');

The lookahead (?!.* {2} can be omitted, and instead start the match with a non whitespace character and end the match with a non whitespace character and use a single space in an optionally repeated group.

If the string can not contain a ' or ; then using [^;'][^ ]$ means that the second last character should not be any of those characters.

But you can omit that part, as the character class [a-zA-Z0-9,()] does not match ; and '

Note that using a character class like [^ ] and [^;'] actually expect a single character, making the pattern that you tried having a minimum length.

Instead, you can rule out the presence of GO or MO preceded by a non whitespace character.

^(?!.*\S[MG]O\b)[a-zA-Z0-9,()]+(?: [a-zA-Z0-9,()]+)*$

The pattern matches:

• ^ Start of string
• (?!.*\S[MG]O\b) Negative lookahead, assert not a non whitspace character followed by either MO or GO to the right. The word boundary \b prevents a partial word match
• [a-zA-Z0-9,()]+ Start the match with 1+ occurrences of any of the listed characters (Note that there is no space in it)
• (?: [a-zA-Z0-9,()]+)* Optionally repeat the same character class with a leading space
• $ End of string

Regex demo

How do I replace any number of spaces using regular expressions

Notepad++ Solution

To match one or more space characters:

• Set "Find what" to + (space followed by +)

To match one of more whitespace characters (space, EOL, and tab all count as whitespace):

• Set "Find what" to \s+

  Warning: Using \s+ will match end of line and therefore join multiple lines together (separated by the "replace with" string)

To replace with a tab character:

• Set "Replace with" to \t

To enable regular expression (so the above special codes will work)

• Select "Regular expression".

Source How to use regular expressions in Notepad++ (tutorial)

You can use the regex /\s{2,}/g:

var s = "Be an      excellent     person"
s.replace(/\s{2,}/g, ' ');

Probably match it again against /\s\s/.

The simplest solution is to split on \s{2,} to get the "words" you want, but if you insist on scanning for the tokens, then where as before you have \S+, what you have now is \S+(\s\S+)*. That's exactly what it says: \S+, followed by zero or more (\s\S+). You can use non-capturing group for performance, i.e. \S+(?:\s\S+)*. You can even make each repetition possessive if your flavor supports it for extra boost, i.e. \S++(?:\s\S++)*+.

Here's a Java snippet to demonstrate:

    String text = "AB C  DE  FG HIJ   KLM    NO  P  QRST";
    Matcher m = Pattern.compile("\\S++(?:\\s\\S++)*+").matcher(text);
    while (m.find()) {
        System.out.println("[" + m.group() + "]");
    }

This prints:

[AB C]
[DE]
[FG HIJ]
[KLM]
[NO]
[P]
[QRST]

You can of course substitute just the space character instead of \s if that's your requirement.

References

• regular-expressions.info/Character Class, Brackets for Grouping, Repetition, Possessive