我假设三个相同的数字串由一个空格分隔，这三个数字中的第一个在字符串的开头，或者前面有一个空格，前面没有相同的字符串，这三个数字中的最后一个字符串在字符串的末尾，或者后面有一个空格，后面没有相同的字符串。
您可以尝试匹配以下正则表达式。

(?: |^)(\d+)(?<!(?: |^)\1 \1)(?: \1){2}(?![^ ]| \1(?: |$))

字符串
Demo
正则表达式可以分解如下。（或者，将光标悬停在链接处表达式的每个部分上，以获得其功能的说明。）

(?: |^)     # match a space or the beginning of the string
(\d+)       # match one or more digits and save to capture group 1
(?<!        # begin a negative lookbehind
  (?: |^)    # match a space or the beginning of the string
  \1 \1      # match the content of capture group 1 twice, separated by a space
)           # end the negative lookbehind
(?: \1)     # match a space followed by the content of capture group 1
{2}         # execute the preceding non-capture group twice
(?!         # begin a negative lookahead
  [^ ]        # match a character other than a space
  |           # or
   \1         # match a space followed by the content of capture group 1
  (?: |$)     # match a space or the end of the string
)           # end the negative lookahead

型
注意，(?: .... )表示非捕获组。

在你的模式中，你混合了空格和\s，\s匹配一个空格字符，也可以匹配一个换行符。
您可以检查第一个捕获组值(\d+)前面是否有相同的值。
带有字边界以防止部分匹配的版本：

\b(\d+)\b(?<!\b\1 \1)(?: \1){2}\b(?! \1\b)

字符串
Regex demo
模式匹配：

• \b(\d+)\b捕获组1，匹配单词边界之间的1+位
• (?<!\b\1 \1)负向后看，在此数字之前Assert不同的数字
• (?: \1){2}\b重复2次空格，组1值结束于单词边界
• (?! \1\b)负前瞻，Assert不是组1值的右边，后面跟着一个字边界

const regex = /\b(\d+)\b(?<!\b\1 \1)(?: \1){2}\b(?! \1\b)/;

console.log(regex.test('I am 42 42 4 hey yoo')); //false --> Correct
 
console.log(regex.test('I am 42 42 42 hey yoo')); //true --> Correct

console.log(regex.test('I am 42 42 42 4 hey yoo')); //true --> Correct

console.log(regex.test('I am 42 42 42 42 hey yoo')); //true --> this output should be false since there are 4 same consecutive digits

型
或者，如果不支持向后查找，您可以匹配3次相同的数字，并可选地匹配第2组中的其余重复数字。
在结果中，您可以检查是否存在不匹配或捕获组2值：

\b(\d+)(?: \1){2}( \1)*\b

型
Regex demo的

const regex = /\b(\d+)(?: \1){2}( \1)*\b/;
[
  'I am 42 42 4 hey yoo',
  'I am 42 42 42 hey yoo',
  'I am 42 42 42 4 hey yoo',
  'I am 42 42 42 42 hey yoo'
].forEach(s => {
  const m = s.match(regex);
  console.log(`${s} --> ${!(!m || m[2])}`);
})

型