Operador de predicción negativo

(?! ...) Operador de ``trailing'' o ``mirar-adelante'' negativo.

Por ejemplo /foo(?!bar)/ contiene a cualquier ocurrencia de foo que no vaya seguida de bar. Aparentemente el operador ``mirar-adelante'' negativo es parecido a usar el operador ``mirar-adelante'' positivo con la negación de una clase. Sin embargo existen al menos dos diferencias:

• Una negación de una clase debe casar algo para tener éxito. Un `mirar-adelante'' negativo tiene éxito si, en particular no logra casar con algo. Por ejemplo:

  \d+(?!\.) casa con $a = '452', mientras que \d+(?=[^.]) lo hace, pero porque 452 es 45 seguido de un carácter que no es el punto:

  > cat lookaheadneg.pl
  #!/usr/bin/perl
  
   $a = "452";
   if ($a =~ m{\d+(?=[^.])}i) { print "$a casa clase negada. \$& = $&\n"; }
   else { print "$a no casa\n"; }
   if ($a =~ m{\d+(?!\.)}i) { print "$a casa predicción negativa. \$& = $&\n"; }
   else { print "$b no casa\n"; }
  nereida:~/perl/src> lookaheadneg.pl
  452 casa clase negada. $& = 45
  452 casa predicción negativa. $& = 452
  

• Una clase negada casa un único carácter. Un `mirar-adelante'' negativo puede tener longitud arbitraria.

Otros dos ejemplos:

• ^(?![A-Z]*$)[a-zA-Z]*$ casa con líneas formadas por secuencias de letras tales que no todas son mayúsculas.
• ^(?=.*?esto)(?=.*?eso) casan con cualquier línea en la que aparezcan esto y eso. Ejemplo:

  > cat estoyeso.pl
  #!/usr/bin/perl
  
   my $a = shift;
  
   if ($a =~ m{^(?=.*?esto)(?=.*?eso)}i) { print "$a matches.\n"; }
   else { print "$a does not match\n"; }
  
  >estoyeso.pl 'hola eso y esto'
  hola eso y esto matches.
  > estoyeso.pl 'hola esto y eso'
  hola esto y eso matches.
  > estoyeso.pl 'hola aquello y eso'
  hola aquello y eso does not match
  > estoyeso.pl 'hola esto y aquello'
  hola esto y aquello does not match
  

  El ejemplo muestra que la interpretación es que cada operador mirar-adelante se interpreta siempre a partir de la posición actual de búsqueda. La expresión regular anterior es básicamente equivalente a (/esto/ && /eso/).
• (?!000)(\d\d\d) casa con cualquier cadena de tres dígitos que no sea la cadena 000.

Nótese que el ``mirar-adelante'' negativo es diferente del ``mirar-atrás''. No puede usar este operador para ``mirar-atrás'': (?!foo)bar/ no casa con una aparición de bar que no ha sido precedida de foo. Lo que dice (?!foo) es que los tres caracteres que siguen no puede ser foo. Así, foo no pertenece a (?!foo)bar/, pero foobar pertenece a (?!foo)bar/ porque bar es una cadena cuyos tres siguientes caracteres son bar y no son foo.

> cat foobar.pl
#!/usr/bin/perl

 my $a = shift;

 if ($a =~ m{(?!foo)bar}i) { print "$a casa la primera. \$& = $&\n"; }
 else { print "$a no casa la primera\n"; }

 if ($a =~ m{(?!foo)...bar}i) { print "$a casa la segunda. \$& = $&\n"; }
 else { print "$a no casa la segunda\n"; }

> foobar.pl foo
foo no casa la primera
foo no casa la segunda
> foobar.pl foobar
foobar casa la primera. $& = bar
foobar no casa la segunda

Si quisieramos conseguir algo parecido tendríamos que escribir algo asi como /(?!foo)...bar/ que casa con una cadena de tres caracteres que no sea foo seguida de bar. En realidad, es mucho mas fácil escribir:

if (/bar/ and $` !~ /foo$/)

Veamos otro ejemplo:

   1 #!/usr/bin/perl -w
   2 $s = "foobar";
   3 if ($s =~ /(?!foo)bar/) {
   4   print "$s matches (?!foo)bar\n";
   5 }
   6 if ($s !~ /(?!foo)...bar/) {
   7   print "$s does not match (?!foo)...bar\n";
   8 }
   9 if ($s =~ /bar/ and $` !~ /foo$/) {
  10   print "$s matches /bar/ and \$` !~ /foo\$/\n";
  11 }
  12 else {
  13   print "$s does not match /bar/ and \$` !~ /foo\$/\n";
  14 }

Los resultados de la ejecución de este ejemplo son:

> lookbehind.pl
foobar matches (?!foo)bar
foobar does not match (?!foo)...bar
foobar does not match /bar/ and $` !~ /foo$/