Compartiendo sentencias y algunos ejemplos basico para empezar con Perl, libre y natural.
puede descargar desde el link siguiente.
<pre>
#!/usr/bin/perl -w
=Esto es un comentario..-
_ ._ _ , _ ._
(_ ‘ ( ` )_ .__)
( ( ( ) `) ) _)
(__ (_ (_ . _) _) ,__)
`~~`\ ‘ . /`~~`
|.|;|
||::|
__________________/_:|_;\_ _______________
| |
| De Natural,ARbol. |
| d = digitar. |
| linea = []. |
| *-para compilar el fichero programando.pl |
| |
| 0.-crear fichero R.so[462][464] |
| 1.-$ perl programando.pl |
| 2.-d -> salir[584] |
| 3.-d -> un numero[616] |
| 4.-d -> escribir para comparar[1557] |
| 5.-_- perl -v |
| 6.-usar -w en lugar de “use warning” v5.x |
|___________________________________________|
Fin del comentario…
=cut
use v5.10;
use strict;
use Getopt::Std;
use Storable qw(dclone);
use Data::Dumper;
#SCALARS
my $var = “texto”;
my $var2 = ‘el texto hackeado’;
my $numero = 234;
my $decimal = 0.00025;
my $suma = $numero+$decimal;
my $precio = ‘$p 2.5’;
my $receta = “solo cuesta 23.50\n”;
print “empezando, $numero + $decimal”,”\tEs el total\n”;
print “\tSUMA = $suma\n”;
print “$precio\n”,”$receta”;
#tipos de comillas
print ‘It\’s caracter especial solo usar el backslash apr ver comilla’,”\n”;
print “Otro \”ejemplo\” comillas doble\n”;
print “el precio \$75.34 \n”;
print “SUMA TOTAL=”.$suma.” Soles\n”;
#desde la version 5.10.0 “say”
say “#imprimir con say desde la version 5.10..!”;
print “imprimiendo con print..\n”;
#———————————–
#ARRAYS
my @tipo =(“nariz”,”cara”,”oreja”);
my @areglo_scalar = (“dentro”,77,”pesado”);
my @numeros = (12,21,11);
print $tipo[1];
print $areglo_scalar[0];
$tipo[1] =”tomate”;
#leyendo un cambio hecho a la posicion en la matriz, tipo.
print “$tipo[1]\n”;
#matriz en pedazos ò rodajas,trozos,etc.
print @tipo[0,2,1],”\n”;
print @numeros[0..2],”\n”;
#modificando areglo alargar cantidad numeros => “perldoc perlop”
print @numeros[1..5] = (12,11,10,13,25),”\n”;
my @ar=(1,2, sort 4,3,5,8,6,9,7);
print @ar.”\n”;
print “repite” x10;
#interpolacion de matriz
print “Mi lista interpolar => @areglo_scalar\n”; #matriz completa
print “prefiero el @areglo_scalar[1,2]\n”; #partes del areglo
print “poco usual estar $areglo_scalar[0]\n”; #muestra solo un valor
#contando la matriz desde el final(hacia atras)
print $tipo[-2];
print $tipo[-1];
print $tipo[-3],”\n”;
#buscando el temaño del areglo
my $cantidad = @tipo;
print “Hay $cantidad elementos dentro..\n”;
say “estos son escalares,(@tipo),de la lista \n”;
#sintaxys violenta como areglo o en la matriz => $#
my $primer_index_usado = $#tipo;
my $conteo_index_tipo = $#tipo +1;
say $primer_index_usado;
say $conteo_index_tipo;
#Usando qw// matrices populares(ahorrando tiempo y dedos)
my @frutas = qw/verde roja skuns morada/;
say “(@frutas)”;
say $frutas[2];
$frutas[2] = “indiga”;
print “$frutas[2]\n”;
#context escalar vs lista de contexto
my @ary = @frutas; #contexto de lista
my $ary = @frutas; #contexto scalar
my $ary2 = scalar(@frutas); #contexto scalar explicito
#forzando idividualmente cumplir con la operacion +o- de la listas.
my @a =(2,5,6);
my @b =(3,1,3,9);
print @a + @b,”\n”;
#Diferencia entre scalares Lista y Matriz
my $a = 1;
my $b=2;
print (“lista”,” “,$a,”\n”);
my @matris=(“matriz”,” “,$b,”\n”);
say @matris;
#crear tu lista de sabores y juega ya tiens capacidad de usar qw//
my @sabores = qw/verde verdeLimon roja morada sativa indiga superGlu
expressSativa indoor superSkuns pepuda saborMentolado /;
say @sabores[0];
say @sabores[-1];
my $contar = $#sabores + 1;
say $contar;
say @sabores[2];
$sabores[2] = “mangoLite”;
say $sabores[2];
say “Escribir: desshi\@inbox.ru”;
print ” \”@sabores\” \n”;
my @web=(1,2,4,5);
say @web[0,1];
say @web[1..5]=(3,4,7,2,6);
#————————————–
#HASHES –> perldoc perldata
my %sabor = (“limon”,5,”mangoLite”,8,”skuns”,10);
my %tipo =(
suave => 2,
ligero => 12,
silencio => 6,
);
my %color=(
primero => ‘verde’,
dos => ‘azul’,
tres => ‘blanco’,
);
say $sabor{“limon”};
say $tipo{ligero};
say $color{dos};
#insertar nuevo valro al hash
say $sabor{“limon”} = 7;
#cambiando valor al hash
say $color{tres}=’negro’;
#eliminando valor del hash
delete($tipo{silencio});
#Buscando salida de tamaño de un hash
my $total = keys %tipo;
say $total;
#Los hashes no tienen orden interno
#Hacer uso de funciones del hashes => perldoc -f funcion-nombre “values(),each(),keys(),delete(),defined(),exists()”
=NOTA, usar modulo “IxHash” ejemplo sin modulo “strict”
use Tie::IxHash;
my %hash;
tie (%hash, Tie::IxHash);
=cut
#———————————————
#VARIABLES ESPECIALES –> perldoc perlvar
$_ = “variable especial, puede ser un it=esto\n”,”linea 159″;
print;
#reemplazando variable espcial @ARGV por pm standares, Getopt::Std y Getopt::Long
my %opts;
getopts(‘iof:D:’,\%opts);
if($opts{iof}){
mkdir $opts{D} or die “poner chdir a $opts{D} – $!”;
}
# modulo desde cpan -> use Perl::Tidy;
=practicando desde -> perldoc -f sprintf
$unid =21;
$prec = 37.00;
$pt = $unid *$prec;
$cost = $pt / $unid;
if($pt>124){
print ‘ S/.’.$cost.” NUEVOS SOLES \n”;
$tor = sprintf(“%07d”,$cost+13424);
$dec = sprintf(“%.3f”,$cost);
say $tor;
say $dec;
say sprintf ‘%2$d %1$d’,8,25;
printf ‘%3$d %d %1$d’,1,2,3;
}
=cut
#——————————————————-
#FUNCTIONES
#para màs informaciòn -> perldoc perlfunc
#para ver documentacion -> perldoc -f print –> ejemplo=”print”
say 7+1+2;
#say (7+1)+2;
say +(7+1)+2;
say ((7+1)+2);
my @coco = qw/te flas h pone a do/;
say @coco;
say “@coco”;
say (@coco[1,2,4,5]);
#valor de retorno
my $dos = 23.45;
my $duro = int($dos);
say $duro;
=este ejemplo necesita pprobar por separado..
#para no ver el valor de retorno puede usar -> <STDIN>
#se utiliza pra eliminar line_siguient y digitar el valor -> chomp
my $pt = <STDIN>;
chomp $pt;
=cut
#funcion apr ver array y hash puede usar -> sort
my @tox= qw/a d b g r f/;
say sort @tox;
#function par ver logitud de una cadena puede usar length()
my $text = “que quera decir hoy!!”;
say length($text);
#en caso de conversion min=lc ,mayus=uc
say lc(“Que tal sub!”);
say uc(“Que Tal Sub!”);
say lcfirst(“QUE no Esta”);
say ucfirst(lc(“nature”));
#funcion chop && chomp
my $voz = “masamorra”;
my $song= chop $voz;
say “[$song] <-chop elimino la ultima letra (masamorra)y lo muestra”;
my $text =”ahi va el arbol “;
my $textt=”ya lo veo \n”;
my $cad = chomp $text;
my $cadd = chomp $textt;
say $text;
say $textt;
say $cad;
say $cadd;#al existir “\” demuestra qeu hay una linea-new para eliminar.
#cadena de texto al revez.rios
my $va = “texto en cadena :S”;
my $vac = reverse $va;
say $vac;
#funcion substr() -> cambiar String a substr() + sustitucion de texto.
my $bo = “Calmando el feroz rio”;
print substr($bo,3,6),”\n”;
substr($bo,0,8,”Asustado”);
say $bo;
#funcions numericas
=puede ser interesantes poner en practica..
abs(),evaluar absuto
sen(), cos() y atan2()
log(), logaritmico
exp(), exponenciacion
rand() y srand(), numeros aleatorios
sqrt(), raiz cuadrda
#conversions numerics, puede usar si es encesario
int(), oct(), hex(), chr(), ord(), scalar()
=cut
#manipulacion listas y matrics,” push, pop, shift y unshitf “
my @n_alt;
foreach(1..10){
say push @n_alt, hex(int(10));
}
#de lo contrario pop puede apagar y consumir el ultimo valor.
my @comid = qw(a i u e o);
my $pago = pop @comid;
say $pago;
#shift y unshift puen actuar como push y pop, al iniciar la lista.
my @num= (1..5);
my $primer = shift @num;
say $primer;
say unshift @num,5;
#creando estrucuta comun con push y shift
my @tarta =(1..7);
say push @tarta,8..12;
unshift @tarta,20,30,40;
#ordenar listas
my @menu = (“a”,”r”,”b”,”d”,”c”,”z”,”p”);
my $orden = sort @menu;
my $revez = reverse(sort(@menu));
say $revez;
=puede usar este ejemplo en otro fichero, los comparadores “cmp y <=> “
son para saber si son 1,-1,0 teniendo en cuenta la derecha o izquierda.
#por defecto sort ordena usando ASCCI-tabla, asi pues parte de un bloque
my @listo =(“a”,”d”,”b”,”c”);
my @nmrs =(1,4,2,9,7,8,3,5);
#esto no es comun entre el bloque y la lista
@listo = sort{a cmp b} @listo;
say @listo;
#ordenar numericamente
@nmrs =sort{1 <=> 0} @nmrs;
say @nmrs;
=cut
#convertir cadenas a lista o viseversa,fonciones->”join() y split()”
my $anon =”pipe:pipa:porro:solo”;
my @unika = split(/:/,$anon);
say @unika;
my $newAnon = join(“|”,@unika);
say $newAnon;
=algo tal vez interesante
#procesamiento de hash
delete(),funcion que elimina un elemento del hash
exists(),funciona ha decir si existe una llave en el hash
keys(),retorna lista de las llaves o evaluciones de un hash
each(),te eprmite una iteracion sobre pares llave-evaluacion
=cut
=tal vez interese.
#Leer y escribir archivos
open(), funcion permite abrir un archivo par escribir o leer.
close(),funcion cierra un archivo despues de terminar con esto.
=cut
#Tiempo, par saber màs “perldoc POSIX”,”perldoc -f localtime”
=la funcion time() concurrentemente retorna el tiempo en formato UNIX
gtime() y localtime() puede sr mejor par agregar una mejor representacion
mistosa del tiempo.como uede ser la hora de Moscu o la hora local..
=cut
use POSIX qw(strftime);
say strftime(“%Y-%m-%d”,localtime());
#Constructores condicionales
#la condicion if() lo contrario unless()
=ejemplo
if(not $hay_hachis){
comprar_mas(); //block o bloque..
}
unless($hay_hachis){
comprar_mas();
}
print “tenemos sativa”, if $hachis;
print “no tenemos”, unless $hachis;
=cut
#Que es un bloque?,lo qu esta entre corchetes {block}.
#puede discutir para uso de interpolacion de bloques.
my $fruta=”coco”;
my $prec=2;
print “en la selva cuesta $prec los ${fruta}s\n”;
#ejempls
my $q = “tox”;
{
my $q=”vos-“;
print $q;
}
say $q;
#otro
my $var =0;
my $bb =0;
unless($var){
$var=2;
my $bb=5;
print $var,”\n”;
}
say “$var $bb”;
#usando “local” y si no es posible usar “my”
$_ =”pescados y mariscos”;
say $_;
{
local $_=$_;
$_.=” para el cebiche :D”;
say $_;
}
say $_;
=conceptos basicos y ejemplos operadores
#operadores de comparacion numerica
==,<,>,!=,<=>,<=,>=
#operadores de comparacion de cadena
eq,ne,lt, gt,le,ge,cmp,
#ejemplos
10 > 2 //verdadero
“0”== 2-2 //verd..
‘dos’ gt ‘doce’; //falso
1+3== “3cor”; //verdad
0 == “hola”; //verd.. es igual en un coenxto numerico
0 eq “hola”; //falso.. no peude ser usado con contexto numerico
0 eq 00; //true
0 eq “00”; //falso no peude ser usado con contexto numerico
undef; //falso siempre sera falso
–Asignar undef a un nombre de variable no definida que se repita..
my $fo= “bar”;
$fo = undef; //crea un $fo indefinido
say undef($fo); //igual que el anterior..
–Existencia y el caracter definitivo
my $pato; // $pato es indefinido y falso
$pato =”valor”; //definido y true
print “true” if $pato; //imprime verdad..
print “define” if defined($pato); //imprime defined
$dos =””; //es falso y definido
print “true” if $doce; //esto no imprime nada
print “define” if defined($dos); //imprime defined
$tox = undef; //falso y sind efinir
print “true” if $coso; //no imprime nada
print “define” if defined($tocc); //no imprime nada
–SI es posible para un “hash” tenga un elemento asociado con un
evaluacion no definida, en este caso los elementos existens pero no
definidos.ha buscar la salida si uno de estos elemts del hash
existente usar la funcion “exists”.
my %planta =(
“hoja” => “verde”, //exists,definido,true
“favorit” => 3, //exists,definido,falso
“color” => “”, //exists,definido,falso
“gen” => undef, //exists,no definido,falso
);
if(exists $coco{“verde coco”}){
print “verde coco existe. \n”; /esto no consigue imprimirse
}
if(exists $coco{“verde”}){
print “verde existe. \n”; //esto consigue imprimirse
}
if(defined $coco{“verde”}){
print “verde coco definido. \n”; //esto no consigue imprimirse
}
my %num_hojas =(
lol => 1, //lol es hoja 1
elo => 2, //elo es hoja 2
bat => 0, //bat no es una hoja
cona => undef, //cona no responde la pregunta
);
–para saber màs “perldoc -f defined” tambien “perldoc -f exists”
#Operadores logicos booleanos(true ò false)
and, or, not
#ejemplo
my $a =1;
my $a =2;
! $a; //falso
not $a; //falso
$a==1 and $b==2; //verdad..
$a==1 or $b==2; //verdad..
$a == 2 or $b == 5; //falso
($a==1 and $b==5)or $b==2; //verdadero((falso) o verdadero)
=cut
#Operadores logicos y circuitos cortos
#pueden ser usado par combiancion de otras intruccion si le parece bien.
#peude ver en “perldoc open”, “perldoc die”
open(my $ficha, “<“, “R.so”) || die (“no se encuentra el fichero: $!”);
#tambien peude ser..
open(my $fichero, “<” , “R.so”) or die(“no existe el archivo: $!”);
#usando &&
#print “saludos hermano\n” if $dia eq ‘Lunes’; esto es un errror
my $dia = ‘Lunes’;
if($dia eq ‘Lunes’){
say “es cierto es lunes..”;
}
#Asignacion de booleano
#$x = $a || $b;
#$x = $a, si $a es verdadero;
#$x = $b, si no cumple la ocasion anterior
#crear $ si es verdadero,sino $, sino $c,sino 0.
#$x =$a || $b || $c || 0;
#En Perl5.10,0 o posterior,es posible usar “defined” o //.
#$x =$a // $b // $c // 0;
#el defined o perador // se usaparticularmente cuando queire obenter
#un 0 o una cadena vacia..
#los operdore slogicos bolleanos son comumnete un camino sumpelentario
#una evaluacion por defecto a una variable..
#Si el $nombre es falso, crea esto igual ha “anonimo”
#$nombre ||= “anonimo”; -> $nombre = $nombre || “anonimo”
#Si la entrada no es definido, crea esto un cero.
#$entrada //= 0; -> $entrada = $entrada // 0 :
#contruccion de bucle condicional
#mientras(whie)
my $num = 1;
while($num <= 4){
print “$num\n”;
$num++;
}
#la oposicion de este contructor es “until”
my $nu = 5;
until($nu < 1){
print “$nu\n”;
$nu–;
}
#Si te gusta la estructura “if” y “unless” constructor, while y until…
my $punto =0;
print “$punto\n” while(++$punto <= 4);
my $punta =5;
print “$punta\n” while($punta– < 1);
#constructor para(for) y para-cada(foreach)
for(my $col=1;$col <=5;$col++){
print “$col\n”;
}
#usando un bucle for
my @matrix= qw/1 2 3 4 5 6/ ;
for( my $i=0;$i < @matrix; $i++){
print $matrix[$i].”\n”;
}
#usando foreach
foreach my $valor (@matrix){
print “$valor\n”;
}
#puede usar si quier limitar una sola instruccion.
foreach my $valor (@matrix){
print “$_\n”;
}
#creando bucle dentro del hash usando “keys” retorna llaves en una lista
#para màs -> “perldocl -f keys”
my %meses = (“Ene”,30,”Feb.”,28,”Mar.”,27,”Sep.”,29);
foreach my $mes(keys %meses){
print “Tiene $meses{$mes} dias el mes $mes.\n”;
}
#tambien para usarlo como vista de todo la lista
say foreach(@matrix);
#peude ser usado para generar autoamticamente de n..m
print foreach(1..7),”\n”;
#modificar variables original por otra..
my @numrs=(2,3,4,5);
foreach my $valor(@numrs){
print $valor = $valor *2,”\n”;
}
#Interaccion entre varios items
foreach(@ar,1..3,’a’..’h’,$a,$b,qw(bon bo dos)){
print $a;
say $ar[2];
}
=STDIN
#Practicando uso de “while” en blucles, tomando entrads desde “STDIN”
#STDIN es la entrada de flujo standar para cualquier programa Unix…
por ejemplo “cat” una utilidad de impresion de todo lo que tiene
un fichero en al linea de comando, peor tambien puede imprimir ficheros
redirigidos a su STDIN..(abrir terminal y problar).
% cat < fichero.pl
Tomando entrada desde STDIN
my $entrada = <STDIN>
La entrada es determinado pro el usuario al presionar “Enter” ,
si queremos repetir tomando desde el STDIN..
while($_=<STDIN>){
print “cacaview”;
}
Podemos ver si el valor es asignado(definido) y no solo saber la verdad..
while(defined($_=<STDIN>){
print “cacaserver”;
}
Tambien se puede contruir while de la forma..
while(<STDIN>){
print”cacadisplay”;
}
En otras circunstancias podemso abreviar aùn màs el bucle..
while(<>){
print “caca”;
}
Con el “<>” contruye un magico diamante, lo abre y lee ficheros dentro
la linea de comando desde @ARG o desde STDIN si los ficheros no son listados
es una incerible utilidad de contruir esto, vale la pena recordarlo…
=cut
#Salir o reiniciar el blucle
=Puede cambiar el flujo del bucle(ha reiniciar o finalizar) usando
la funcion “next”,”last”,”red”…
while($entrada=<STDIN>){
if($entrada eq “”){
next;
}
elsif($entrada eq “q”){
last;
}
}
Al escribir “q” y presionar Enter saldra dle bucle..
=cut
#ejemplo evaluar y dividir la palabras en todo y terminar si en la linea
#escribe la palabra “salir”
print “Escribir salir :”;
LINE:
while (my $entrada = <STDIN>){
chomp $entrada; #elimina la lina nueva..
next if $entrada eq “”; #omite lineas en blanco..
foreach my $magia(split /\s+/, $entrada){
last LINE if lc($magia) eq ‘salir’;
}
}
=Usnado otro flujo deblucle “redo”, se usa par reiniciar evaluando la
condicion, este comando no se usa mucho pero es util para programar..
Para saber mas “perldoc – last”,”perldoc -f next”,”perldoc -f redo”
foreach my $ficha(@lista_negra){
print “quiere eliminar este archivo $ficha? [y|n]\n”;
my $resp = <STDIN>;
chomp $resp;
$resp = lc $resp;
if($resp eq ‘y’){
unlink $ficha or warn “Eliminacion fallida: $!”;
}
elsif($resp eq ‘n’){
print “$ficha no eliminado\n”;
}
else{
redo;
}
}
=cut
#”given” y “when” , a partir de Perl 5.10
my $secreto = int(rand 100)+1;
my @goya=qw/a i u e o/;
say “vamos ver si existe numeros entre 1-100”;
while (my $secreto =<STDIN>){
chomp $secreto;
given($secreto){
when (/\D/){say “Dame un numero entero :)”;}
when (@goya){say “Esta letra existe en su areglo”;}
when($secreto){say “justo lo que queria, he salido!”; last;}
when($_ < $secreto){say “muy bajo”; continue;}#es lexico,nose muestra..
when($_ > $secreto){say “muy alto”; continue;}#al econtrar un coicidencia ningun bloque se verifica o ejecuta..
push(@goya,$_);
}
}
say “yo puse “, scalar(@goya),” letras.”;
#SUB-RUTINAS
#–Se usa para evitra o reducir codigo renundante
#–A improvisar mantenibilidad y reduce posiblemente de errores
#–A reducir complejidad por rupturas dentro de problemas pequeños,piezas màs simples
#–A mejorar la legibilidad en el programa
sub print_cabez{
print “torque dos”;
print “por\n”;
print “desshi san\n”;
return;
}
#llamando a una subrutina
print print_cabez();#tambien peude ser sin “()” pero seria ambiguo..
#Pasando argumento a una subrutina
#–pasando en scalares
imp_dos(“Esta pelicula fue “,”candente lava fria..”);
my $vid = “oldboy”;
my $autor = “Frita”;
imp_dos($vid,$autor);
sub imp_dos{
my ($pel, $aut) = @_;
print “$pel\n”;
print “Por\n”;
print “$aut\n”;
return;
}
#En el interior de una subrutine,el “shift” retorna argumentos desde el inicio de “@_”
print imp_doce();
sub imp_doce{
my $vista = shift || “anonimo”;
my $libro = shift || “pirata”;
print “$vista\n”;
print “by\n”;
print “$libro\n”;
return;
}
#Pasando una matriz y hashes
#–par sar un solo areglo, crea este elemento al final de tu lsita de argumentos..
my $nomb=”Los Andes”;
my $tipo=”sativa”;
my @precios=qw/5 10 20/;
venta_canbs($nomb, $tipo, @precios);
sub venta_canbs{
my ($nomb, $tipo, @precios) = @_;
print “\nDe:$nomb\nCalidad:$tipo\n”;
if(@precios){
#Si quremos imprimir todos los valores de @precio
print “Precio desde: @precios \n”;
}
return;
}
=Si crea este ejemplo no obtendra lso resultados que quiere..
my @colors = qw/verde auzl rojo blanco negro/;
my @otros = qw/rojo verde azul/;
dos_listas(@colors, @otros);
sub dos_listas {
my (@colors, @otros) = @_;
….
return;
}
=cut
#Usar referencia para solucionar ejemplo anterior en coemntario anterior
#para saber mas “perldoc perlreftut”
my @colors = qw/verde auzl rojo blanco negro/;
my @otros = qw/rojo verde azul/;
dos_listas(\@colors, \@otros);
sub dos_listas {
my (@colors, @otros) = @_;
my @color_rf = @colors;
my @otros_rf = @otros;
print “@color_rf\n”;
print “@otros_rf\n”;
return;
}
#Retornando evaluaciones desde una subrutina
sub dos_retorno {
my ($colors,$otros) = @_;
return “$colors\ny\n$otros\n”;
}
sub sum{
foreach(@_){
$total = $total +$_;
}
return $total;
}
#–estos valores de retorno se podrian usar de la siguente manera.
my $colrs = dos_retorno(“color claro”,”color oscuro”);
print $colrs;
my $totdo = sum(1..100);
print “$total\n”;
my $combinacion = sum($totdo, length($colrs));
print “$combinacion\n”;
#–tambien puedes retornar listas desde tu subrutina
sub randon_ints{
my ($donde,$max) = @_;
my @randoms;
foreach(1..$donde){
push @randoms, int(rand $max);
}
return @randoms;
}
my @trs_randms = randon_ints(3,10);
#-|alternativo
my ($x,$y,$z) = randon_ints(4,15);
#EXPRESIONES REGULARES
=para saber más “perldoc perlre”
#Expresiones regualres, operadores y funciones
“m/patron/” ->(funcion de coincidencia)..
#en los scalares retorna verdaedo(1) if la coincidencia es exitosa..
while (<>){
print if m/doss/; #imprime si la linea contiene “dosss”
print if m/doce/i; #imprime si la linea contiene “doce”o “DOCE”
print if /tor/i; #exactamente lo mismo, la “m” es opcional
print if m#tor#i; #exactamente lo mismo..
print if /http:\/\//; #imprime si la linea es “http://”
print if m!http://!; #usando “!” es una alternativa par limitar
print if m{http://}; #usando “{}” es una limitacion..
continue ;
}
#el operador de sustitucion s/patron/sustituto/ ->(funcion de sustitucion)
while (<>){
s/liber/libre/g; #corregir “liber” a “libre” dentro de la linea..
s/peru/Perú/g;
s/trux/Trujillo/ig;
print;
}
#Vincular operadores,
# es “true”, si el patron coincide “=~”, es “true”si el patron no coincide “!~”
say “digite su URL”;
$url = <>;
if($url !~ /^http:/){
print “La direccion no es un link HTTP URL\n”;
}
if($url =~ /desshi/){
print “Veo tu pagina deshi,lo veo!!\n”;
}
my $scritura = “nasfree arpol y razi viven”;
$scritura =~ s/arpol/arbol/;
$scritura =~ s/razi/raíz/;
print $scritura;
#cuantificadores
? = 0 a 10; * = de 0 a más; + = de 1 a more; {n} = coincide n momentos;
{n,} = coincide n ò más momentos; {n,m} = coincide entre n y m moments;
….
/Sr\.? Deshi/;
/camello.*perl/;
/b+\
/x{1,5};
#Tecnicas de agrupacion
while(<>){
print if /^(tu|yo|èl)$/;
}
——
while (<>) {
print if /^(De|Para|Fecha):\s/;
}
#concepto de atomos.
esto bien del concepto de la invisibilidad,un grupo atomico puede cuantificar
adjuntos para ellos,por instancia..
–coincidie 3 letras(pata tarapot)
/(b\w+\s*){3}/;
–coincidie 3 o màs caracter iniciando por “a” en uan fila
/(\ba\w*\s){3,}/;
=cut
#INTRODUCCION A MODULOS
#un modulo es un fichero separado que contiene codigo fuente perl
#Usar declaraciones
=tambien el File::copy modulo contiene un packete llamdo File::Copy..
if($teinteresa){
use File::Copy qw(copy);
copy($filea,$fileb) or die “Fallo la copia: $!”;
}
=cut
=si quiere cargar un modulo con dependecias dentro la condiciones,puede
usar “if” pragmatico, para ver mas -> “perldoc if”
if ($interesado){
use warnings;
print undef; #ningun mensaje de error warn..
}
=cut
#El Comprensivo Perl Archivo de Red (CPAN)
=para la covertura de instalacion de modulos leer “perldoc perlmodlib”
Si tu quieres distribuir tu modulos leer “perldo perlnewmod”
#Instalar manualmente desde un tar-ball
% tar .xvxf ver.modulo-0-0.tgz
% cd ver.modulo/
% perl Makefile.PL
% make
% make test
% make install
#Installar manual ocn “cpan!
% cpan Text::CSV_XS
#Agregar ruta de acceso ha @INC usar “lib”
use lib “/ruta/tor/libs”;
use Module;
#ruta de acceso relativo
use FindBin wq($Bin);
–usa el directorio relativo de la ruta
use lib “$Bin/”;
–usa el direcotrio relativo de la ruta lib5
use lib “$Bin/lib5”
#Trabajando con una instalacion lcal
#Instalacion locla de modulso locales
% perl Makefile.PL INSTALL_BASE=/home/tor/perl5
% use lib “$ENV{HOME}/perl5/lib/perl5”;
% use lib “$ENV{HOME}/perl5/lib/perl5/x86_64-linux-gnu-thread-multi”;
#Instalando moduloes locales con cpan
% cpan
> o conf makepl_arg “INSTALL_BASE=/home/tor/perl5”
> o conf commit
#local::lib y cpanm
Tiene una jerarquia de modulos Perl instalados en tu home directorio o
si no es transparene,esto no es comun por defecto con Perl,peor es facil
de instalar, tambien si tu no cuentas con permiso de super usuario..
Este local::lib primeramente asigna un numero de variables de entorno..
export PERL_MB_OPT=’–install_base /home/tor/perl5’
export PERL_MM_OPT=’INSTALL_BASE=/home/tor/perl5’
export PERL5LIB=’/home/tor/perl5/lib/perl5/i486-linux-[…]’
export PATH=”/home/tor/perl5/bin:$PATH”
Si instalamos los modulos dentro de /home/tor/perl/ tambien tu codigo
puee justamente escribir..
use local::lib;
Si estamos instalando modulos con cpanm podemos escribir..
cpanm ==local-lib-Text::CSV_XS
=cut
#ARCHiVOS EXTERNOS Y PAQUETES
=perl implementa un numero de mecanismos poara cargar codigos desde
archivos del exterior, lo mas simple de esto es por el uso del la
funcion “require”,ejemplo..
require ‘fichero.pl’;
require ‘archivo.pl’;
=cut
=Para saber más use ‘perldoc Carp’ esto es sobre errores, warning,strict..
#Paquetes variables y “our”
use Carp;
$Carp::Verbose= 1;
package Carp;
our $VERSION =’1.0.2′;
——ejemplo de paquete diferencia entre require————–
{
package zombi;
sub ligero
{
return “bless”;
}
say “El paquete “.__PACKAGE__.” tiene algo de “,ligero();
}
—————————————————————–
=cut
#ESCRIBIENDO MODULOS
=los roles para escribr un modulo
#organizar nombrando el contenido del modulo..
Proyecto
::buscar
::xcodigo
::xnombre
::reportar
::xtiempo
::estado
–Un modulo peude contenre multiples paquetes, estos tienes nombres apropiados
y viven dentro del sistema de archivos en estos tendriamos a continuacion
Proyecto::buscar::xcodigo dentro del paquete Proyecto/buscar/xcodig.pm
–Cuando escriben modulos es importante estar seguro de estar bien nombrado
par no tener problemas con modulos provenients desde CPAN, si es necesario
crear un modulo apr trabajo interno se usa la palara reservada “Local::”
–para saber màs sobre la escritura de modulos -> ‘perldoc perlmodlib’
tambien ‘perldoc perlmod’.
#USE vs REQUIRE
use = con esto se carga y ejecuta en tiempo de compilacion y no en tiempo
de ejecucion.Esto significa qeu todos subrutinas,variables y
otras estructuras existan antes qeu al principal ejecucion del codigo.
Tambien significa q usted podra ver los archivos que Perl no podra cargar.
Permite importar variables,subrutinas desde el pakete usado actualmente.
Esto puede ahcer que la programacion sea màs facil y + conscisa.
Donde es posible “use” y modulos Perl son preferido pr encima de “require”
#Creando esto dentro un modulo
crear fiechero ‘mi_test.pm’ usando strict y warnings
–Testear modulo y verficar al sisntaxys de error usando el comando..
% perl -c mi_test.pm
#moviendo un modulo dentro de un sub directori….
crear directorio,crear modulo test.pm y copiar al directorio creado..
para llamar al modulo dsde el drectorio puede buscar el modulo saundo
” use lib ‘directorio’; “
——–ejemplo llamar modulo desde carpeta tox—————-
use strict;
use warnings;
use lib ‘tox’;
…
=cut
=xxxxx
#Exportando e importando subrutinas
@EXPORT = simbolo ha exportar dentro los nobmrs de usauris espacio por defecto
@EXPORT_OK = simbolo buscando los usuario que peuden solicitar un exportacion
@EXPORT_TAGS = esta disponible para paquetes de sibolos ha exportar cuando
el usuario solicita un especial exportacion.
@ISA
Para tomar ventaja de Exportador de la función de importación que tenemos
que dejar de Perl saber que nuestro paquete tiene un especial relación
con el Exportador paquete. Hacemos esto por decirle a Perl que se heredan de
Exportador.Ahora, cuando Perl va en busca de la función de importación
buscará primero en nuestro paquete. Si no se puede se encuentran allí,
Perl buscará un especial de array llamado @ISA.
–ejemplo——–
use Exportador;
our @ISA = qw(Exportador);
—————————-
-usar base
use base qw(exportador);
—————————
–ejemplo màs claro—-
package Gente::lider;
use base qw(Exportador);
our @EXPORT = qw(invitar $nombre $amigs $codigos);
our @EXPORT = qw(logros $rivals $caza $solos);
————————————————-
=cut
#Exportando por defecto.
=El uso de la matriz @eEXPORT es limitado.
Usando @EXPORT_OK permite al usuario elegir lso simbolos qeu requiere traer a su nombre..
Todos lso simbolos s epeuden traer con su nobmre completo como “Gente::lider::invitar()”
cuando sea requerido..
——————ejemplo—————————
Tu modulo
*****Gente/lider.pm***********
package Gente::lider;
use strict;
use warnings;
use base qw(Exportador);
**listar tu
our @EXPORT_OK = qw(invitar $name $logos @codigos
logros $rivals @caza $solos);
#las variable snecesitan declarar con “our” no con “my”..
our $name = “Deshi”;
our $logos = “toxX”;
our @codigos = qw(anonimo);
our @caza = qw(toro vaca);
our $rivals = “sativa”;
our $solos = “Av. RIvadavia y Matheu”;
our %librocentro = {
Paco => “al 200 de alberti”;
BsAirs => “al 4400 de Moreno”;
Tarap => “pasje flores Fonabi”;
};
sub invitar{
my ($amigo, $dato) = @_;
return “Saludos $amigo, \n $rivals y quiero decir que haya paz”;
“Comidad para todos en $solos\n”;
“Si tu ers el sr. $name\n”;
}
sub logros{
my ($enemigo) = @_;
return “Muerte $name si luchas contra la $rivals”;
}
1;
——————————————————
Tu programam
*****comida.pl***********
#!/usr/bin/perl
use strict;
use warnings;
use Gente::lider qw(invitado %librocentro);
# only using a few things
# invitar a la gnete a tu cena.
foreach my $persona (keys %librocentro) {
print invitado($persona,”siguente pegada”);
}
————————————————
resumen: un modulo puede usarse para definicines de clases, o para
librerias para codigos comunes.
Un modulo puede contener multiples paquetes, pero esto es una mala idea.
Esto es buena idea amenudo si tu modulo esta dentro de espacio de nombre “Local”
o en un proyecto espeficio.
=cut
#USANDO OBJECTOS EN PERL
=Objetos en breve:
Un objeto es una collecion de datos(atributos) y subrutinas(metodos) eso
tiene uncluido dentro un solo intem..
Un objeto en Perl es una referencia a un especialmente prepearcion
de datos estructurado.Esta estructura puede ser un ‘hash’. un ‘matriz’,
un ‘escalar’,o algo màs complejo.
La orientacion a objectos dospone a crear multiples objectos desde la
misma clase que cada uno puede direfenciar la informacion y comportase
diferentemente de acuerdo a esta informacion.Esto ahce que sea muy facil
para los usuarios de los objectos,esto ahce la informacion facil de seguir y manipular..
para saber màs -> “perldoc perlboot,perldoc perltoot,perldoc perltooc,perldoc perlbot”.
=cut
#Cargando una clase
=A usar un modulo Perl buscando un porveedor orientado a intefaces nostros
usamos ‘use’ es importante par cualquier metodo.Por ejemplo usaremos
el modulo ‘DBI’ ,que permite interactuar con un mumnero de base de datos,
este modulo es uno de lo mas comunes en Perl…par ver màs -> “perldoc DBI”
use DBI; #podemso ahora crear objectos DBI.
=cut
#Instanciando un objecto.
=A crear un numeovo objecto nostros llamamos al metodo constructor dentro del nombre de la clase.
En muchos cases este metodo es llamdo ‘new’,sin embargo con DBI esto es llamado
‘connect;’como llamar tu basedatos manejado por la coneccion a una base de datos.
use DBI;
use www:mecanismo;
#crear un objeto DBI(database coneccion manejo)
my $dbm = DBI->($nombre_db ,$usuario, $contraseña);
#crear un objeto www:mecanismo(agente)
my $mecan = www::mecanismo->new();
Por conviccion, tu conexion de objecto a debasedatos es llamado $dbm ,para manipulacion de DB..
Nosotros podemos crear un numero de DB manuladas(objetos) con la misma coneccion
a direfentes basesdedatos o conectando a la misma basedatos(DB).
my $oracle_dbm = DBI->($orace_tor,$oracleuser,$oraclepassword);
my $postgres_dbm = DBI->($postgres_tor,$postgreuser,$oraclepassword);
my $mysql_dbm = DBI->($mysql_tor,$mysqluser,$mysqlpassword);
my $mysql_dbm1 = DBI->($mysql_tor,$mysqluser,$mysqlpassword);
=cut
#Llamando metodos dentro de un objeto
=Podemos agregar a los contenidos de una referencia normal por el uso del operador flecha.
$array_ref ->[$index]; #accediento matriz elemento via matriz referencia
$hash_ref ->{$llave}; #accediendo array elemento via hash referencia
#En la impresion comun .podemos accede mothos de objetos Perl(ò funciones si tu lo prefieres)..
$objecto->metodo(); #llamando metodo() dentro del $objeto
#In un espeficico caso,podemo llamar un metodo dentro un de tu DBI object..
my $dbm = DBI->connect($name_db,$user,$contrasena);
$dbm->do(UPDATE amigos SET fono =’949092777′, WHERE nombre =’deshi’);
#Destruyendo un objecto
Cuando ya no necesita un objecto peude dejar fuera del ambito,por ello
se recomiendo usar una funcion de limpieza de cualqueir otra estrucutra Perl.
En este caso DBI se recomienda descoenctar de la basededatos.
$dbm->disconnect();
=cut
#Referencias y complejos estructuras de datos
=Perl referencia puede ser usado para crear complejos estrucutras de datos,
para instanciar hashes de array,array de hashes,hashes de hashes y màs..
=cut
#pasando arrays y hashes a subrutines y funciones
my @ar1 = qw(a b c);
my @ar2 = qw(d e f);
printargs(@ar1,@ar2);
sub printargs{
print “@_\n”;
return;
}
#Creando y diferenciando referencias
#—-para saber màs -> “perldoc -f ref”
my $escalar = “Este es un scalar”;
my @aregllo = qw(esto es una matriz);
my %hashh =(
esto => ‘es’,
un => ‘mixto’,
famoso => ‘hash’,
);
my $escalar_ref = \$escalar;
my $areglo_ref = \@aregllo;
my $hashh_ref = \%hashh;
#Todas estas referencias son scalares,por contienen un solo item de
#informacion;la direcccion de memoria de la data actual..
say $escalar_ref;
say $areglo_ref;
say $hashh_ref;
#Puedes buscar la salida si es un escalar,array o hash, usando la funcion “ref()”
say ref($escalar_ref);
say ref($areglo_ref);
say ref($hashh_ref);
#Desreferenciar(elimiar el actual punto de referencia)se consigue poniendo un simbolo sigiloso
#para la referencia por ejmplo un hash_referencia se usa el simbolo “%”
my $new_escalar = $$escalar_ref;
my @new_matriz = @$areglo_ref;
my %new_hashh = %$hashh_ref;
say $new_escalar;
say @new_matriz;
say %new_hashh;
#–agregando item en un arglo mediante una referencia..
push(@$areglo_ref,’nuevo’,’dato’);
say @$areglo_ref;
#–asignando una lista de keys mediante un hash referencia.
my @coto = keys %$hashh_ref;
say @coto[0];
#–acceso de elements del areglo o parte de ello,y has elementos
say @$areglo_ref[0];
say @$areglo_ref[1,2];
say $$hashh_ref{‘un’};
#–otro camino acceder evaluar puntos de referencia se usa la notacion “flecha”.
say $areglo_ref -> [0];
say $hashh_ref -> {‘un’};
#Asignando mediante referencias
my @arbol =qw/limon manzana kiwi/;
my $arbol_ref = \@arbol;
$arbol_ref ->[3] = ‘mispero’;
say “@arbol”;
#–otro ejmp.–
my %listF =(
dulce => ‘manzana’,
agri => ‘tamarindo’,
acido => ‘naranja’,
);
my $listF_ref = \%listF;
$listF_ref ->{kiwi} = “manzana y tamarindo”;
say %listF;
#Pasando multiples arrays/hashes como argumentos
my @habita =qw/muros fierro cuadro lapiz/;
my @extra = qw/rizo led/;
lista_dos(@extra,@habita);
sub lista_dos{
my (@extra,@habita) = @_;
say @extra;
say @habita;
return;
}
#si queremos mantener separados necesitamos pasar una referncia ala instancia del array.
ref_lista_dos(\@extra,\@habita);
sub ref_lista_dos{
my ($ref_extra,$ref_habita) = @_;
print “lista (extra)\n”;
foreach(@$ref_extra){
print “$_\n”;
}
print “lista (habita)\n”;
foreach(@$ref_habita){
print “$_\n”;
}
}
=cuando pasamos referencia dentro de uan subrutina tenemos la subrutina
con acceso tota a la estructura ha lo qeu las referencia se refiere.
por ejemplo..
sub ref_lista_dos{
my ($ref_extra, ref_habita) = @_;
my @ref_copia_extra = @$ref_extra;
my @ref_copia_habita = @$ref_habita;
…
return;
}
=cut
#Estructura de datos anonimo
=Podemos usar estructuras de datos anonimos al crear complejas estructuras
de datos con salida teniendo para declarar variables temporales.Arrays
anonimos son creados por el uso de corchetes y los hash por llaves.
=cut
my @muro = qw/d e s h i/;
my $ref_muro = \@muro;
#creando un array anonimo
#my $ref_muro = [‘d’,’e’,’s’,’h’,’i’];
#–usando qw().
my $ref_muro = [ qw(d e s h i)];
#imprimir la letra ‘s’ mediante la referencia
print “$ref_muro->[3]\n”;
#mas uso puede crear un array anonimo dentro de un hash.
my %wikilks = (
libros => [ qw(binario sol luna planeta)],
ramas => [qw(verde green gclaro)],
remos => [qw(kaya sativa mongolia)],
);
#imprimir ‘sativa’ mediante el hash wikilks
print “$wikilks{remos}->[1]\n”;
#Para mas tecninca puede usar la creacion de hash anonimo
my %hash = (
a => 1,
b => 2,
c => 3,
);
my $hash_ref = \%hash;
#la forma as rapida,con un hash anonimo
my $ref_hash = {
a => 1,
b => 2,
c => 3,
};
say $ref_hash-> {a};
#Creando structura compleja
my %codigo =( name=>”Atahualpa”,cod=>11,rango=>”superior”,);
my %tipo =(color=>”verde”,masa=>”kl”,tiempo=>-25.3);
my %venta =(dia=>”feriados”,costo=>1230,tarfia=>”free”);
my @tienda =(
\%codigo,
\%tipo,
\%venta,
);
#imprimir de “tipo” el “color”
say $tienda[1]->{color};
#Disferenciando expresiones(eliminar la referencia de las expresions)..
my @ref_tienda = \@tienda;
foreach my $tienda(@ref_tienda){
print “queeesososo:S\n”;
}
#Copiando compleja estructura de datos
my %codigo =(
name=> [qw(Atahualpa 11 superior)],
cargo=> [qw(jefe teniente cabo)],
);
#crear copia del hash usando “dclone” retorna una referencia.
=para que haga realidad se usa el modulo al principio del fichero.
“use Storable qw(dclone)”
=cut
my $codigo_copia = dclone \%codigo;
#agrega rango en tu hash copia
$codigo_copia->{cargo}[3] = “comandante”;
#agregar usando “push”
#–push @{ $codigo_copia->{cargo} },”soldado”;
#imprimir cargo desde el hash codigo_copia
my @new_rango = @{ $codigo_copia->{cargo}};
say @new_rango;
#imprimir cargo desde el “hash codigo” orginal
my @original_codigo = @{ $codigo{cargo}};
say @original_codigo;
#Data::Dumper
=Si quiere usar imprimir lineas de codigo para uso de depuracion puede
usar el modulo Data::Dumper, esta creado para ahorrar tiempo en crear
codigo para lineas de codigo qeu se quiere depurar ,como puede ser el
hash del hash o matrix del hash,etc..
para ver màs sobre dumper –> ” perldoc Data::Dumper “
=cut
#ejemplo
my %hut = (
bon=>{
edad => 98,
color => “verde”,
deporte => “kaya”,
lengua => “Perl”,
},
tera=>{
edad => 10,
color => “azul”,
deporte => “natacion”,
lengua => “Perl”,
},
);
print Dumper \%hut;
#EXPRESIONES REGULARES AVANZADAS
#Capturando parte de la cadena a un escalar
$_= “bonx”;
say /((\w)(\w))/; #igualar 2 caracteres del texto en al tienda, $1,$2
$_ = “1234567890”;
say /(\d)+/; #partir en digitos y los almacena el ultimo digito, $1
say /(\d+)/; #Captura todo de 1234567890
#Evaluando una expresion regular en lista contextual en otro modo de ver la informacion…
$_ = “Servidor de videos desshi.hol.es”;
my($todo,$host,$dominio) = /(([\w-]+)\.([\w.-]+))/;
print $1,”\n”;
say $todo;
say “$2 : $3”;
say “$host : $dominio”;
#Nombrar capturas
=Perl 5.10.x trae cpautas de nombre apra crear capturas desde expresiones
regulares facilmente..
Tomando en ejemplo la sigueinte expresion regular
/$tiempofix (\t({4})-(\t({2})-(\t({2})/;
Cual dato va en $1 ?
no podemos saberlo, no tenemos la forma como contar la posicion de dato.
Con la captura de nombres podemos posicionar sobre el valor de dato de
coincidencia,podemso nombrar la coincidencia como crear acceso tambien
por los usos de la sintaxis especial (?<name>match)..
/$tiempofix (?<año>\t{4})-(?<mes>\t{2})-(?<dia>\t{2})/;
Ahora como cpturar una coincidencia y tambien ahcer uan referencia por
su nombre,par hacer realidad usar el hash especial “%+”..
say “Coincidir AÑO : $+{año}”;
say “Coincidir MES : $+{mes}”;
say “Coincidir DIA : $+{dia}”;
si usamos algunos de los nombres para mas de uan captura,tambien la
evalua en %+ con la sigueinte coincidencia de evaluacion.Cuando todos
tienen acceso a las coincidencias desde el hash epsecial %- que contienen
referencia de matrices del resultado de coincidentia.
my $cuenta = qr{ (?<cuenta> \t{7} ) }x;
my $moneda = qr{ (?<moneda> \t+\.\d{2} ) }x;
my $fecha = qr{ (?<fecha> \t{4}-\t{2}-\t{2} )}x;
if(/Tranfiere $moneda from $moneda to $cuenta on $fecha/){
say “Envia Cuenta: $-{cuenta}[0] “;
say “De Cuenta: $-{cuenta}[1]”;
}
=cut
#Expresiones regulares extendidas
=Las expresioens regulares peuden ser dificultosas con el tiempo,
especialmente si son grandes o complejas..
Perl divide una expresion regualar a travez de multiples lineas y empotra
comentaros dentro de tu expresion regular.Esto es expresiones regulares extendidas.
A crear una expresion regular extendidad usamos el modificador especial “/x”.
Espacios(incluyendo tabulacion y nueva linea)en regular expresion son ignorados.
Cualquier efecto en un hash de escape(#) es ignorado hasta el fin de la linea.
expresioens realugares extendidas no altear el formato de la segunda parte
en uan sustitucion.
Si quiere incluir un literal espacio o hash en una ex.re.ex puede usar “\”.
m{^([\w-]+)\s+(\d+)\s+(\w+)\s+(\w+)\s+(\d+)\s+(\w+\s+\d+\s+[\d:]+)\s+(.*)$};
dentro de esto:
–parsear una lina desde “ln -l”
m{
^ # $0 – inicio de linea
([\w-]+)\s+ # $1 – permisos de archivo
(\d+)\s+ # $2 – enlaces duros
(\w+)\s+ # $3 – usuario
(\w+)\s+ # $4 – grupo
(\d+)\s+ # $5 – tamaño de archivo
(\w+\s+\d+\s+[\d:]+)\s+ # $6 – Fecha y hora
(.*) # $7 – Nombre de archivo
$ # fin de la linea
}x;
Puede usar expresiones regulares extendidas para crear codigo mucho màs
facil de leer,entender y mantener..
=cut
#La codicia
=La regular expresioens son por defecto “codicia”,esto significa que esta
en cualqueir expresion regular,para instaciar “*” tratar una coincidencia
mas grande qeu se pueda chaer posible.la codicia es aveces referida a la
maxima coincidencia..
$_ = “el perro linux esta viejo”;
/p.*o/; #avaricia – $1=”perro linux esta viejo”
/p.?o/; #no avaricia – $1=”perro”
/(e.*x)(.*o)/; #avaricia – $1=”el perro linux”;
#no avaric – $1=”viejo”
/(e.*?l)(.*o)/; #no avaricia – $1=”el”;
#avaricia – $1=”perro linux viejo”
=cut
#Archivo I/O
#aprendiendo abrir e intereactuar con archivos.
=La lina de entrada(input) operador, para ver mas -> “perldoc -f readline”
#leyendo lineas desde STDIN(o desde archivos dentro del comando de linea)
while(<>{
#procesa la linea de entrada en $_
}
#leyendo una sola linea de entrada de usuario desde STDIN
my $input = <STDIN>;
#leyendo todos las lineas desde STDIN dentro un array
my @input = <STDIN>;
=cut
#abriendo un archivo para leer,escribir o anexar..
=si necesita mas control de como abrir ver -> “perldoc -f sysopen”
< decir abrir el fichero para leer.
> decir abrir el fichero para escrbir.
>> decir abrir el fichero para anexar.
=cut
#Abrir y leer desde un archvo
=ejemplo leer
my $fichero;
open($fichero, ‘<‘, ‘/home/desshi/Escritorio/R.so’)
or die “Fallo a abrir el fichero para leer: $!”;
#abrir pero ahora usando el operador “readline”
open(my $fichero, ‘<‘, ‘/home/desshi/Escritorio/R.so’)
or die “Fallo a abrir el fichero para leer: $!”;
while(<$fichero>){
#hacer algo con $_
}
#abrir tu fichero para leer
open(my $fichero, ‘<‘, ‘/home/desshi/Escritorio/R.so’)
or die “Fallo a abrir el fichero para leer: $!”;
while(my $linea = <fichero>){
#hace algo con $linea
}
=cut
=escribir,anexar..
#abrir fichero para escribir
open(my $fichero, ‘>’, ‘/home/desshi/Escritorio/R.so’)or die $!;
#escribir en fichero
print $fichero “este texto estara escrito en el fichero R.so -_-\n”
#abrir fichero para anexar
open(my $fichero, ‘>>’, ‘/home/desshi/Escritorio/R.so’)or die $!;
=cut
=salir
#Cerrando tu archivo
close($fichero) or die “Fallo al cerrar la salida del fichero: $! “;
–para ver mas -> “perldoc perlvar” tambien “perldoc -f die”
=cut
#Usando “autodie”
=devuelve el error de manipulacion
use autodie;
open(my $fichero, ‘<‘, $file);
close($fichero);
=cut
#Manipulaciones de paquetes(legado)
=el codigo legado peude buscar paquetes mientras esta usando
manipulacion en escalar.esto no tiene sigilo a mostrar y se ecriben
todo el mayusculas…
use autodie;
open(LOGFILE, ‘<‘, ‘/home/desshi/Escritorio/r.log’);
while(<LOGFILE>){
print if m{\Q desshi.tk \E }x;
}
close LOGFILE;
=cut
#Cambiar contenidos del archivo
=cuando manipulamos archivos,podemos usar imprtacion desde un array,
para saber màs -> “perldoc -f rename”
#un programa esta leyendo en un fichero y clasificndo en orden.
use autodie;
open(my $enfichero, “<“, “fichero.txt”);
my @lineas = <$enfichero>; #soplar todo las lineas dentro de @lineas.
close $enfichero;
@lineas = sort @lineas;
#abrir temporalmente el fichero donde guardara los datos dentro.
open(my $salirfichero, “>”, “fichero.txt.tmp”);
#use print si abilitara un impresion de listas
print {$salirfichero} @lineas;
close $salirfichero;
# como vmeos donde esta hecho esto no es el fichero original
#movemos el fichero despues de cerrar,renobramos la manipulacion al origional.
rename(“fichero.txt.tmp”, “fichero.txt”);
=cut
#Archivos temporales seguros
=el modulo “File::Temp” crea un nombre y coincidencia a un archivo temporal.
utilizando la funcion “binmode” marcamso el texto del fichero cuando lo necesitamos.
use File::Temp qw(tempArch);
my ($temp_coin, $temp_nombre) = tempArch();
#asignar el archivo como un archivo-texto en systema win32
binmode ($temp_coin,’:crlf’) if ($ eq “Win32”);
print {$temp_coin} @linea;
#con mover el archivos despues” de acabar de configurar se ha cerrado.
rename($temp_nombre, “archivo.txt”);
el modulo File::Temp puede tam bien ser usado en creacion de ficheros
en-memoria temporal is requiere..
=cut
#Abriendo archivos para uso simultaneos, lectura/escritura
#–leyendo un fichero y agregando al final..
use autodie;
say “Escribir algo en elfichero si no existe:”;
my $usr_nomb=<STDIN>;
chomp $usr_nomb;
open(my $usr_conf, “+<“, “R.so”);
my $encontrar;
while(<$usr_conf>){
chomp;
#caso insensitivo de coincidencias mayus. minus.
if(lc($_) eq lc($usr_nomb)){;
$encontrar = 1;
last;
}
}
#llegaremos al final si $encontrar no esta establecido..
unless ($encontrar){
print {$usr_conf} “$usr_nomb\n”;
}
close $usr_conf;
#Buffering
=En perl el almacenamiento en bufèr de entrada es como en otro lenguajes
ademàs guarda en bufer de salida lso datos seguros para cuando la memoria
necesite màs o cuando haya terminao la ejecucion,puede inprimir los datos
en un archivo o STDOUT y solo se imprimi cuando se tiene suficiente..
=cut
foreach(1..5){
print “paciencia..\n”;
sleep(1);
}
#Abriendo pipes(canales,tubos)
=procesamso lso argumentos en liena de comandos confiando explicitamente
los usuario confiando sus datos para leer un archivo desde otra maquina.
my ($dir, $archivo) = @ARGV;
unless ($dir and $archivo) {
die “Usando: $0 direccion nombreArchivo\n”;
}
open (my $ssh_conf, “-|”, “ssh $dir cat $archivo”);
while(<$ssh_conf>) {
#podemso procesar el fichero en cualquier camino como quiera.
#en este caso vamso solo imprimir esto en tu STDOUT.
print;
}
=cut
#intereaccion con el sistema
=este ejemplo no es compatible ocn todos los sistemas operativos,para
saber sobre como crear tu programam portable ver -> “perldoc perlport”
=cut
#La funcion system()
#Abrir un archivo para el ususario pueda editar.
=puede usa rotro editor,nano,ee,vim,gedit’
system(‘vi R.so’);
#Leer el contenido del archivo que el usuario ha finalizado.
open(my $entrada_conf, ‘<‘, ‘R.so’) or die “$!”;
# mostrar todo el .so archivo a STDOUT
system(‘cat *.so’);
=cut
#Sistema multi-argumentos
=hay que saber que esta es otra forma mas segura de “system” o “exec”
que no pasa la shell.si tienes un systema o exec en una lista asumir
que se ejecutara el primer comando si este es un argumento..
system(‘vi’,’R.so’);
#-siempre es posible usar la funcion “glob” para expandir
#-para nosotros nombres sin internvencion de la shell
system(‘cat’,glob(‘*.so’));
#Funcion exec
exec(‘cat’,glob(‘*so’));
=cut
#Utilizando datos contaminados(modelo de seguridad en Perl)
#codigo inseguro
=imagina imaginador
#!/usr/bin/perl
use strict;
use warnings;
print Como tu quieres manosear? “;
my $usuario = <STDIN>;
print qx(finger $usuario);
–que pasaria si el ususario entraria como datos, dos; cat /etc/passwd ,
o aun peor, dos; rm -rf /.el sistema ejecutaria una lina tras otra como
si fuera introducido mediante comandos de shell..
#configuraciones explicitas $ENV{PATH}
Para asegurar la llamda del programa correcto se debe establecer explicitamente
la variable PATH que se encuentra en $ENV{PATH}..
#–Unix systemas (paths son separados por : )
$ENV{PATH} = “/bin:/usr/bin:/usr/local/bin”;
#–M.Windows (paths son seprads por ; )
$ENV{PATH} = ’C:\Windows;C:\Windows\System32’;
=cut
#Limpiando datos corruptos
=ejemplo
#!/usr/bin/perl -Tw
use strict;
$ENV{PATH} = “/bin:/usr/bin”; # corrupta requiere we set our path.
print “Como tu quieres tocar?\n”;
my $usuario = <STDIN>;
chomp($usuario);
# comprobar $usuario se ve bien. ISi es asi use el valor capturado tocar..
if ( $username =~ /^(\w{1,20})$/ ) {
# $1 es de los contenidos de la primera serie de parentesis en al expresion regular.
print qx(tocar $1);
}
else {
print “Este no es un nombre valido!\n”;
}
=cut
say ‘
oMMM
ooooooM” M” ooMoooo
ooMo”o”M” ” ” ” oo” MMM””””MMMo
oo ” ” “o” oMM” “MMo
“Mo” M oMM” MMo
“”o”M”Moo M MMM MMo
“”M M ooMM” “MMoo
M oM oMM”” “”Moo
M MM oM”” “MMo
“M MM oMM “MMo
M “M oM” “Mo
M “Mo ooM” o MM
Mo “”M”M”M” oMM MMMMo
“M MM MM Mo
MM MM MMM M
“Mo MM o MM M”
“”MMoMoMoMMM MM “M oMMMoo MM” M
“”””” ” “Mo MMooo oooM “MMo Mo MM “M
“MM oM “””MMMMM”””MM “Mo”MoM “M Mo
MM oM Mo MM “M MM Mo
“Mo M” M “M MM M MM
MM M” MM Mo MMo o “Mooo
M” Moo Mo “M “Mo “Mo “”
oM MoM M MM “Mo “M
Mo oM Mo M oM M MM MM
“M M” Mo M M MM MM M”
M”M” M “o MM M” M” MM
M”M “M M M oM M oM
M”M “M “o M” M “M M
MM M M M oooM ” Mo M
oM oM”” oMMMo o ooo”M “
oMM” “M “””M” “””” “MM “M
“MMMoMMM” “””Mo”M”
http://desshi.com
‘;
__END__
</pre>
0 responses on "Perl en español"