Operatores en PERL

Hemos visto que el perl utiliza los operadores matemáticos normales empleados para los números: + para la suma, – para la resta, * para la multiplicación, / para la división.

Además, == se utiliza para la igualdad, y vuelve «verdadero» o «falso» según que los números sean iguales o no. El opuesto es != .

 

Como se puede esperar, < es el símbolo de menor y > el de mayor, <= es el símbolo de menor o igual e => el de mayor o igual.

 

Usar estos símbolos con operadores no matemáticos, producirá, si se llama al script con la opción -w, un warning.

 

Hay también operadores que trabajan en la cadena:

 

.

(sí, realmente el punto) ejecuta la concatenación

 

eq

controla que las cadenas sean iguales

 

ne

es el opuesto de eq

 

3 == 3

es verdad

 

3 == «03»

es verdad

 

«bla» eq «arr»

es falso

 

«bla» ne «arr»

es verdad

 

«bla».3

es equivalente a «bla».»3″, que restituye «bla3»

 

«bla eek!»

es lo mismo di $bla.»eek!»

 

Están después los operadores lógicos: && (AND), || (OR), ! (NOT). && y || van entre dos expresiones, mientras ! va al principio de la expresión (ya que la niega)

 

3 == «03» && «bla»ne «arr»

es verdadera

 

Esta expresión funciona porque == y tienen una precedencia más alta respecto a &&, pero la misma expresión habría podido escribirse más claramente como:

 

(3 == 03) && («bla» ne «arr»)

 

!(«eek» eq $bla)

es lo mismo de («eek» ni $bla)

 

Una particularidad de los operadores && y || es que pueden utilizarse como atajo para «se ha verificado la condición haz esto».

 

unlink «dumbfile» || die «Couldn’t remove file\n»;

 

De este modo primero se valora unlink() y, si esto tiene éxito, la condición introducida por || viene ignorada, de otro modo (en caso de fracaso) dicha condición se ejecuta.

El operador =~ es curioso: éste mira si 2 pattern son iguales y los sustituye. La sintaxis es:

 

valor =~ /pattern/;

Controla si las variables son iguales

 

valor !~ /pattern/

Forma corta para !($variable=~/pattern/;). Controla que no sean iguales

 

$variable =~ s/pattern/replacement/;

Busca el pattern en la variable y la sustituye con replacement

 

Si la variable se omite, =~ y !~ actúan sobre $_

En la primera forma, sin la s/ , =~ y !~ no modifican los argumentos, pero realiza un test sólo si se acoplan. En la segunda forma, el pattern «replacement» se sustituye con pattern si se encuentra.

 

Y aún más, algunos modificadores pueden añadirse antes del ; para especificar como los pattern tienen que acoplarse:

 

i – case-insensitive

g – match globale. Controla y restituye también más de un valor

 

Los pattern son expresiones regulares bastante parecidas a las de grep. Esto se explicará inmediatamente.

 

«bla» =~ /bl/;

verdadero porque bla contiene bl

 

«blabla» =~ /bl/;

idem

 

«blabla» =~ /bl/g;

encuentra 2 matches

 

«bla» !~ /c/i;

vero

 

$var = «blabla»;

 

$var =~ s/bl/QQ/;

verdadero, y cambia $var en «QQahbla»

 

$var =~ s/BL/qq/ig;

verdadero, y $var se transforma en «qqahqqah»

 

El operador = asigna el segundo elemento al primero. Hay atajos para usar este operador.

 

$var += $value:

añade $value a $var

 

$var -= $value;

resta $value de $var

 

$var *= $value;

multiplica $var por $value

 

$var /= $value;

divide $var por $value

 

Estas expresiones se utilizan para incrementar el valor de las variables:

 

$counter += $step;

 

$var ++

añade 1 a $var

 

++$var

valora $var+1

 

Todos estos operadores (menos =~) y el matching de los pattern se aplican también en C, de manera casi idéntica