blocks|key|1269768|text|您可以使用negative+look-ahead+or+look-behind|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1269769|%5E(?!.*?bar).*
%5E(.(?<!bar))*?$|code-block|syntax|javascript|1269770|或者只使用基础知识：|1269771|%5E(?:[%5Eb]%2B%7Cb(?:$%7C[%5Ea]%7Ca(?:$%7C[%5Er])))*$|1269772|这些都与任何不包含bar的内容相匹配。|style|CODE|1269773|entityMap|0|LINK|mutability|MUTABLE|url|http://www.regular-expressions.info/lookaround.html^0|5|Y|0|0|0|0|0|9|3|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|15|8|@$A|16|B|17|O|P]]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

You could either use a <a href="http://www.regular-expressions.info/lookaround.html" rel="noreferrer">negative look-ahead or look-behind</a>:

<pre><code>^(?!.*?bar).*
^(.(?&lt;!bar))*?$
</code></pre>

Or use just basics:

<pre><code>^(?:[^b]+|b(?:$|[^a]|a(?:$|[^r])))*$
</code></pre>

These all match anything that does not contain <code>bar</code>.

blocks|key|1269839|text|除非最关心的是性能，否则只需运行第二遍结果，跳过那些与您想要否定的单词匹配的单词，通常会更容易。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1269840|正则表达式通常意味着您正在执行脚本或某种低性能任务，所以请找到一个易于阅读、易于理解和易于维护的解决方案。|1269841|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Unless performance is of utmost concern, it's often easier just to run your results through a second pass, skipping those that match the words you want to negate. 

Regular expressions usually mean you're doing scripting or some sort of low-performance task anyway, so find a solution that is easy to read, easy to understand and easy to maintain.

blocks|key|1269953|text|下面的正则表达式将做你想做的事情(只要支持负的lookbehinds和lookahead)，正确地匹配事物；唯一的问题是它匹配单个字符(即每个匹配是单个字符，而不是两个连续的“bar”之间的所有字符)，如果你使用非常长的字符串，可能会导致很高的开销。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1269954|b(?!ar)%7C(?<!b)a%7Ca(?!r)%7C(?<!ba)r%7C[%5Ebar]|code-block|syntax|javascript|1269955|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The following regex will do what you want (as long as negative lookbehinds and lookaheads are supported), matching things properly; the only problem is that it matches individual characters (i.e. each match is a single character rather than all characters between two consecutive "bar"s), possibly resulting in a potential for high overhead if you're working with very long strings.

<pre><code>b(?!ar)|(?&lt;!b)a|a(?!r)|(?&lt;!ba)r|[^bar]
</code></pre>

blocks|key|1270042|text|想想其他可以做的事情。这与我的第一个答案非常不同，因为它不使用正则表达式，所以我决定做第二个答案帖子。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1270043|在字符串上使用您选择的语言的split()方法等效项，并将单词to+negate作为拆分对象的参数。使用Python的示例：|offset|length|style|CODE|1270044|>>>+text+=+'barbarasdbarbar+1234egb+ar+bar32+sdfbaraadf'
>>>+text.split('bar')
['',+'',+'asd',+'',+'+1234egb+ar+',+'32+sdf',+'aadf']|code-block|syntax|javascript|1270045|这样做的好处是，至少在Python中(我不记得功能在Visual+Basic或Java中是否相同)，它让您间接地知道字符串中何时重复了"bar“，因为"bar”之间的空字符串包含在结果列表中(尽管开头的空字符串是由于字符串开头有一个“bar”)。如果你不想这样，你可以简单地从列表中删除空字符串。|1270046|entityMap^0|0|E|7|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Just thought of something else that could be done. It's very different from my first answer, as it doesn't use regular expressions, so I decided to make a second answer post.

Use your language of choice's <code>split()</code> method equivalent on the string with the word to negate as the argument for what to split on. An example using Python:

<pre><code>&gt;&gt;&gt; text = 'barbarasdbarbar 1234egb ar bar32 sdfbaraadf'
&gt;&gt;&gt; text.split('bar')
['', '', 'asd', '', ' 1234egb ar ', '32 sdf', 'aadf']
</code></pre>

