Я знаю, что можно сопоставить слово, а затем отменить совпадения, используя другие инструменты (например grep -v). Однако возможно ли сопоставить строки, которые не содержат определенного слова, например hede, с использованием регулярного выражения?

Входные данные:

hoho
hihi
haha
hede

Код:

grep "<Regex for 'doesn't contain hede'>" input

Желаемый результат:

hoho
hihi
haha

Понятие, что регулярное выражение не поддерживает обратное сопоставление, не совсем верно. Вы можете имитировать это поведение, используя негативные осмотры:

^((?!hede).)*$

Приведенное выше регулярное выражение будет соответствовать любой строке или строке без разрыва строки, не содержащей (под) строку 'hede'. Как уже упоминалось, это не то , что регулярное выражение «хорошо» в (или должны делать), но все же, это возможно.

И если вам нужно сопоставить символы разрыва строки, используйте модификатор DOT-ALL (трейлинг sв следующем шаблоне):

/^((?!hede).)*$/s

или используйте его в строке:

/(?s)^((?!hede).)*$/

(где /.../разделители регулярных выражений, т. е. не являются частью шаблона)

Если модификатор DOT-ALL недоступен, вы можете имитировать то же поведение с классом символов [\s\S]:

/^((?!hede)[\s\S])*$/

объяснение

Строка - это просто список nсимволов. До и после каждого символа есть пустая строка. Таким образом, список nсимволов будет иметь n+1пустые строки. Рассмотрим строку "ABhedeCD":

    ┌──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┐
S = │e1│ A │e2│ B │e3│ h │e4│ e │e5│ d │e6│ e │e7│ C │e8│ D │e9│
    └──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┘

index    0      1      2      3      4      5      6      7

где eэто пустые строки. Регулярное выражение (?!hede).смотрит вперед, чтобы увидеть, нет ли подстроки, "hede"которая будет видна, и если это так (то есть что-то еще видно), то .(точка) будет соответствовать любому символу, кроме разрыва строки. Осмотры также называются утверждениями нулевой ширины, потому что они не потребляют никаких символов. Они только утверждают / подтверждают что-то.

Итак, в моем примере каждая пустая строка сначала проверяется, чтобы увидеть, нет ли "hede"впереди, прежде чем символ будет использован .(точка). Регулярное выражение (?!hede).будет делать это только один раз, так что он обернут в группе, и повторяться ноль или более раз: ((?!hede).)*. Наконец, начало и конец ввода привязываются, чтобы убедиться, что весь вход используется:^((?!hede).)*$

Как вы можете видеть, вход "ABhedeCD"будет не потому , что на e3регулярное выражение (?!hede)не удается (там находится "hede" впереди!).

Обратите внимание, что решение не начинается с «хеде» :

^(?!hede).*$

обычно гораздо эффективнее, чем решение , не содержащее «хеде» :

^((?!hede).)*$

Первый проверяет «hede» только в первой позиции входной строки, а не в каждой позиции.

Если вы просто используете его для grep, вы можете использовать grep -v hedeдля получения всех строк, которые не содержат хеде.

ЭТА О, перечитывая вопрос, grep -vвы, вероятно, подразумевали «инструменты».

Ответ:

^((?!hede).)*$

Объяснение:

^начало строки, (группировка и захват в \ 1 (0 или более раз (соответствует максимально возможному количеству)),
(?!посмотрите вперед, если нет,

hede твоя строка,

)конец упреждения, .любой символ, кроме \ n,
)*конец \ 1 (Примечание: поскольку вы используете квантификатор для этого перехвата, только последнее ПОСЛЕДНЕЕ повторение захваченного шаблона будет сохранено в \ 1)
$перед необязательным \ n, и конец строки

Приведенные ответы прекрасно, просто академический балл:

Регулярные выражения в смысле теоретических компьютерных наук НЕ МОГУТ делать это так. Для них это должно было выглядеть примерно так:

^([^h].*$)|(h([^e].*$|$))|(he([^h].*$|$))|(heh([^e].*$|$))|(hehe.+$) 

Это только соответствует ПОЛНОМУ. Делать это для под-матчей было бы еще более неловко.

Если вы хотите, чтобы тест регулярного выражения завершился неудачей, только если вся строка совпадает, будет работать следующее:

