III - Lenguajes de Scripting - Perl

Lenguajes de Scripting
Introducción al lenguaje Perl

Detalles del lenguaje
Orientación a objetos en Perl
Perl
Horst H. von Brand
Departamento de Informática
Universidad Técnica Federico Santa Marı́a
Horst H. von Brand Scripting – Perl

Contenido
Tipos de datos
Contextos
Operadores
Estructuras de control
Funciones predefinidas
Expresiones regulares
Subrutinas
Estructuras de datos y referencias
Paquetes Horst H. von Brand Scripting – Perl
Caracterı́sticas de lenguajes de scripting
I “Script” es guión
I Invocar programas automáticamente
I Lenguajes interpretados
I Muy alto nivel
I Caracterı́sticas generales
I Manejo de strings y expresiones regulares
I Sin tipos, variables no se declaran
I Administración automática de memoria
I Caracterı́sticas adicionales
I Empotrable: Puede usarse desde dentro de programas
I Extensible: Pueden agregarse nuevas funcionalidades

Algunos lenguajes
I Perl: Oficialmente, abreviatura de Practical Extraction and

Report Language
I Python: Por Monty Python
I PHP: Abreviatura de PHP: Hypertext Processor
I Ruby: La piedra preciosa (si hay perlas. . . )
I TCL: Es Tool Control Language, creado con la idea de ser
un lenguaje de extensión/configuración
I expect: Una extensión de TCL, orientada a controlar
programas interactivos
I AWK: Lenguaje inventado por Aho, Weinberger,
Kernighan.
Perl
I Practical Extracting and Report Language

I Pathologically Eclectic Rubish Lister
I Lema: “There’s more than one way to do it” (TMTOWTDI)

I No pretende ser simple, regular, ortogonal
I Si aspira a ser cómodo, natural y rápido de usar

Lı́nea de comandos
El tradicional programa en Perl puede escribirse:
perl -e ’print "Hello, world!\n";’

Lı́nea de comandos
Repetir un comando sobre cada lı́nea de los archivos

mencionados, que se editan en su lugar, quedando los
originales en los respectivos .bak:
perl -pi.bak -e ’s/hoy/ayer/g’ uno dos

Ejemplos simples
Contar lı́neas, palabras, caracteres
# ! / usr / bin / p e r l
while (<>) {
$ l i n e s ++;
$words += s p l i t ;
$chars += length ;
}
p r i n t ” $ l i n e s $words $chars \n ” ;

Ejemplos simples
Contar lı́neas, palabras, caracteres – versión “completa”
# ! / u s r / b i n / p e r l −w
use s t r i c t ;
my( $ l i n e , $ l i n e s , $words , $chars , @tmp ) ;
while ( $ l i n e = <STDIN>) {
$ l i n e s ++;
@tmp = s p l i t ( / \ s + / , $ l i n e ) ; $words += @tmp ;
$chars += length ( $ l i n e ) ;
}
p r i n t STDOUT ” $ l i n e s $words $chars \n ” ;

Ejemplos simples
Referencias cruzadas
while (<>) {
foreach $w ( s p l i t ( / \W+ / ) ) {
i f ( ! defined ( $ r {$w } ) ) {
$ r {$w} = $ . ;
} else {
$ r {$w} . = ” , $ . ” unless $ r {$w} =˜ / $ . / ;
}
}
}
foreach $w ( s o r t keys %r ) {
p r i n t ” $w : $ r {$w}\n ” i f $w ;
} Horst H. von Brand Scripting – Perl
Ejemplos simples
Entrada y salida
open ( IN , ”< i n p u t ” ) ; chomp( @ l i s t = <IN > ) ; close ( IN ) ;
open (PGM, ” s o r t i n p u t | ” ) ; open (OUT, ”> o u t p u t ” ) ;

