Regex para a sequência que não termina com o sufixo fornecido

Não consegui encontrar uma regex adequada para corresponder a nenhuma sequência que não termina com alguma condição. Por exemplo, não quero corresponder nada que termine com um a.

Isso corresponde

b
ab
1

Isso não corresponde

a
ba

Eu sei que o regex deve terminar com $para marcar o final, embora eu não saiba o que deve preceder.

Edit : A pergunta original não parece ser um exemplo legítimo para o meu caso. Então: como lidar com mais de um personagem? Diga alguma coisa que não termine com ab?

Eu fui capaz de corrigir isso, usando este segmento :

.*(?:(?!ab).).$

Embora a desvantagem disso seja, ele não corresponde a uma sequência de um caractere.

Você não nos fornece o idioma, mas se o suporte ao sabor de expressão regular estiver por trás da afirmação , é disso que você precisa:

.*(?<!a)$

(?<!a)é uma asserção lookbehind negada que garante que, antes do final da string (ou linha com mmodificador), não haja o caractere "a".

Veja aqui no Regexr

Você também pode estender isso facilmente com outros caracteres, pois essa verificação da cadeia de caracteres e não é uma classe de caracteres.

.*(?<!ab)$

Isso corresponderia a qualquer coisa que não termine com "ab", veja no Regexr

Use o símbolo not ( ^):

.*[^a]$

Se você colocar o ^símbolo no início dos colchetes, significa "tudo, exceto as coisas entre colchetes". $é simplesmente uma âncora até o fim.

Para vários caracteres , basta colocá-los todos em seu próprio conjunto de caracteres:

.*[^a][^b]$

Para procurar arquivos que não terminem com ".tmp", usamos o seguinte regex:

^(?!.*[.]tmp$).*$

Testado com o Regex Tester fornece o seguinte resultado:

.*[^a]$

a regex acima corresponderá às strings que não terminam com a.

Tente isto

/.*[^a]$/

A []denota uma classe de caracteres, e as ^inverte a classe de caracteres para corresponder tudo, mas um a.

A pergunta é antiga, mas não consegui encontrar uma solução melhor, posto aqui a minha. Encontre todas as unidades USB, mas não liste as partições , removendo a "parte [0-9]" dos resultados. Acabei fazendo dois grep, o último nega o resultado:

ls -1 /dev/disk/by-path/* | grep -P "\-usb\-" | grep -vE "part[0-9]*$"

Isso resulta no meu sistema:

pci-0000:00:0b.0-usb-0:1:1.0-scsi-0:0:0:0

Se eu apenas quero as partições, eu poderia fazer:

ls -1 /dev/disk/by-path/* | grep -P "\-usb\-" | grep -E "part[0-9]*$"

Onde eu recebo:

pci-0000:00:0b.0-usb-0:1:1.0-scsi-0:0:0:0-part1
pci-0000:00:0b.0-usb-0:1:1.0-scsi-0:0:0:0-part2

E quando eu faço:

readlink -f /dev/disk/by-path/pci-0000:00:0b.0-usb-0:1:1.0-scsi-0:0:0:0

Eu recebo:

/dev/sdb

A resposta aceita é boa se você pode usar lookarounds. No entanto, há também outra abordagem para resolver esse problema.

Se olharmos para o regex amplamente proposto para esta pergunta:

.*[^a]$

Veremos que quase funciona. Ele não aceita uma string vazia, o que pode ser um pouco inconviniente. No entanto, esse é um problema menor ao lidar com apenas um personagem. No entanto, se queremos excluir uma string inteira, por exemplo, "abc", então:

.*[^a][^b][^c]$

não vai fazer. Não aceita AC, por exemplo.

Existe uma solução fácil para esse problema. Podemos simplesmente dizer:

.{,2}$|.*[^a][^b][^c]$

ou versão mais generalizada:

.{,n-1}$|.*[^firstchar][^secondchar]$ onde n comprimento da corda que você quer proibir (para é abcque é 3), e firstchar, secondchar... são de primeira, personagens segunda ... enésima de sua seqüência (por abcque seria a, então b, a seguir c).

Isso vem de uma simples observação de que uma string menor que o texto que não proibimos não pode conter esse texto por definição. Portanto, podemos aceitar qualquer coisa que seja mais curta ("ab" não é "abc") ou qualquer coisa que seja longa o suficiente para aceitarmos, mas sem o final.

Aqui está um exemplo de localização que excluirá todos os arquivos que não são .jpg:

find . -regex '.{,3}$|.*[^.][^j][^p][^g]$' -delete

Qualquer coisa que corresponda a algo que termine com --- .*a$Então, quando você corresponder à regex, negue a condição ou, alternativamente, você também poderá fazer .*[^a]$onde [^a]significa qualquer coisa que sejanot a

Se você estiver usando grepou seda sintaxe será um pouco diferente. Observe que o [^a][^b]método seqüencial não funciona aqui:

balter@spectre3:~$ printf 'jd8a\n8$fb\nq(c\n'
jd8a
8$fb
q(c
balter@spectre3:~$ printf 'jd8a\n8$fb\nq(c\n' | grep ".*[^a]$"
8$fb
q(c
balter@spectre3:~$ printf 'jd8a\n8$fb\nq(c\n' | grep ".*[^b]$"
jd8a
q(c
balter@spectre3:~$ printf 'jd8a\n8$fb\nq(c\n' | grep ".*[^c]$"
jd8a
8$fb
balter@spectre3:~$ printf 'jd8a\n8$fb\nq(c\n' | grep ".*[^a][^b]$"
jd8a
q(c
balter@spectre3:~$ printf 'jd8a\n8$fb\nq(c\n' | grep ".*[^a][^c]$"
jd8a
8$fb
balter@spectre3:~$ printf 'jd8a\n8$fb\nq(c\n' | grep ".*[^a^b]$"
q(c
balter@spectre3:~$ printf 'jd8a\n8$fb\nq(c\n' | grep ".*[^a^c]$"
8$fb
balter@spectre3:~$ printf 'jd8a\n8$fb\nq(c\n' | grep ".*[^b^c]$"
jd8a
balter@spectre3:~$ printf 'jd8a\n8$fb\nq(c\n' | grep ".*[^b^c^a]$"

FWIW, estou encontrando os mesmos resultados no Regex101 , que acho que é a sintaxe JavaScript.

Ruim: https://regex101.com/r/MJGAmX/2
Bom: https://regex101.com/r/LzrIBu/2