^(?!hede$).*

Например, если вы хотите разрешить все значения, кроме «foo» (то есть «foofoo», «barfoo» и «foobar» пройдут, но «foo» завершится ошибкой), используйте: ^(?!foo$).*

Конечно, если вы проверяете точное равенство, лучшим общим решением в этом случае является проверка на равенство строк, т.е.

myStr !== 'foo'

Вы даже можете поместить отрицание вне теста, если вам нужны какие-либо функции регулярных выражений (здесь, нечувствительность к регистру и согласование диапазона):

!/^[a-f]oo$/i.test(myStr)

Однако решение regex в верхней части этого ответа может быть полезным в ситуациях, когда требуется положительный тест regex (возможно, через API).

FWIW, поскольку регулярные языки (или рациональные языки) закрыты при дополнении, всегда можно найти регулярное выражение (также называемое рациональное выражение), которое отрицает другое выражение. Но не многие инструменты реализуют это.

Vcsn поддерживает этот оператор (который обозначает {c}postfix).

Вы сначала определить тип ваших выражений: этикетки письмо ( lal_char) , чтобы выбрать из , aчтобы z, например (определение алфавита при работе с комплементарности, конечно, очень важно), и «значение» вычисляется для каждого слова просто Boolean : trueслово принято false, отклонено.

В Python:

In [5]: import vcsn
        c = vcsn.context('lal_char(a-z), b')
        c
Out[5]: {a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z} → 𝔹

затем вы вводите выражение:

In [6]: e = c.expression('(hede){c}'); e
Out[6]: (hede)^c

преобразовать это выражение в автомат:

In [7]: a = e.automaton(); a

наконец, преобразовать этот автомат обратно в простое выражение.

In [8]: print(a.expression())
        \e+h(\e+e(\e+d))+([^h]+h([^e]+e([^d]+d([^e]+e[^]))))[^]*

где +обычно обозначается |, \eобозначает пустое слово и [^]обычно пишется .(любой символ). Итак, немного переписав ()|h(ed?)?|([^h]|h([^e]|e([^d]|d([^e]|e.)))).*.

Вы можете увидеть этот пример здесь и попробовать Vcsn онлайн там .

Вот хорошее объяснение того, почему не легко отрицать произвольное регулярное выражение. Я должен согласиться с другими ответами, хотя: если это что-то кроме гипотетического вопроса, то регулярное выражение здесь не правильный выбор.

С отрицательным взглядом, регулярное выражение может соответствовать чему-то, не содержащему определенного шаблона. На это отвечает и объясняет Барт Киерс. Отличное объяснение!

Тем не менее, с ответом Барта Киерса, предварительная часть будет проверять от 1 до 4 символов вперед при сопоставлении с любым отдельным символом. Мы можем избежать этого и позволить предзаголовочной части проверить весь текст, убедиться, что нет «хеде», и тогда нормальная часть (. *) Может съесть весь текст за один раз.

Вот улучшенное регулярное выражение:

/^(?!.*?hede).*$/

Обратите внимание, что (*?) Ленивый квантификатор в части с отрицательным прогнозом не является обязательным, вы можете вместо этого использовать (*) жадный квантификатор, в зависимости от ваших данных: если 'hede' присутствует и в первой половине текста, ленивый квантификатор может быть быстрее; в противном случае жадный квантификатор будет быстрее. Однако, если «hede» не присутствует, оба будут равны медленно.

Вот демонстрационный код .

Для получения дополнительной информации о Lookahead, пожалуйста, прочитайте большую статью: Освоение Lookahead и Lookbehind .

Кроме того, ознакомьтесь с RegexGen.js , генератором регулярных выражений JavaScript, который помогает создавать сложные регулярные выражения. С помощью RegexGen.js вы можете создать регулярное выражение более читабельным способом:

var _ = regexGen;

var regex = _(
    _.startOfLine(),             
    _.anything().notContains(       // match anything that not contains:
        _.anything().lazy(), 'hede' //   zero or more chars that followed by 'hede',
                                    //   i.e., anything contains 'hede'
    ), 
    _.endOfLine()
);

Ориентиры

Я решил оценить некоторые из представленных опций и сравнить их производительность, а также использовать некоторые новые функции. Сравнительный анализ на .NET Regex Engine: http://regexhero.net/tester/

