+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       ___                                                            Language: Portuguese Brazilian.
     .'   `"-._                                                                        Encode: UTF-8.
    / ,        `'-.-. 
   / /`'.       ,' _ \
  `-'    `-.  ,' ,'\\/
            \, ,'  ee`-.               Und3rZ1n3 0x01 - Perl para iniciantes.
            / ./  ,(_   \      ,                 Escrito por Constantine, 17 de Janeiro de 2015.
           (_/\\\ \__|`--'     ||                
           ///\\|     \        ||
           ////||-./`-.}    .--||    
              /     `-.__.-`_.-.|                 'A mente que domina a magia dos 
              |      '._,-'`|___}    `;                        bits controla o mundo!'
              /   '.        |/ || ,;'`                                             - Constantine
              |     '.__,.-`   || ':,
              |       |        || ,;'
              /       /     _,.||oOoO.,_
             |        |     \-.O,o_O..-/          Greatz for L1sbeth and P0cl4bs Team.
            /         /     /          \                    https://github.com/P0cL4bs
           |         /     /            \          
           |         |    |      ,       |
           /         |    \   ) (     )  / 
          |           \   ,'.(:, ),: (_.'.
         /            /'.' ="`""="="=="= '.
        `'"---'-.__.'"""`    ` "" "" `""       
                                                                          constantine.sourceforge.net
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

|=[ Tabela de conteúdo ]=--------------------------------------------------------------------------=|
| 0x4A - Apresentação e introdução ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 0x00 - Interpretador ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 0x01 - Comentários ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 0x02 - Módulos ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 0x03 - Variáveis ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 0x04 - Condições ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 0x05 - Repetições ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 0x06 - Operadores e caracteres especiais ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 0x07 - Entrada e saída de dados ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 0x08 - Funções/Sub-rotinas ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 0x09 - Manipulação de variáveis/dados ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 0x0a - Regex ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 0x0b - Manipulação de arquivos ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 0x0c - Sockets ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 0x0d - Threads ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 0x0e - Orientação a Objetos (POO) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 0x0f - Finalização ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|=-------------------------------------------------------------------------------------------------=|

|=[ 0x4A - Apresentação e introdução ]=------------------------------------------------------------=|
  
Olá, prazer, antes de tudo quero me desculpar por meus erros de português.

Se você nunca ouviu falar sobre Perl, tenha em mente que ela é uma linguagem de programação, e uma 
linguagem de programação podemos dizer que são instruções para a máquina (seu computador) executar, 
é basicamente assim que os programas de computador são feitos, apenas um código que contém uma 
sequência de instruções. Caso esteja na dúvida sobre alguns itens citados no texto, não se preocupe 
pois no final tudo fica mais claro.

Neste texto darei uma breve e superficial introdução sobre a Linguagem de Programação Perl. Falarei 
sobre coisas básicas porém essenciais para criação de uma quantidade enorme de softwares.

Sem mais, vamos ao que interessa.

|=[ 0x00 - Interpretador ]=------------------------------------------------------------------------=|

Basicamente, o interpretador da linguagem Perl é o programa responsável por ler nosso código escrito 
na linguagem e executar as instruções diretamente na máquina.

Em ambiente Linux, BSD, *NIX em geral, devemos setar no início de nosso código fonte o texto abaixo, 
o mesmo está dizendo onde se encontra nosso interpretador Perl que será necessário para ler nosso 
código.

   #!/usr/bin/perl
    
Apenas para deixar claro, se por acaso você usa Windows, não se preocupe, basta setar o mesmo texto, 
e quando instalar o Active Perl (faça download do mesmo se não tem instalado em sua máquina), ele vai
converter esse caminho para o caminho do interpretador no Windows, ou seja, por padrão será 
convertido de '#!/usr/bin/perl' para algo como '#!C:\Program Files\Perl\bin\perl.exe'.

E apenas para deixar claro, para executar um programa em perl, abrimos o terminal (ou cmd caso 
esteja no Windows) e digitar o seguinte texto.

   perl programa.pl

Onde 'programa.pl' se refere ao arquivo de texto salvo com o código Perl dentro.

|=[ 0x01 - Comentários ]=--------------------------------------------------------------------------=|

Um comentário é todo texto que deve ser ignorado pelo interpretador da linguagem. Para fazer uso de
comentários em Perl utilizamos o caracter '#' no início da linha. Segue o exemplo abaixo.

   # Isso é um comentário em Perl
   # Este texto será sempre ignorado pelo interpretador.

|=[ 0x02 - Módulos ]=------------------------------------------------------------------------------=|

