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