Контрольный текст:

Первые 7 строк не должны совпадать, поскольку они содержат искомое выражение, а нижние 7 строк должны совпадать!

Regex Hero is a real-time online Silverlight Regular Expression Tester.
XRegex Hero is a real-time online Silverlight Regular Expression Tester.
Regex HeroRegex HeroRegex HeroRegex HeroRegex Hero is a real-time online Silverlight Regular Expression Tester.
Regex Her Regex Her Regex Her Regex Her Regex Her Regex Her Regex Hero is a real-time online Silverlight Regular Expression Tester.
Regex Her is a real-time online Silverlight Regular Expression Tester.Regex Hero
egex Hero egex Hero egex Hero egex Hero egex Hero egex Hero Regex Hero is a real-time online Silverlight Regular Expression Tester.
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRegex Hero is a real-time online Silverlight Regular Expression Tester.

Regex Her
egex Hero
egex Hero is a real-time online Silverlight Regular Expression Tester.
Regex Her is a real-time online Silverlight Regular Expression Tester.
Regex Her Regex Her Regex Her Regex Her Regex Her Regex Her is a real-time online Silverlight Regular Expression Tester.
Nobody is a real-time online Silverlight Regular Expression Tester.
Regex Her o egex Hero Regex  Hero Reg ex Hero is a real-time online Silverlight Regular Expression Tester.

Результаты:

Результатами являются итерации в секунду в качестве медианы 3 прогонов - большее число = лучшее

