 |
|
|
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.
| |
|
|
|