The nice thing about doing it this way, in Python at least (I don't remember if the functionality would be the same in, say, Visual Basic or Java), is that it lets you know indirectly when "bar" was repeated in the string due to the fact that the empty strings between "bar"s are included in the list of results (though the empty string at the beginning is due to there being a "bar" at the beginning of the string). If you don't want that, you can simply remove the empty strings from the list.

blocks|key|1484676|text|公认的答案很好，但实际上是对正则表达式中缺少简单的子表达式否定操作符的一种变通办法。这就是grep+--invert-match退出的原因。因此，在*nixes中，您可以使用管道和第二个正则表达式实现所需的结果。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1484677|grep+'something+I+want'+%7C+grep+--invert-match+'but+not+these+ones'|code-block|syntax|javascript|1484678|这仍然是一种变通方法，但可能更容易记住。|1484679|entityMap^0|19|J|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

The accepted answer is nice but is really a work-around for the lack of a simple sub-expression negation operator in regexes. This is why <code>grep --invert-match</code> exits. So in *nixes, you can accomplish the desired result using pipes and a second regex.

<pre><code>grep 'something I want' | grep --invert-match 'but not these ones'
</code></pre>

Still a workaround, but maybe easier to remember.

blocks|key|1270167|text|我希望对已接受的答案进行补充，并用我最近的答案为讨论做出贡献。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1270168|@ChrisVanOpstal分享了this+regex+tutorial，这是一个学习正则表达式的很好的资源。|offset|length|1270169|然而，通读这本书真的很耗时。|1270170|为了方便记忆，我做了一个小抄。|1270171|这个引用基于每个类前面的花括号[]、()和{}，我发现它很容易回忆起来。|style|CODE|1270172|Regex+=+{
+'single_character':+['[]',+'.',+{'negate':'%5E'}],
+'capturing_group'+:+['()',+'%7C',+'\\',+'backreferences+and+named+group'],
+'repetition'++++++:+['{}',+'*',+'%2B',+'?',+'greedy+v.s.+lazy'],
+'anchor'++++++++++:+['%5E',+'\b',+'$'],
+'non_printable'+++:+['\n',+'\t',+'\r',+'\f',+'\v'],
+'shorthand'+++++++:+['\d',+'\w',+'\s'],
+}|code-block|syntax|javascript|1270173|entityMap|0|LINK|mutability|MUTABLE|url|http://www.regular-expressions.info/lookaround.html^0|0|I|J|0|0|0|0|F|2|I|2|L|2|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@$D|12|E|13|1|14]]|A|$]]|$1|F|3|G|5|6|7|15|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|16|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|17|8|@$D|18|E|19|L|M]|$D|1A|E|1B|L|M]|$D|1C|E|1D|L|M]]|9|@]|A|$]]|$1|N|3|O|5|P|7|1E|8|@]|9|@]|A|$Q|R]]|$1|S|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

I wish to complement the accepted answer and contribute to the discussion with my late answer.

@ChrisVanOpstal shared <a href="http://www.regular-expressions.info/lookaround.html" rel="nofollow noreferrer">this regex tutorial</a> which is a great resource for learning regex.

However, it was really time consuming to read through.

I made a cheatsheet for mnemonic convenience. 

This reference is based on the braces <code>[]</code>, <code>()</code>, and <code>{}</code> leading each class, and I find it easy to recall.

<pre><code>Regex = {
 'single_character': ['[]', '.', {'negate':'^'}],
 'capturing_group' : ['()', '|', '\\', 'backreferences and named group'],
 'repetition' : ['{}', '*', '+', '?', 'greedy v.s. lazy'],
 'anchor' : ['^', '\b', '$'],
 'non_printable' : ['\n', '\t', '\r', '\f', '\v'],
 'shorthand' : ['\d', '\w', '\s'],
 }
</code></pre>

blocks|key|1270218|text|由bkDJ从this+comment中提取|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1270219|%5E(?!bar$).*|code-block|syntax|javascript|1270220|这个解决方案的好特性是可以清楚地否定(排除)多个单词：|1270221|%5E(?!bar$%7Cfoo$%7Cbanana$).*|1270222|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/2320322/bkdj|1|https://stackoverflow.com/questions/1240275/how-to-negate-specific-word-in-regex?answertab=active#comment88451186_3688210^0|1|4|0|6|C|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]|$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|F|7|13|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|14|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|15|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

Extracted from <a href="https://stackoverflow.com/questions/1240275/how-to-negate-specific-word-in-regex?answertab=active#comment88451186_3688210">this comment</a> by <a href="https://stackoverflow.com/users/2320322/bkdj">bkDJ</a>:

<pre><code>^(?!bar$).*
</code></pre>

The nice property of this solution is that it's possible to clearly negate (exclude) multiple words:

<pre><code>^(?!bar$|foo$|banana$).*
</code></pre>

I know that I can negate group of chars as in <code>[^bar]</code> but I need a regular expression where negation applies to the specific word - so in my example how do I negate an actual <code>bar</code>, and not "any chars in bar"?

How to negate specific word in regex?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我知道我可以像[^bar]一样否定一组字符，但是我需要一个正则表达式，其中否定适用于特定的单词-那么在我的示例中，我如何否定一个实际的bar，而不是“条中的任何字符”？

问如何在正则表达式中否定特定的单词？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在正则表达式中否定特定的单词？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在正则表达式中否定特定的单词？
EN