Regex: corresponde a tudo, menos ao padrão específico

Eu preciso de um regex capaz de corresponder a tudo, exceto uma string que comece com um padrão específico (especificamente index.phpe o que se segue, como index.php?id=2342343)

Não é um especialista em regexp, mas acho que você pode usar um lookahead negativo desde o início, por exemplo ^(?!foo).*$, não deve corresponder a nada do que começar foo.

Regex: corresponde a tudo, exceto :

• uma sequência iniciada com um padrão específico (por exemplo, qualquer sequência vazia - também não iniciada foo):
  • Solução baseada em Lookahead para NFAs:
    • ^(?!foo).*$
    • ^(?!foo)
  • Solução baseada em classe de caracteres negados para mecanismos regex que não oferece suporte a lookarounds :
    • ^(([^f].{2}|.[^o].|.{2}[^o]).*|.{0,2})$
    • ^([^f].{2}|.[^o].|.{2}[^o])|^.{0,2}$
• uma sequência que termina com um padrão específico (digamos, não world.no final):
  • Solução baseada em Lookbehind:
    • (?<!world\.)$
    • ^.*(?<!world\.)$
  • Solução POSIX:
    • ^(.*([^w].{5}|.[^o].{4}|.{2}[^r].{3}|.{3}[^l].{2}|.{4}[^d].|.{5}[^.])|.{0,5})$
    • ([^w].{5}|.[^o].{4}|.{2}[^r].{3}|.{3}[^l].{2}|.{4}[^d].|.{5}[^.]$|^.{0,5})$
• uma string contendo texto específico (por exemplo, não corresponde a uma string que possui foo) (nenhum padrão compatível com POSIX, desculpe):
  • ^(?!.*foo)
  • ^(?!.*foo).*$
• uma sequência contendo caracteres específicos (por exemplo, evite combinar uma sequência com um |símbolo):
  • ^[^|]*$
• uma string igual a alguma string (digamos, diferente de foo):
  • Baseado em lookaround:
    • ^(?!foo$)
    • ^(?!foo$).*$
  • POSIX:
    • ^(.{0,2}|.{4,}|[^f]..|.[^o].|..[^o])$
• uma sequência de caracteres :
  • PCRE (corresponde a qualquer texto, mas cat): /cat(*SKIP)(*FAIL)|[^c]*(?:c(?!at)[^c]*)*/iou/cat(*SKIP)(*FAIL)|(?:(?!cat).)+/is
  • Outros mecanismos que permitem pesquisas: (cat)|[^c]*(?:c(?!at)[^c]*)*(ou (?s)(cat)|(?:(?!cat).)*, ou (cat)|[^c]+(?:c(?!at)[^c]*)*|(?:c(?!at)[^c]*)+[^c]*) e, em seguida, verifique com o idioma significa: se o Grupo 1 correspondeu, não é o que precisamos, senão, pegue o valor da correspondência se não estiver vazio
• um determinado caractere único ou um conjunto de caracteres :
  • Use uma classe de caracteres negada : [^a-z]+(qualquer caractere que não seja uma letra ASCII minúscula)
  • Corresponde a qualquer caractere, mas |:[^|]+

Nota de demonstração : a nova linha \né usada nas classes de caracteres negados nas demos para evitar o estouro da correspondência com as linhas vizinhas. Eles não são necessários ao testar seqüências individuais.

Nota da âncora : Em muitas linguagens, use \Apara definir o início inequívoco da sequência e \z(no Python \Z, no JavaScript, $é bom) definir o final da sequência.

Nota de ponto : em muitos tipos (mas não em POSIX, TRE, TCL), .corresponde a qualquer caractere, exceto um caractere de nova linha . Certifique-se de usar um modificador DOTALL correspondente ( /sem PCRE / Boost / .NET / Python / Java e /mRuby) para .corresponder a qualquer caractere, incluindo uma nova linha.

Nota da barra invertida : nos idiomas em que é necessário declarar padrões com as seqüências C que permitem sequências de escape (como \npara uma nova linha), é necessário dobrar as barras invertidas com caracteres especiais para que o mecanismo possa tratá-los como caracteres literais (por exemplo, em Java, world\.será declarado como "world\\."ou use uma classe de caracteres:) "world[.]". Use literais de string bruto (Python r'\bworld\b'), literais de string literal C # @"world\."ou notações literais de strings / regex slashy como /world\./.

Você pode colocar um ^no início de um conjunto de caracteres para corresponder a qualquer coisa, menos esses caracteres.

[^=]*

vai combinar tudo, menos =

Basta combinar /^index\.php/e rejeitar o que quer que seja.

Em python:

>>> import re
>>> p='^(?!index\.php\?[0-9]+).*$'
>>> s1='index.php?12345'
>>> re.match(p,s1)
>>> s2='index.html?12345'
>>> re.match(p,s2)
<_sre.SRE_Match object at 0xb7d65fa8>

Eu preciso de um poder regex para combinar tudo , mas , exceto uma string que começa com index.php um padrão específico (especificamente index.php eo que se segue, como index.php? Id = 2342343)

Use o método Exec

    let match,
        arr = [],
        myRe = /([\s\S]+?)(?:index\.php\?id.+)/g;

    var str = 'http://regular-viragenia/index.php?id=2342343';

    while ((match = myRe.exec(str)) != null) {
         arr.push(match[1]);
    } 
    
    console.log(arr);

var myRe = /([\s\S]+?)(?:index\.php\?id=.+)/g;
var str = 'http://regular-viragenia/index.php?id=2342343';
var matches_array = myRe.exec(str);
console.log(matches_array[1]);

OU OUTRO JOGO

let match,
            arr = [],
            myRe = /index.php\?id=((?:(?!index)[\s\S])*)/g;

        var str = 'http://regular-viragenia/index.php?id=2342343index.php?id=111index.php?id=222';

        while ((match = myRe.exec(str)) != null) {
             arr.push(match[1]);
        } 

        console.log(arr);

Que tal não usar regex:

// In PHP
0 !== strpos($string, 'index.php')