01: ^((?!Regex Hero).)*$                    3.914   // Accepted Answer
02: ^(?:(?!Regex Hero).)*$                  5.034   // With Non-Capturing group
03: ^(?>[^R]+|R(?!egex Hero))*$             6.137   // Lookahead only on the right first letter
04: ^(?>(?:.*?Regex Hero)?)^.*$             7.426   // Match the word and check if you're still at linestart
05: ^(?(?=.*?Regex Hero)(?#fail)|.*)$       7.371   // Logic Branch: Find Regex Hero? match nothing, else anything

P1: ^(?(?=.*?Regex Hero)(*FAIL)|(*ACCEPT))  ?????   // Logic Branch in Perl - Quick FAIL
P2: .*?Regex Hero(*COMMIT)(*FAIL)|(*ACCEPT) ?????   // Direct COMMIT & FAIL in Perl

Поскольку .NET не поддерживает глаголы действий (* FAIL и т. Д.), Я не смог протестировать решения P1 и P2.

Резюме:

Я пытался протестировать большинство предложенных решений, возможна некоторая оптимизация для определенных слов. Например, если первые две буквы строки поиска не совпадают, ответ 03 можно расширить до ^(?>[^R]+|R+(?!egex Hero))*$небольшого прироста производительности.

Но в целом наиболее читаемым и быстродействующим решением, по-видимому, является 05 с использованием условного оператора или 04 с положительным квантификатором. Я думаю, что Perl-решения должны быть еще быстрее и более легко читаемыми.

Не регулярное выражение, но я нашел логичным и полезным использовать последовательные greps с pipe для устранения шума.

например. искать файл конфигурации apache без всех комментариев-

grep -v '\#' /opt/lampp/etc/httpd.conf      # this gives all the non-comment lines

а также

grep -v '\#' /opt/lampp/etc/httpd.conf |  grep -i dir

Логика последовательных grep'ов есть (не комментарий) и (соответствует dir)

при этом вы избегаете проверять прогноз на каждой позиции:

/^(?:[^h]+|h++(?!ede))*+$/

эквивалентно (для .net):

^(?>(?:[^h]+|h+(?!ede))*)$

Старый ответ:

/^(?>[^h]+|h+(?!ede))*$/

Вышеупомянутое (?:(?!hede).)*замечательно, потому что это может быть закреплено.

^(?:(?!hede).)*$               # A line without hede

foo(?:(?!hede).)*bar           # foo followed by bar, without hede between them

Но в этом случае будет достаточно:

^(?!.*hede)                    # A line without hede

Это упрощение готово к добавлению предложений «И»:

^(?!.*hede)(?=.*foo)(?=.*bar)   # A line with foo and bar, but without hede
^(?!.*hede)(?=.*foo).*bar       # Same

Вот как я это сделаю:

^[^h]*(h(?!ede)[^h]*)*$

Точнее и эффективнее других ответов. Он реализует метод эффективности «развернутой петли» Фридла и требует гораздо меньшего возврата.

Если вы хотите сопоставить символ, чтобы отрицать слово, подобное отрицанию класса символов:

Например, строка:

<?
$str="aaa        bbb4      aaa     bbb7";
?>

Не используйте:

<?
preg_match('/aaa[^bbb]+?bbb7/s', $str, $matches);
?>

Использование:

<?
preg_match('/aaa(?:(?!bbb).)+?bbb7/s', $str, $matches);
?>

Обратите внимание, что "(?!bbb)."это не взгляд назад и не взгляд вперед, это выглядит как ток, например:

"(?=abc)abcde", "(?!abc)abcde"

На мой взгляд, более читаемый вариант верхнего ответа:

^(?!.*hede)

По сути, «совпадать в начале строки тогда и только тогда, когда в ней нет слова« хеде »», поэтому требование почти напрямую переводится в регулярное выражение.

Конечно, возможно наличие нескольких требований отказа:

^(?!.*(hede|hodo|hada))

Детали: Якорь ^ гарантирует, что механизм регулярных выражений не повторяет совпадение в каждом месте строки, что соответствует каждой строке.

Якорь ^ в начале предназначен для обозначения начала строки. Инструмент grep сопоставляет каждую строку по одной за раз, в тех случаях, когда вы работаете с многострочной строкой, вы можете использовать флаг "m":

/^(?!.*hede)/m # JavaScript syntax

или

(?m)^(?!.*hede) # Inline flag

ОП не указывал или Tagпост, чтобы указать контекст (язык программирования, редактор, инструмент), в котором будет использоваться Regex.

Для меня, иногда мне нужно сделать это при редактировании файла с помощью Textpad.

Textpad поддерживает некоторые Regex, но не поддерживает lookahead или lookbehind, поэтому требуется несколько шагов.

Если я хочу сохранить все строки, которые НЕ содержат строку hede, я бы сделал это так:

1. Поиск / замена всего файла, чтобы добавить уникальный «тег» в начало каждой строки, содержащей любой текст.

    Search string:^(.)  
    Replace string:<@#-unique-#@>\1  
    Replace-all  

2. Удалите все строки, содержащие строку hede(строка замены пуста):

    Search string:<@#-unique-#@>.*hede.*\n  
    Replace string:<nothing>  
    Replace-all  

3. На этом этапе все оставшиеся строки НЕ содержат строку hede. Удалите уникальный «тег» из всех строк (строка замены пуста):

    Search string:<@#-unique-#@>
    Replace string:<nothing>  
    Replace-all  

Теперь у вас есть оригинальный текст со всеми строками, содержащими hedeудаленную строку .

Если я хочу сделать что-то еще только для строк, которые НЕ содержат строку hede, я бы сделал это так:

1. Поиск / замена всего файла, чтобы добавить уникальный «тег» в начало каждой строки, содержащей любой текст.

    Search string:^(.)  
    Replace string:<@#-unique-#@>\1  
    Replace-all  

2. Для всех строк, которые содержат строку hede, удалите уникальный «Tag»:

    Search string:<@#-unique-#@>(.*hede)
    Replace string:\1  
    Replace-all  

3. На этом этапе все строки, начинающиеся с уникального «тега», НЕ содержат строку hede. Теперь я могу сделать что- то еще только для этих строк.

4. Когда я закончу, я удаляю уникальный «Tag» из всех строк (строка замены пуста):

    Search string:<@#-unique-#@>
    Replace string:<nothing>  
    Replace-all  

Поскольку никто другой не дал прямого ответа на заданный вопрос , я сделаю это.

Ответ в том, что с POSIX grepневозможно буквально удовлетворить этот запрос:

grep "<Regex for 'doesn't contain hede'>" input

Причина в том, что POSIX grepтребуется только для работы с базовыми регулярными выражениями , которые просто недостаточно мощны для выполнения этой задачи (они не способны анализировать обычные языки из-за отсутствия чередования и скобок).

Тем не менее, GNU grepреализует расширения, которые позволяют это. В частности, \|оператор Чередование в реализации проекта GNU в Бре, а \(и \)являются круглые скобки. Если ваш механизм регулярных выражений поддерживает чередование, выражения с отрицательными скобками, круглые скобки и звездочку Клини и может привязывать начало и конец строки, это все, что вам нужно для этого подхода. Тем не менее, обратите внимание, что отрицательные множества [^ ... ]очень удобны в дополнение к тем, потому что в противном случае вам нужно заменить их выражением формы, в (a|b|c| ... )котором перечислены все символы, которых нет в наборе, что является чрезвычайно утомительным и чрезмерно длинным, особенно если весь набор символов Unicode.

С GNU grepответом будет что-то вроде:

grep "^\([^h]\|h\(h\|eh\|edh\)*\([^eh]\|e[^dh]\|ed[^eh]\)\)*\(\|h\(h\|eh\|edh\)*\(\|e\|ed\)\)$" input

(найдено с Grail и некоторыми дополнительными оптимизациями, сделанными вручную).

Вы также можете использовать инструмент, который реализует расширенные регулярные выражения , например egrep, чтобы избавиться от обратной косой черты:

egrep "^([^h]|h(h|eh|edh)*([^eh]|e[^dh]|ed[^eh]))*(|h(h|eh|edh)*(|e|ed))$" input

Вот скрипт для его проверки (обратите внимание, что он генерирует файл testinput.txtв текущем каталоге):

#!/bin/bash
REGEX="^\([^h]\|h\(h\|eh\|edh\)*\([^eh]\|e[^dh]\|ed[^eh]\)\)*\(\|h\(h\|eh\|edh\)*\(\|e\|ed\)\)$"

# First four lines as in OP's testcase.
cat > testinput.txt <<EOF
hoho
hihi
haha
hede

h
he
ah
head
ahead
ahed
aheda
ahede
hhede
hehede
hedhede
hehehehehehedehehe
hedecidedthat
EOF
diff -s -u <(grep -v hede testinput.txt) <(grep "$REGEX" testinput.txt)

В моей системе это печатает:

Files /dev/fd/63 and /dev/fd/62 are identical

как и ожидалось.

Для тех, кто интересуется деталями, используется метод преобразования регулярного выражения, соответствующего слову, в конечный автомат, затем инвертирование автомата путем изменения каждого состояния принятия в непринятие и наоборот, а затем преобразование полученного FA обратно в регулярное выражение.

Наконец, как все уже заметили, если ваш движок регулярных выражений поддерживает отрицательный прогноз, это значительно упрощает задачу. Например, с помощью GNU grep:

grep -P '^((?!hede).)*$' input

Обновление: я недавно нашел превосходную библиотеку FormalTheory Кендалла Хопкинса , написанную на PHP, которая обеспечивает функциональность, аналогичную Grail. Используя его и написанный мной упрощатель, я смог написать онлайн-генератор отрицательных регулярных выражений с учетом входной фразы (в настоящее время поддерживаются только буквенно-цифровые и пробельные символы): http://www.formauri.es/personal/ pgimeno / разное / неигровые-регулярное выражение /

Для hedeэтого выводит:

^([^h]|h(h|e(h|dh))*([^eh]|e([^dh]|d[^eh])))*(h(h|e(h|dh))*(ed?)?)?$

что эквивалентно вышеизложенному.

С момента появления ruby-2.4.1 мы можем использовать новый оператор Absent в регулярных выражениях Ruby.

из официального документа

(?~abc) matches: "", "ab", "aab", "cccc", etc.
It doesn't match: "abc", "aabc", "ccccabc", etc.

Таким образом, в вашем случае ^(?~hede)$делает работу за вас

2.4.1 :016 > ["hoho", "hihi", "haha", "hede"].select{|s| /^(?~hede)$/.match(s)}
 => ["hoho", "hihi", "haha"]

Через глагол PCRE (*SKIP)(*F)

^hede$(*SKIP)(*F)|^.*$

Это полностью пропустит строку, которая содержит точную строку hedeи соответствует всем оставшимся строкам.

DEMO

Исполнение частей:

Давайте рассмотрим приведенное выше регулярное выражение, разбив его на две части.

1. Часть перед |символом. Часть не должна совпадать .

   ^hede$(*SKIP)(*F)

2. Часть после |символа. Часть должна соответствовать .

   ^.*$

ЧАСТЬ 1

Движок Regex начнет выполнение с первой части.

^hede$(*SKIP)(*F)

Объяснение:

• ^ Утверждает, что мы на старте.
• hede Соответствует строке hede
• $ Утверждает, что мы находимся в конце строки.

Таким образом, строка, содержащая строку hede, будет сопоставлена. Как только механизм регулярных выражений видит следующий (*SKIP)(*F)( Примечание: вы можете написать (*F)как(*FAIL) ) глагол, он пропускает и делает совпадение неудачным. |Вызывается изменение или логический оператор ИЛИ, добавленный рядом с глаголом PCRE, который соответствует всем границам, существующим между каждым и каждым символом во всех строках, за исключением того, что строка содержит точную строку hede. Смотрите демо здесь . То есть он пытается сопоставить символы из оставшейся строки. Теперь регулярное выражение во второй части будет выполнено.

ЧАСТЬ 2

^.*$

Объяснение:

• ^ Утверждает, что мы на старте. то есть он соответствует всем началам строки, кроме той, что в hedeстроке. Смотрите демо здесь .

• .*В многострочном режиме .будет соответствовать любому символу, кроме символов новой строки или возврата каретки. И *будет повторять предыдущий символ ноль или более раз. Так .*будет соответствовать всей линии. Смотрите демо здесь .

  Эй, почему ты добавил. * Вместо. +?

  Потому что .*будет соответствовать пустой строке, но .+не будет соответствовать пустой. Мы хотим сопоставить все строки, за исключением того hede, что возможна также пустая строка на входе. поэтому вы должны использовать .*вместо .+. .+будет повторять предыдущий символ один или несколько раз. Смотрите .*совпадения пустой строкой здесь .

• $ Привязка конца строки здесь не нужна.

Это может быть более приемлемым для двух регулярных выражений в вашем коде, один для первого сопоставления, а затем, если он совпадает, запустите второе регулярное выражение, чтобы проверить наличие выбросов, которые вы хотите заблокировать, например, ^.*(hede).*затем иметь соответствующую логику в своем коде.

Хорошо, я признаю, что это не совсем ответ на опубликованный вопрос, и он также может использовать немного больше обработки, чем одно регулярное выражение. Но для разработчиков, которые пришли сюда в поисках быстрого экстренного решения для случайного случая, это решение не следует упускать из виду.

Другой вариант заключается в том, чтобы добавить положительный прогноз и проверить, есть ли heheгде-нибудь в строке ввода, то мы бы отрицали это, используя выражение, подобное:

^(?!(?=.*\bhede\b)).*$

с границами слова.

Выражение объяснено на верхней правой панели regex101.com , если вы хотите изучить / упростить / изменить его, и по этой ссылке вы можете посмотреть, как оно будет соответствовать некоторым образцам входных данных, если хотите.

RegEx Circuit

jex.im визуализирует регулярные выражения:

Язык TXR поддерживает отрицание регулярных выражений.

$ txr -c '@(repeat)
@{nothede /~hede/}
@(do (put-line nothede))
@(end)'  Input

Более сложный пример: сопоставить все строки, которые начинаются с aи заканчиваются z, но не содержат подстроки hede:

$ txr -c '@(repeat)
@{nothede /a.*z&~.*hede.*/}
@(do (put-line nothede))
@(end)' -
az         <- echoed
az
abcz       <- echoed
abcz
abhederz   <- not echoed; contains hede
ahedez     <- not echoed; contains hede
ace        <- not echoed; does not end in z
ahedz      <- echoed
ahedz

Отрицание регулярных выражений не особенно полезно само по себе, но когда у вас также есть пересечение, вещи становятся интересными, поскольку у вас есть полный набор операций с булевыми множествами: вы можете выразить «множество, которое соответствует этому, за исключением вещей, которые соответствуют этому».

Функция ниже поможет вам получить желаемый результат

<?PHP
      function removePrepositions($text){

            $propositions=array('/\bfor\b/i','/\bthe\b/i'); 

            if( count($propositions) > 0 ) {
                foreach($propositions as $exceptionPhrase) {
                    $text = preg_replace($exceptionPhrase, '', trim($text));

                }
            $retval = trim($text);

            }
        return $retval;
    }


?>

^ ((?! hede).) * $ - элегантное решение, за исключением того, что оно использует символы, поэтому вы не сможете комбинировать его с другими критериями. Например, скажем, вы хотели проверить отсутствие «хеде» и наличие «хаха». Это решение будет работать, потому что оно не будет потреблять символы:

^ (?!. \ bhede \ b) (? =. \ bhaha \ b)

Как использовать контрольные глаголы PCRE для соответствия строке, не содержащей слова

Вот метод, который я раньше не видел:

/.*hede(*COMMIT)^|/

Как это работает

Сначала он пытается найти «хеде» где-то в очереди. В случае успеха на этом этапе (*COMMIT)двигатель сообщает не только не возвращаться в случае сбоя, но и не предпринимает попыток дальнейшего сопоставления в этом случае. Затем мы пытаемся сопоставить что-то, что не может совпадать (в этом случае^ ).

Если строка не содержит «hede», тогда вторая альтернатива, пустой подшаблон, успешно соответствует строке темы.

Этот метод не более эффективен, чем негативный взгляд, но я решил, что просто добавлю его здесь на случай, если кто-то найдет его изящным и найдет применение для других, более интересных приложений.

Более простое решение - использовать оператор not !

Ваше заявление if должно соответствовать «содержит», а не соответствовать «исключает».

var contains = /abc/;
var excludes =/hede/;

if(string.match(contains) && !(string.match(excludes))){  //proceed...

Я считаю, что дизайнеры RegEx ожидали использования не операторов.

Возможно, вы найдете это в Google, пытаясь написать регулярное выражение, которое может соответствовать сегментам строки (в отличие от целых строк), которые не содержат подстроки. Уделите мне немного времени, чтобы понять, поэтому я поделюсь:

Учитывая строку: <span class="good">bar</span><span class="bad">foo</span><span class="ugly">baz</span>

Я хочу соответствовать <span> теги, которые не содержат подстроку «плохо».

/<span(?:(?!bad).)*?>будет соответствовать <span class=\"good\">и<span class=\"ugly\"> .

Обратите внимание, что есть два набора (слоя) скобок:

• Самый внутренний - для негативного взгляда (это не группа захвата)
• Самая внешняя сторона была интерпретирована Ruby как группа захвата, но мы не хотим, чтобы она была группой захвата, поэтому я добавил?: В начале, и она больше не интерпретируется как группа захвата.

Демо в Ruby:

s = '<span class="good">bar</span><span class="bad">foo</span><span class="ugly">baz</span>'
s.scan(/<span(?:(?!bad).)*?>/)
# => ["<span class=\"good\">", "<span class=\"ugly\">"]

С помощью ConyEdit вы можете использовать командную строку, cc.gl !/hede/чтобы получить строки, которые не содержат совпадения с регулярным выражением, или использовать командную строку cc.dl /hede/для удаления строк, которые содержат сопоставление с регулярным выражением. У них одинаковый результат.

Я хотел бы добавить еще один пример, если вы пытаетесь сопоставить всю строку, которая содержит строку X , но также не содержит строку Y .

Например, допустим, мы хотим проверить, содержит ли наш URL / строка « вкусные угощения », если он также нигде не содержит « шоколад ».

Этот шаблон регулярного выражения будет работать (работает и в JavaScript)

^(?=.*?tasty-treats)((?!chocolate).)*$

(глобальные, многострочные флаги в примере)

Интерактивный пример: https://regexr.com/53gv4

Матчи

(Эти URL содержат «вкусные угощения», а также не содержат «шоколад»)

• example.com/tasty-treats/strawberry-ice-cream
• example.com/desserts/tasty-treats/banana-pudding
• example.com/tasty-treats-overview

Не совпадает

(Эти URL-адреса содержат где-то «шоколад» - поэтому они не будут совпадать, даже если они содержат «вкусные угощения»)

• example.com/tasty-treats/chocolate-cake
• example.com/home-cooking/oven-roasted-chicken
• example.com/tasty-treats/banana-chocolate-fudge
• example.com/desserts/chocolate/tasty-treats
• example.com/chocolate/tasty-treats/desserts