API tools faq
paste
KillerRootOficiaL

[ E-Zine ] - Und3rZ1n3 0x01 - Perl para iniciantes

KillerRootOficiaL
Oct 17th, 2015
2,217
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Perl 36.64 KB | None | 0 0
raw download clone embed print report
  1.  
  2. +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  3.        ___                                                            Language: Portuguese Brazilian.
  4.      .'   `"-._                                                                        Encode: UTF-8.
  5.    / ,        `'-.-.
  6.    / /`'.       ,' _ \
  7.  `-'    `-.  ,' ,'\\/
  8.            \, ,'  ee`-.               Und3rZ1n3 0x01 - Perl para iniciantes.
  9.            / ./  ,(_   \     ,                 Escrito por Constantine, 17 de Janeiro de 2015.
  10.           (_/\\\ \__|`--'     ||                
  11.           ///\\|     \        ||
  12.           ////||-./`-.}    .--||    
  13.              /     `-.__.-`_.-.|                 'A mente que domina a magia dos
  14.               |      '._,-'`|___}    `;                        bits controla o mundo!'
  15.              /   '.        |/ || ,;'`                                             - Constantine
  16.              |     '.__,.-`   || ':,
  17.              |       |        || ,;'
  18.              /       /     _,.||oOoO.,_
  19.             |        |     \-.O,o_O..-/          Greatz for L1sbeth and P0cl4bs Team.
  20.            /         /     /          \                   https://github.com/P0cL4bs
  21.           |         /     /            \        
  22.           |         |    |      ,       |
  23.           /         |    \  ) (     )  /
  24.          |           \  ,'.(:, ),: (_.'.
  25.         /            /'.' ="`""="="=="= '.
  26.        `'"---'-.__.'"""`    ` "" "" `""      
  27.                                                                          constantine.sourceforge.net
  28. +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  29.  
  30. |=[ Tabela de conteúdo ]=--------------------------------------------------------------------------=|
  31. | 0x4A - Apresentação e introdução ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
  32. | 0x00 - Interpretador ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
  33. | 0x01 - Comentários ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
  34. | 0x02 - Módulos ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
  35. | 0x03 - Variáveis ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
  36. | 0x04 - Condições ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
  37. | 0x05 - Repetições ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
  38. | 0x06 - Operadores e caracteres especiais ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
  39. | 0x07 - Entrada e saída de dados ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
  40. | 0x08 - Funções/Sub-rotinas ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
  41. | 0x09 - Manipulação de variáveis/dados ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
  42. | 0x0a - Regex ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
  43. | 0x0b - Manipulação de arquivos ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
  44. | 0x0c - Sockets ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
  45. | 0x0d - Threads ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
  46. | 0x0e - Orientação a Objetos (POO) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
  47. | 0x0f - Finalização ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
  48. |=-------------------------------------------------------------------------------------------------=|
  49.  
  50. |=[ 0x4A - Apresentação e introdução ]=------------------------------------------------------------=|
  51.  
  52. Olá, prazer, antes de tudo quero me desculpar por meus erros de português.
  53.  
  54. Se você nunca ouviu falar sobre Perl, tenha em mente que ela é uma linguagem de programação, e uma
  55. linguagem de programação podemos dizer que são instruções para a máquina (seu computador) executar,
  56. é basicamente assim que os programas de computador são feitos, apenas um código que contém uma
  57. sequência de instruções. Caso esteja na dúvida sobre alguns itens citados no texto, não se preocupe
  58. pois no final tudo fica mais claro.
  59.  
  60. Neste texto darei uma breve e superficial introdução sobre a Linguagem de Programação Perl. Falarei
  61. sobre coisas básicas porém essenciais para criação de uma quantidade enorme de softwares.
  62.  
  63. Sem mais, vamos ao que interessa.
  64.  
  65. |=[ 0x00 - Interpretador ]=------------------------------------------------------------------------=|
  66.  
  67. Basicamente, o interpretador da linguagem Perl é o programa responsável por ler nosso código escrito
  68. na linguagem e executar as instruções diretamente na máquina.
  69.  
  70. Em ambiente Linux, BSD, *NIX em geral, devemos setar no início de nosso código fonte o texto abaixo,
  71. o mesmo está dizendo onde se encontra nosso interpretador Perl que será necessário para ler nosso
  72. código.
  73.  
  74.   #!/usr/bin/perl
  75.    
  76. Apenas para deixar claro, se por acaso você usa Windows, não se preocupe, basta setar o mesmo texto,
  77. e quando instalar o Active Perl (faça download do mesmo se não tem instalado em sua máquina), ele vai
  78. converter esse caminho para o caminho do interpretador no Windows, ou seja, por padrão será
  79. convertido de '#!/usr/bin/perl' para algo como '#!C:\Program Files\Perl\bin\perl.exe'.
  80.  
  81. E apenas para deixar claro, para executar um programa em perl, abrimos o terminal (ou cmd caso
  82. esteja no Windows) e digitar o seguinte texto.
  83.  
  84.   perl programa.pl
  85.  
  86. Onde 'programa.pl' se refere ao arquivo de texto salvo com o código Perl dentro.
  87.  
  88. |=[ 0x01 - Comentários ]=--------------------------------------------------------------------------=|
  89.  
  90. Um comentário é todo texto que deve ser ignorado pelo interpretador da linguagem. Para fazer uso de
  91. comentários em Perl utilizamos o caracter '#' no início da linha. Segue o exemplo abaixo.
  92.  
  93.   # Isso é um comentário em Perl
  94.   # Este texto será sempre ignorado pelo interpretador.
  95.  
  96. |=[ 0x02 - Módulos ]=------------------------------------------------------------------------------=|
  97.  
  98. Os módulos são necessários para poder fazer o uso de determinados itens da linguagem, coisas
  99. como funções, comandos para controles de fluxo, dentre outros. Basicamente para fazer uso de
  100. algum módulo utilizamos o comando 'use'.
  101. Por exemplo, para poder utilizar sockets (Não se preocupe se não souber o que é socket, mais
  102. para frente falaremos sobre isso) devemos fazer o uso do módulo 'Sockets', para isso fazemos:
  103.  
  104.    use Sockets;
  105.  
  106. |=[ 0x03 - Variáveis ]=----------------------------------------------------------------------------=|
  107.  
  108. Variáveis são regiões frequentemente localizada na memória onde são referenciadas por um nome.
  109. Por exemplo, se queremos armazenar o valor '10' em algum local, devemos utilizar uma variável, o
  110. mesmo vale para textos e outras coisas. Portanto vamos para alguns exemplos simples, se por acaso eu
  111. queira guardar o texto 'Hello World!' em algum local para fazer uso do mesmo posteriormente, basta eu
  112. criar uma variável com qualquer nome da seguinte maneira.
  113.  
  114.   my $meu_texto = "Hello World!";
  115.  
  116. Nesse caso acima, nossa variável se chama '$meu_texto', sempre que precisar fazer o uso da mesma,
  117. basta utilizar o nome '$meu_texto' pois dentro dele que se encontra do texto 'Hello World'. No
  118. exemplo acima fizemos o uso de uma variável para armazenar texto, para armazenar números basta fazer
  119. como no exemplo abaixo.
  120.  
  121.   my $meu_numero = 10;
  122.  
  123. Obs: Não foi citado anteriormente, mas o caracter ';' (ponto e virgula) significa o fim de um comando.
  124.  
  125. Por fim, para armazenar listas, o que podemos e vamos chamar de arrays ou vetores futuramente, fazemos
  126. como no exemplo abaixo.
  127.  
  128.   my @lista = ( "Item 1 da lista", "Item 2 da lista", "Item 3 da lista" );
  129.  
  130. Para ter acesso aos itens da do vetor acima, devemos especificar seu indice, onde o mesmo é iniciado
  131. em 0. Portanto, segue a lógica do 'desenho' abaixo.
  132.  
  133.   @lista [0] = "Item 1 da lista";
  134.   @lista [1] = "Item 2 da lista";
  135.   @lista [2] = "Item 3 da lista";
  136.  
  137. Observe que em todos os exemplos de variaveis, sempre que precisamos acesar os dados contidos dentro
  138. delas, utilizamos como referencia o nome da mesma, no caso utilizamos o nome '$meu_texto' para ter
  139. acesso ao texto 'Hello World!' que estava armazendo 'dentro' dela, no exemplo seguinte, para ter
  140. acesso ao número '10', utilizamos o nome '$meu_numero', e por fim, no exemplo com vetores, para ter
  141. acesso a seus itens utilizamos seu indice que é iniciado em 0, '@lista [0]' para ter acesso ao texto
  142. 'Item 1 da lista' e assim sucessivamente.
  143.  
  144. Agora falaremos de um tipo de variável diferente chamada de 'hash', onde podemos especificar o nome
  145. de nossas referencias de uma maneira um pouco diferente. Segue abaixo um exemplo da mesma.
  146.  
  147.   %minha_hash_variavel = ('nome', 'Constantine', 'idade', '20', 'language', 'Perl');
  148.  
  149. A maneira de acessar os itens dessa variável segue a seguinte lógica...
  150.  
  151.   $minha_hash_var{'nome'} contém o texto 'Constantine'.
  152.   $minha_hash_var{'idade'} contém o texto '20'.
  153.   $minha_hash_var{'language'} contém o texto 'Perl'.
  154.  
  155. |=[ 0x04 - Condições ]=----------------------------------------------------------------------------=|
  156.  
  157. Para escrever um programa, como são muitas coisas a serem feitas, precisamos de algo onde podemos
  158. desviar o fluxo dos dados manipulados no programa. Por exemplo, vamos imaginar que nosso programa
  159. verifica se o computador tem conexão com a internet, dependendo da resposta retornada vamos realizar
  160. alguma ação. Portanto um algoritmo ficaria algo como o exemplo abaixo.
  161.  
  162.   SE CONEXAO_COM_INTERNET_EXISTE
  163.       FAÇA ALGO
  164.   SE NÂO
  165.       FAÇA OUTRA COISA
  166.  
  167. Basicamente, o programa acima faz uma verificação, se 'CONEXAO_COM_INTERNET_EXISTE' for verdadeiro,
  168. então entra no 'FAÇA ALGO', caso contrário, se não existir conexão com a internet, ele não deve
  169. executar o 'FAÇA ALGO' e sim o 'FAÇA OUTRA COISA'.
  170.  
  171. Em Perl para controle de condições temos o comando 'if', 'elsif' e 'else'. Vamos para alguns códigos
  172. de exemplo. No código abaixo, criamos uma variável com o valor 10 e verificamos se o valor atribuido
  173. a ela é maior que 5.
  174.  
  175.   my $variavel = 10;
  176.    
  177.    if ( $variavel > 5 ) {
  178.      # Aqui entra o código a ser executado se por acaso a '$variavel' for maior que 5.
  179.    }
  180.  
  181. Lembrando que toda linha que começar com o caracter '#' significa que é um comentário e isso não é
  182. interpretado como código.
  183.  
  184. Observe que fizemos apenas o uso do comando 'if', o caracter '>' significa 'maior que', portanto o
  185. código 'if ( $variavel > 5 )' seria o equivalente a 'SE $variavel É MAIOR QUE 5' e se for verdadeiro,
  186. ou seja, se realmente o valor que está armazenado na '$variavel' for maior que 5, execute o bloco de
  187. código que está dentro dos chaves { }, uma abre o bloco de código '}' e a outra fecha o bloco '}'.
  188.  
  189. No exemplo seguinte vamos fazer uso do 'if' e do 'else'.
  190.  
  191.   my $variavel = 4;
  192.    
  193.    if ( $variavel > 5 ) {
  194.      # Aqui entra o código a ser executado se por acaso a '$variavel' for maior que 5.
  195.    }
  196.   else {
  197.      # O valor armazenado em '$variavel' não é maior que 5, então executado esse bloco de código.
  198.   }
  199.  
  200. Se por acaso a '$variavel' não for maior que 5, automaticamente o 'else' é executado.
  201. Agora vamos fazer um exemplo, utilizando o 'if', 'elsif' e 'else', segue o exemplo abaixo.
  202.  
  203.   my $variavel = 3;
  204.    
  205.    if ( $variavel > 5 ) {
  206.      # Executa esse bloco de código se o valor armazenado em '$variavel' for maior que 5.
  207.    }
  208.    elsif ( $variavel < 2 ) {
  209.      # Executa esse bloco de código se o valor armazenado em '$variavel' for menor que 2.
  210.   }
  211.   else {
  212.      # Nenhuma das condições acima foi dada como verdadeira, por padrão, executa então o 'else'.
  213.      # Sendo ele esse bloco de código.
  214.   }
  215.  
  216. A lógica das condições acima na verdade é bem simples e apenas uma será executada, ou seja, se o
  217. primeiro 'if' for verdadeiro, então executa apenas ele e não será executado o 'elsif' e nem o 'else'.
  218.  
  219. Para controle de condições temos também o comando 'unless', vamos seguir o raciocínio, o 'if' em sua
  220. natureza significa 'SE FOR VERDADE', vamos pegar como exemplo o 'if' do exemplo acima.
  221.  
  222.   if ( $variavel > 5 ) { ...
  223.  
  224. No 'if' acima, observe que fazemos o uso de colchetes ( ), ou seja, a expressão definida dentro dos
  225. colchetes será analizada, e se o resultado for verdadeiro, ai sim ele executa o bloco de código.
  226.  
  227. Basicamente o 'if' faz uma 'pergunta', sendo algo como.
  228.  
  229.   'É VERDADE QUE O VALOR ARMAZENADO EM $variavel É MAIOR QUE 5?'
  230.  
  231. Se a resposta for verdadeira, ou seja, se realmente o valor armazenado em '$variavel' for mesmo maior
  232. que 5, então executa o bloco de código.
  233. O comando unless funciona com a lógica contrária, ou seja, ao invés de pergunta 'SE É VERDADE...' ele
  234. pergunta 'SE NÃO É VERDADE', vamos a um exemplo prática.
  235.  
  236.   my $variavel = 7;
  237.  
  238.   unless ( $variavel < 5 ) {
  239.      # Executa bloco de código se o conteúdo armazenado em '$variavel' NÃO for menor que 5.
  240.      # Esse bloco de código será executado pois '$variavel' não é menor que 5, ela contém o valor 7.
  241.   }
  242.  
  243. Para deixar mais claro, o comando acima é lido da seguinte maneira: 'SE O CONTEÚDO ARMAZENADO EM
  244. $variavel NÃO FOR MENOR QUE 5...', se essa expressão como um todo é verdadeira, ou seja, se
  245. realmente o conteúdo armazenado em '$variavel' não for menor que 5, então o bloco de código ( que
  246. é os dados entre as chaves) é executado.
  247.  
  248. E por fim, para terminar os comandos utilizados para trabalhar com condições, vamos falar agora do
  249. 'switch', para fazer o uso do mesmo, é necessário declarar um módulo chamado 'Switch' e para isso
  250. fazemos como no exemplo abaixo.
  251.  
  252.   use Switch;
  253.  
  254. Vamos então para um exemplo de uso do comando 'switch'. O código ao todo ficaria.
  255.  
  256.   #!/usr/bin/perl
  257.   use Switch;
  258.  
  259.   my $variavel = 1;
  260.  
  261.   switch ( $variavel ) {
  262.      case (0) {
  263.         # Esse bloco de código não será executado, pois '$variavel' não é igual a 0.
  264.      }
  265.      
  266.      case (1) {
  267.         # Esse bloco de código será executado, pois '$variavel' é igual a 1.
  268.      }
  269.      
  270.      case (2) {
  271.         # Esse bloco de código não será executado, pois '$variavel' não é igual a 2.
  272.      }
  273.      
  274.      else {
  275.         # Esse bloco de código não será executado, pois '$variavel' é igual a 1 e já existe o 'case (1)' para isso.
  276.         # Mas se por acaso nenhum dos 'case' acima fosse dado como verdadeiro, então esse 'else' aqui seria executado.
  277.      }
  278.   }
  279.    
  280. A lógica do 'switch' na verdade é muito simples, ele avalia o valor que está armazenado em '$variavel'
  281. e tem os 'case' para achar o valor representado, portanto 'case (1)' equivale a 'SE O VALOR EM $variavel
  282. É IGUAL A 1...', ai entro no bloco de código.
  283.  
  284. Para testar o código, basta salvar com algum nome qualquer, por exemplo, 'programa.pl' ou pode ser
  285. 'programa.txt', em seguida abrir o terminal (ou cmd, caso esteja no Windows) e rodar o programa.
  286.  
  287.   perl programa.pl
  288.    
  289.   ou
  290.    
  291.   perl programa.txt
  292.  
  293. |=[ 0x05 - Repetições ]=---------------------------------------------------------------------------=|
  294.  
  295. Repetições podemos dizer que são blocos de códigos, onde seus valores são sendo modificados em tempo
  296. real, e para não escrever centenas ou milhares de linhas, utilizamos algum comando de repetição, para
  297. resumir essa instruçao (ou sequência de instruções, como queira chamar) de código.
  298.  
  299. Vamos falar aqui nessa área de repetição sobre 3 comandos, sendo eles o 'for', 'while' e 'foreach'.  
  300. Vamos começar com o comando 'for'.
  301.  
  302. O comando 'for' é repartido em 3 partes, onde elas são separadas por ';' (ponto e virgula).
  303. Basicamente seria assim seu algoritmo.
  304.  
  305.   for ( INICIALIZAÇÃO ; CONDIÇÃO ; INCREMENTO ) {
  306.      # bloco de código que será executado enquando a CONDIÇÃO for VERDADEIRA.
  307.   }
  308.  
  309. Vamos para um exemplo prático para que fique mais claro.
  310. No exemplo abaixo vamos criar uma variável com o valor 0 e utilizar ela em nosso for.
  311. Essa variável será incrementada em 1, ou seja, a cada vez que o bloco de código for repetido será
  312. somado mais 1 nessa variável.
  313.  
  314.   my $variavel = 0;
  315.  
  316.   for ( $variavel = 0; $variavel <= 10 ; $variavel = $variavel + 1 ) {
  317.      # Bloco de código que será executado até que '$variavel <= 10', ou seja, até que o valor armazenado
  318.      # em '$variavel' seja menor ou igual a 10. Após isso, ou seja, a partir do momento em que o valor
  319.      # armazenado em '$variavel' for maior que 10, o for será encerrado e esse bloco de código irá parar
  320.      # de ser executado.
  321.   }
  322.  
  323. Lembrando que o 'for' é dividido em três partes sendo elas separadas por ';' (ponto e virgula).
  324. No início do 'for' temos então a 'INICIALIZAÇÃO', sendo ela representada por '$variavel = 0', onde
  325. a '$variavel' é inicializada com o valor 0.
  326.  
  327. Após isso temos a parte do meio do 'for', sendo ela a 'CONDIÇÃO', representada por '$variavel <= 10',
  328. essa condição seria parecida com o 'if', é como se a cada vez que o bloco de código fosse executado o
  329. 'for' verificasse 'SE O VALOR EM $variavel É MENOR OU IGUAL A 10', quando o valor armazenado em
  330. '$variavel' for maior que 10, ou seja, quando deixar de ser 'menor ou igual a 10', o 'for' é encerrado
  331. e o bloco de código deixa de ser executado repetidas vezes.
  332.  
  333. Por fim, temos a parte final do 'for', sendo ela representada por '$variavel = $variavel + 1', a cada
  334. vez que o bloco de código é executado (lembrando que o mesmo é executado até que a CONDIÇÃO seja falsa)
  335. o INCREMENTO é também executado, ou seja, a cada vez que o 'for' é executado o valor especificado em
  336. '$variavel' é incrementada em 1, sendo assim, somado 1 na própria variável.
  337.  
  338. Para deixar claro, o 'for' de exemplo acima é executado 10 vezes e depois finalizado.
  339. Vamos agora falar do comando 'while'.
  340.  
  341. O comando 'while' é executado até que sua EXPRESSÃO seja dada como falsa, ou seja, ele sempre ficará
  342. executando seu bloco de código até que sua expressão seja dada como falsa ou você force a parada dele.
  343. Segue abaixo o algoritmo do comando 'while'.
  344.  
  345.   while ( EXPRESSÃO ) {
  346.      # Executa bloco de código até que a EXPRESSÃO seja falsa.
  347.   }
  348.  
  349. Vamos para um exemplo prático.
  350.  
  351.   my $variavel = 0;
  352.  
  353.   while ( $variavel <= 10 ) {
  354.      # Executa bloco de código até que o valor armazenado em '$variavel' seja menor ou igual a 10.
  355.         $variavel = $variavel + 1;
  356.   }
  357.  
  358. Observe que a '$variavel' foi definida fora do 'while' com o valor 0, dentro do bloco de código do
  359. 'while' a '$variavel' é sempre incrementada em 1 assim como na parte de INCREMENTO de nosso 'for'
  360. de exemplo anterior. O 'while' ficará sempre sendo executado até que o valor armazenado em
  361. '$variavel' seja menor ou  igual a 10.
  362.  
  363. Por fim, vamos fazer uso do comando 'foreach'.
  364. Um algoritmo para o 'foreach' poderia ser algo como o exemplo abaixo.
  365.  
  366.   foreach INDICE ( DADOS ) {
  367.      # Executa bloco de código enquanto exitir dados.
  368.   }
  369.  
  370. Vamos para um exemplo prático. No exemplo abaixo estamos percorrendo os itens de um vetor do início
  371. ao fim do mesmo.
  372.  
  373.   @lista = ( 'uva', 'goiaba', 'laranja' );
  374.  
  375.   foreach $indice ( @lista ) {
  376.      # Usar a variável '$indice' para acessar os itens da '@lista'.
  377.   }
  378.  
  379. O bloco de código do comando 'foreach' acima será executado 3 vezes, a variável '$indice' estará
  380. apontando para um item da '@lista'. Segue o exemplo abaixo para deixar mais claro.
  381.  
  382.   primeira execução do bloco de código = $indice contém o valor 'uva'.
  383.   segunda execução do bloco de código  = $indice contém o valor 'goiaba'.
  384.   terceira execução do bloco de código = $indice contém o valor 'laranja'.
  385.  
  386. |=[ 0x06 - Operadores e caracteres especiais ]=----------------------------------------------------=|
  387.  
  388. Como vemos nos comandos exemplos de códigos dos tópicos acima, utilizamos coisas como '<=', '>' e '<',
  389. onde significam 'menor ou igual', 'maior que', 'menor que', etc.
  390.  
  391. Agora vou dar para vocês mais detalhes sobre os operadores existentes na linguagem Perl.
  392. Segue abaixo uma lista dos símbolos e sua descrição falando sobre a funcionalidade do mesmo.
  393.  
  394.   Operadores matemáticos.
  395.   +            Soma
  396.   -            Subtrai
  397.   *            Multiplica
  398.   /            Divisão
  399.   **           Potenciação
  400.   %            Resto da divisão
  401.  
  402.   Operadores para incremento e decremento.
  403.   $a++         Retorna variável '$a' e depois incrementa.
  404.   ++$a         Incrementa variável '$a' e depois retorna.
  405.   $a--         Retorna variável '$a' e depois decrementa.
  406.   --$a         Decrementa variável '$a' e depois retorna.
  407.  
  408.   Operadores para strings/textos.
  409.   .            Concatena.
  410.   x            Repete texto.
  411.  
  412.   Operadores para determinar valores.
  413.   $a = $b      Atribui o valor de '$b' em '$a'.
  414.   $a += $b     Soma o valor de '$b' ao valor de '$a'.
  415.   $a -= $b     Subtrai o valor de '$b' ao valor de '$a'.
  416.   $a .= $b     Concatena o valor de '$b' em '$a'.
  417.   $a == $b     Compara o valor de '$a' com '$b'.
  418.  
  419. Não se preocupe em decorar os operadores, com o tempo e prática tudo fica muito mais simples.
  420. Os caracteres especiais são utilizados em strings. Segue abaixo os caracteres especiais e sua descrição.
  421.  
  422.   \n           Nova linha.
  423.   \r           Retorno \ Carriage return.
  424.   \b           Backspace.
  425.   \a           Emite beep (alert, alarm).
  426.   \t           Tabulação.
  427.   \e           Caracter ESC.
  428.  
  429. Existem outros caracteres especiais, em caso de duvida consulte a referencia da Linguagem Perl em
  430. seu site oficial.
  431.  
  432. |=[ 0x07 - Entrada e saída de dados ]=-------------------------------------------------------------=|
  433.  
  434. Como o que estamos fazendo é escrever software, obviamente temos de ter meios para o usuário entrar
  435. com dados, como também temos de ter meios para exibir os dados (saida dos dados).
  436.  
  437. Para isso vamos por partes, primeiro vamos ver como podemos fazer para receber dados via linha de comando.
  438. Para isso fazemos o uso da variável @ARGV. Onde seu indice é inicializado em 0. Segue abaixo um exemplo.
  439.  
  440.   perl script.pl parametro01 parametro02 parametro03
  441.  
  442. Na variável @ARGV automaticamente será setado os valores dos parametros e como foi dito, tendo sua
  443. indexação inciada em 0. Portanto segue a abaixo os indeces da variável e seus respectivos valores.
  444.  
  445.   @ARGV [0] contém o valor "parametro01"
  446.   @ARGV [1] contém o valor "parametro02"
  447.   @ARGV [2] contém o valor "parametro03"
  448.  
  449. Para entrada de dados enquanto o programa estiver executando, utilizando o '<STDIN>'.
  450. Basta definir uma variável atribuindo para ela como valor o '<STDIN>'. O programa irá 'pausar', ele
  451. vai ficar aguardando o usuário digitar algo e pressionar enter, após o pressionamento da tecla enter
  452. o programa prossegue normalmente. Segue abaixo um exemplo com '<STDIN>'.
  453.  
  454.   my $variavel = '<STDIN>';
  455.    
  456. Por fim, para exibir dados na tela (saida de dados), podemos fazer uso do print. Sendo ela (o print)
  457. na verdade uma função que pega seus dados e envia para saida de dado padrão (que no caso é o terminal
  458. (ou console caso esteja no Windows)).
  459.  
  460. Para usar a função é simples, vamos por exemplo exibir um texto na tela. Para isso fazemos como o
  461. exemplo abaixo.
  462.  
  463.   print "Esse texto será exibido na tela!\n";
  464.    
  465. Obs: O caracter '\n' no final do texto, significa que após exibir o texto ele vai pular uma linha.
  466.  
  467. |=[ 0x08 - Funções/Sub-rotinas ]=------------------------------------------------------------------=|
  468.  
  469. Podemos dizer que uma função ou sub-rotina consiste em um bloco de código, onde o mesmo pode ou não
  470. retornar um valor, mas geralmente na maioria dos casos é utilizadas pra resolver um problema especifico
  471. ou apenas para deixar o código mais organizado, digamos em áreas.
  472. Uma função em Perl começa com a palavra 'sub', a sintaxe seria.
  473.  
  474.   sub nome_da_funcao {
  475.      # Código da função aqui.
  476.   }
  477.  
  478. Abaixo um exemplo de uma função que não recebe parametros e apenas exibe uma mensagem na tela com a
  479. função print.
  480.  
  481.   sub exibe_mensagem {
  482.      print "Hello World!\n";
  483.   }
  484.  
  485. Para chamar a função, basta escrever o nome da mesma seguida do ponto e virgula para indicar termino
  486. do comando. Como no exemplo abaixo.
  487.  
  488.   exibe_mensagem;
  489.  
  490. Agora vamos ver um exemplo de uma função que recebe parametros, vamos fazer uma função que recebe como
  491. parametros dois números para que seja realizado uma soma, em seguida, exibir o resultado na tela.
  492.  
  493.  sub funcao_somar {
  494.    @argv = @_; # Processa argumentos recebidos.
  495.    
  496.    $a = $argv[0]; # Primeiro item passado via parametro, no caso o valor 10.
  497.    $b = $argv[1]; # Segundo item passado via parametro, no caso o valor 20.
  498.    $c = $a + $b;  # Armazena o resultado da soma, que no caso é 10 + 20.
  499.    
  500.    print $c . "\n"; # Exibe o resultado na tela com a função print.
  501.  }
  502.  
  503.  funcao_somar ( 10, 20 ); # Chama função passando como parametro os valores 10 e 20.
  504.  
  505. Observe que utilizamos o . (ponto) para concatenar os dados, mais para frente vamos falar mais sobre
  506. isso. O resultado exibe na tela é 30.
  507.  
  508. Por fim, vamos ver um simples exemplo de uma função que retorne algo, em Perl, como não temos tipos
  509. de dados definidos podemos retornar qualquer coisa, tanto strings como números. Para isso basta fazer
  510. uso do comando 'return'. Vamos usar como exemplo a função acima, porém, ao invés de exibir uma mensagem
  511. na tela, vamos retornar a mensagem para que a função 'print' seja chamada fora da 'funcao_somar'.
  512.  
  513.  sub funcao_somar {
  514.    @argv = @_; # Processa argumentos recebidos.
  515.    
  516.    $a = $argv[0]; # Primeiro item passado via parametro, no caso o valor 10.
  517.    $b = $argv[1]; # Segundo item passado via parametro, no caso o valor 20.
  518.    $c = $a + $b;  # Armazena o resultado da soma, que no caso é 10 + 20.
  519.    
  520.    return $c . "\n"; # Concatena dados e retorna para local que a chamou.
  521.  }
  522.  
  523.  print funcao_somar ( 10, 20 ); # Chama função print passando como parametro outra função, onde
  524.                                 # a mesma retorna os dados que serão exibidos, sendo esses dados
  525.                                 # o resultado da soma de 10 + 20. O número 30 é exibido na tela.
  526.  
  527. |=[ 0x09 - Manipulação de variáveis/dados ]=-------------------------------------------------------=|
  528.  
  529. Não vamos nos aprofundar muito na manipulação dos dados, darei aqui apenas alguns exemplos simples de
  530. como realizar algumas ações muito uteis no dia-a-dia. Vamos lá.
  531.  
  532. Para comparação de inteiros, como já foi citado no tópico de '0x06 - Operadores e caracteres especiais'
  533. o operador '==' que significa 'se for igual'. Segue abaixo um exemplo.
  534.  
  535.   my $a = 10;
  536.   my $b = 10;
  537.  
  538.   if ( $a == $b ) {
  539.      print "Variavel A e igual a variavel B.\n";
  540.   }
  541.   else {
  542.      print "Variaveis com valores diferentes.\n";
  543.   }
  544.  
  545. Para comparação de strings utilizamos o operador '=~', vamos para um exemplo.
  546.  
  547.   my $string_a = 10;
  548.   my $string_b = 10;
  549.  
  550.   if ( $string_a =~ $string_b ) {
  551.      print "Variavel STRING_A e igual a variavel STRING_B.\n";
  552.   }
  553.   else {
  554.      print "Variaveis com valores diferentes.\n";
  555.   }
  556.  
  557. Para concatenação de inteiros e strings utilizamos o . (ponto). Vamos para um exemplo.
  558.  
  559.   my $string_a = "texto 01";
  560.   my $string_b = "texto 02";
  561.   my $string_c = $string_a . " " . $string_b . "\n";
  562.  
  563.   print $string_c; # Exibe mensagem: 'texto 01 texto 02'.
  564.  
  565. Outro método de concatenar é utilizar o '.='. Vamos para um exemplo.
  566.  
  567.   my $string_a = "texto 01";
  568.   my $string_b = "texto 02";
  569.   my $string_c = "";
  570.  
  571.   $string_c .= $string_a;
  572.   $string_c .= " ";
  573.   $string_c .= $string_b;
  574.   $string_c .= "\n";
  575.  
  576.   print $string_c; # Exibe mensagem: 'texto 01 texto 02'.
  577.  
  578. Procura string dentro de outra. Vamos para um exemplo.
  579.  
  580.   my $string = "Esse eh meu texto onde vou procurar algo dentro dele!";
  581.   if ( index ( $string, "texto" ) ) {
  582.      print "Achou 'texto' dentro da string.\n";
  583.   }
  584.   else {
  585.      print "Nada foi encontrado.\n";
  586.   }
  587.  
  588. |=[ 0x0a - Regex ]=--------------------------------------------------------------------------------=|
  589.  
  590. Não vamos nos aprofundar também no uso das regex, pois existem muitas. Darei alguns exemplos para
  591. mostrar como seria o uso simples de regex em Perl, inclusive Perl é muito famosa por ser extremamente
  592. flexivel nessa questão, o que faz Perl uma das linguagens preferidas entre os sysadmins.
  593.  
  594. Verifica se existem as letras de 'a' até 'z' maiúsculo e minúsculo.
  595.  
  596.   my $variavel = "Testando palavra.";
  597.  
  598.   if ($variavel =~ /[a-zA-Z]/) {
  599.      print "Isso e uma palavra\n";
  600.   }
  601.    
  602. Verifica se são apenas números.
  603.  
  604.   my $variavel = "0123456789";
  605.  
  606.   if ($variavel =~ /[0-9]/) {
  607.      print "Isso é apenas números\n";
  608.   }
  609.  
  610. Recomendo que busquem informação no Google sobre o uso de Regex em Perl pois realmente tem muita coisa
  611. interessante.
  612.  
  613. |=[ 0x0b - Manipulação de arquivos ]=--------------------------------------------------------------=|
  614.  
  615. Vamos ver agora como podemos para realizar ações simples com arquivos. Coisas como ler e escrever em
  616. arquivo de texto. Para isso vamos utilizar a função 'open' para abrir o arquivo e a função 'close'
  617. para fechar o mesmo, dentre outras.
  618.  
  619. Segue abaixo um exemplo onde escrevemos um buffer no arquivo de texto.
  620.  
  621.   #!/usr/bin/perl
  622.  
  623.   # Buffer que será salvo.
  624.   @lista = (
  625.      "Meu buffer numero 01\n",
  626.      "Meu buffer numero 02\n",
  627.      "Meu buffer numero 03\n"
  628.   );
  629.  
  630.   # Abre arquivo para escrita.
  631.   open (my $handle, ">", "arquivo.txt");
  632.    
  633.   # Salva dados no arquivo.
  634.   print {$handle} @lista;
  635.    
  636.   # Fecha arquivo.
  637.   close ($handle);
  638.  
  639. Segue abaixo um exemplo onde lemos o conteúdo de um arquivo de texto.
  640.  
  641.   #!/usr/bin/perl
  642.  
  643.   # Abre arquivo para escrita.
  644.   open (my $handle, "<", "arquivo.txt");
  645.    
  646.   # Percorre arquivo de texto.
  647.   while (<$handle>) {
  648.      print "$_"; # '$_' é uma variável interna.
  649.   }
  650.    
  651.   # Fecha arquivo.
  652.   close ($handle);
  653.    
  654. Verifica se determinado arquivo ou diretório existem.
  655.   if (-e "arquivo.txt") {
  656.      print "arquivo.txt existe!\n";
  657.   }
  658.  
  659. Renomeando arquivos com tratamento de erro (função die).
  660.   rename ("arquivo.txt", "arquivo_rename.txt") || die ("Nao foi possivel renomear arquivos.\n");
  661.  
  662. Copia arquivo.
  663.   copy ("arquivo_rename.txt", "arquivo_rename_2.txt");
  664.   move ("arquivo_rename_2.txt", "arquivo_rename.txt");
  665.  
  666. Deleta arquivos.
  667.   unlink ("arquivo_rename.txt");
  668.    
  669. Deletar diretórios.
  670.   rmdir ("diretorio");
  671.  
  672. Ler conteúdo de diretório.
  673.  
  674.   opendir ($handle, "."); # Abre diretorio atual.
  675.   @files = readdir ($handle);
  676.  
  677.   foreach (@files) {
  678.      print "file: $_\n";
  679.   }
  680.   closedir ($handle); # Fecha diretorio.
  681.  
  682. Criar diretorio.
  683.   mkdir ("newdir", 0777) || print "Nao foi possivel criar diretorio.\n";
  684.    
  685. |=[ 0x0c - Sockets ]=------------------------------------------------------------------------------=|
  686.  
  687. Para estabelecer qualquer gênero de conexão com outro computador da internet, é necessário fazer uso
  688. de sockets independente da linguagem de programação. Recomendo que pesquise sobre sockets e aprenda
  689. o máximo possível. Vou aqui dar dois exemplos de uso de sockets.
  690. Lembrando que para fazer uso de sockets em Perl, devemos declarar o módulo 'Socket'.
  691.  
  692. Exemplo de conexão simples com IRC.
  693.  
  694.   # Módulo necessário para utilizar sockets.
  695.   use Socket;
  696.  
  697.   # Endereço e porta do IRC.
  698.   my $host = "irc.freenode.net";
  699.   my $port = 6667;
  700.   my $name = "bot_nick_666";
  701.  
  702.   print "Conectando no IRC...\n";
  703.    
  704.   # Criando conexão.
  705.   socket ( SOCKET, PF_INET, SOCK_STREAM, (getprotobyname('tcp'))[2] ) or
  706.      die "Can't create a socket!\n";
  707.  
  708.   # Conecta em host.
  709.   connect ( SOCKET, pack_sockaddr_in($port, inet_aton($host)) ) or
  710.      die "Can't connect to port $port!\n";
  711.  
  712.   print "Connected on $host $port\n";
  713.  
  714.   # Envia dados para servidor IRC.
  715.   send ( SOCKET, "NICK $name\r\n", 0 );
  716.   send ( SOCKET, "USER $name * * :$name\r\n", 0 );
  717.   send ( SOCKET, "QUIT\r\n", 0 );
  718.  
  719.   print "Quiting IRC...\nConnection closed!\n";
  720.    
  721.   # Fecha conexão.
  722.   close ( SOCKET );
  723.    
  724. Exemplo de conexão com website.
  725.  
  726.   # Módulo necessário para utilizar sockets.
  727.   use Socket;
  728.  
  729.   # Endereço e porta.
  730.   my $host = "google.com";
  731.   my $port = 80;
  732.  
  733.   print "Conectando no IRC...\n";
  734.    
  735.   # Criando conexão.
  736.   socket ( SOCKET, PF_INET, SOCK_STREAM, (getprotobyname('tcp'))[2] ) or
  737.      die "Can't create a socket!\n";
  738.  
  739.   # Conecta em host.
  740.   connect ( SOCKET, pack_sockaddr_in($port, inet_aton($host)) ) or
  741.      die "Can't connect to port $port!\n";
  742.  
  743.   @header = (
  744.      "GET / HTTP/1.1\r\n",
  745.      "Host: google.com\r\n",
  746.      "User-Agent: Mozilla/5.0 (Windows NT 6.1; rv:33.0) Gecko/20100101 Firefox/33.0\r\n",
  747.      "Connection: Close\r\n\r\n"
  748.   );
  749.  
  750.   # Envia dados para servidor.
  751.   foreach my $index (@header) {
  752.      send ( SOCKET, $index, 0 );
  753.   }
  754.  
  755.   # Recebe dados do servidor.
  756.   while (<SOCKET>) {
  757.      print "$_";
  758.   }
  759.    
  760.   # Fecha conexão.
  761.   close ( SOCKET );
  762.    print "Connection closed!\n";
  763.  
  764. |=[ 0x0d - Threads ]=------------------------------------------------------------------------------=|
  765.  
  766. As vezes quando seu software fica muito grande e com muitas funcionalidades você sente a necessidade
  767. de fazer o uso de multiplos processos ao mesmo instante, para isso existe as threads, ela faz com que
  768. sua função seja aberta em um sub-processo.
  769.  
  770. Para fazer uso de threads em Perl devemos definir o módulo 'Threads'. Segue abaixo um exemplo de
  771. código pronto, utilizando threads.
  772.  
  773.   #!/usr/bin/perl
  774.  
  775.   use Threads; # Módulo necessário para utilização de threads.
  776.  
  777.   # Função que será aberta em sub-processo.
  778.   sub funcao {
  779.      for ( my $a = 0; $a < 5 ; $a++ ) {
  780.            print "[$a] - Thread called: @_[0]\n"; # Exibe mensagem com número do loop e dados passado
  781.                                               # via parametro no momento de criação da thread.
  782.            sleep 1; # Aguarda 1 segundo.
  783.      }
  784.   }
  785.  
  786.   my $thread0 = threads -> create ("funcao", "thread_0"); # Cria thread 1.
  787.   my $thread1 = threads -> create ("funcao", "thread_1"); # Cria thread 2.
  788.   my $thread2 = threads -> create ("funcao", "thread_2"); # Cria thread 3.
  789.  
  790.   print "\nThreads created!\n";
  791.   while (1) { sleep 2; } # Loop infinito.
  792.  
  793. |=[ 0x0e - Orientação a Objetos (POO) ]=-----------------------------------------------------------=|
  794.  
  795. Enfim, chegamos a orientação a objetos na linguagem Perl.
  796. Como você pode notar, aqui no paper procurei não falar muito de teoria e procurar dar mais exemplos
  797. práticos, e o mesmo vai se aplicar a OOP aqui em Perl. Eu particularmente prefiro uma linguagem de
  798. programação estruturada, Perl é uma linguagem muito flexivel, com ela você pode programar tanto com
  799. OOP (Object-oriented programming) ou sem. Mas como o texto tem que ser um pouco decente, tenho a
  800. obrigação de falar sobre OOP aqui.
  801.  
  802. Caso não tem conhecimento algum sobre OOP, pesquise no Google, leia links para que compreenda a lógica.
  803. Segue abaixo o código de uma classe simples, com alguns métodos, o código está todo comentado.
  804.  
  805.   #!/usr/bin/perl
  806.  
  807.   # Define classe.
  808.   package classe;
  809.   {
  810.     # Atributos da classe.
  811.      my $attributes = {
  812.         nome  => undef,
  813.         idade => undef
  814.      };
  815.      
  816.      # Construtor da classe.
  817.      sub new {
  818.         my ($instance, $nome) = @_;
  819.         $attributes -> {nome} = $nome;
  820.         bless $attributes, $instance;
  821.         return $attributes;
  822.      }
  823.      
  824.      # Método 'set_idade'.
  825.      sub set_idade {
  826.         my ($this, $idade) = @_;
  827.         $this -> {idade} = $idade;
  828.      }
  829.      
  830.      # Método 'show'.
  831.      sub show {
  832.         my ($this) = @_;
  833.         print "\n". $this -> {nome} .' tem '. $this -> {idade} ." anos de idade.\n";
  834.      }
  835.   }
  836.  
  837.   # Instancia objeto.
  838.   my $obj = new classe ( 'Constantine' );
  839.   $obj -> set_idade ('20');
  840.   $obj -> show;
  841.  
  842.   # Exibindo dados de atributo de uma classe fora do objeto da mesma.
  843.   print "test if variable is public: \"". $attributes -> {nome} . "\"\n\n";
  844.  
  845. |=[ 0x0f - Finalização e agradecimentos ]=---------------------------------------------------------=|
  846.  
  847. Muito obrigado se você leu esse texto até aqui, espero ter ajudado em algo, o texto é muito superficial
  848. então recomendo que vá no Google e baixe alguns livros e/ou apostilas da linguagem Perl, pois ela
  849. realmente é muito interessante e bem flexivel.
  850.  
  851. Und3rgr0undz f0r3v3r.
  852.  
  853. +-+  EOF  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!