Os módulos são necessários para poder fazer o uso de determinados itens da linguagem, coisas
como funções, comandos para controles de fluxo, dentre outros. Basicamente para fazer uso de
algum módulo utilizamos o comando 'use'.
Por exemplo, para poder utilizar sockets (Não se preocupe se não souber o que é socket, mais 
para frente falaremos sobre isso) devemos fazer o uso do módulo 'Sockets', para isso fazemos:

    use Sockets;

|=[ 0x03 - Variáveis ]=----------------------------------------------------------------------------=|

Variáveis são regiões frequentemente localizada na memória onde são referenciadas por um nome.
Por exemplo, se queremos armazenar o valor '10' em algum local, devemos utilizar uma variável, o 
mesmo vale para textos e outras coisas. Portanto vamos para alguns exemplos simples, se por acaso eu
queira guardar o texto 'Hello World!' em algum local para fazer uso do mesmo posteriormente, basta eu
criar uma variável com qualquer nome da seguinte maneira.

   my $meu_texto = "Hello World!";
   
Nesse caso acima, nossa variável se chama '$meu_texto', sempre que precisar fazer o uso da mesma,
basta utilizar o nome '$meu_texto' pois dentro dele que se encontra do texto 'Hello World'. No 
exemplo acima fizemos o uso de uma variável para armazenar texto, para armazenar números basta fazer
como no exemplo abaixo.

   my $meu_numero = 10;

Obs: Não foi citado anteriormente, mas o caracter ';' (ponto e virgula) significa o fim de um comando.

Por fim, para armazenar listas, o que podemos e vamos chamar de arrays ou vetores futuramente, fazemos
como no exemplo abaixo.

   my @lista = ( "Item 1 da lista", "Item 2 da lista", "Item 3 da lista" );

Para ter acesso aos itens da do vetor acima, devemos especificar seu indice, onde o mesmo é iniciado 
em 0. Portanto, segue a lógica do 'desenho' abaixo.

   @lista [0] = "Item 1 da lista";
   @lista [1] = "Item 2 da lista";
   @lista [2] = "Item 3 da lista";

Observe que em todos os exemplos de variaveis, sempre que precisamos acesar os dados contidos dentro
delas, utilizamos como referencia o nome da mesma, no caso utilizamos o nome '$meu_texto' para ter 
acesso ao texto 'Hello World!' que estava armazendo 'dentro' dela, no exemplo seguinte, para ter 
acesso ao número '10', utilizamos o nome '$meu_numero', e por fim, no exemplo com vetores, para ter 
acesso a seus itens utilizamos seu indice que é iniciado em 0, '@lista [0]' para ter acesso ao texto
'Item 1 da lista' e assim sucessivamente.

Agora falaremos de um tipo de variável diferente chamada de 'hash', onde podemos especificar o nome
de nossas referencias de uma maneira um pouco diferente. Segue abaixo um exemplo da mesma.

   %minha_hash_variavel = ('nome', 'Constantine', 'idade', '20', 'language', 'Perl');

A maneira de acessar os itens dessa variável segue a seguinte lógica...

   $minha_hash_var{'nome'} contém o texto 'Constantine'.
   $minha_hash_var{'idade'} contém o texto '20'.
   $minha_hash_var{'language'} contém o texto 'Perl'.

|=[ 0x04 - Condições ]=----------------------------------------------------------------------------=|

Para escrever um programa, como são muitas coisas a serem feitas, precisamos de algo onde podemos 
desviar o fluxo dos dados manipulados no programa. Por exemplo, vamos imaginar que nosso programa 
verifica se o computador tem conexão com a internet, dependendo da resposta retornada vamos realizar
alguma ação. Portanto um algoritmo ficaria algo como o exemplo abaixo.

   SE CONEXAO_COM_INTERNET_EXISTE
       FAÇA ALGO
   SE NÂO
       FAÇA OUTRA COISA

Basicamente, o programa acima faz uma verificação, se 'CONEXAO_COM_INTERNET_EXISTE' for verdadeiro,
então entra no 'FAÇA ALGO', caso contrário, se não existir conexão com a internet, ele não deve 
executar o 'FAÇA ALGO' e sim o 'FAÇA OUTRA COISA'.

Em Perl para controle de condições temos o comando 'if', 'elsif' e 'else'. Vamos para alguns códigos
de exemplo. No código abaixo, criamos uma variável com o valor 10 e verificamos se o valor atribuido
a ela é maior que 5.

   my $variavel = 10;
    
    if ( $variavel > 5 ) {
      # Aqui entra o código a ser executado se por acaso a '$variavel' for maior que 5.
    }

Lembrando que toda linha que começar com o caracter '#' significa que é um comentário e isso não é
interpretado como código.

