HTMLpointHTMLpoint HTMLpoint.com


 Operatori



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.


  Torna a inizio pagina