• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Perl
 

Perl

on

  • 1,260 views

 

Statistics

Views

Total Views
1,260
Views on SlideShare
1,256
Embed Views
4

Actions

Likes
2
Downloads
0
Comments
0

3 Embeds 4

http://www.linkedin.com 2
http://twitter.com 1
http://orhowilearnedtolovetheperl.com 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Perl Perl Presentation Transcript

    • Perl Isidro Vila Verde Pratical Extraction and Report Language
    • O que é?
      • O PERL é uma linguagem scriptica criada por Larry Wall
      • "Perl is designed to make the easy jobs easy, without making the difficult jobs impossible." -- Larry Wall, Programming Perl
      • A primeira versão do PERL foi lançada em 1987
    • O que é?
      • O PERL é código livre
      • Linguagem interpretada
      • Canivete suiço das linguagens “scripticas”
      • Combina o C com sh, AWK e SED
          • Exemplo de um script que conta o número de linhas de um ficheiro
            • $ c ++ while (<>);
            • print &quot;nlinhas = $c&quot; ;
    • Para que serve?
      • Optimizada para processamento de texto
        • Mas actualmente com mais de 500 módulos disponíveis (www.cpan.org) permite desde controlo domótico, passando por processamento XML, criação de gráficos dinâmica, interfaces gráficas, acesso a serviços de rede, leitura de cartões magnéticos, etc.
      • Excelente para gestão de Plataformas informáticas
        • Sistemas operativos, routers, etc
    • Quêm usa ?
      • Para administração de sistemas
      • Para interfaces WEB a Base de Dados
        • CGI
      • Para monitorização de equipamentos
      • Estas são as algumas das áreas mais significativas do utilização do PERL mas é usado em áreas tão diversas como seja o controlo de robots LEGO e os sistemas de reserva de viagens.
    • Onde corre ?
      • Corre “nativamente” em UNIX mas existem diversos portes para outra plataformas
      • Em windows há várias implementações
        • O activeperl 5.6 é dos mais utilizados
          • (já existe o 5.8 mas nem todos os módulos estão disponíveis em PPD)
    • Plataformas com ‘portes’ já feitos
      • Acorn
      • AIX
      • Amiga
      • Apple
      • Atari
      • AtheOS
      • BeOS
      • BSD
      • BSD/OS
      • Coherent
      • Compaq
      • Concurrent
      • Cygwin
      • DG/UX
      • Digital
      • DEC OSF/1
      • Digital UNIX
      • DYNIX/ptx
      • EPOC
      • EMC
      • FreeBSD
      • Fujitsu-Siemens
      • Guardian
      • HP
      • HP-UX
      • IBM
      • IRIX
      • Japanese
      • JPerl
      • Linux
      • LynxOS
      • Macintosh
      • Mac OS
      • Mac OS X
      • MachTen
      • Minix
      • MinGW
      • MiNT
      • MPE/iX
      • MS-DOS
      • MVS
      • NetBSD
      • NetWare
      • NEWS-OS
      • NextStep
      • Novell
      • NonStop
      • NonStop-UX
      • OpenBSD
      • ODT
      • OpenVMS
      • Open UNIX
    • Plataformas com ‘portes’já feitos
      • OS/2
      • OS/390
      • OS/400
      • OSF/1
      • OSR
      • Plan 9
      • Pocket PC
      • PowerMAX
      • Psion
      • QNX
      • Reliant UNIX
      • RISCOS
      • SCO
      • SGI
      • Symbian
      • Sequent
      • Siemens
      • SINIX
      • Solaris
      • SONY
      • Sun
      • Stratus Tandem
      • Tru64
      • Ultrix
      • UNIX
      • U/WIN
      • Unixware
      • VMS
      • VOS
      • Win31
      • Win32
      • WinCE
      • WinMe
      • Windows 3.1
      • Windows 95/98/Me/NT/2000/XP
      • z/OS
    • Hello World
    • Exemplo “Hello World”
      • #!/usr/bin/perl
      • print &quot;Hello Wordn&quot; ;
      • Em Perl um comentário inicia-se com um #
      • Em unix um comentário na primeira linha iniciado pela sequência #! identifica o interpretador a usar
        • Evita a chamada ao perl na shell
          • Ex: [jvv@Arquinho jvv]$ perl ex1.pl
        • Pode-se invocar directamente o script
          • Ex: [jvv@Arquinho jvv]$ ex1.pl
          • Nota: não esquecer de dar-lhe permissões de execução
              • Ex: chmod 755 ex1.pl
              • Ex: chmod 700 ex1.pl
      • Os ‘statments’ terminam com ;
    • Variáveis Escalares
    • Escalares
      • Em perl não é obrigatório a declaração de variáveis (excepto se for declarado o uso restrito com use strict )
      • As variáveis escalares são identificadas por um $ antes do nome da variável
      #!/usr/bin/perl #print 'Isto é uma variável escalar: $a'; $ a = 3 ; print &quot;Isto é o valor da variável $a: $an&quot; ; Sequência de escape para escrever literalmente o símbolo $ Substituí pelo valor de $a
    • Escalares
      • #!/usr/bin/perl $ a = 3 ; $ b = &quot;uma sequência de caracteres&quot; ; $ c = 3 + length $ b ; print &quot;a=$anb=$bnc=$c&quot; ;
      • O Perl é uma linguagem untyped logo as variáveis não tem tipo .
          • O perl induz o tipo de variável conforme o valor que esta assume
              • $a = 3 #$a é um inteiro
              • $a = 3.6 #$a é um float
              • $a = “ex” #$a é uma string
    • Listas ou Arrays
    • Exemplo de listas
      • #!/usr/bin/perl @ list = ( 7 , 3 , 4 , 12 , 'a' , &quot;Um exemplo de um elemento de uma 'lista'&quot; , 8 , 'c' ); $ list [ 2 ] = 5 ; @ list2 = @ list [ 1 .. 4 ]; @ list3 = ( 1 .. 20 ); @ list3 [ 3 , 4 , 5 ] = ( 23 , 33 , 43 ); @ list4 = @ list [ 0 , 3 , 6 ]; print '@list =' , &quot;@listn&quot; ; print '$list[5]=' , &quot;$list[5]n&quot; ; print '@list2=' , &quot;@list2n&quot; ; print '@list3=' , &quot;@list3n&quot; ; print '@list4=' , &quot;@list4n&quot; ; print '$#list3=' , &quot;$#list3n&quot; ; $ #list3 = 5 ; print '@list3=' , &quot;@list3n&quot; ;
      @list3 é um lista dos valores de 1 a 20 As posições 3,4 e 5 de @list3 são alteradas para os valores 23,33 e 43 lista @list2 criada com os valores das posições de 1 a 4 da lista @list Lista @list3 amputada aos primeiros 6 elementos
      • Em perl os vectores ou arrays são chamados listas
      • Um lista é identificada por um @ antes do nome.
      • Uma mesma lista pode conter inteiros, caracteres, strings, floats, referências, etc)
          • @ list = ( 7 , 3 , 4 , 12 , 'a' , &quot;Um exemplo de um elemento de uma 'lista'&quot; , 8 , 'c' );
      • Uma lista anónima é definida por parênteses curvos
      • Em perl, ao contrário do C, é possível atribuir o valor de uma lista a outra
              • Nota: em C é necessário um ciclo para copiar um array para outro.
      Listas 1
      • Um lista de valores sequenciais pode ser criada com o operador ..
          • @ list3 = ( 1 .. 20 );
      • A indexação de um, ou mais, elementos de uma lista é feita com recurso aos parênteses rectos
          • $ list [ 2 ] = 5 ; @ list2 = @ list [ 1 .. 4 ]; @ list3 [ 3 , 4 , 5 ] = ( 23 , 33 , 43 ); @ list4 = @ list [ 0 , 3 , 6 ];
      • O acesso ao elementos de uma lista pode ser feito em contexto escalar
          • $ list [ 2 ] = 5 ;
      • Ou num contexto de lista
          • @ list3 [ 3 , 4 , 5 ] = ( 23 , 33 , 43 );
      Listas 2
      • Num contexto de lista podemos aceder (leitura ou escrita) simultaneamente a vários elementos da lista
          • @ list2 = @ list [ 1 .. 4 ]; @ list3 [ 3 , 4 , 5 ] = ( 23 , 33 , 43 ); @ list4 = @ list [ 0 , 3 , 6 ];
      • O índice do último elemento da lista é dado pela sequência $# seguida do nome da lista
          • $ #list3 = 5 ;
      • É possível amputar (ou ampliar) uma lista atribuindo um valor ao índice do último elemento
      Listas 3
    • Arrays associativos ou Hash Tables
    • Exemplo de Arrays Associativos
      • #!/usr/bin/perl $ nota { 'Ana Cristina' } = 16 ; $ nota { 'Jose Manuel' } = 12 ; $ nota { 'Antonio Joaquim' } = 14 ; @ nota { 'Jose Manuel' , 'Antonio Joaquim' } = ( 18 , 16 );
      • % idade = ( 'Ana Cristina' , 23 ,
      • 'Jose Manuel' , 25 ,
      • 'Antonio Joaquim' , 24 ); % natural = ( 'Ana Cristina' => 'Braga' ,
      • 'Jose Manuel' => 'Viana' ,
      • 'Antonio Joaquim' => 'Aveiro' ); $ x = $ natural { 'Ana Cristina' };
      • @ y = @ nota { 'Ana Cristina' , 'Jose Manuel' }; @ z = ($ nota { 'Antonio Joaquim' },
      • $ nota { 'Ana Cristina' });
      • @ w = % idade ; print '$x=' , &quot;$xn&quot; ; print '@y=' , &quot;@yn&quot; ; print '@z=' , &quot;@zn&quot; ; print '@w=' , &quot;@wn&quot; ;
      É indiferente usar => ou , Um array associativo é uma lista com um número par de elementos
      • Um array associativo não é mais do que uma lista de pares (chave, valor)
          • % idade = ( 'Ana Cristina' , 23 ,
          • 'Jose Manuel' , 25 ,
          • 'Antonio Joaquim' , 24 );
      • Um lista é identificada por um % antes do nome.
      • A indexação de arrays associativos é feita com chavetas.
          • $ nota { 'Ana Cristina' } = 16 ; $ nota { 'Jose Manuel' } = 12 ; $ nota { 'Antonio Joaquim' } = 14 ; $ x = $ natural { 'Ana Cristina' };
      Arrays Associativos 1
      • O índice de um valor do array é dado pelo nome da chave (que pode ser qualquer string) e não por um inteiro como nas listas ou nos arrays do C ou do Java
      • A cada chave pode estar associado um valor, acedido, por indexação do array, com a referida chave
          • $ nota { 'Ana Cristina' } = 16 ;
          • Nota: o acesso de leitura a um índice não existente devolve o valor undef
            • $ v = $ nota { ‘Joao Pestana' };
      Arrays Associativos 2
      • O acesso aos valores de um array associativo pode ser feito em contexto escalar
          • $ nota { 'Ana Cristina' } = 16 ; $ nota { 'Jose Manuel' } = 12 ; $ nota { 'Antonio Joaquim' } = 14 ; $ x = $ natural { 'Ana Cristina' };
      • Ou num contexto de lista
          • @ nota { 'Jose Manuel' , 'Antonio Joaquim' } = ( 18 , 16 ); @ y = @ nota { 'Ana Cristina' , 'Jose Manuel' };
      Arrays Associativos 3
    • Definição de funções
    • Definição de funções
      • #!/usr/bin/perl sub fsum { ($ x ,$ y ) = @ _ ; $ x + $ y ; } sub fpro { $ x = @ _ [ 0 ]; $ y = @ _ [ 1 ]; $ x * $ y ; } sub fsub ($$){ ($ x ,$ y ) = @ _ ; return $ x - $ y ; } sub fdiv { ($ x ,$ y ) = @ _ ; return $ x / $ y ; }
      print &quot;nt&quot; , fsum ( 3 , 5 ); print &quot;nt&quot; , fpro 3 , 5 ; print &quot;nt&quot; , fsub 3 , 5 ; print &quot;nt&quot; , & fdiv ( 3 , 5 ); Estas duas formas de obter os parâmetros são equivalentes Estas duas formas de obter os parâmetros são equivalentes
    • Definição de Funções
      • Uma função é definida com a palavra sub seguida do nome da função
      • O valor de retorno de uma função é sempre o valor da última expressão (o return pode ser omitido)
          • sub fsum { ($ x ,$ y ) = @ _ ; $ x + $ y ; }
      • Os parâmetros para a função não precisam de ser definidos
      • O valor dos parâmetros é passado na variável especial @_ . Esta variável é uma lista e o primeiro parâmetro está em @_[0] , o segundo em @_[1] , ...
    • Definição de Funções
      • No entanto é possível especificar o número de parâmetros e se estes são escalares, listas, arrays associativos, etc
          • sub fsub ($$){ ($ x ,$ y ) = @ _ ; return $ x - $ y ; }
      • A invocação de uma função (definida ou interna) não necessita de parênteses
          • print &quot;nt&quot; , fpro 3 , 5 ;
      • Excepto se a invocação utilizar o antigo estilo com o & a preceder o nome da função.
          • print &quot;nt&quot; , & fdiv ( 3 , 5 );
          • Neste caso os parâmetros nunca são verificados.
    • Funções internas do perl
    • Funções para manuseamento de listas
    • Função scalar
      • #!/usr/bin/perl @ list = ( 1 , 5 , 3 , 9 ); $ l = @ list ; print $ l , &quot;n&quot; ; print @ list , &quot;n&quot; ; print scalar @ list , &quot;n&quot; ;
      • A função scalar devolve o número de elementos de uma lista
      • Num contexto escalar a referência à lista devolve sempre o número de elementos
          • $ l = @ list ;
      • Mas num contexto de lista onde se pretende não os elementos da lista, mas o seu número, tem-se de usar scalar @lista
          • print scalar @ list , &quot;n&quot; ;
      Imprime os elementos da lista seguidos de uma mudança de linha
    • Funções push pop shift unshift
      • #!/usr/bin/perl @ list = ( 1 , 5 , 3 , 9 , 7 ); @ l =( 'a' , 'bbbbbbbbbbbbb' ); push @ list ,@ l ; push @ list , 33 ; push @ list , 44 , 55 ; print &quot;1:t&quot; , pop @ list , &quot;n&quot; ; print &quot;2:t&quot; , shift @ list , &quot;n&quot; ; unshift @ list , 100 ; $ i = 200 ; unshift @ list ,$ i ; print &quot;----n&quot; , join ( &quot;n&quot; ,@ list ), &quot;n&quot; ;
    • Função join
      • #!/usr/bin/perl @ list = ( 1 , 5 , 3 , 9 , 7 ); $ res = join ( &quot;+&quot; ,@ list ); print $ res , &quot;n&quot; ;
    • Função reverse
      • #!/usr/bin/perl @ list = ( 1 , 5 , 3 , 9 , 7 ); print join ( &quot;;&quot; ,@ list ), &quot;n&quot; ; @ tsil = reverse @ list ; print join ( &quot;:&quot; ,@ tsil ), &quot;n&quot; ;
    • Função split
      • #!/usr/bin/perl $ s = &quot;Isto é uma cadeia de caracteres separados por espaços&quot; ; @ r = split (/ /,$ s ); print &quot;1:t&quot; ,$ r [ 0 ], &quot;n&quot; ; print &quot;2:t&quot; ,$ r [$ #r ], &quot;n&quot; ; $ s = &quot;Isto é uma frase que, por motivos de demonstração, está separada por vírgulas&quot; ; @ r = split (/,/,$ s ); print &quot;3:t&quot; ,$ r [ 0 ], &quot;n&quot; ; print &quot;4:t&quot; ,$ r [$ #r ], &quot;n&quot; ;
      Sepera a string pelos espaços Separa a string pelas vírgulas
    • Função sort
      • #!/usr/bin/perl @ list = ( 1 , 5 , 3 , 9 , 7 ); print &quot;1:t&quot; ,( sort @ list ), &quot;n&quot; ;
      • # ou print &quot;1:t&quot;,sort (@list), &quot;n&quot;; print &quot;2:t&quot; ,( sort f @ list ), &quot;n&quot; ; print &quot;3:t&quot; ,( sort g @ list ), &quot;n&quot; ; print &quot;4:t&quot; ,( sort {$ b <=> $ a } @ list ), &quot;n&quot; ; sub f { return $ a <=> $ b ; } sub g { return $ b <=> $ a ; }
      Os parênteses são necessários para excluir o “n” da lista de argumentos para o sort Este operador devolve -1, 0, ou 1 conforme o operando esquerdo é numericamente inferior, igual ou superior ao operador direito
    • Função sort 2
    • Funções para manuseamento de arrays associativos
    • Funções values e keys
      • #!/usr/bin/perl % A = ( 7 => 'aaaaa' ,
      • 'a' => 23 ,
      • 12 => 123 ,
      • 'b' => 'ssssssssss' ); @ v = values % A ; print $ v [ 0 ], ' ' ,$ v [ 1 ], ' ' ,$ v [ 2 ], ' ' ,$ v [ 3 ], &quot;n&quot; ; @ v = keys % A ; print $ v [ 0 ], ' ' ,$ v [ 1 ], ' ' ,$ v [ 2 ], ' ' ,$ v [ 3 ], &quot;n&quot; ;
    • Funções values e keys 2
      • #!/usr/bin/perl @ list = ( 1 , 5 , 3 , 9 , 7 ); % array1 = ( 'a' => 'zwsdre' ,
      • 'b' => 'ghtrry' ,
      • 'bb' => 'zwsdr' ); % array2 = ( 'a' => 5 , 'b' => 3 , 'bb' => 4 ); print &quot;1:t&quot; , join ( ',' , sort @ list ), &quot;n&quot; ; print &quot;2:t&quot; , join ( ',' , sort values % array1 ), &quot;n&quot; ; print &quot;3:t&quot; , join ( ',' , sort values % array2 ), &quot;n&quot; ; print &quot;4:t&quot; , join ( ',' , sort keys % array1 ), &quot;n&quot; ; print &quot;5:t&quot; , join ( ',' , sort keys % array2 ), &quot;n&quot; ; print &quot;6:t&quot; , join ( ',' , sort {$ array1 {$ a } cmp $ array1 {$ b }} keys % array1 ), &quot;n&quot; ; print &quot;7:t&quot; , join ( ',' , sort f keys % array2 ), &quot;n&quot; ; print &quot;8:t&quot; , join ( ',' , sort g keys % array2 ), &quot;n&quot; ; sub f { return $ array2 {$ b } <=> $ array2 {$ a }; } sub g { return $ array2 {$ a } <=> $ array2 {$ b }; }
    • Função each
      • #!/usr/bin/perl % A = ( 7 => 'aaaaa' ,
      • 'a' => 23 ,
      • 12 => 123 ,
      • 'b' => 'ssssssssss' ); @ p = each % A ; $ k = each % A ; print &quot;1:t$p[0] $p[1]n&quot; ; print &quot;2:t$kn&quot; ; @ p = each % A ; $ k = each % A ; print &quot;3:t$p[0] $p[1]n&quot; ; print &quot;4:t$kn&quot; ;
    • Função delete
      • #!/usr/bin/perl % A = ( 7 => 'aaaaa' ,
      • 'a' => 23 ,
      • 12 => 123 ,
      • 'b' => 'ssssssssss' ); @ A = ( 1 , 5 , 3 , 6 , 4 , 2 , 1 );
      • #NOTA: @A é uma variável distinta de %A delete $ A { 'a' }; delete @ A { '7' , '12' }; delete @ A [ 1 .. 4 ]; print &quot;$A[0],$A[1],$A[3],$A[4],$A[5],$A[6]n&quot; ; print &quot;$A{'7'},$A{'a'},$A{'12'},$A{'b'}n&quot; ;
    • Função exist
      • #!/usr/bin/perl % A = ( 7 => 'aaaaa' ,
      • 'a' => 23 ,
      • 12 => 123 ,
      • 'b' => 'ssssssssss' ); print &quot;12 é uma chave do array e o seu valor é: $A{12}n&quot; if exists $ A { 12 }; print &quot;'12' é uma chave do array e o seu valor é: $A{'12'}n&quot; if exists $ A { '12' }; $ i = 12 ; print &quot;$i é uma chave do array e o seu valor é: $A{$i}n&quot; if exists $ A {$ i }; $ i = 'aa' ; print &quot;$i não é uma chave do arrayn“
      • unless exists $ A {$ i };
    • Lista de Funções internas
    • Lista de Funções 1
    • Lista de Funções 2
    • Lista de Funções 3
    • Lista de Funções 4
    • Lista de Funções 5
    • Lista de Funções 6
    • Mecanismos de controlo de fluxo
    • Controlo de Fluxo
      • O perl implementa os mesmos mecanismos de controlo de fluxo do C, com algumas variantes bastante úteis
        • IF
        • WHILE
        • DO WHILE
        • FOR
        • FOREACH
        • SWITCH (só no perl 5.8)
    • IF
      • #!/usr/bin/perl if ($ ARGV [ 1 ]){ print $ ARGV [ 1 ], &quot;n&quot; ; } elsif ($ ARGV [ 0 ]){ print $ ARGV [ 0 ], &quot;n&quot; ; } else { print &quot;Usage: $0 arg1 arg2n&quot; ; } print &quot;$ARGV[0] é impar n&quot; if ($ ARGV [ 0 ] % 2 ); #ERRADO: precisa da definição de um bloco após a #declaração da EXPRESSÃO #if ($ARGV[1]) print &quot;arg1=$ARGV[1]n&quot;; #CORRECTO: if ($ ARGV [ 1 ]) { print &quot;arg1=$ARGV[1]n&quot; };
    • IF
    • Unless
      • #!/usr/bin/perl unless (@ ARGV ) { print &quot;Usage: $0 arg1, arg2,...argnntn >= 2ntargv1 > 5n&quot; ; print &quot;targv0 deve ser imparn&quot; ; exit ; }; #ERRADO tal como no if antes da declaração unless só é permitido #uma declaração e não um bloco #{ # print &quot;Usage: $0 arg1, arg2,...argnn&quot;; # exit; #}unless $ARGV[0] % 2; #CORRECTO, a construção 'do {BLOCK}' é uma apenas uma declaração do { print &quot;Usage: $0 arg1, arg2,...argnntn >= 2ntargv1 > 5n&quot; ; print &quot;targv0 deve ser imparn&quot; ; exit ; } unless @ ARGV >= 2 ; print &quot;targv1 deve existir e ser maior que 5n&quot;
      • unless $ ARGV [ 1 ] > 5 ; #CORRECTO, a construção 'declaração, declaração' não é um bloco $ i = 'arg0 deve ser impar' , print &quot;t$in&quot;
      • unless $ ARGV [ 0 ] % 2 ; print 'FIM' , &quot;n&quot; ;
    • Unless
    • While
      • !/usr/bin/perl $ j = 0 ; while ($ j ++ < 4 ){ print &quot;j=$jn&quot; ; } print &quot;nt-----n&quot; ; print &quot;j=$jn&quot; while $ j --;
    • For
      • #!/usr/bin/perl for ($ j = 0 ;$ j < 5 ; $ j ++){ print $ j , &quot;n&quot; ; } print &quot;t+++++n&quot; ; for ($ j = 0 ;$ j ++ < 5 ;){ print $ j , &quot;n&quot; ; } print &quot;t--------n&quot; ; for (;$ j --;){ print $ j , &quot;n&quot; ; } print &quot;t******n&quot; ; for $ j ( 1 , 2 , 3 , 4 ){ print $ j , &quot;n&quot; ; } print &quot;t%%%%%%%n&quot; ; print $ j ++, &quot;n&quot; for 1 .. 3 ; for (;;){ print 'a' }; #an endless cycle
      Assume sucessivamente os valores 1,2,3 e 4 Nota: Esta variável é local ao ciclo for Nota: termina quando $j = 0 mas $j é decrementado após o teste O ciclo é executado para os valores 1,2 e 3
    • For
    • Last e Next #!/usr/bin/perl @ l = ( 4 , 7 , 3 ,, 8 , 9 , 'a' , 'b' , 'c' ); foreach $ j (@ l ){ next unless $ j ; last if $ j == 'a' ; print &quot;$jn&quot; ; }
    • Variáveis especiais do PERL
    • Variáveis Especiais
      • #!/usr/bin/perl die &quot;$0 file1 file2 file3 ... filen&quot; unless @ ARGV ; $ = &quot;n&quot; ; $, = ' <-> ' ; # pode ser a string que eu quiser print @ ARGV ; print &quot;nt++++n&quot; ; for (@ ARGV ){ print ; #assume como argumento o valor $_ } print &quot;nt----n&quot; ; $, = ' :-> ' ; foreach (@ ARGV ){ print &quot;Tamanho do nome do fx $_&quot; , length ; } print &quot;t**** Print de todos os ficheiros recebidos como argmentos***&quot; ; undef $/;
      • while (<>){ print &quot;n----------Ficheiro $ARGV ------------n&quot; ; #$ARGV tem o nome do fx do qual se está a ler print ; #imprime o valor de $_ }
    • Variáveis especiais mais usadas Ver a lista completa com o man perlvar
    • Operadores
    • Operadores
      • O perl suporta as operações básicas de qualquer linguagem como sejam as operações:
        • aritméticas + - * /
        • Resto da divisão inteira %
        • Comparação < > < <= >= == !=
        • Deslocamento << >>
        • Lógicas && || ^ !
        • “ Exponenciação” **
        • “ Referenciação” ->
    • Precedência e Associatividade
    • Precedência e Associatividade 2 Continuação...
    • Operadores “específicos” do PERL
    • Operadores =~ e !~
      • #!/usr/bin/perl $ s = 'abcdef' ; print &quot;match 'cd' on 'abcdef'n&quot; if ($ s =~ / cd /); print &quot;not match 'CD' on 'abcdef'n&quot;
      • if ($ s !~ / CD /);
    • Operador negação binária
      • #!/usr/bin/perl $= &quot;n&quot; ; $ i = 5 ; $ j = ~$ i ; #$j é o complemento para 1 de $i -- em 32 bits $ k = ~$ i & 0 b111 ; #filtra os 3 bits menos significativos #o prefixo 0b indica que se trata de um número binário print $ j ; print $ k ; #$l = complemento para 1 de $i -- em 32 bits $ l = 2 ** 32 - 1 - $ i ;
      • print $ l ;
    • Mais Operadores
      • #!/usr/bin/perl $ a = 3 ; $ b = 5 ; $ s = &quot;Isto é uma string&quot; ; $ r = &quot;Isto é uma string longa&quot; ; $ p = &quot;Esta é uma string&quot; ; $= &quot;n&quot; ; $,= ' => ' ; print &quot;$a <=> $b&quot; ,$ a <=> $ b ; print &quot;$b <=> $a&quot; ,$ b <=> $ a ; print &quot;$s <=> $r&quot; ,$ s <=> $ r ; print &quot;$s cmp $r&quot; ,$ s cmp $ r ; print &quot;$s cmp $p&quot; ,$ s cmp $ p ; $ m = $ s .$ r ; print '$m' ,$ m ; $ c = 0 ; $ d = $ c or $ a ; #construção inutil. = toma precedência sobre or; print '$d1' ,$ d ; $ d = $ c || $ a ; #|| tem precedência sobre = print '$d2' ,$ d ;
    • Mais Operadores 2
      • for ( 'a' .. 'e' ){ print &quot;$X[$c]&quot; ,$ _ ; $ X [$ c ++] = $ _ ; } $ p = @ X ; #p é uma referência para @X print '$c' ,$ c ; $, = ' == ' ; for ( 0 ..$ c - 1 ){ print $ p ->[$ _ ],$$ p [$ _ ]; }
      Continuação...
    • Mais Operadores 3
    • Operador //
      • #!/usr/bin/perl $ s = 'abcdefCdCD' ; print '$s=' , &quot;$sn&quot; ; $ s =~ / CD / i ; print &quot;1: antes do mathing: $`, matching:$&, pos-matching:$'n&quot; ; $ s =~ / CD / ig ; print &quot;2: antes do mathing: $`, matching:$&, pos-matching:$'n&quot; ; @ s = ($ s =~ / CD / i ); $, = ',' ; $ = &quot;n&quot; ; print @ s ; @ s = ($ s =~ / CD / ig ); print @ s ;
    • Operador s///
      • #!/usr/bin/perl $ s = 'abcdefcdcd' ; $ i = 'X' ; $ j = 'W' ; while ($ s =~ s / CD /$ i / i ){ print &quot;1: $sn&quot; ; $ i ++; } $ s = 'abcdefcdcd' ; while ($ s =~ s / CD /$ j / ig ){ print &quot;2: $sn&quot; ; }
    • Operador <>
      • #!/usr/bin/perl $= &quot;n&quot; ; $,= &quot;=>&quot; ; #abre o stdin ou morre open ( FILE , &quot;<-&quot; )
      • or die &quot;não posso aceder ao stdin: $!&quot; ; #lê, uma linha de cada vez, do fx identificado por #FILE, neste caso o stdin while (< FILE >){ #termina quando uma linha contiver apenas um 'A' last if /^ A $/; print &quot;'A' para continuar&quot; ; } print '@ARGV' ,@ ARGV ; #aguarda pelo 'B' print &quot;'B' para continuar&quot; while (< FILE > !~ /^ B $/); #$f1 fica com o valor do 1º arg $ f1 = shift or die &quot;nº de args insuficiente&quot; ; print '@ARGV' ,@ ARGV ; #aguarda pelo 'C' print &quot;'C' para continuar&quot; while (< FILE > !~ /^ C $/); #$f2 fica com o valor do 2º arg $ f2 = shift or die &quot;nº de args insuficiente&quot; ; print '@ARGV' ,@ ARGV ;
      o sinal '<' sinaliza que é se pretende abrir o fx para leitura o sinal '-' indica que o fx a abrir é o stdin
    • Operador <>
      • #aguarda pelo 'D' print &quot;'D' para continuar&quot; until (< FILE > =~ /^ D $/); #lê os fxs identificados pelos 3º,4º,..nº, argumento while (<>){ print $ ARGV ,$ _ ; } print '@ARGV' ,@ ARGV ; print &quot;Introduza um caracter diferente de 'S'&quot; ; print &quot;Ou 'S' seguido de enter para terminar&quot; ; #lê do stdin porque @ARGV é nulo while (<>){ #termina quando uma linha contiver apenas um 'S' last if /^ S $/; print ; } #redireciona o STDIN open ( STDIN , &quot;<$f1&quot; ) or die &quot;não posso abrir o $f1: $!&quot; ; #lê do STDIN que está redirecionado para o ficheiro $f1; while (<>){ print ; } print &quot;---------&quot; ;
    • Operador <>
      • open ( FILE , &quot;<$f2&quot; ) or die &quot;não posso abrir o $f2: $!&quot; ; # lê do do ficheiro $f2; while (< FILE >){ print ; } print &quot;++++++++&quot; ; #o script entra em ciclo infinito na próxima linha #porque o FILE já não é o stdin mas sim o fx cujo nome #foi passado no 2º arg e este foi completamente lido no #ciclo anterior #Logo o resultado de <FILE> é nulo e por maioria de #razão não faz matching com /^G$/ 1 while (< FILE > !~ /^ G $/); #removido e substituido pela linha anterior para evitar #o scrolling de G’s: #print &quot;'G' para continuar&quot; while(<FILE> !~ /^G$/);
    • Operador <> (conclusão)
      • < FILEHANDLE >
        • Devolve a próxima ' linha ' do ficheiro identificado pelo handler FILEHANDLE
        • Em caso de omissão deste, lê do ficheiro identificado por @ARGV[0]
        • E no caso de @ARGV ser nulo e FILEHANDLE estar omisso, lê do STDIN
        • Uma ‘ linha ’ termina quando é encontrado o caracter definido em $/ (por omissão um newline)
          • Se $/ = undef ou $/ = ord(0) a ‘ linha ’ é o ficheiro todo
            • Situação muito prática para ler ficheiros com uma só instrução
              • Ex: $/ = undef; #linhas de código aqui $file = <>; #lê o ficheiro inteiro para a variável $file
    • Expressões regulares
    • Expressões Regulares
      • Nota: Ver os apontamento de Expressões Regulares antes de prosseguir com estes apontamentos
      • O PERL é a linguagem que mais aprofunda a implementação das expressões regulares
        • Além de implementar todas as construções enumeradas nas ER’s o PERL adiciona o uso dos modificadores que permitem multipicar o número de construções possíveis
        • Uma descrição pormenorizada das ER’s encontra-se na página do manual man perlre
    • Modificadores
      • i
        • torna a ER insensível à capitulação dos caracteres
      • g
        • a ER deve ser aplicada até não haver mais ocorrências
      • m
        • a string é considerada multi-linha. Os meta-caracteres ^ e $ passam a ter efeito no início e fim de cada linha e não apenas no início e fim da string
      • s
        • A string é considerada single-line. O meta-caracter . aplica-se também a qualquer caracter newline encontrado
    • Resultados
      • O resultado de operação de matching // ou de substituição s/// devolve vários resultados
        • Resultado principal
          • Operador //
            • Num contexto escalar devolve 1 ou 0 conforme houve ou não verificação
              • Ex: next if $s =~ /ab/;
            • Num contexto de lista devolve os (sub)padrões que foram verificados
              • o uso de parênteses curvos ou o modificar g permite obter mais do que um sub-padrão
              • Ex: ($x,$y) = $s =~ /^a(b+c)(.+?)$/;
              • Ex: @hrefs = $s =~ /hrefs*=s*”.+?”/g;
          • Operador s///
            • Devolve sempre o número de substituições efectuadas
    • Resultados
        • Resultado colaterais
          • $&
            • Contém o padrão que se verificou
          • $’
            • Resto da string a seguir ao padrão verificado
          • $`
            • Início da string até ao padrão verificado
          • Nota: $`.$&.$’ é igual à string sujeita à verificação
          • $1,$2,...,$9
            • Subpadrões verificados nos grupos delimitados por parênteses
              • Se “abbcdef” =~ /(a(b+c))(.*)/
              • $1 fica com ‘abbc’
              • $2 fica com ‘bbc’
              • $3 fica com ‘def’
          • Nota e cuidado: estas variáveis especiais ficam sempre com o valor da última expressão que verificou um dado padrão, mesmo que entretanto se tenha tentado verificar outras strings contra outros padrões. Isto é, se o resultado for falso estas variáveis não ficam com o valor nulo ou undef , mas sim com o valor da última verificação positiva.
      Continuação...
    • ER’s exemplo
      • #!/usr/bin/perl $ = &quot;n&quot; ; $, = &quot;,&quot; ; $ s = &quot;Isto é uma stringnEsta é uma Stringn&quot; ; $ s .= &quot;Esta é a terceira linhan&quot; ; $ s .= &quot; Esta é a quarta linhan&quot; ; $ s .= &quot;Esta não é a última frasen&quot; ; $ s .= &quot;Esta é a última linhan&quot; ; $ s =~ /^ Isto / && print 'verificou-se /^Isto/' ; $ s =~ /^ Esta / || print 'não se verificou /^Esta/' ; $ s =~ /^ Esta / m && print 'verificou-se /^Esta/m' ; @ l = $ s =~ /^ Esta / mg and $ j = @ l ,
      • print &quot;verificou-se /^Esta/mg $j vezes&quot; , 'list:' ,@ l ; @ l = $ s =~ /^[ EI ] st [ ao ]/ mg and $ j = @ l ,
      • print &quot;verificou-se /^[EI]st[ao]/mg $j vezes&quot; , 'list:' , @ l ; @ l = $ s =~ /^ Isto |^ Esta / mg and $ j = @ l ,
      • print &quot;verificou-se /^Isto|^Esta/mg $j vezest&quot; , @ l ;
    • ER’s exemplo
      • @ l = $ s =~ /^ Isto | Esta / mg and $ j = @ l , print &quot;verificou-se /^Isto|Esta/mg $j vezest&quot; , @ l ; $ msg = 'verificou-se /(terceira|quarta|última)’; $ msg .= '(linha|frase)$/ e ($1,$2) =' . print $ msg . &quot;('$1','$2') <= '$&'&quot; while ($ s =~ s /( terceira | quarta | última ) ( linha | frase )$// m ); print &quot;verificou-se /.tring/ em $&&quot; while ($ s =~ s /. tring //); print $ s ;
      Continuação...
    • ER’s exemplo 2
      • #!/usr/bin/perl $ = &quot;n&quot; ; $, = &quot;,&quot; ; $ s = &quot;Isto é uma stringnEsta é uma Stringn &quot; ; $ s .= &quot;Esta é a terceira linhan&quot; ; $ s .= &quot; Esta é a quarta linhan &quot; ; $ s .= &quot;Esta não é a última frasen&quot; ; $ s .= &quot;Esta é a última linhan&quot; ; $ s =~ /^ Isto .+/ && print 'verificou-se /^Isto.+/ em: ' .$&; print &quot;----------&quot; ; $ s =~ /^ Isto .+/ s && print 'verificou-se /^Isto.+/s em: ' . &quot;n$&&quot; ; print &quot;+++++++++++&quot; ; $ s =~ /^ Isto .+ Esta / s && print 'verificou-se /^Isto.+Esta/s em:‘ . &quot;n$&&quot; ;
    • ER’s exemplo 2
      • print &quot;************&quot; ; $ s =~ /^ Isto .+? Esta / s && print 'verificou-se /^Isto.+?Esta/s em:‘ . &quot;n$&&quot; ; print &quot;%%%%%%%%%%%&quot; ; @ l = ( &quot; aa = 20&quot; , &quot;bbb= -40&quot; , &quot;'c'= +60&quot; , &quot;'dddd'=80&quot; ); foreach (@ l ){ /^ s *( '?[a-z]{1,3}' ?) s *= s *[+-]?( d +)/ and $ F {$ 1 } = $ 2 ; } foreach ( sort keys % F ){ print &quot;$_=>$F{$_}&quot; }
      Continuação...