Observe que fizemos apenas o uso do comando 'if', o caracter '>' significa 'maior que', portanto o 
código 'if ( $variavel > 5 )' seria o equivalente a 'SE $variavel É MAIOR QUE 5' e se for verdadeiro,
ou seja, se realmente o valor que está armazenado na '$variavel' for maior que 5, execute o bloco de
código que está dentro dos chaves { }, uma abre o bloco de código '}' e a outra fecha o bloco '}'.

No exemplo seguinte vamos fazer uso do 'if' e do 'else'.

   my $variavel = 4;
    
    if ( $variavel > 5 ) {
      # Aqui entra o código a ser executado se por acaso a '$variavel' for maior que 5.
    }
   else {
      # O valor armazenado em '$variavel' não é maior que 5, então executado esse bloco de código.
   }

Se por acaso a '$variavel' não for maior que 5, automaticamente o 'else' é executado.
Agora vamos fazer um exemplo, utilizando o 'if', 'elsif' e 'else', segue o exemplo abaixo.

   my $variavel = 3;
    
    if ( $variavel > 5 ) {
      # Executa esse bloco de código se o valor armazenado em '$variavel' for maior que 5.
    }
    elsif ( $variavel < 2 ) {
      # Executa esse bloco de código se o valor armazenado em '$variavel' for menor que 2.
   }
   else {
      # Nenhuma das condições acima foi dada como verdadeira, por padrão, executa então o 'else'.
      # Sendo ele esse bloco de código.
   }

A lógica das condições acima na verdade é bem simples e apenas uma será executada, ou seja, se o
primeiro 'if' for verdadeiro, então executa apenas ele e não será executado o 'elsif' e nem o 'else'.