while (<PGM>) {
chomp ;
f o r ( $ i = 0 ; $ i <= $# l i s t ; $ i ++) {
p r i n t OUT ” $ i : $ l i s t [ $ i ] \ n ” i f ( $ l i s t [ $ i ] eq $ ) ;
}
}
close (PGM, OUT ) ;

Tipos de datos
Contextos
Lenguajes de Scripting Operadores
Introducción al lenguaje Perl Estructuras de control
Detalles del lenguaje Funciones predefinidas
Orientación a objetos en Perl Expresiones regulares
Subrutinas
Tipos de datos básicos
I $escalar: Strings, números, referencias.

I @arreglo: Elementos $arreglo[0], . . . , $arreglo[$#arreglo]
I %hash: Arreglo asociativo, elementos $hash{”clave”}
I Slices: @arreglo[1, 17, 3], @hash{”uno”, ”doce”, ”nueve”}

I Inicializar:
I @a = (”Do”, ”Lu”, ”Ma”, ”Mi”, ”Ju”, ”Vi” , ”Sa”);
I %h = (”cero” => 0, ”uno” => 1, ”dos” => 2);

Tipos de datos
Contextos
Subrutinas
Constantes numéricas
I Decimal: 100
I Para legibilidad: 1 000
I Decimales: 3.141592
I Con exponente: 6.024e24
I Octal: 0277
I Hexadecimal: 0x3ff
I Binario: 0b1010 0011

Tipos de datos
Contextos
Subrutinas
Escapes en strings
Los de C, con algunos adicionales:

Código Significado
”\cC” Control-C
”\x{263a}” Unicode (smiley)
”\N{Nombre}” Caracter por nombre

Tipos de datos
Contextos
Subrutinas
Escapes activos en strings
Código Acción
”\u” Siguiente es mayúscula (titlecase)
”\l ” Siguiente es minúscula
”\U” Mayúsculas
”\L” Minúsculas
”\Q” Backslash antes de no-alfanuméricos
”\E” Fin de ”\U”, ”\L”, ”\Q”

Tipos de datos
Contextos
Subrutinas
Contextos
Toda expresión se evalúa en el contexto dado por cómo se usa.

Hay dos contextos básicos:
Escalar: Arreglos dan su largo, hashes dan estadı́sticas de
su uso, y una variedad de funciones entregan
resultados escalares
Lista: Arreglos/listas dan sus valores; hashes dan los
pares (clave, valor) en una lista; escalares dan
una lista de un elemento

Tipos de datos
Contextos
Subrutinas
Valores de verdad
Cuando se requiere un valor de verdad, esto provee

impı́citamente contexto escalar. Perl usa los siguientes
criterios:
I Cualquier string, salvo ” ” y ”0”, es verdadero
I Todo número, salvo 0, es verdadero
I Cualquier referencia es verdadera
I Cualquier valor no definido es falso

Tipos de datos
Contextos
Subrutinas
Operadores
Básicamente los de C, pero con algunas adiciones:

I Rango: 1..10, \”a0 \”..\” z9\”
I Concatenación de strings: $saludo . ” , ” . $nombre
(Claro que se escribirı́a ”$saludo, $nombre” más bien)
I Repetir un string: ”\t ” x ($k / 8) . ” ” x ($k % 8)
I Potencia: $num ∗∗ 5
Además las combinadas con asignación (salvo rango).

Tipos de datos
Contextos
Subrutinas
Operadores lógicos adicionales
Hay operadores lógicos de muy baja precedencia, usados más

que nada por la evaluación en cortocircuito:
open(IN, ”< $file” ) or die ”Can’t open $file” ;
/ˆ #/ and next;

Tipos de datos
Contextos
Subrutinas
Comparaciones
Comparación Número String

Menor que < lt
Menor o igual que <= le
Igual a == eq
Mayor o igual que >= ge
Mayor que > gt
No igual a != ne
Comparar <=> cmp

Tipos de datos
Contextos
Subrutinas
i f ( CONDITION ) {
...
}
e l s i f ( CONDITION ) {
...
}
else {
...
}
unless ( CONDITION ) {
...
}
Tipos de datos
Contextos
Subrutinas
while ( CONDITION ) {
...
last ;
...
next ;
...
} continue {
...
}

Tipos de datos
Contextos
Subrutinas
u n t i l ( CONDITION ) {
...
last ;
...
next ;
...
} continue {
...
}

Tipos de datos
Contextos
Subrutinas
f o r ( I N I T ; CONDITION ; UPDATE) {
...
next ;
...
last ;
...
}

Tipos de datos
Contextos
Subrutinas
foreach VAR ( LIST ) {

...
next ;
...
last ;
...
}

Tipos de datos
Contextos
Subrutinas
Modificadores
... i f ( CONDITION ) ;
. . . unless ( CONDITION ) ;
. . . while ( CONDITION ) ;
. . . u n t i l ( CONDITION ) ;
. . . foreach LIST ;

Tipos de datos
Contextos
Subrutinas
Modificadores
do {
...
} while ( CONDITION ) ;
do {
...
} u n t i l ( CONDITION ) ;

Tipos de datos
Contextos
Subrutinas
Rótulos de ciclos
LABEL : {
...
next LABEL ;
...
l a s t LABEL ;
...
}

Tipos de datos
Contextos
Subrutinas
Manejo de arreglos como deque
I push ARRAY, LIST

I $var = pop ARRAY
I $var = shift ARRAY
Por omisión, @ARGV o @
I unshift ARRAY, LIST

Tipos de datos
Contextos
Subrutinas
Combinar/dividir strings
I join EXPR, LIST

I split /PATTERN/, EXPR, LIMIT
O sea, se puede hacer algo como:
perl -e ’print join(" ", split //, shift), "\n";’ ’

Tipos de datos
Contextos
Subrutinas
Manipulación de arreglos
I sort BLOCK ARRAY

BLOCK compara $a con $b
I map BLOCK ARRAY o map EXPR, ARRAY
I grep BLOCK ARRAY o grep EXPR, ARRAY

Tipos de datos
Contextos
Subrutinas
Manipulación de strings
I lc EXPR, uc EXPR
I lcfirst EXPR, ucfirst EXPR

Tipos de datos
Contextos
Subrutinas
Otras clases
I Manipulación de procesos
I Hebras (threads)
I Numéricas
I Llamadas propias de U NIX

Tipos de datos
Contextos
Subrutinas
Un ejemplo de uso
Datos
Supongamos que tenemos un archivo con el siguiente

“creativo” formato. Viene ordenado por apellido:
HERNANDEZ:GOMEZ:LUIS:234567-8
IN:OUT:GIGO:891234-6
LI:CHIANG:DANIEL ALBERTO:345678-9
NOGUERA:NORAMBUENA:NELLY NORA:987654-3
PEREZ:LOPEZ:JUAN PABLO:123456-7
SALGADO:NARDEZ:JOSEFO LUIS ALBERTO JAVIER:456789-K
ZAMORA:YUMA:ADAN BENJAMIN CARLOS DAVID:132547-6

Tipos de datos
Contextos
Subrutinas
Un ejemplo de uso
Salida deseada
Se requiere un archivo con el rol, seguido por el nombre. Debe

estar ordenado por rol:
123456-7: Juan Pablo Perez Lopez

132547-6: Adan Benjamin Carlos David Zamora Yuma
234567-8: Luis Hernandez Gomez
345678-9: Daniel Alberto Li Chiang
456789-K: Josefo Luis Alberto Javier Salgado Nardez
891234-6: Gigo In Out
987654-3: Nelly Nora Noguera Norambuena

Tipos de datos
Contextos
Subrutinas
Un ejemplo de uso
El programa
open (OUT, ” | s o r t ” ) ;
while (<>) {
chomp ;
@a = map { j o i n ’ ’ , map { u c f i r s t l c } s p l i t }
split / : / ;
p r i n t OUT ” \U$a [ 3 ] : ” , j o i n ( ’ ’ , @a[ 2 , 0 , 1 ] ) ,
” \n ” ;
}
close (OUT ) ;

Tipos de datos
Contextos
Subrutinas
Referencias cruzadas
Una versión más sofisticada
while (<>) {
foreach ( s p l i t / \W+ / ) {
/ ˆ $ / and next ;
$ref {$ } .= $ref {$ } ? ” , $ . ” : $ .
unless $ r e f { $ } =˜ / $ . / ;
}
}
p r i n t map ” $ : $ r e f { $ }\n ” , s o r t keys %r e f ;

Tipos de datos
Contextos
Subrutinas
Operadores especiales
Común Gral Int Significa
’ ... ’ q {...} No String
” ... ” qq{...} Si String
‘...‘ qx{...} Si Comando
qw{...} No Palabras
/.../ m{...}imosx Si Calza patrón
qr {...} imosx Si Patrón
s {...}{...} egimosx Si Reemplazo
tr {...}{...} cds No Transliterar
Los delimitadores pueden ser “cualquier cosa”. Paréntesis
deben parearse.
Tipos de datos
Contextos
Subrutinas
Calce de patrón
En m /.../ imosx y qr /.../ imosx:

i No distinga mayúsculas/minúsculas
m Múltiples lı́neas
o Compilar una sola vez (once)
s Una sola lı́nea
x Expresiones regulares extendidas
qr /.../ retorna un objeto que puede darse en vez de un patrón
al buscar/reemplazar.

Tipos de datos
Contextos
Subrutinas
Reemplazo
En s /.../.../ egimosx:
e Lado derecho es expresión
g Globalmente
i No distinga mayúsculas/minúsculas
m Múltiples lı́neas
o Compilar una sola vez (once)
s Una sola lı́nea
x Expresiones regulares extendidas

Tipos de datos
Contextos
Subrutinas
Transliterar
En tr /BUSCA/REEMPLAZO/cds:
c Complemento
d Elimine los sin traducción
s Secuencias duplicadas se reducen a uno (squash)
tr /A−J/0−9/: Como tr /ABCDEFGHIJ/0123456789/
tr/0−9/9/
tr /A−Za−z//s: ’Mississippi’ ’Misisipi’

Tipos de datos
Contextos
Subrutinas
Son patrones de búsqueda en texto. Siendo Perl un lenguaje

basado en manipular texto, son fundamentales. Mucha
manipulación de texto es “búsqueda y reemplazo”, donde
obviamente son parte central.
Las de Perl existen también como biblioteca aparte para uso
en otros programas: PCRE. En rigor, no son expresiones
regulares, pero no seremos nosotros quienes cambien el uso
del término. . .

Tipos de datos
Contextos
Subrutinas
En los patrones hay caracteres “normales” (que se representan

a sı́ mismos) y metacaracteres, con significado especial. En
Perl todos los metacaracteres son caracteres no alfanuméricos,
y todos ellos pierden su significado especial si se preceden con
backslash. Esta es la función del escape ”\Q...\E”.

Tipos de datos
Contextos
Subrutinas
Cada construcción calza con un patrón dado, en una posición

especı́fica. A las construcciones que sólo registran una
posición (no calzan con caracteres) les llaman anchor.
Las construcciones en general son voraces: Calzan lo más que
pueden. Pero también son poco previsoras: Calzan en la
primera oportunidad, aunque hayan calces “mejores” más
adelante.

Tipos de datos
Contextos
Subrutinas
Caracteres individuales
. Calza con cualquier caracter (salvo ”\n”, si /s)

[...] Conjunto de caracteres.
ˆ niega, – rango.
[: ... :] conjunto POSIX

Tipos de datos
Contextos
Subrutinas
Caracteres individuales
”\w” Palabra (alfanumérico y )

”\W” No-palabra
”\s” Espacio
”\S” No-espacio
”\d” Dı́gito
”\D” No-dı́gito

Tipos de datos
Contextos
Subrutinas
Operadores
* Repetir lo anterior cero o más veces

+ Repetir lo anterior una o más veces
? Lo anterior es opcional
{m, n} Repetir lo anterior entre m y n veces, {n}
exactamente n veces, {n,} al menos n veces
| Alternativas
(...) Agrupa (y recuerda en ”\1” y $1, . . . )

Tipos de datos
Contextos
Subrutinas
Anchors
ˆ Principio del string (o la lı́nea, si /m)

$ Fin del string (o la lı́nea, si /m)

Tipos de datos
Contextos
Subrutinas
Anchors
”\b” Borde de palabra

”\B” No-borde de palabra
”\A” Principio del string
”\Z” Final del string (o antes de ”\n” final)
”\z” Final del string

Tipos de datos
Contextos
Subrutinas
Expresiones regulares extendidas
Permite espacios y comentarios.

(?imsx–imsx) Opciones (– apaga)
+?, *? Mı́nimo posible (no voraz)
(?# ...) Comentario
(?: ...) Agrupa sin recordar, (?imsx–imsx: ...) con
opciones
(?= ...) Lookahead positivo, (?! ...) negativo
Hay mas. . .

Tipos de datos
Contextos
Subrutinas
Búsquedas y reemplazos
m/(\w+) \1/ # Palabras repetidas

($h, $m, $s) = $hms =˜ m/(\d+):(\d+):(\d+)/;
m{ˆ(.∗): GIF}; # Ahora $1 es lo que calza
s<ˆ(?:foo|bar)([0−9]+)>[$1−baz−$1]
s/(\[0−9\]+)/$1 + 3/ge

Tipos de datos
Contextos
Subrutinas
Subutinas
Un ejemplo simple
sub Ul
{
my $x = s h i f t ;
r e t u r n u c f i r s t l c $x ;
}
while (<>) {
p r i n t Ul $ ;
}

Tipos de datos
Contextos
Subrutinas
Subrutinas
Manejo de arreglos
sub acc
{
my $s ;
foreach (@ ) {$s += $ ; $ = $s ; }
return @ ;
}
while (<>) { p r i n t j o i n ’ ’ , acc s p l i t ; p r i n t ” \n ” ; }

Tipos de datos
Contextos
Subrutinas
Subrutinas – definición general

Prototipos
La definición general de subrutina tiene la forma:

sub NAME(PROTO): ATTRS BLOCK
I El prototipo y los atributos son opcionales.

I Si no hay bloque, es declaración únicamente.
I Si no se da nombre, es anónima.

Tipos de datos
Contextos
Subrutinas

Prototipos
$ Escalar
@ Arreglo
\@ Referencia a arreglo
\% Referencia a hash
& Bloque
∗ Glob
\[$@] Escalar o arreglo
\ %;$ Referencia a hash, escalar opcional

Tipos de datos
Contextos
Subrutinas

Atributos
Mecanismo para limitar acceso o dar información sobre la

subrutina. Básicamente definido por el usuario.

Tipos de datos
Contextos
Subrutinas
Múltiples dimensiones
En Perl es posible escribir por ejemplo:

$a [3][4] = $b{’Lu’}[2]{ ’ C−201’}
Claro que esto es diferente de lo que parece. . .
Tenemos un hash %b que bajo ’ Lu’ tiene una referencia a un
arreglo anónimo, cuyo tercer elemento es una referencia a un
hash anónimo del cual tomamos el valor con clave ’ C−201’.

Tipos de datos
Contextos
Subrutinas
Manejo explı́cito de referencias
Podemos depositar una referencia en una variable

$a = \$x; $b = \@y; $c = \ %h;
y después usarla descaradamente
${$a} = 37; push @{$b}, (1, 2, 3); ${$c}{’Lu’} .= ” , FIS”;
desmanes que son aplicables también a rutinas
sub una fun; $f = \&una fun; &{$f}(1, 2, 3);
donde nada impide que tengamos arreglos (o hashes) con
elementos de diferentes tipos. . .

Tipos de datos
Contextos
Subrutinas
Objetos anónimos
Podemos crear objetos anónimos de los distintos tipos, y

asignar referencias a ellos:
$a[0] = [1, 2, $x, @y]; # Arreglo
$a[1] = {’uno’ => 1, ’dos’ => 2}; # Hash
$a[2] = sub {map $ ∗ 3, @ }; # Rutina

Tipos de datos
Contextos
Subrutinas
Un ejemplo extraño
$a [ 0 ] = [ 0 , 1 , 2 ] ; $a [ 0 ] [ 3 ] = 3 ; push @{$a [ 0 ] } , 4 , 5 ;
$a [ 1 ] = { ’ uno ’ => 1 , ’ dos ’ => 2 } ;

$a [ 1 ] { ’ t r e s ’ } = 3 ;
$a [ 2 ] = sub {map $ ∗ 3 , @ };
p r i n t ” $ : $a [ 1 ] { $ }\n ” foreach ( s o r t keys %{$a [ 1 ] } ) ;

p r i n t j o i n ( ’ ’ , $a [ 2 ] (@{$a [ 0 ] } ) ) , ” \n ” ;

Paquetes
Módulos
Objetos
Paquetes
package Saludos ;
$Despedida = ” Chao . . . ” ;
$ h i = ” Hola ! ” ;
sub bye ( ) { $Despedida ; }
package main ;
p r i n t $Saludos : : h i . ” \n ” ;
p r i n t Saludos : : bye ( ) . ” \n ” ;

Paquetes
Módulos
Objetos
Módulos
El usuario
use Modulo ;
p r i n t f u n c @ARGV;
p r i n t ” \n ” ;

Paquetes
Módulos
Objetos
Módulos
El módulo mismo
# Modulo .pm
package Module ;
BEGIN {
use E x p o r t e r ( ) ;
our ( $VERSION , @ISA,
@EXPORT, @EXPORT OK, % EXPORT TAGS ) ;
@ISA = qw( E x p o r t e r ) ;
@EXPORT = qw(& f u n c ) ;
}
sub f u n c { ” | ” . ( j o i n ’ : ’ , @ ) . ” | ” ; }
1; Horst H. von Brand Scripting – Perl

Paquetes
Módulos
Objetos
Objetos en Perl
1. Un objeto es una referencia que sabe a qué clase

pertenece
2. Una clase es un paquete que provee métodos para
referencias a objetos
3. Un método es una subrutina que recibe una referencia a
un objeto (o el nombre del paquete, para métodos de
clase) como primer argumento

Paquetes
Módulos
Objetos
Estructura de la herencia
I El arreglo @ISA de la clase contiene los nombres de las

clases base. Búsqueda de métodos es en profundidad, de
derecha a izquierda.
I Toda clase hereda de UNIVERSAL

Paquetes
Módulos
Objetos
Sintaxis de llamadas
$mage = Wizard−>summon ( ” Gandalf ” ) ; # Metodo de c l a s e

$mage−>speak ( ” f r i e n d ” ) ; # de i n s t a n c i a
$ c l a s e = r e f ( $mage ) ; # Clase a l a que pertenece
$ t r a v e l = $companion eq ” Shadowfax ” ? ” r i d e ” : ” walk ” ;

$mage−>$ t r a v e l ( ” seven leagues ” ) ; # Metodo r i d e o walk

Paquetes
Módulos
Objetos
Crear objetos
La función bless asocia una referencia con un paquete:

$obj = {}; # R e f e r e n c i a a hash anonimo
bless ( $ o b j ) ; # En paquete a c t u a l
bless ( $obj , ” C r i t t e r ” ) ; # En paquete C r i t t e r
Comúnmente se usan hashes como almacenamiento de los
objetos, pero puede usarse cualquier tipo de referencia.

Paquetes
Módulos
Objetos
Ejemplo de clase
Definición de la clase
# Clase .pm
package Clase ;
sub new {
my $ i n v o c a n t = s h i f t ;
my $ c l a s s = r e f ( $ i n v o c a n t ) | | $ i n v o c a n t ;
my $ s e l f = { @ } ; bless ( $ s e l f , $ c l a s s ) ;
return $ s e l f ;
}
sub get name ( ) { ${ $ [ 0 ] } { name } ; }
1;

Paquetes
Módulos
Objetos
Ejemplo de clase
Uso de la clase
use Clase ;
$ o b j = Clase−>new ( name => ” i n t i ” ) ;
p r i n t $obj−>get name , ” \n ” ;

III - Lenguajes de Scripting - Perl

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

III - Lenguajes de Scripting - Perl

Uploaded by

Copyright:

Available Formats

Lenguajes de Scripting

Introducción al lenguaje Perl

Horst H. von Brand

Horst H. von Brand Scripting – Perl

Caracterı́sticas de lenguajes de scripting

Horst H. von Brand Scripting – Perl

I Perl: Oficialmente, abreviatura de Practical Extraction and

I Practical Extracting and Report Language

I Lema: “There’s more than one way to do it” (TMTOWTDI)

Horst H. von Brand Scripting – Perl

El tradicional programa en Perl puede escribirse:

perl -e ’print "Hello, world!\n";’

Horst H. von Brand Scripting – Perl

Repetir un comando sobre cada lı́nea de los archivos

perl -pi.bak -e ’s/hoy/ayer/g’ uno dos

Horst H. von Brand Scripting – Perl

Horst H. von Brand Scripting – Perl

my( $ l i n e , $ l i n e s , $words , $chars , @tmp ) ;

Horst H. von Brand Scripting – Perl

open (PGM, ” s o r t i n p u t | ” ) ; open (OUT, ”> o u t p u t ” ) ;

Horst H. von Brand Scripting – Perl

Tipos de datos básicos

I $escalar: Strings, números, referencias.

I Slices: @arreglo[1, 17, 3], @hash{”uno”, ”doce”, ”nueve”}

Horst H. von Brand Scripting – Perl

Horst H. von Brand Scripting – Perl

Los de C, con algunos adicionales:

Horst H. von Brand Scripting – Perl

Escapes activos en strings

Horst H. von Brand Scripting – Perl

Toda expresión se evalúa en el contexto dado por cómo se usa.

Horst H. von Brand Scripting – Perl

Cuando se requiere un valor de verdad, esto provee

Horst H. von Brand Scripting – Perl

Básicamente los de C, pero con algunas adiciones:

Horst H. von Brand Scripting – Perl

Operadores lógicos adicionales

Hay operadores lógicos de muy baja precedencia, usados más

Horst H. von Brand Scripting – Perl

Comparación Número String

Horst H. von Brand Scripting – Perl

Horst H. von Brand Scripting – Perl

Horst H. von Brand Scripting – Perl

Horst H. von Brand Scripting – Perl

foreach VAR ( LIST ) {

Horst H. von Brand Scripting – Perl

Horst H. von Brand Scripting – Perl

Horst H. von Brand Scripting – Perl

Horst H. von Brand Scripting – Perl

I push ARRAY, LIST

Horst H. von Brand Scripting – Perl

I join EXPR, LIST

perl -e ’print join(" ", split //, shift), "\n";’ ’

Horst H. von Brand Scripting – Perl

I sort BLOCK ARRAY

Horst H. von Brand Scripting – Perl

Horst H. von Brand Scripting – Perl

Horst H. von Brand Scripting – Perl

Supongamos que tenemos un archivo con el siguiente

Horst H. von Brand Scripting – Perl

Se requiere un archivo con el rol, seguido por el nombre. Debe

123456-7: Juan Pablo Perez Lopez

Horst H. von Brand Scripting – Perl

Horst H. von Brand Scripting – Perl