Para controle de condições temos também o comando 'unless', vamos seguir o raciocínio, o 'if' em sua
natureza significa 'SE FOR VERDADE', vamos pegar como exemplo o 'if' do exemplo acima.

   if ( $variavel > 5 ) { ...

No 'if' acima, observe que fazemos o uso de colchetes ( ), ou seja, a expressão definida dentro dos 
colchetes será analizada, e se o resultado for verdadeiro, ai sim ele executa o bloco de código.

Basicamente o 'if' faz uma 'pergunta', sendo algo como.

   'É VERDADE QUE O VALOR ARMAZENADO EM $variavel É MAIOR QUE 5?'

Se a resposta for verdadeira, ou seja, se realmente o valor armazenado em '$variavel' for mesmo maior
que 5, então executa o bloco de código.
O comando unless funciona com a lógica contrária, ou seja, ao invés de pergunta 'SE É VERDADE...' ele
pergunta 'SE NÃO É VERDADE', vamos a um exemplo prática.

   my $variavel = 7;
   
   unless ( $variavel < 5 ) {
      # Executa bloco de código se o conteúdo armazenado em '$variavel' NÃO for menor que 5.
      # Esse bloco de código será executado pois '$variavel' não é menor que 5, ela contém o valor 7.
   }

Para deixar mais claro, o comando acima é lido da seguinte maneira: 'SE O CONTEÚDO ARMAZENADO EM 
$variavel NÃO FOR MENOR QUE 5...', se essa expressão como um todo é verdadeira, ou seja, se 
realmente o conteúdo armazenado em '$variavel' não for menor que 5, então o bloco de código ( que 
é os dados entre as chaves) é executado.

E por fim, para terminar os comandos utilizados para trabalhar com condições, vamos falar agora do
'switch', para fazer o uso do mesmo, é necessário declarar um módulo chamado 'Switch' e para isso 
fazemos como no exemplo abaixo.

   use Switch;

Vamos então para um exemplo de uso do comando 'switch'. O código ao todo ficaria.

   #!/usr/bin/perl
   use Switch;

   my $variavel = 1;
   
   switch ( $variavel ) {
      case (0) {
         # Esse bloco de código não será executado, pois '$variavel' não é igual a 0.
      }
      
      case (1) {
         # Esse bloco de código será executado, pois '$variavel' é igual a 1.
      }
      
      case (2) {
         # Esse bloco de código não será executado, pois '$variavel' não é igual a 2.
      }
      
      else {
         # Esse bloco de código não será executado, pois '$variavel' é igual a 1 e já existe o 'case (1)' para isso.
         # Mas se por acaso nenhum dos 'case' acima fosse dado como verdadeiro, então esse 'else' aqui seria executado.
      }
   }
    
A lógica do 'switch' na verdade é muito simples, ele avalia o valor que está armazenado em '$variavel'
e tem os 'case' para achar o valor representado, portanto 'case (1)' equivale a 'SE O VALOR EM $variavel
É IGUAL A 1...', ai entro no bloco de código.

Para testar o código, basta salvar com algum nome qualquer, por exemplo, 'programa.pl' ou pode ser 
'programa.txt', em seguida abrir o terminal (ou cmd, caso esteja no Windows) e rodar o programa.

   perl programa.pl
    
   ou
    
   perl programa.txt

|=[ 0x05 - Repetições ]=---------------------------------------------------------------------------=|

Repetições podemos dizer que são blocos de códigos, onde seus valores são sendo modificados em tempo
real, e para não escrever centenas ou milhares de linhas, utilizamos algum comando de repetição, para
resumir essa instruçao (ou sequência de instruções, como queira chamar) de código.

Vamos falar aqui nessa área de repetição sobre 3 comandos, sendo eles o 'for', 'while' e 'foreach'.   
Vamos começar com o comando 'for'.

O comando 'for' é repartido em 3 partes, onde elas são separadas por ';' (ponto e virgula).
Basicamente seria assim seu algoritmo.

   for ( INICIALIZAÇÃO ; CONDIÇÃO ; INCREMENTO ) {
      # bloco de código que será executado enquando a CONDIÇÃO for VERDADEIRA.
   }

Vamos para um exemplo prático para que fique mais claro.
No exemplo abaixo vamos criar uma variável com o valor 0 e utilizar ela em nosso for.
Essa variável será incrementada em 1, ou seja, a cada vez que o bloco de código for repetido será 
somado mais 1 nessa variável.

   my $variavel = 0;
   
   for ( $variavel = 0; $variavel <= 10 ; $variavel = $variavel + 1 ) {
      # Bloco de código que será executado até que '$variavel <= 10', ou seja, até que o valor armazenado
      # em '$variavel' seja menor ou igual a 10. Após isso, ou seja, a partir do momento em que o valor
      # armazenado em '$variavel' for maior que 10, o for será encerrado e esse bloco de código irá parar
      # de ser executado.
   }

Lembrando que o 'for' é dividido em três partes sendo elas separadas por ';' (ponto e virgula).
No início do 'for' temos então a 'INICIALIZAÇÃO', sendo ela representada por '$variavel = 0', onde 
a '$variavel' é inicializada com o valor 0.

Após isso temos a parte do meio do 'for', sendo ela a 'CONDIÇÃO', representada por '$variavel <= 10',
essa condição seria parecida com o 'if', é como se a cada vez que o bloco de código fosse executado o 
'for' verificasse 'SE O VALOR EM $variavel É MENOR OU IGUAL A 10', quando o valor armazenado em 
'$variavel' for maior que 10, ou seja, quando deixar de ser 'menor ou igual a 10', o 'for' é encerrado 
e o bloco de código deixa de ser executado repetidas vezes.

Por fim, temos a parte final do 'for', sendo ela representada por '$variavel = $variavel + 1', a cada
vez que o bloco de código é executado (lembrando que o mesmo é executado até que a CONDIÇÃO seja falsa)
o INCREMENTO é também executado, ou seja, a cada vez que o 'for' é executado o valor especificado em
'$variavel' é incrementada em 1, sendo assim, somado 1 na própria variável.

Para deixar claro, o 'for' de exemplo acima é executado 10 vezes e depois finalizado.
Vamos agora falar do comando 'while'.

O comando 'while' é executado até que sua EXPRESSÃO seja dada como falsa, ou seja, ele sempre ficará
executando seu bloco de código até que sua expressão seja dada como falsa ou você force a parada dele.
Segue abaixo o algoritmo do comando 'while'.

   while ( EXPRESSÃO ) {
      # Executa bloco de código até que a EXPRESSÃO seja falsa.
   }
   
Vamos para um exemplo prático.

   my $variavel = 0;

   while ( $variavel <= 10 ) {
      # Executa bloco de código até que o valor armazenado em '$variavel' seja menor ou igual a 10.
         $variavel = $variavel + 1;
   }
   
Observe que a '$variavel' foi definida fora do 'while' com o valor 0, dentro do bloco de código do 
'while' a '$variavel' é sempre incrementada em 1 assim como na parte de INCREMENTO de nosso 'for'
de exemplo anterior. O 'while' ficará sempre sendo executado até que o valor armazenado em 
'$variavel' seja menor ou  igual a 10.

Por fim, vamos fazer uso do comando 'foreach'.
Um algoritmo para o 'foreach' poderia ser algo como o exemplo abaixo.

   foreach INDICE ( DADOS ) {
      # Executa bloco de código enquanto exitir dados.
   }

Vamos para um exemplo prático. No exemplo abaixo estamos percorrendo os itens de um vetor do início 
ao fim do mesmo.

   @lista = ( 'uva', 'goiaba', 'laranja' );

   foreach $indice ( @lista ) {
      # Usar a variável '$indice' para acessar os itens da '@lista'.
   }

O bloco de código do comando 'foreach' acima será executado 3 vezes, a variável '$indice' estará 
apontando para um item da '@lista'. Segue o exemplo abaixo para deixar mais claro.

   primeira execução do bloco de código = $indice contém o valor 'uva'.
   segunda execução do bloco de código  = $indice contém o valor 'goiaba'.
   terceira execução do bloco de código = $indice contém o valor 'laranja'.

|=[ 0x06 - Operadores e caracteres especiais ]=----------------------------------------------------=|

Como vemos nos comandos exemplos de códigos dos tópicos acima, utilizamos coisas como '<=', '>' e '<',
onde significam 'menor ou igual', 'maior que', 'menor que', etc.

Agora vou dar para vocês mais detalhes sobre os operadores existentes na linguagem Perl.
Segue abaixo uma lista dos símbolos e sua descrição falando sobre a funcionalidade do mesmo.

   Operadores matemáticos.
   +            Soma
   -            Subtrai
   *            Multiplica
   /            Divisão
   **           Potenciação
   %            Resto da divisão
   
   Operadores para incremento e decremento.
   $a++         Retorna variável '$a' e depois incrementa.
   ++$a         Incrementa variável '$a' e depois retorna.
   $a--         Retorna variável '$a' e depois decrementa.
   --$a         Decrementa variável '$a' e depois retorna.
   
   Operadores para strings/textos.
   .            Concatena.
   x            Repete texto.
   
   Operadores para determinar valores.
   $a = $b      Atribui o valor de '$b' em '$a'.
   $a += $b     Soma o valor de '$b' ao valor de '$a'.
   $a -= $b     Subtrai o valor de '$b' ao valor de '$a'.
   $a .= $b     Concatena o valor de '$b' em '$a'.
   $a == $b     Compara o valor de '$a' com '$b'.

Não se preocupe em decorar os operadores, com o tempo e prática tudo fica muito mais simples.
Os caracteres especiais são utilizados em strings. Segue abaixo os caracteres especiais e sua descrição.

   \n           Nova linha.
   \r           Retorno \ Carriage return.
   \b           Backspace.
   \a           Emite beep (alert, alarm).
   \t           Tabulação.
   \e           Caracter ESC.

Existem outros caracteres especiais, em caso de duvida consulte a referencia da Linguagem Perl em
seu site oficial.

|=[ 0x07 - Entrada e saída de dados ]=-------------------------------------------------------------=|

Como o que estamos fazendo é escrever software, obviamente temos de ter meios para o usuário entrar
com dados, como também temos de ter meios para exibir os dados (saida dos dados).

Para isso vamos por partes, primeiro vamos ver como podemos fazer para receber dados via linha de comando.
Para isso fazemos o uso da variável @ARGV. Onde seu indice é inicializado em 0. Segue abaixo um exemplo.

   perl script.pl parametro01 parametro02 parametro03

Na variável @ARGV automaticamente será setado os valores dos parametros e como foi dito, tendo sua
indexação inciada em 0. Portanto segue a abaixo os indeces da variável e seus respectivos valores.

   @ARGV [0] contém o valor "parametro01"
   @ARGV [1] contém o valor "parametro02"
   @ARGV [2] contém o valor "parametro03"

Para entrada de dados enquanto o programa estiver executando, utilizando o '<STDIN>'.
Basta definir uma variável atribuindo para ela como valor o '<STDIN>'. O programa irá 'pausar', ele
vai ficar aguardando o usuário digitar algo e pressionar enter, após o pressionamento da tecla enter
o programa prossegue normalmente. Segue abaixo um exemplo com '<STDIN>'.

   my $variavel = '<STDIN>';
    
Por fim, para exibir dados na tela (saida de dados), podemos fazer uso do print. Sendo ela (o print)
na verdade uma função que pega seus dados e envia para saida de dado padrão (que no caso é o terminal
(ou console caso esteja no Windows)).

Para usar a função é simples, vamos por exemplo exibir um texto na tela. Para isso fazemos como o 
exemplo abaixo.

   print "Esse texto será exibido na tela!\n";
    
Obs: O caracter '\n' no final do texto, significa que após exibir o texto ele vai pular uma linha.

|=[ 0x08 - Funções/Sub-rotinas ]=------------------------------------------------------------------=|

Podemos dizer que uma função ou sub-rotina consiste em um bloco de código, onde o mesmo pode ou não
retornar um valor, mas geralmente na maioria dos casos é utilizadas pra resolver um problema especifico
ou apenas para deixar o código mais organizado, digamos em áreas.
Uma função em Perl começa com a palavra 'sub', a sintaxe seria.

   sub nome_da_funcao {
      # Código da função aqui.
   }

Abaixo um exemplo de uma função que não recebe parametros e apenas exibe uma mensagem na tela com a
função print.

   sub exibe_mensagem {
      print "Hello World!\n";
   }
   
Para chamar a função, basta escrever o nome da mesma seguida do ponto e virgula para indicar termino
do comando. Como no exemplo abaixo.

   exibe_mensagem;

Agora vamos ver um exemplo de uma função que recebe parametros, vamos fazer uma função que recebe como
parametros dois números para que seja realizado uma soma, em seguida, exibir o resultado na tela.

  sub funcao_somar {
    @argv = @_; # Processa argumentos recebidos.
    
    $a = $argv[0]; # Primeiro item passado via parametro, no caso o valor 10.
    $b = $argv[1]; # Segundo item passado via parametro, no caso o valor 20.
    $c = $a + $b;  # Armazena o resultado da soma, que no caso é 10 + 20.
    
    print $c . "\n"; # Exibe o resultado na tela com a função print.
  }
  
  funcao_somar ( 10, 20 ); # Chama função passando como parametro os valores 10 e 20.
   
Observe que utilizamos o . (ponto) para concatenar os dados, mais para frente vamos falar mais sobre
isso. O resultado exibe na tela é 30.

Por fim, vamos ver um simples exemplo de uma função que retorne algo, em Perl, como não temos tipos 
de dados definidos podemos retornar qualquer coisa, tanto strings como números. Para isso basta fazer
uso do comando 'return'. Vamos usar como exemplo a função acima, porém, ao invés de exibir uma mensagem
na tela, vamos retornar a mensagem para que a função 'print' seja chamada fora da 'funcao_somar'.

  sub funcao_somar {
    @argv = @_; # Processa argumentos recebidos.
    
    $a = $argv[0]; # Primeiro item passado via parametro, no caso o valor 10.
    $b = $argv[1]; # Segundo item passado via parametro, no caso o valor 20.
    $c = $a + $b;  # Armazena o resultado da soma, que no caso é 10 + 20.
    
    return $c . "\n"; # Concatena dados e retorna para local que a chamou.
  }
  
  print funcao_somar ( 10, 20 ); # Chama função print passando como parametro outra função, onde
                                 # a mesma retorna os dados que serão exibidos, sendo esses dados
                                 # o resultado da soma de 10 + 20. O número 30 é exibido na tela.

|=[ 0x09 - Manipulação de variáveis/dados ]=-------------------------------------------------------=|

Não vamos nos aprofundar muito na manipulação dos dados, darei aqui apenas alguns exemplos simples de
como realizar algumas ações muito uteis no dia-a-dia. Vamos lá.

Para comparação de inteiros, como já foi citado no tópico de '0x06 - Operadores e caracteres especiais'
o operador '==' que significa 'se for igual'. Segue abaixo um exemplo.

   my $a = 10;
   my $b = 10;
   
   if ( $a == $b ) {
      print "Variavel A e igual a variavel B.\n";
   }
   else {
      print "Variaveis com valores diferentes.\n";
   }

Para comparação de strings utilizamos o operador '=~', vamos para um exemplo.

   my $string_a = 10;
   my $string_b = 10;
   
   if ( $string_a =~ $string_b ) {
      print "Variavel STRING_A e igual a variavel STRING_B.\n";
   }
   else {
      print "Variaveis com valores diferentes.\n";
   }

Para concatenação de inteiros e strings utilizamos o . (ponto). Vamos para um exemplo.

   my $string_a = "texto 01";
   my $string_b = "texto 02";
   my $string_c = $string_a . " " . $string_b . "\n";

   print $string_c; # Exibe mensagem: 'texto 01 texto 02'.

Outro método de concatenar é utilizar o '.='. Vamos para um exemplo.

   my $string_a = "texto 01";
   my $string_b = "texto 02";
   my $string_c = "";

   $string_c .= $string_a;
   $string_c .= " ";
   $string_c .= $string_b;
   $string_c .= "\n";
   
   print $string_c; # Exibe mensagem: 'texto 01 texto 02'.

Procura string dentro de outra. Vamos para um exemplo.

   my $string = "Esse eh meu texto onde vou procurar algo dentro dele!";
   if ( index ( $string, "texto" ) ) {
      print "Achou 'texto' dentro da string.\n";
   }
   else {
      print "Nada foi encontrado.\n";
   }

|=[ 0x0a - Regex ]=--------------------------------------------------------------------------------=|

Não vamos nos aprofundar também no uso das regex, pois existem muitas. Darei alguns exemplos para 
mostrar como seria o uso simples de regex em Perl, inclusive Perl é muito famosa por ser extremamente
flexivel nessa questão, o que faz Perl uma das linguagens preferidas entre os sysadmins.

Verifica se existem as letras de 'a' até 'z' maiúsculo e minúsculo.

   my $variavel = "Testando palavra.";

   if ($variavel =~ /[a-zA-Z]/) {
      print "Isso e uma palavra\n";
   }
    
Verifica se são apenas números.

   my $variavel = "0123456789";

   if ($variavel =~ /[0-9]/) {
      print "Isso é apenas números\n";
   }

Recomendo que busquem informação no Google sobre o uso de Regex em Perl pois realmente tem muita coisa
interessante.

|=[ 0x0b - Manipulação de arquivos ]=--------------------------------------------------------------=|

Vamos ver agora como podemos para realizar ações simples com arquivos. Coisas como ler e escrever em
arquivo de texto. Para isso vamos utilizar a função 'open' para abrir o arquivo e a função 'close'
para fechar o mesmo, dentre outras.

Segue abaixo um exemplo onde escrevemos um buffer no arquivo de texto.

   #!/usr/bin/perl
   
   # Buffer que será salvo.
   @lista = (
      "Meu buffer numero 01\n",
      "Meu buffer numero 02\n",
      "Meu buffer numero 03\n"
   );
   
   # Abre arquivo para escrita.
   open (my $handle, ">", "arquivo.txt");
    
   # Salva dados no arquivo.
   print {$handle} @lista;
    
   # Fecha arquivo.
   close ($handle);
   
Segue abaixo um exemplo onde lemos o conteúdo de um arquivo de texto.

   #!/usr/bin/perl
   
   # Abre arquivo para escrita.
   open (my $handle, "<", "arquivo.txt");
    
   # Percorre arquivo de texto.
   while (<$handle>) {
      print "$_"; # '$_' é uma variável interna. 
   }
    
   # Fecha arquivo.
   close ($handle);
    
Verifica se determinado arquivo ou diretório existem.
   if (-e "arquivo.txt") {
      print "arquivo.txt existe!\n";
   }
   
Renomeando arquivos com tratamento de erro (função die).
   rename ("arquivo.txt", "arquivo_rename.txt") || die ("Nao foi possivel renomear arquivos.\n");
   
Copia arquivo.
   copy ("arquivo_rename.txt", "arquivo_rename_2.txt");
   move ("arquivo_rename_2.txt", "arquivo_rename.txt");
   
Deleta arquivos.
   unlink ("arquivo_rename.txt");
    
Deletar diretórios.
   rmdir ("diretorio");
   
Ler conteúdo de diretório.

   opendir ($handle, "."); # Abre diretorio atual.
   @files = readdir ($handle);
   
   foreach (@files) {
      print "file: $_\n";
   }
   closedir ($handle); # Fecha diretorio.
   
Criar diretorio.
   mkdir ("newdir", 0777) || print "Nao foi possivel criar diretorio.\n";
    
|=[ 0x0c - Sockets ]=------------------------------------------------------------------------------=|

Para estabelecer qualquer gênero de conexão com outro computador da internet, é necessário fazer uso
de sockets independente da linguagem de programação. Recomendo que pesquise sobre sockets e aprenda 
o máximo possível. Vou aqui dar dois exemplos de uso de sockets.
Lembrando que para fazer uso de sockets em Perl, devemos declarar o módulo 'Socket'.

Exemplo de conexão simples com IRC.

   # Módulo necessário para utilizar sockets.
   use Socket;

   # Endereço e porta do IRC.
   my $host = "irc.freenode.net";
   my $port = 6667;
   my $name = "bot_nick_666";
   
   print "Conectando no IRC...\n";
    
   # Criando conexão.
   socket ( SOCKET, PF_INET, SOCK_STREAM, (getprotobyname('tcp'))[2] ) or 
      die "Can't create a socket!\n";
   
   # Conecta em host.
   connect ( SOCKET, pack_sockaddr_in($port, inet_aton($host)) ) or 
      die "Can't connect to port $port!\n";
   
   print "Connected on $host $port\n";
   
   # Envia dados para servidor IRC.
   send ( SOCKET, "NICK $name\r\n", 0 );
   send ( SOCKET, "USER $name * * :$name\r\n", 0 );
   send ( SOCKET, "QUIT\r\n", 0 );
   
   print "Quiting IRC...\nConnection closed!\n";
    
   # Fecha conexão.
   close ( SOCKET );
    
Exemplo de conexão com website.

   # Módulo necessário para utilizar sockets.
   use Socket;

   # Endereço e porta.
   my $host = "google.com";
   my $port = 80;
   
   print "Conectando no IRC...\n";
    
   # Criando conexão.
   socket ( SOCKET, PF_INET, SOCK_STREAM, (getprotobyname('tcp'))[2] ) or 
      die "Can't create a socket!\n";
   
   # Conecta em host.
   connect ( SOCKET, pack_sockaddr_in($port, inet_aton($host)) ) or 
      die "Can't connect to port $port!\n";
   
   @header = (
      "GET / HTTP/1.1\r\n",
      "Host: google.com\r\n",
      "User-Agent: Mozilla/5.0 (Windows NT 6.1; rv:33.0) Gecko/20100101 Firefox/33.0\r\n",
      "Connection: Close\r\n\r\n"
   );
   
   # Envia dados para servidor.
   foreach my $index (@header) {
      send ( SOCKET, $index, 0 );
   }
   
   # Recebe dados do servidor.
   while (<SOCKET>) {
      print "$_";
   }
    
   # Fecha conexão.
   close ( SOCKET );
    print "Connection closed!\n";
   
|=[ 0x0d - Threads ]=------------------------------------------------------------------------------=|

As vezes quando seu software fica muito grande e com muitas funcionalidades você sente a necessidade
de fazer o uso de multiplos processos ao mesmo instante, para isso existe as threads, ela faz com que
sua função seja aberta em um sub-processo.

Para fazer uso de threads em Perl devemos definir o módulo 'Threads'. Segue abaixo um exemplo de
código pronto, utilizando threads.

   #!/usr/bin/perl

   use Threads; # Módulo necessário para utilização de threads.

   # Função que será aberta em sub-processo.
   sub funcao {
      for ( my $a = 0; $a < 5 ; $a++ ) {
            print "[$a] - Thread called: @_[0]\n"; # Exibe mensagem com número do loop e dados passado
                                               # via parametro no momento de criação da thread.
            sleep 1; # Aguarda 1 segundo.
      }
   }

   my $thread0 = threads -> create ("funcao", "thread_0"); # Cria thread 1.
   my $thread1 = threads -> create ("funcao", "thread_1"); # Cria thread 2.
   my $thread2 = threads -> create ("funcao", "thread_2"); # Cria thread 3.

   print "\nThreads created!\n";
   while (1) { sleep 2; } # Loop infinito.

|=[ 0x0e - Orientação a Objetos (POO) ]=-----------------------------------------------------------=|

Enfim, chegamos a orientação a objetos na linguagem Perl.
Como você pode notar, aqui no paper procurei não falar muito de teoria e procurar dar mais exemplos
práticos, e o mesmo vai se aplicar a OOP aqui em Perl. Eu particularmente prefiro uma linguagem de
programação estruturada, Perl é uma linguagem muito flexivel, com ela você pode programar tanto com
OOP (Object-oriented programming) ou sem. Mas como o texto tem que ser um pouco decente, tenho a
obrigação de falar sobre OOP aqui.

Caso não tem conhecimento algum sobre OOP, pesquise no Google, leia links para que compreenda a lógica.
Segue abaixo o código de uma classe simples, com alguns métodos, o código está todo comentado.

   #!/usr/bin/perl

   # Define classe.
   package classe; 
   {
     # Atributos da classe.
      my $attributes = {
         nome  => undef,
         idade => undef
      };
      
      # Construtor da classe.
      sub new {
         my ($instance, $nome) = @_;
         $attributes -> {nome} = $nome;
         bless $attributes, $instance;
         return $attributes;
      }
      
      # Método 'set_idade'.
      sub set_idade {
         my ($this, $idade) = @_;
         $this -> {idade} = $idade;
      }
      
      # Método 'show'.
      sub show {
         my ($this) = @_;
         print "\n". $this -> {nome} .' tem '. $this -> {idade} ." anos de idade.\n";
      }
   }
   
   # Instancia objeto.
   my $obj = new classe ( 'Constantine' );
   $obj -> set_idade ('20');
   $obj -> show;
   
   # Exibindo dados de atributo de uma classe fora do objeto da mesma.
   print "test if variable is public: \"". $attributes -> {nome} . "\"\n\n";

|=[ 0x0f - Finalização e agradecimentos ]=---------------------------------------------------------=|

Muito obrigado se você leu esse texto até aqui, espero ter ajudado em algo, o texto é muito superficial
então recomendo que vá no Google e baixe alguns livros e/ou apostilas da linguagem Perl, pois ela 
realmente é muito interessante e bem flexivel.

Und3rgr0undz f0r3v3r.

+-+  EOF  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+