Perl - Guia Rápido

Perl é uma linguagem de programação de propósito geral desenvolvida originalmente para manipulação de texto e agora usada para uma ampla gama de tarefas, incluindo administração de sistema, desenvolvimento da Web, programação de rede, desenvolvimento de GUI e muito mais.

O que é Perl?

Perl é uma linguagem de programação multiplataforma estável.
Embora Perl não seja oficialmente um acrônimo, poucas pessoas o usaram como Practical Extraction and Report Language.
É usado para projetos de missão crítica nos setores público e privado.
Perl é um software de código aberto, licenciado sob sua Licença Artística ou GNU General Public License (GPL) .
Perl foi criado por Larry Wall.
Perl 1.0 foi lançado para alt.comp.sources da usenet em 1987.
No momento em que este tutorial foi escrito, a versão mais recente do perl era 5.16.2.
Perl está listado no Oxford English Dictionary .

A PC Magazine anunciou a Perl como finalista do Prêmio de Excelência Técnica de 1998 na categoria Ferramenta de Desenvolvimento.

Recursos Perl

Perl obtém os melhores recursos de outras linguagens, como C, awk, sed, sh e BASIC, entre outras.
A interface de integração de banco de dados Perls DBI oferece suporte a bancos de dados de terceiros, incluindo Oracle, Sybase, Postgres, MySQL e outros.
Perl funciona com HTML, XML e outras linguagens de marcação.
Perl oferece suporte a Unicode.
Perl é compatível com o ano 2000.
Perl suporta programação procedural e orientada a objetos.
Perl faz interface com bibliotecas C / C ++ externas por meio de XS ou SWIG.
Perl é extensível. Existem mais de 20.000 módulos de terceiros disponíveis na Comprehensive Perl Archive Network ( CPAN ).
O interpretador Perl pode ser embutido em outros sistemas.

Perl e a web

Perl costumava ser a linguagem de programação web mais popular devido às suas capacidades de manipulação de texto e ciclo de desenvolvimento rápido.
Perl é amplamente conhecido como " a fita adesiva da Internet ".
Perl pode lidar com dados criptografados da Web, incluindo transações de e-commerce.
Perl pode ser embutido em servidores web para acelerar o processamento em até 2.000%.
O mod_perl do Perl permite que o servidor web Apache incorpore um interpretador Perl.
O pacote DBI do Perl facilita a integração do banco de dados da web.

Perl é interpretado

Perl é uma linguagem interpretada, o que significa que seu código pode ser executado como está, sem um estágio de compilação que cria um programa executável não portátil.

Os compiladores tradicionais convertem programas em linguagem de máquina. Quando você executa um programa Perl, ele primeiro é compilado em um código de byte, que é então convertido (conforme o programa é executado) em instruções de máquina. Portanto, não é exatamente o mesmo que shells, ou Tcl, que sãostrictly interpretado sem uma representação intermediária.

Também não é como a maioria das versões de C ou C ++, que são compiladas diretamente em um formato dependente da máquina. Ele está em algum lugar no meio, junto com os arquivos Python e awk e Emacs .elc.

Antes de começarmos a escrever nossos programas Perl, vamos entender como configurar nosso ambiente Perl. Perl está disponível em uma ampla variedade de plataformas -

Unix (Solaris, Linux, FreeBSD, AIX, HP / UX, SunOS, IRIX etc.)
Win 9x / NT / 2000 /
WinCE
Macintosh (PPC, 68K)
Solaris (x86, SPARC)
OpenVMS
Alpha (7.2 e posterior)
Symbian
Debian GNU / kFreeBSD
MirOS BSD
E muitos mais...

É mais provável que o seu sistema tenha perl instalado. Apenas tente dar o seguinte comando no prompt $ -

$perl -v

Se você tiver o perl instalado em sua máquina, receberá uma mensagem como a seguinte -

This is perl 5, version 16, subversion 2 (v5.16.2) built for i686-linux

Copyright 1987-2012, Larry Wall

Perl may be copied only under the terms of either the Artistic License or the
GNU General Public License, which may be found in the Perl 5 source kit.

Complete documentation for Perl, including FAQ lists, should be found on
this system using "man perl" or "perldoc perl".  If you have access to the
Internet, point your browser at http://www.perl.org/, the Perl Home Page.

Se você ainda não tem o perl instalado, prossiga para a próxima seção.

Obtendo a instalação do Perl

O código-fonte, binários, documentação, notícias, etc. mais atualizados e atuais estão disponíveis no site oficial do Perl.

Perl Official Website - https://www.perl.org/

Você pode baixar a documentação do Perl no site a seguir.

Perl Documentation Website - https://perldoc.perl.org

Instale Perl

A distribuição Perl está disponível para uma ampla variedade de plataformas. Você precisa baixar apenas o código binário aplicável à sua plataforma e instalar o Perl.

Se o código binário para sua plataforma não estiver disponível, você precisa de um compilador C para compilar o código-fonte manualmente. Compilar o código-fonte oferece mais flexibilidade em termos de escolha de recursos que você precisa em sua instalação.

Aqui está uma rápida visão geral da instalação do Perl em várias plataformas.

Instalação Unix e Linux

Aqui estão as etapas simples para instalar o Perl em uma máquina Unix / Linux.

Abra um navegador da Web e vá para https://www.perl.org/get.html.
Siga o link para baixar o código-fonte compactado disponível para Unix / Linux.
Baixar perl-5.x.y.tar.gz arquivo e emita os seguintes comandos no prompt $.

$tar -xzf perl-5.x.y.tar.gz
$cd perl-5.x.y $./Configure -de
$make $make test
$make install

NOTE - Aqui $ é um prompt Unix onde você digita seu comando, então certifique-se de não digitar $ enquanto digita os comandos mencionados acima.

Isso instalará o Perl em um local padrão / usr / local / bin e suas bibliotecas serão instaladas em / usr / local / lib / perlXX , onde XX é a versão do Perl que você está usando.

Demorará um pouco para compilar o código-fonte após emitir o makecomando. Assim que a instalação for concluída, você pode emitirperl -vcomando no prompt $ para verificar a instalação do perl. Se tudo estiver bem, ele exibirá uma mensagem como mostramos acima.

Instalação Windows

Aqui estão as etapas para instalar o Perl em uma máquina Windows.

Siga o link para a instalação do Strawberry Perl no Windows http://strawberryperl.com
Baixe a versão de instalação de 32 bits ou 64 bits.
Execute o arquivo baixado clicando duas vezes no Windows Explorer. Isso abre o assistente de instalação do Perl, que é realmente fácil de usar. Apenas aceite as configurações padrão, espere até que a instalação seja concluída e você esteja pronto para começar!

Instalação Macintosh

Para construir sua própria versão do Perl, você precisará de 'make', que faz parte das ferramentas de desenvolvedor da Apple normalmente fornecidas com os DVDs de instalação do Mac OS. Você não precisa da versão mais recente do Xcode (que agora é cobrada) para instalar o make.

Aqui estão as etapas simples para instalar o Perl em uma máquina Mac OS X.

Abra um navegador da Web e vá para https://www.perl.org/get.html.
Siga o link para baixar o código-fonte compactado disponível para Mac OS X.
Baixar perl-5.x.y.tar.gz arquivo e emita os seguintes comandos no prompt $.

$tar -xzf perl-5.x.y.tar.gz
$cd perl-5.x.y $./Configure -de
$make $make test
$make install

Isso instalará o Perl em um local padrão / usr / local / bin e suas bibliotecas serão instaladas em / usr / local / lib / perlXX , onde XX é a versão do Perl que você está usando.

Executando Perl

A seguir estão as diferentes maneiras de iniciar o Perl.

Intérprete Interativo

Pode entrar perle comece a codificar imediatamente no interpretador interativo, iniciando-o na linha de comando. Você pode fazer isso a partir do Unix, DOS ou qualquer outro sistema, que forneça um interpretador de linha de comando ou janela de shell.

$perl  -e <perl code>           # Unix/Linux

or 

C:>perl -e <perl code>          # Windows/DOS

Aqui está a lista de todas as opções de linha de comando disponíveis -

Sr. Não.	Opção e descrição
1	-d[:debugger] Executa o programa no depurador
2	-Idirectory Especifica o diretório @ INC / # include
3	-T Ativa verificações de contaminação
4	-t Ativa avisos de contaminação
5	-U Permite operações inseguras
6	-w Ativa muitos avisos úteis
7	-W Ativa todos os avisos
8	-X Desativa todos os avisos
9	-e program Executa o script Perl enviado como programa
10	file Executa o script Perl de um determinado arquivo

Script da linha de comando

Um script Perl é um arquivo de texto, que mantém o código perl nele e pode ser executado na linha de comando chamando o interpretador em seu aplicativo, como a seguir -

$perl  script.pl          # Unix/Linux

or 

C:>perl script.pl         # Windows/DOS

Ambiente de desenvolvimento integrado

Você também pode executar o Perl a partir de um ambiente de interface gráfica com o usuário (GUI). Tudo que você precisa é de um aplicativo GUI em seu sistema que suporte Perl. Você pode baixar o Padre, o Perl IDE . Você também pode usar o Eclipse Plugin EPIC - Perl Editor e IDE para Eclipse se estiver familiarizado com o Eclipse.

Antes de prosseguir para o próximo capítulo, certifique-se de que seu ambiente esteja configurado corretamente e funcionando perfeitamente bem. Se você não conseguir configurar o ambiente adequadamente, peça ajuda ao administrador do sistema.

Todos os exemplos dados nos capítulos subsequentes foram executados com a versão v5.16.2 disponível no tipo CentOS do Linux.

Perl empresta sintaxe e conceitos de muitas linguagens: awk, sed, C, Bourne Shell, Smalltalk, Lisp e até inglês. No entanto, existem algumas diferenças definidas entre os idiomas. Este capítulo foi projetado para ajudá-lo a entender rapidamente a sintaxe esperada em Perl.

Um programa Perl consiste em uma sequência de declarações e instruções, que são executadas de cima para baixo. Loops, sub-rotinas e outras estruturas de controle permitem que você pule dentro do código. Cada instrução simples deve terminar com um ponto e vírgula (;).

Perl é uma linguagem de forma livre: você pode formatar e recuar como quiser. O espaço em branco serve principalmente para separar tokens, ao contrário de linguagens como Python, onde é uma parte importante da sintaxe, ou Fortran, onde é imaterial.

Primeiro Programa Perl

Programação de modo interativo

Você pode usar o interpretador Perl com -eopção na linha de comando, que permite executar instruções Perl a partir da linha de comando. Vamos tentar algo em $ prompt da seguinte forma -

$perl -e 'print "Hello World\n"'

Esta execução produzirá o seguinte resultado -

Hello, world

Programação em modo script

Assumindo que você já está no prompt $, vamos abrir um arquivo de texto hello.pl usando o editor vi ou vim e colocar as seguintes linhas dentro do seu arquivo.

#!/usr/bin/perl

# This will print "Hello, World"
print "Hello, world\n";

Aqui /usr/bin/perlé realmente o binário do interpretador perl. Antes de executar seu script, certifique-se de alterar o modo do arquivo de script e dar privilégio de execução, geralmente uma configuração de 0755 funciona perfeitamente e, finalmente, você executa o script acima da seguinte maneira -

$chmod 0755 hello.pl $./hello.pl

Esta execução produzirá o seguinte resultado -

Hello, world

Você pode usar parênteses para argumentos de funções ou omiti-los de acordo com seu gosto pessoal. Eles são necessários apenas ocasionalmente para esclarecer as questões de precedência. As duas declarações seguintes produzem o mesmo resultado.

print("Hello, world\n");
print "Hello, world\n";

Extensão de arquivo Perl

Um script Perl pode ser criado dentro de qualquer programa editor de texto simples normal. Existem vários programas disponíveis para cada tipo de plataforma. Existem muitos programas projetados para programadores disponíveis para download na web.

Como uma convenção Perl, um arquivo Perl deve ser salvo com uma extensão de arquivo .pl ou .PL para ser reconhecido como um script Perl em funcionamento. Os nomes dos arquivos podem conter números, símbolos e letras, mas não devem conter espaços. Use um sublinhado (_) em lugares de espaços.

Comentários em Perl

Os comentários em qualquer linguagem de programação são amigos dos desenvolvedores. Os comentários podem ser usados para tornar o programa amigável e são simplesmente ignorados pelo intérprete sem afetar a funcionalidade do código. Por exemplo, no programa acima, uma linha começando com hash# é um comentário.

Simplesmente dizer que os comentários em Perl começam com um símbolo de hash e vão até o final da linha -

# This is a comment in perl

As linhas que começam com = são interpretadas como o início de uma seção de documentação incorporada (pod), e todas as linhas subsequentes até o próximo = corte são ignoradas pelo compilador. A seguir está o exemplo -

#!/usr/bin/perl

# This is a single line comment
print "Hello, world\n";

=begin comment
This is all part of multiline comment.
You can use as many lines as you like
These comments will be ignored by the 
compiler until the next =cut is encountered.
=cut

Isso produzirá o seguinte resultado -

Hello, world

Espaços em branco em Perl

Um programa Perl não se preocupa com espaços em branco. O programa a seguir funciona perfeitamente -

#!/usr/bin/perl

print       "Hello, world\n";

Mas se os espaços estiverem dentro das strings entre aspas, eles serão impressos como estão. Por exemplo -

#!/usr/bin/perl

# This would print with a line break in the middle
print "Hello
          world\n";

Isso produzirá o seguinte resultado -

Hello
          world

Todos os tipos de espaços em branco como espaços, tabulações, novas linhas, etc. são equivalentes para o intérprete quando são usados fora das aspas. Uma linha contendo apenas espaços em branco, possivelmente com um comentário, é conhecida como uma linha em branco e o Perl a ignora totalmente.

Aspas simples e duplas em Perl

Você pode usar aspas duplas ou simples em torno de strings literais da seguinte maneira -

#!/usr/bin/perl

print "Hello, world\n";
print 'Hello, world\n';

Isso produzirá o seguinte resultado -

Hello, world
Hello, world\n$

Há uma diferença importante entre aspas simples e duplas. Apenas aspas duplasinterpolatevariáveis e caracteres especiais, como novas linhas \ n, enquanto aspas simples não interpola nenhuma variável ou caractere especial. Verifique o exemplo abaixo onde estamos usando $ a como uma variável para armazenar um valor e, posteriormente, imprimir esse valor -

#!/usr/bin/perl

$a = 10; print "Value of a = $a\n";
print 'Value of a = $a\n';

Isso produzirá o seguinte resultado -

Value of a = 10
Value of a = $a\n$

Documentos "Aqui"

Você pode armazenar ou imprimir texto multilinha com grande conforto. Até você pode fazer uso de variáveis dentro do documento "aqui". Abaixo está uma sintaxe simples, verifique cuidadosamente se não deve haver espaço entre o << e o identificador.

Um identificador pode ser uma palavra simples ou algum texto entre aspas, como usamos o EOF abaixo. Se o identificador estiver entre aspas, o tipo de citação que você usa determina o tratamento do texto dentro do documento here, assim como nas citações regulares. Um identificador sem aspas funciona como aspas duplas.

#!/usr/bin/perl

$a = 10;
$var = <<"EOF"; This is the syntax for here document and it will continue until it encounters a EOF in the first line. This is case of double quote so variable value will be interpolated. For example value of a = $a
EOF
print "$var\n"; $var = <<'EOF';
This is case of single quote so variable value will be 
interpolated. For example value of a = $a EOF print "$var\n";

Isso produzirá o seguinte resultado -

This is the syntax for here document and it will continue
until it encounters a EOF in the first line.
This is case of double quote so variable value will be
interpolated. For example value of a = 10

This is case of single quote so variable value will be
interpolated. For example value of a = $a

Personagens em fuga

Perl usa o caractere de barra invertida (\) para escapar de qualquer tipo de caractere que possa interferir em nosso código. Vamos dar um exemplo onde queremos imprimir aspas duplas e o sinal $ -

#!/usr/bin/perl

$result = "This is \"number\""; print "$result\n";
print "\$result\n";

Isso produzirá o seguinte resultado -

This is "number"
$result

Identificadores Perl

Um identificador Perl é um nome usado para identificar uma variável, função, classe, módulo ou outro objeto. Um nome de variável Perl começa com $, @ ou% seguido por zero ou mais letras, sublinhados e dígitos (0 a 9).

Perl não permite caracteres de pontuação como @, $ e% nos identificadores. Perl é umcase sensitivelinguagem de programação. portanto$Manpower e $manpower são dois identificadores diferentes em Perl.

Perl é uma linguagem vagamente tipada e não há necessidade de especificar um tipo para seus dados ao usar em seu programa. O interpretador Perl escolherá o tipo com base no contexto dos próprios dados.

Perl tem três tipos de dados básicos: escalares, matrizes de escalares e hashes de escalares, também conhecidos como matrizes associativas. Aqui estão alguns detalhes sobre esses tipos de dados.

Sr. Não.	Tipos e descrição
1	Scalar Os escalares são variáveis simples. Eles são precedidos por um cifrão ($). Um escalar é um número, uma string ou uma referência. Uma referência é na verdade o endereço de uma variável, que veremos nos próximos capítulos.
2	Arrays Arrays são listas ordenadas de escalares que você acessa com um índice numérico, que começa com 0. Eles são precedidos por um sinal "arroba" (@).
3	Hashes Hashes são conjuntos não ordenados de pares de chave / valor que você acessa usando as chaves como subscritos. Eles são precedidos por um sinal de porcentagem (%).

Literais Numéricos

Perl armazena todos os números internamente como inteiros com sinal ou valores de ponto flutuante de precisão dupla. Literais numéricos são especificados em qualquer um dos seguintes formatos de ponto flutuante ou inteiro -

Tipo	Valor
Inteiro	1234
Inteiro negativo	-100
Ponto flutuante	2000
Notação científica	16.12E14
Hexadecimal	0xffff
Octal	0577

Literais de string

Strings são sequências de caracteres. Eles geralmente são valores alfanuméricos delimitados por aspas simples (') ou duplas ("). Eles funcionam como aspas do shell do UNIX, onde você pode usar strings entre aspas simples e duplas.

Literais de string entre aspas duplas permitem interpolação de variáveis, e strings com aspas simples não. Existem certos caracteres que são precedidos por uma barra invertida, têm um significado especial e são usados para representar como nova linha (\ n) ou tabulação (\ t).

Você pode incorporar novas linhas ou qualquer uma das seguintes sequências de Escape diretamente em suas strings entre aspas duplas -

Sequência de fuga	Significado
\\	Barra invertida
\ '	Citação única
\ "	Citação dupla
\uma	Alerta ou sino
\ b	Backspace
\ f	Feed de formulário
\ n	Nova linha
\ r	Retorno de carruagem
\ t	Aba horizontal
\ v	Aba vertical
\ 0nn	Cria números formatados em octal
\ xnn	Cria números formatados hexadecimais
\ cX	Controla os caracteres, x pode ser qualquer caractere
\você	Força o próximo caractere a maiúsculas
\eu	Força o próximo caractere para minúsculas
\VOCÊ	Força todos os caracteres seguintes a maiúsculas
\EU	Força todos os caracteres seguintes para minúsculas
\ Q	Barra invertida em todos os caracteres não alfanuméricos seguintes
\ E	Fim \ U, \ L ou \ Q

Exemplo

Vamos ver novamente como as strings se comportam com aspas simples e duplas. Aqui, usaremos escapes de string mencionados na tabela acima e faremos uso da variável escalar para atribuir valores de string.

#!/usr/bin/perl

# This is case of interpolation.
$str = "Welcome to \ntutorialspoint.com!";
print "$str\n"; # This is case of non-interpolation. $str = 'Welcome to \ntutorialspoint.com!';
print "$str\n"; # Only W will become upper case. $str = "\uwelcome to tutorialspoint.com!";
print "$str\n"; # Whole line will become capital. $str = "\UWelcome to tutorialspoint.com!";
print "$str\n"; # A portion of line will become capital. $str = "Welcome to \Ututorialspoint\E.com!"; 
print "$str\n"; # Backsalash non alpha-numeric including spaces. $str = "\QWelcome to tutorialspoint's family";
print "$str\n";

Isso produzirá o seguinte resultado -

Welcome to
tutorialspoint.com!
Welcome to \ntutorialspoint.com!
Welcome to tutorialspoint.com!
WELCOME TO TUTORIALSPOINT.COM!
Welcome to TUTORIALSPOINT.com!
Welcome\ to\ tutorialspoint\'s\ family

Variáveis são os locais de memória reservados para armazenar valores. Isso significa que, ao criar uma variável, você reserva algum espaço na memória.

Com base no tipo de dado de uma variável, o interpretador aloca memória e decide o que pode ser armazenado na memória reservada. Portanto, ao atribuir diferentes tipos de dados a variáveis, você pode armazenar inteiros, decimais ou strings nessas variáveis.

Aprendemos que Perl tem os seguintes três tipos básicos de dados -

Scalars
Arrays
Hashes

Conseqüentemente, usaremos três tipos de variáveis em Perl. UMAscalarA variável será precedida por um cifrão ($) e pode armazenar um número, uma string ou uma referência. Aarraya variável precederá o sinal @ e armazenará listas ordenadas de escalares. Finalmente, oHash a variável será precedida pelo sinal% e será usada para armazenar conjuntos de pares de chave / valor.

Perl mantém cada tipo de variável em um namespace separado. Portanto, você pode, sem medo de conflito, usar o mesmo nome para uma variável escalar, um array ou um hash. Isso significa que $ foo e @foo são duas variáveis diferentes.

Criação de variáveis

As variáveis Perl não precisam ser declaradas explicitamente para reservar espaço de memória. A declaração acontece automaticamente quando você atribui um valor a uma variável. O sinal de igual (=) é usado para atribuir valores às variáveis.

Observe que é obrigatório declarar uma variável antes de usá-la, se usarmos use strict declaração em nosso programa.

O operando à esquerda do operador = é o nome da variável e o operando à direita do operador = é o valor armazenado na variável. Por exemplo -

$age = 25;             # An integer assignment
$name = "John Paul"; # A string $salary = 1445.50;     # A floating point

Aqui, 25, "John Paul" e 1445,50 são os valores atribuídos às variáveis $ age , $ name e $ salary , respectivamente. Em breve veremos como podemos atribuir valores a arrays e hashes.

Variáveis Escalares

Um escalar é uma única unidade de dados. Esses dados podem ser um número inteiro, ponto flutuante, um caractere, uma string, um parágrafo ou uma página da web inteira. Simplesmente dizer que pode ser qualquer coisa, mas apenas uma coisa.

Aqui está um exemplo simples de uso de variáveis escalares -

#!/usr/bin/perl

$age = 25;             # An integer assignment
$name = "John Paul"; # A string $salary = 1445.50;     # A floating point

print "Age = $age\n"; print "Name = $name\n";
print "Salary = $salary\n";

Isso produzirá o seguinte resultado -

Age = 25
Name = John Paul
Salary = 1445.5

Variáveis de matriz

Uma matriz é uma variável que armazena uma lista ordenada de valores escalares. Variáveis de matriz são precedidas por um sinal "arroba" (@). Para se referir a um único elemento de uma matriz, você usará o cifrão ($) com o nome da variável seguido pelo índice do elemento entre colchetes.

Aqui está um exemplo simples de uso de variáveis de matriz -

#!/usr/bin/perl

@ages = (25, 30, 40);             
@names = ("John Paul", "Lisa", "Kumar");

print "\$ages[0] = $ages[0]\n";
print "\$ages[1] = $ages[1]\n";
print "\$ages[2] = $ages[2]\n";
print "\$names[0] = $names[0]\n";
print "\$names[1] = $names[1]\n";
print "\$names[2] = $names[2]\n";

Aqui usamos o sinal de escape (\) antes do sinal $ apenas para imprimi-lo. Outro Perl o entenderá como uma variável e imprimirá seu valor. Quando executado, isso produzirá o seguinte resultado -

$ages[0] = 25
$ages[1] = 30 $ages[2] = 40
$names[0] = John Paul $names[1] = Lisa
$names[2] = Kumar

Variáveis de hash

Um hash é um conjunto de key/valuepares. Variáveis hash são precedidas por um sinal de porcentagem (%). Para se referir a um único elemento de um hash, você usará o nome da variável hash seguido pela "chave" associada ao valor entre colchetes.

Aqui está um exemplo simples de uso de variáveis hash -

#!/usr/bin/perl

%data = ('John Paul', 45, 'Lisa', 30, 'Kumar', 40);

print "\$data{'John Paul'} = $data{'John Paul'}\n"; print "\$data{'Lisa'} = $data{'Lisa'}\n"; print "\$data{'Kumar'} = $data{'Kumar'}\n";

Isso produzirá o seguinte resultado -

$data{'John Paul'} = 45
$data{'Lisa'} = 30 $data{'Kumar'} = 40

Contexto Variável

O Perl trata a mesma variável de maneira diferente com base no Contexto, ou seja, a situação onde uma variável está sendo usada. Vamos verificar o seguinte exemplo -

#!/usr/bin/perl

@names = ('John Paul', 'Lisa', 'Kumar');

@copy = @names;
$size = @names; print "Given names are : @copy\n"; print "Number of names are : $size\n";

Isso produzirá o seguinte resultado -

Given names are : John Paul Lisa Kumar
Number of names are : 3

Aqui, @names é um array, que foi usado em dois contextos diferentes. Primeiro nós o copiamos em qualquer outro array, ou seja, lista, então ele retornou todos os elementos assumindo que o contexto é o contexto de lista. Em seguida, usamos o mesmo array e tentamos armazenar esse array em um escalar, portanto, neste caso, ele retornou apenas o número de elementos neste array, assumindo que o contexto é escalar. A tabela a seguir lista os vários contextos -

Sr. Não.	Contexto e descrição
1	Scalar A atribuição a uma variável escalar avalia o lado direito em um contexto escalar.
2	List A atribuição a uma matriz ou hash avalia o lado direito em um contexto de lista.
3	Boolean O contexto booleano é simplesmente qualquer lugar onde uma expressão está sendo avaliada para ver se ela é verdadeira ou falsa.
4	Void Esse contexto não só não se importa com o valor de retorno, como nem mesmo quer um valor de retorno.
5	Interpolative Este contexto só acontece entre aspas, ou coisas que funcionam como aspas.

Um escalar é uma única unidade de dados. Esses dados podem ser um número inteiro, ponto flutuante, um caractere, uma string, um parágrafo ou uma página da web inteira.

Aqui está um exemplo simples de uso de variáveis escalares -

#!/usr/bin/perl

$age = 25; # An integer assignment $name = "John Paul";   # A string 
$salary = 1445.50; # A floating point print "Age = $age\n";
print "Name = $name\n"; print "Salary = $salary\n";

Isso produzirá o seguinte resultado -

Age = 25
Name = John Paul
Salary = 1445.5

Escalares Numéricos

Um escalar é geralmente um número ou uma string. O exemplo a seguir demonstra o uso de vários tipos de escalares numéricos -

#!/usr/bin/perl

$integer = 200; $negative = -300;
$floating = 200.340; $bigfloat = -1.2E-23;

# 377 octal, same as 255 decimal
$octal = 0377; # FF hex, also 255 decimal $hexa = 0xff;

print "integer = $integer\n"; print "negative = $negative\n";
print "floating = $floating\n"; print "bigfloat = $bigfloat\n";
print "octal = $octal\n"; print "hexa = $hexa\n";

Isso produzirá o seguinte resultado -

integer = 200
negative = -300
floating = 200.34
bigfloat = -1.2e-23
octal = 255
hexa = 255

Escalares de corda

O exemplo a seguir demonstra o uso de vários tipos de escalares de string. Observe a diferença entre strings entre aspas simples e strings entre aspas duplas -

#!/usr/bin/perl

$var = "This is string scalar!"; $quote = 'I m inside single quote - $var'; $double = "This is inside single quote - $var"; $escape = "This example of escape -\tHello, World!";

print "var = $var\n"; print "quote = $quote\n";
print "double = $double\n"; print "escape = $escape\n";

Isso produzirá o seguinte resultado -

var = This is string scalar!
quote = I m inside single quote - $var
double = This is inside single quote - This is string scalar!
escape = This example of escape -       Hello, World

Operações Escalares

Você verá um detalhe de vários operadores disponíveis em Perl em um capítulo separado, mas aqui vamos listar algumas operações numéricas e de string.

#!/usr/bin/perl

$str = "hello" . "world";       # Concatenates strings.
$num = 5 + 10; # adds two numbers. $mul = 4 * 5;                   # multiplies two numbers.
$mix = $str . $num; # concatenates string and number. print "str = $str\n";
print "num = $num\n"; print "mix = $mix\n";

Isso produzirá o seguinte resultado -

str = helloworld
num = 15
mul = 20
mix = helloworld15

Multiline Strings

Se você deseja introduzir strings de várias linhas em seus programas, você pode usar as aspas simples padrão conforme abaixo -

#!/usr/bin/perl

$string = 'This is a multiline string'; print "$string\n";

Isso produzirá o seguinte resultado -

This is
a multiline
string

Você pode usar a sintaxe de documento "aqui" também para armazenar ou imprimir multilinhas como abaixo -

#!/usr/bin/perl

print <<EOF;
This is
a multiline
string
EOF

Isso também produzirá o mesmo resultado -

This is
a multiline
string

V-Strings

Um literal no formato v1.20.300.4000 é analisado como uma string composta de caracteres com os ordinais especificados. Esta forma é conhecida como v-strings.

Uma v-string fornece uma maneira alternativa e mais legível de construir strings, em vez de usar a forma de interpolação um pouco menos legível "\ x {1} \ x {14} \ x {12c} \ x {fa0}".

Eles são qualquer literal que comece com av e seja seguido por um ou mais elementos separados por pontos. Por exemplo -

#!/usr/bin/perl

$smile = v9786; $foo    = v102.111.111;
$martin = v77.97.114.116.105.110; print "smile = $smile\n";
print "foo = $foo\n"; print "martin = $martin\n";

Isso também produzirá o mesmo resultado -

smile = ☺
foo = foo
martin = Martin
Wide character in print at main.pl line 7.

Literais Especiais

Até agora, você deve ter uma ideia sobre os escalares de string e sua operação de concatenação e interpolação. Então, deixe-me falar sobre três literais especiais __FILE__, __LINE__ e __PACKAGE__ representam o nome do arquivo atual, o número da linha e o nome do pacote naquele ponto do seu programa.

Eles podem ser usados apenas como tokens separados e não serão interpolados em strings. Verifique o exemplo abaixo -

#!/usr/bin/perl

print "File name ". __FILE__ . "\n";
print "Line Number " . __LINE__ ."\n";
print "Package " . __PACKAGE__ ."\n";

# they can not be interpolated
print "__FILE__ __LINE__ __PACKAGE__\n";

Isso produzirá o seguinte resultado -

File name hello.pl
Line Number 4
Package main
__FILE__ __LINE__ __PACKAGE__

Aqui está um exemplo simples de como usar as variáveis de matriz -

#!/usr/bin/perl

@ages = (25, 30, 40);             
@names = ("John Paul", "Lisa", "Kumar");

print "\$ages[0] = $ages[0]\n"; print "\$ages[1] = $ages[1]\n"; print "\$ages[2] = $ages[2]\n"; print "\$names[0] = $names[0]\n"; print "\$names[1] = $names[1]\n"; print "\$names[2] = $names[2]\n";

Aqui, usamos o sinal de escape (\) antes do sinal $ apenas para imprimi-lo. Outro Perl o entenderá como uma variável e imprimirá seu valor. Quando executado, isso produzirá o seguinte resultado -

$ages[0] = 25 $ages[1] = 30
$ages[2] = 40 $names[0] = John Paul
$names[1] = Lisa $names[2] = Kumar

Em Perl, os termos de lista e matriz são freqüentemente usados como se fossem intercambiáveis. Mas a lista são os dados e a matriz é a variável.

Criação de Array

Variáveis de matriz são prefixadas com o sinal @ e são preenchidas usando parênteses ou o operador qw. Por exemplo -

@array = (1, 2, 'Hello');
@array = qw/This is an array/;

A segunda linha usa o operador qw //, que retorna uma lista de strings, separando a string delimitada por um espaço em branco. Neste exemplo, isso leva a uma matriz de quatro elementos; o primeiro elemento é 'this' e o último (quarto) é 'array'. Isso significa que você pode usar linhas diferentes da seguinte forma -

@days = qw/Monday
Tuesday
...
Sunday/;

Você também pode preencher uma matriz atribuindo cada valor individualmente da seguinte forma -

$array[0] = 'Monday'; ... $array[6] = 'Sunday';

Acessando Elementos de Matriz

Ao acessar elementos individuais de uma matriz, você deve prefixar a variável com um cifrão ($) e, em seguida, anexar o índice do elemento entre colchetes após o nome da variável. Por exemplo -

#!/usr/bin/perl

@days = qw/Mon Tue Wed Thu Fri Sat Sun/;

print "$days[0]\n";
print "$days[1]\n"; print "$days[2]\n";
print "$days[6]\n"; print "$days[-1]\n";
print "$days[-7]\n";

Isso produzirá o seguinte resultado -

Mon
Tue
Wed
Sun
Sun
Mon

Os índices da matriz começam do zero, portanto, para acessar o primeiro elemento, você precisa fornecer 0 como índices. Você também pode fornecer um índice negativo, caso em que seleciona o elemento do final, em vez do início, da matriz. Isso significa o seguinte -

print $days[-1]; # outputs Sun
print $days[-7]; # outputs Mon

Matrizes de números sequenciais

Perl oferece um atalho para números e letras sequenciais. Em vez de digitar cada elemento ao contar até 100, por exemplo, podemos fazer algo como o seguinte -

#!/usr/bin/perl

@var_10 = (1..10);
@var_20 = (10..20);
@var_abc = (a..z);

print "@var_10\n";   # Prints number from 1 to 10
print "@var_20\n";   # Prints number from 10 to 20
print "@var_abc\n";  # Prints number from a to z

Aqui, o ponto duplo (..) é chamado range operator. Isso produzirá o seguinte resultado -

1 2 3 4 5 6 7 8 9 10
10 11 12 13 14 15 16 17 18 19 20
a b c d e f g h i j k l m n o p q r s t u v w x y z

Tamanho da Matriz

O tamanho de uma matriz pode ser determinado usando o contexto escalar na matriz - o valor retornado será o número de elementos na matriz -

@array = (1,2,3);
print "Size: ",scalar @array,"\n";

O valor retornado sempre será o tamanho físico da matriz, não o número de elementos válidos. Você pode demonstrar isso, e a diferença entre @array escalar e $ # array, usando este fragmento é a seguinte -

#!/usr/bin/perl

@array = (1,2,3);
$array[50] = 4; $size = @array;
$max_index = $#array;

print "Size:  $size\n"; print "Max Index: $max_index\n";

Isso produzirá o seguinte resultado -

Size: 51
Max Index: 50

Existem apenas quatro elementos na matriz que contém informações, mas a matriz tem 51 elementos, com um índice mais alto de 50.

Adicionando e removendo elementos na matriz

Perl fornece várias funções úteis para adicionar e remover elementos em um array. Você pode ter uma pergunta o que é uma função? Até agora você usouprintfunção para imprimir vários valores. Da mesma forma, existem várias outras funções ou às vezes chamadas de sub-rotinas, que podem ser usadas para várias outras funcionalidades.

Sr. Não.	Tipos e descrição
1	push @ARRAY, LIST Coloca os valores da lista no final da matriz.
2	pop @ARRAY Aparece e retorna o último valor da matriz.
3	shift @ARRAY Desloca o primeiro valor da matriz e o retorna, encurtando a matriz em 1 e movendo tudo para baixo.
4	unshift @ARRAY, LIST Anexa a lista à frente da matriz e retorna o número de elementos na nova matriz.

#!/usr/bin/perl

# create a simple array
@coins = ("Quarter","Dime","Nickel");
print "1. \@coins  = @coins\n";

# add one element at the end of the array
push(@coins, "Penny");
print "2. \@coins  = @coins\n";

# add one element at the beginning of the array
unshift(@coins, "Dollar");
print "3. \@coins  = @coins\n";

# remove one element from the last of the array.
pop(@coins);
print "4. \@coins  = @coins\n";

# remove one element from the beginning of the array.
shift(@coins);
print "5. \@coins  = @coins\n";

Isso produzirá o seguinte resultado -

1. @coins = Quarter Dime Nickel
2. @coins = Quarter Dime Nickel Penny
3. @coins = Dollar Quarter Dime Nickel Penny
4. @coins = Dollar Quarter Dime Nickel
5. @coins = Quarter Dime Nickel

Elementos de matriz de fatias

Você também pode extrair uma "fatia" de uma matriz - ou seja, você pode selecionar mais de um item de uma matriz para produzir outra matriz.

#!/usr/bin/perl

@days = qw/Mon Tue Wed Thu Fri Sat Sun/;

@weekdays = @days[3,4,5];

print "@weekdays\n";

Isso produzirá o seguinte resultado -

Thu Fri Sat

A especificação de uma fatia deve ter uma lista de índices válidos, positivos ou negativos, cada um separado por uma vírgula. Para velocidade, você também pode usar o.. operador de alcance -

#!/usr/bin/perl

@days = qw/Mon Tue Wed Thu Fri Sat Sun/;

@weekdays = @days[3..5];

print "@weekdays\n";

Isso produzirá o seguinte resultado -

Thu Fri Sat

Substituindo Elementos de Matriz

Agora vamos apresentar mais uma função chamada splice(), que tem a seguinte sintaxe -

splice @ARRAY, OFFSET [ , LENGTH [ , LIST ] ]

Esta função removerá os elementos de @ARRAY designados por OFFSET e LENGTH, e os substituirá por LIST, se especificado. Finalmente, ele retorna os elementos removidos do array. A seguir está o exemplo -

#!/usr/bin/perl

@nums = (1..20);
print "Before - @nums\n";

splice(@nums, 5, 5, 21..25); 
print "After - @nums\n";

Isso produzirá o seguinte resultado -

Before - 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
After - 1 2 3 4 5 21 22 23 24 25 11 12 13 14 15 16 17 18 19 20

Aqui, a substituição real começa com o 6º número depois que cinco elementos são então substituídos de 6 a 10 com os números 21, 22, 23, 24 e 25.

Transforme Strings em Arrays

Vamos dar uma olhada em mais uma função chamada split(), que tem a seguinte sintaxe -

split [ PATTERN [ , EXPR [ , LIMIT ] ] ]

Esta função divide uma string em uma matriz de strings e a retorna. Se LIMIT for especificado, divide no máximo esse número de campos. Se PATTERN for omitido, divide-se em espaços em branco. A seguir está o exemplo -

#!/usr/bin/perl

# define Strings
$var_string = "Rain-Drops-On-Roses-And-Whiskers-On-Kittens"; $var_names = "Larry,David,Roger,Ken,Michael,Tom";

# transform above strings into arrays.
@string = split('-', $var_string); @names = split(',', $var_names);

print "$string[3]\n"; # This will print Roses print "$names[4]\n";   # This will print Michael

Isso produzirá o seguinte resultado -

Roses
Michael

Transforme Arrays em Strings

Podemos usar o join()função para reunir os elementos da matriz e formar uma longa sequência escalar. Esta função tem a seguinte sintaxe -

join EXPR, LIST

Esta função une as strings separadas de LIST em uma única string com campos separados pelo valor de EXPR e retorna a string. A seguir está o exemplo -

#!/usr/bin/perl

# define Strings
$var_string = "Rain-Drops-On-Roses-And-Whiskers-On-Kittens"; $var_names = "Larry,David,Roger,Ken,Michael,Tom";

# transform above strings into arrays.
@string = split('-', $var_string); @names = split(',', $var_names);

$string1 = join( '-', @string ); $string2 = join( ',', @names );

print "$string1\n"; print "$string2\n";

Isso produzirá o seguinte resultado -

Rain-Drops-On-Roses-And-Whiskers-On-Kittens
Larry,David,Roger,Ken,Michael,Tom

Classificando matrizes

o sort()função classifica cada elemento de uma matriz de acordo com os padrões numéricos ASCII. Esta função tem a seguinte sintaxe -

sort [ SUBROUTINE ] LIST

Esta função classifica a LIST e retorna o valor da matriz classificada. Se SUBROUTINE for especificado, a lógica especificada dentro do SUBTROUTINE será aplicada durante a classificação dos elementos.

#!/usr/bin/perl

# define an array
@foods = qw(pizza steak chicken burgers);
print "Before: @foods\n";

# sort this array
@foods = sort(@foods);
print "After: @foods\n";

Isso produzirá o seguinte resultado -

Before: pizza steak chicken burgers
After: burgers chicken pizza steak

Observe que a classificação é realizada com base no valor numérico ASCII das palavras. Portanto, a melhor opção é primeiro transformar cada elemento da matriz em letras minúsculas e, em seguida, executar a função de classificação.

Mesclando matrizes

Como uma matriz é apenas uma sequência de valores separados por vírgulas, você pode combiná-los conforme mostrado abaixo -

#!/usr/bin/perl

@numbers = (1,3,(4,5,6));

print "numbers = @numbers\n";

Isso produzirá o seguinte resultado -

numbers = 1 3 4 5 6

Os arrays incorporados tornam-se apenas uma parte do array principal, conforme mostrado abaixo -

#!/usr/bin/perl

@odd = (1,3,5);
@even = (2, 4, 6);

@numbers = (@odd, @even);

print "numbers = @numbers\n";

Isso produzirá o seguinte resultado -

numbers = 1 3 5 2 4 6

Selecionando Elementos de Listas

A notação de lista é idêntica à dos arrays. Você pode extrair um elemento de uma matriz acrescentando colchetes à lista e fornecendo um ou mais índices -

#!/usr/bin/perl

$var = (5,4,3,2,1)[4]; print "value of var = $var\n"

Isso produzirá o seguinte resultado -

value of var = 1

Da mesma forma, podemos extrair fatias, embora sem a necessidade de um caractere @ inicial -

#!/usr/bin/perl

@list = (5,4,3,2,1)[1..3];

print "Value of list = @list\n";

Isso produzirá o seguinte resultado -

Value of list = 4 3 2

Um hash é um conjunto de key/valuepares. Variáveis hash são precedidas por um sinal de porcentagem (%). Para se referir a um único elemento de um hash, você usará o nome da variável hash precedido por um sinal "$" e seguido pela "chave" associada ao valor entre colchetes.

Aqui está um exemplo simples de uso de variáveis hash -

#!/usr/bin/perl

%data = ('John Paul', 45, 'Lisa', 30, 'Kumar', 40);

print "\$data{'John Paul'} = $data{'John Paul'}\n"; print "\$data{'Lisa'} = $data{'Lisa'}\n"; print "\$data{'Kumar'} = $data{'Kumar'}\n";

Isso produzirá o seguinte resultado -

$data{'John Paul'} = 45
$data{'Lisa'} = 30 $data{'Kumar'} = 40

Criando Hashes

Hashes são criados de uma das seguintes maneiras. No primeiro método, você atribui um valor a uma chave nomeada em uma base um por um -

$data{'John Paul'} = 45; $data{'Lisa'} = 30;
$data{'Kumar'} = 40;

No segundo caso, você usa uma lista, que é convertida tomando pares individuais da lista: o primeiro elemento do par é usado como a chave e o segundo, como o valor. Por exemplo -

%data = ('John Paul', 45, 'Lisa', 30, 'Kumar', 40);

Para maior clareza, você pode usar => como um alias para, para indicar os pares de chave / valor da seguinte forma -

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

Aqui está mais uma variante da forma acima, dê uma olhada nela, aqui todas as chaves foram precedidas por hífen (-) e nenhuma citação é necessária em torno delas -

%data = (-JohnPaul => 45, -Lisa => 30, -Kumar => 40);

Mas é importante notar que existe uma única palavra, ou seja, sem espaços as chaves foram usadas nesta forma de formação de hash e se você construir seu hash desta forma, as chaves serão acessadas usando hífen apenas como mostrado abaixo.

$val = %data{-JohnPaul}
$val = %data{-Lisa}

Acessando Elementos Hash

Ao acessar elementos individuais de um hash, você deve prefixar a variável com um cifrão ($) e, em seguida, anexar a chave do elemento entre chaves após o nome da variável. Por exemplo -

#!/usr/bin/perl

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

print "$data{'John Paul'}\n"; print "$data{'Lisa'}\n";
print "$data{'Kumar'}\n";

Isso produzirá o seguinte resultado -

45
30
40

Extraindo fatias

Você pode extrair fatias de um hash da mesma forma que pode extrair fatias de uma matriz. Você precisará usar o prefixo @ para a variável para armazenar o valor retornado porque eles serão uma lista de valores -

#!/uer/bin/perl


%data = (-JohnPaul => 45, -Lisa => 30, -Kumar => 40);

@array = @data{-JohnPaul, -Lisa};

print "Array : @array\n";

Isso produzirá o seguinte resultado -

Array : 45 30

Extraindo chaves e valores

Você pode obter uma lista de todas as chaves de um hash usando keys função, que tem a seguinte sintaxe -

keys %HASH

Esta função retorna um array de todas as chaves do hash nomeado. A seguir está o exemplo -

#!/usr/bin/perl 

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

@names = keys %data;

print "$names[0]\n";
print "$names[1]\n"; print "$names[2]\n";

Isso produzirá o seguinte resultado -

Lisa
John Paul
Kumar

Da mesma forma, você pode usar valuesfunção para obter uma lista de todos os valores. Esta função tem a seguinte sintaxe -

values %HASH

Esta função retorna uma matriz normal que consiste em todos os valores do hash nomeado. A seguir está o exemplo -

#!/usr/bin/perl 

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

@ages = values %data;

print "$ages[0]\n"; print "$ages[1]\n";
print "$ages[2]\n";

Isso produzirá o seguinte resultado -

30
45
40

Verificando a existência

Se você tentar acessar um par chave / valor de um hash que não existe, normalmente obterá o undefinedvalor, e se você tiver avisos ativados, você receberá um aviso gerado em tempo de execução. Você pode contornar isso usando oexists função, que retorna verdadeiro se a chave nomeada existe, independentemente de qual seja seu valor -

#!/usr/bin/perl

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

if( exists($data{'Lisa'} ) ) {
   print "Lisa is $data{'Lisa'} years old\n";
} else {
   print "I don't know age of Lisa\n";
}

Aqui, apresentamos a instrução IF ... ELSE, que estudaremos em um capítulo separado. Por agora você apenas assume queif( condition ) parte será executada apenas quando a condição dada for verdadeira, caso contrário elseparte será executada. Então, quando executamos o programa acima, ele produz o seguinte resultado porque aqui a condição dada existe ($ data {'Lisa'} retorna verdadeiro -

Lisa is 30 years old

Obtendo o tamanho do hash

Você pode obter o tamanho - ou seja, o número de elementos de um hash usando o contexto escalar em chaves ou valores. Simplesmente dizendo que primeiro você deve obter uma matriz de chaves ou valores e, em seguida, você pode obter o tamanho da matriz da seguinte forma -

#!/usr/bin/perl

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

@keys = keys %data;
$size = @keys; print "1 - Hash size: is $size\n";

@values = values %data;
$size = @values; print "2 - Hash size: is $size\n";

Isso produzirá o seguinte resultado -

1 - Hash size: is 3
2 - Hash size: is 3

Adicionar e remover elementos em hash

Adicionar um novo par chave / valor pode ser feito com uma linha de código usando o operador de atribuição simples. Mas para remover um elemento do hash, você precisa usardelete função conforme mostrado abaixo no exemplo -

#!/usr/bin/perl

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
@keys = keys %data;
$size = @keys; print "1 - Hash size: is $size\n";

# adding an element to the hash;
$data{'Ali'} = 55; @keys = keys %data; $size = @keys;
print "2 - Hash size:  is $size\n"; # delete the same element from the hash; delete $data{'Ali'};
@keys = keys %data;
$size = @keys; print "3 - Hash size: is $size\n";

Isso produzirá o seguinte resultado -

1 - Hash size: is 3
2 - Hash size: is 4
3 - Hash size: is 3

As declarações condicionais Perl ajudam na tomada de decisão, que requerem que o programador especifique uma ou mais condições a serem avaliadas ou testadas pelo programa, junto com uma declaração ou declarações a serem executadas se a condição for determinada como verdadeira e, opcionalmente, outras declarações a serem executadas se a condição for considerada falsa.

A seguir está a parte geral de uma estrutura típica de tomada de decisão encontrada na maioria das linguagens de programação -

O número 0, as strings '0' e "", a lista vazia () e undef são todos false em um contexto booleano e todos os outros valores são true. Negação de um valor verdadeiro por! ou not retorna um valor falso especial.

A linguagem de programação Perl fornece os seguintes tipos de instruções condicionais.

Sr. Não.	Declaração e descrição
1	declaração if A if statement consiste em uma expressão booleana seguida por uma ou mais instruções.
2	declaração if ... else A if statement pode ser seguido por um opcional else statement.
3	declaração if ... elsif ... else A if statement pode ser seguido por um opcional elsif statement e então por um opcional else statement.
4	a menos que declaração A unless statement consiste em uma expressão booleana seguida por uma ou mais instruções.
5	a menos ... declaração else A unless statement pode ser seguido por um opcional else statement.
6	a menos ... declaração elsif..else A unless statement pode ser seguido por um opcional elsif statement e então por um opcional else statement.
7	declaração switch Com as versões mais recentes do Perl, você pode usar o switchdeclaração. que permite uma maneira simples de comparar um valor de variável com várias condições.

O ? : Operador

Vamos verificar o conditional operator ? :que pode ser usado para substituir if...elseafirmações. Tem a seguinte forma geral -

Exp1 ? Exp2 : Exp3;

Onde Exp1, Exp2 e Exp3 são expressões. Observe o uso e a localização do cólon.

O valor de um? expressão é determinada assim: Exp1 é avaliada. Se for verdade, então Exp2 é avaliado e se torna o valor de todo? expressão. Se Exp1 for falso, então Exp3 é avaliado e seu valor se torna o valor da expressão. Abaixo está um exemplo simples usando este operador -

#!/usr/local/bin/perl
 
$name = "Ali"; $age = 10;

$status = ($age > 60 )? "A senior citizen" : "Not a senior citizen";

print "$name is - $status\n";

Isso produzirá o seguinte resultado -

Ali is - Not a senior citizen

Pode haver uma situação em que você precise executar um bloco de código várias vezes. Em geral, as instruções são executadas sequencialmente: a primeira instrução em uma função é executada primeiro, seguida pela segunda e assim por diante.

As linguagens de programação fornecem várias estruturas de controle que permitem caminhos de execução mais complicados.

Uma instrução de loop nos permite executar uma instrução ou grupo de instruções várias vezes e a seguir está a forma geral de uma instrução de loop na maioria das linguagens de programação -

A linguagem de programação Perl fornece os seguintes tipos de loop para lidar com os requisitos de loop.

Sr. Não.	Tipo de Loop e Descrição
1	loop while Repete uma declaração ou grupo de declarações enquanto uma determinada condição for verdadeira. Ele testa a condição antes de executar o corpo do loop.
2	até o laço Repete uma declaração ou grupo de declarações até que uma determinada condição se torne verdadeira. Ele testa a condição antes de executar o corpo do loop.
3	para loop Executa uma sequência de instruções várias vezes e abrevia o código que gerencia a variável de loop.
4	loop foreach O loop foreach itera sobre um valor de lista normal e define a variável VAR para ser cada elemento da lista por vez.
5	fazer ... loop while Como uma instrução while, exceto que testa a condição no final do corpo do loop
6	loops aninhados Você pode usar um ou mais loops dentro de qualquer outro loop while, for ou do..while.

Declarações de controle de loop

As instruções de controle de loop alteram a execução de sua sequência normal. Quando a execução deixa um escopo, todos os objetos automáticos que foram criados nesse escopo são destruídos.

Perl oferece suporte às seguintes instruções de controle. Clique nos links a seguir para verificar seus detalhes.

Sr. Não.	Declaração de controle e descrição
1	próxima declaração Faz com que o loop pule o restante de seu corpo e teste novamente sua condição imediatamente antes de reiterar.
2	última declaração Encerra a instrução de loop e transfere a execução para a instrução imediatamente após o loop.
3	continuar declaração Um CONTINUAR BLOCO, é sempre executado pouco antes de a condicional ser avaliada novamente.
4	refazer declaração O comando redo reinicia o bloco de loop sem avaliar a condicional novamente. O bloco de continuação, se houver, não é executado.
5	declaração goto Perl suporta um comando goto com três formas: goto label, goto expr e goto & name.

The Infinite Loop

Um loop se torna um loop infinito se uma condição nunca se torna falsa. oforloop é tradicionalmente usado para esse propósito. Uma vez que nenhuma das três expressões que formam ofor são necessários, você pode fazer um loop infinito deixando a expressão condicional vazia.

#!/usr/local/bin/perl
 
for( ; ; ) {
   printf "This loop will run forever.\n";
}

Você pode encerrar o loop infinito acima pressionando as teclas Ctrl + C.

Quando a expressão condicional está ausente, ela é considerada verdadeira. Você pode ter uma expressão de inicialização e incremento, mas como um programador, use mais comumente a construção for (;;) para significar um loop infinito.

O que é um operador?

Uma resposta simples pode ser dada usando a expressão 4 + 5 é igual a 9 . Aqui, 4 e 5 são chamados de operandos e + é chamado de operador. A linguagem Perl suporta muitos tipos de operadores, mas a seguir está uma lista de operadores importantes e usados com mais frequência -

Operadores aritméticos
Operadores de igualdade
Operadores lógicos
Operadores de atribuição
Operadores bit a bit
Operadores lógicos
Operadores de orçamento
Operadores diversos

Vamos dar uma olhada em todos os operadores, um por um.

Operadores Aritméticos Perl

Assumir variável $a holds 10 and variable $b contém 20, a seguir estão os operadores aritmáticos Perl -

Mostrar exemplo

Sr. Não.	Operador e descrição
1	+ ( Addition ) Adiciona valores em qualquer lado do operador Example - $a + $b dará 30
2	- (Subtraction) Subtrai o operando direito do operando esquerdo Example - $a - $b vai dar -10
3	* (Multiplication) Multiplica os valores em ambos os lados do operador Example - $a * $b vai dar 200
4	/ (Division) Divide operando esquerdo pelo operando direito Example - $b / $a dará 2
5	% (Modulus) Divide operando esquerdo pelo operando direito e retorna o resto Example - $b % $a dará 0
6	(Exponent) Executa cálculo exponencial (potência) nos operadores Example - $a$b dará 10 à potência 20

Operadores de igualdade Perl

Eles também são chamados de operadores relacionais. Assumir variável$a holds 10 and variable $b contém 20 então, vamos verificar os seguintes operadores de igualdade numérica -

Mostrar exemplo

Sr. Não.	Operador e descrição
1	== (equal to) Verifica se os valores de dois operandos são iguais ou não, se sim a condição torna-se verdadeira. Example - ($a == $b) não é verdade.
2	!= (not equal to) Verifica se o valor de dois operandos são iguais ou não; se os valores não são iguais, a condição se torna verdadeira. Example - ($a != $b) é verdade.
3	<=> Verifica se o valor de dois operandos é igual ou não e retorna -1, 0 ou 1 dependendo se o argumento esquerdo é numericamente menor, igual ou maior que o argumento direito. Example - ($a <=> $b) retorna -1.
4	> (greater than) Verifica se o valor do operando esquerdo é maior que o valor do operando direito, se sim então a condição torna-se verdadeira. Example - ($a > $b) não é verdade.
5	< (less than) Verifica se o valor do operando esquerdo é menor que o valor do operando direito; se sim, a condição torna-se verdadeira. Example - ($a < $b) é verdade.
6	>= (greater than or equal to) Verifica se o valor do operando esquerdo é maior ou igual ao valor do operando direito, se sim a condição torna-se verdadeira. Example - ($a >= $b) não é verdade.
7	<= (less than or equal to) Verifica se o valor do operando esquerdo é menor ou igual ao valor do operando direito; em caso afirmativo, a condição torna-se verdadeira. Example - ($a <= $b) é verdade.

Abaixo está uma lista de operadores de ações. Assumir variável$a holds "abc" and variable $b contém "xyz" então, vamos verificar os seguintes operadores de igualdade de string -

Mostrar exemplo

Sr. Não.	Operador e descrição
1	lt Retorna verdadeiro se o argumento esquerdo for menor que o argumento direito. Example - ($a lt $b) é verdade.
2	gt Retorna verdadeiro se o argumento esquerdo for stringwise maior que o argumento direito. Example - ($a gt $b) é falso.
3	le Retorna verdadeiro se o argumento esquerdo for stringwise menor ou igual ao argumento direito. Example - ($a le $b) é verdade.
4	ge Retorna verdadeiro se o argumento esquerdo for stringwise maior ou igual ao argumento direito. Example - ($a ge $b) é falso.
5	eq Retorna verdadeiro se o argumento esquerdo for stringwise igual ao argumento direito. Example - ($a eq $b) é falso.
6	ne Retorna verdadeiro se o argumento esquerdo for stringwise diferente do argumento direito. Example - ($a ne $b) é verdade.
7	cmp Retorna -1, 0 ou 1 dependendo se o argumento esquerdo é stringwise menor, igual ou maior que o argumento direito. Example - ($a cmp $b) é -1.

Operadores de atribuição Perl

Assumir variável $a holds 10 and variable $b contém 20, abaixo estão os operadores de atribuição disponíveis em Perl e seu uso -

Mostrar exemplo

Sr. Não.	Operador e descrição
1	= Operador de atribuição simples, atribui valores de operandos do lado direito para operando do lado esquerdo Example - $c = $a + $b will assigned value of $a + $b into $c
2	+= Adicionar operador de atribuição AND, adiciona o operando direito ao operando esquerdo e atribui o resultado ao operando esquerdo Example - $c += $a é equivalente a $c = $c + $ a
3	-= Subtrai o operador de atribuição AND, subtrai o operando direito do operando esquerdo e atribui o resultado ao operando esquerdo Example - $ c - = $a is equivalent to $c = $c - $uma
4	= Multiplicar E operador de atribuição, multiplica o operando direito com o operando esquerdo e atribui o resultado ao operando esquerdo Example* - $c = $a é equivalente a $c = $c $ a
5	/= Operador de atribuição e divisão, divide o operando esquerdo com o operando direito e atribui o resultado ao operando esquerdo Example - $ c / = $a is equivalent to $c = $c / $uma
6	%= Módulo E operador de atribuição, leva o módulo usando dois operandos e atribui o resultado ao operando esquerdo Example - $c %= $a é equivalente a $c = $c% a
7	= Exponente E operador de atribuição, executa cálculo exponencial (potência) nos operadores e atribui valor ao operando esquerdo Example - $c = $a é equivalente a $c = $c ** $ a

Operadores Perl Bitwise

O operador bit a bit funciona em bits e executa a operação bit a bit. Suponha que $ a = 60; e $ b = 13; Agora, em formato binário, eles serão os seguintes -

$ a = 0011 1100

$ b = 0000 1101

-----------------

$ a & $ b = 0000 1100

$ a | $ b = 0011 1101

$ a ^ $ b = 0011 0001

~ $ a = 1100 0011

Existem os seguintes operadores Bitwise suportados pela linguagem Perl, suponha que se $a = 60; and $b = 13

Mostrar exemplo

Sr. Não.	Operador e descrição
1	& O operador Binário AND copia um bit para o resultado se ele existir em ambos os operandos. Example - ($a & $b) dará 12 que é 0000 1100
2	\| O operador binário OR copia um bit se ele existir no operando eather. Example - ($a \| $b) dará 61 que é 0011 1101
3	^ O operador binário XOR copia o bit se estiver definido em um operando, mas não em ambos. Example - ($a ^ $b) dará 49 que é 0011 0001
4	~ O operador de complemento binários é unário e tem o efeito de 'inverter' bits. Example - (~ $ a) dará -61 que é 1100 0011 na forma de complemento de 2 devido a um número binário com sinal.
5	<< Operador binário de deslocamento à esquerda. O valor dos operandos à esquerda é movido para a esquerda pelo número de bits especificado pelo operando à direita. Example - $ a << 2 dará 240 que é 1111 0000
6	>> Operador binário de deslocamento à direita. O valor dos operandos à esquerda é movido para a direita pelo número de bits especificado pelo operando à direita. Example - $ a >> 2 resultará em 15, que é 0000 1111

Operadores lógicos Perl

Existem os seguintes operadores lógicos suportados pela linguagem Perl. Suponha que a variável $ a seja verdadeira e a variável $ b seja falsa, então -

Mostrar exemplo

Sr. Não.	Operador e descrição
1	and Operador lógico chamado AND. Se ambos os operandos forem verdadeiros, a condição se torna verdadeira. Example - ($ a e $ b) é falso.
2	&& O operador AND lógico estilo C copia um bit para o resultado se ele existir em ambos os operandos. Example - ($ a && $ b) é falso.
3	or Operador lógico ou chamado. Se qualquer um dos dois operandos for diferente de zero, a condição torna-se verdadeira. Example - ($ a ou $ b) é verdadeiro.
4	\|\| O operador OR lógico estilo C copia um bit se ele existir no operando eather. Example - ($ a \|\| $ b) é verdadeiro.
5	not Operador lógico chamado NOT. Use para reverter o estado lógico de seu operando. Se uma condição for verdadeira, o operador NOT lógico tornará falso. Example - not ($ a e $ b) é verdadeiro.

Operadores de orçamento

Existem os seguintes operadores do tipo Quote suportados pela linguagem Perl. Na tabela a seguir, um {} representa qualquer par de delimitadores que você escolher.

Mostrar exemplo

Sr. Não.	Operador e descrição
1	q{ } Inclui uma string entre aspas simples Example - q {abcd} dá 'abcd'
2	qq{ } Inclui uma string entre aspas duplas Example - qq {abcd} dá "abcd"
3	qx{ } Envolve uma string com aspas invertidas Example - qx {abcd} dá `abcd`

Operadores diversos

Existem diversos operadores a seguir suportados pela linguagem Perl. Suponha que a variável a tenha 10 e a variável b tenha 20, então -

Mostrar exemplo

Sr. Não.	Operador e descrição
1	. O operador binário ponto (.) Concatena duas strings. Example - Se $ a = "abc", $b = "def" then $a. $ b dará "abcdef"
2	x O operador de repetição x retorna uma string que consiste no operando esquerdo repetido o número de vezes especificado pelo operando direito. Example - ('-' x 3) dará ---.
3	.. O operador de intervalo .. retorna uma lista de valores contados (em unidades) do valor esquerdo para o valor direito Example - (2..5) dará (2, 3, 4, 5)
4	++ O operador de incremento automático aumenta o valor inteiro em um Example - $ a ++ dará 11
5	-- O operador Auto Decrement diminui o valor inteiro em um Example - $ a-- dará 9
6	-> O operador de seta é usado principalmente para remover a referência de um método ou variável de um objeto ou nome de classe Example - $ obj->$a is an example to access variable $a do objeto $ obj.

Precedência de operadores Perl

A tabela a seguir lista todos os operadores da mais alta precedência à mais baixa.

Mostrar exemplo

left	terms and list operators (leftward)
left	->
nonassoc	++ --
right	**
right	! ~ \ and unary + and -
left	=~ !~
left	* / % x
left	+ - .
left	<< >>
nonassoc	named unary operators
nonassoc	< > <= >= lt gt le ge
nonassoc	== != <=> eq ne cmp ~~
left	&
left	| ^
left	&&
left	|| //
nonassoc	..  ...
right	?:
right	= += -= *= etc.
left	, =>
nonassoc	list operators (rightward)
right	not
left	and
left	or xor

Este capítulo lhe dará o conhecimento básico sobre como processar e manipular datas e horas em Perl.

Data e hora atuais

Vamos começar com localtime()função, que retorna valores para a data e hora atuais se não houver argumentos. A seguir está a lista de 9 elementos retornada pelolocaltime função ao usar no contexto de lista -

sec,     # seconds of minutes from 0 to 61
min,     # minutes of hour from 0 to 59
hour,    # hours of day from 0 to 24
mday,    # day of month from 1 to 31
mon,     # month of year from 0 to 11
year,    # year since 1900
wday,    # days since sunday
yday,    # days since January 1st
isdst    # hours of daylight savings time

Experimente o seguinte exemplo para imprimir diferentes elementos retornados pela função localtime () -

#!/usr/local/bin/perl
 
@months = qw( Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec );
@days = qw(Sun Mon Tue Wed Thu Fri Sat Sun);

($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime();
print "$mday $months[$mon] $days[$wday]\n";

Quando o código acima é executado, ele produz o seguinte resultado -

16 Feb Sat

Se você usar a função localtime () no contexto escalar, ela retornará a data e a hora do fuso horário atual definido no sistema. Experimente o seguinte exemplo para imprimir a data e hora atuais em formato completo -

#!/usr/local/bin/perl
 
$datestring = localtime();
print "Local date and time $datestring\n";

Quando o código acima é executado, ele produz o seguinte resultado -

Local date and time Sat Feb 16 06:50:45 2013

Hora GMT

A função gmtime()funciona exatamente como a função localtime (), mas os valores retornados são localizados para o fuso horário de Greenwich padrão. Quando chamado no contexto de lista, $ isdst, o último valor retornado por gmtime, é sempre 0. Não há horário de verão no GMT.

Você deve tomar nota do fato de que localtime () retornará a hora local atual na máquina que executa o script e gmtime () retornará a hora universal de Greenwich, ou GMT (ou UTC).

Experimente o seguinte exemplo para imprimir a data e hora atuais, mas em escala GMT -

#!/usr/local/bin/perl

$datestring = gmtime(); print "GMT date and time $datestring\n";

Quando o código acima é executado, ele produz o seguinte resultado -

GMT date and time Sat Feb 16 13:50:45 2013

Formato de data e hora

Você pode usar a função localtime () para obter uma lista de 9 elementos e mais tarde você pode usar o printf() função para formatar data e hora com base em seus requisitos, como segue -

#!/usr/local/bin/perl
 
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(); printf("Time Format - HH:MM:SS\n"); printf("%02d:%02d:%02d", $hour, $min, $sec);

Quando o código acima é executado, ele produz o seguinte resultado -

Time Format - HH:MM:SS
06:58:52

Tempo de época

Você pode usar a função time () para obter o tempo da época, ou seja, o número de segundos decorridos desde uma determinada data, no Unix é 1º de janeiro de 1970.

#!/usr/local/bin/perl
 
$epoc = time(); print "Number of seconds since Jan 1, 1970 - $epoc\n";

Quando o código acima é executado, ele produz o seguinte resultado -

Number of seconds since Jan 1, 1970 - 1361022130

Você pode converter um determinado número de segundos em string de data e hora da seguinte maneira -

#!/usr/local/bin/perl

$datestring = localtime(); print "Current date and time $datestring\n";

$epoc = time(); $epoc = $epoc - 24 * 60 * 60; # one day before of current date. $datestring = localtime($epoc); print "Yesterday's date and time $datestring\n";

Quando o código acima é executado, ele produz o seguinte resultado -

Current date and time Tue Jun  5 05:54:43 2018
Yesterday's date and time Mon Jun  4 05:54:43 2018

Função POSIX strftime ()

Você pode usar a função POSIX strftime()para formatar a data e a hora com a ajuda da tabela a seguir. Observe que os especificadores marcados com um asterisco (*) dependem da localidade.

Especificador	Substituído por	Exemplo
`%a`	Nome abreviado do dia da semana *	`Thu`
`%A`	Nome completo do dia da semana *	`Thursday`
`%b`	Nome abreviado do mês *	`Aug`
`%B`	Nome completo do mês *	`August`
`%c`	Representação de data e hora *	`Thu Aug 23 14:55:02 2001`
`%C`	Ano dividido por 100 e truncado em um número inteiro ( `00-99`)	`20`
`%d`	Dia do mês, preenchido com zeros ( `01-31`)	`23`
`%D`	`MM/DD/YY`Data abreviada , equivalente a`%m/%d/%y`	`08/23/01`
`%e`	Dia do mês, preenchido com espaço ( `1-31`)	`23`
`%F`	`YYYY-MM-DD`Data abreviada , equivalente a`%Y-%m-%d`	`2001-08-23`
`%g`	Ano baseado na semana, últimos dois dígitos ( `00-99`)	`01`
`%G`	Ano baseado na semana	`2001`
`%h`	Nome abreviado do mês * (igual a `%b`)	`Aug`
`%H`	Hora no formato 24h ( `00-23`)	`14`
`%I`	Hora no formato 12h ( `01-12`)	`02`
`%j`	Dia do ano ( `001-366`)	`235`
`%m`	Mês como um número decimal ( `01-12`)	`08`
`%M`	Minuto ( `00-59`)	`55`
`%n`	Caractere de nova linha ( `'\n'`)
`%p`	Designação AM ou PM	`PM`
`%r`	Relógio de 12 horas *	`02:55:02 pm`
`%R`	Tempo de 24 horas `HH:MM`, equivalente a`%H:%M`	`14:55`
`%S`	Segundo ( `00-61`)	`02`
`%t`	Caractere de tabulação horizontal ( `'\t'`)
`%T`	Formato de hora ISO 8601 ( `HH:MM:SS`), equivalente a`%H:%M:%S`	`14:55`
`%u`	Dia da semana ISO 8601 como número com segunda-feira como `1`( `1-7`)	`4`
`%U`	Número da semana com o primeiro domingo como o primeiro dia da semana um ( `00-53`)	`33`
`%V`	Número da semana ISO 8601 ( `00-53`)	`34`
`%w`	Dia da semana como um número decimal com domingo como `0`( `0-6`)	`4`
`%W`	Número da semana com a primeira segunda-feira como o primeiro dia da semana um ( `00-53`)	`34`
`%x`	Representação de data *	`08/23/01`
`%X`	Representação de tempo *	`14:55:02`
`%y`	Ano, últimos dois dígitos ( `00-99`)	`01`
`%Y`	Ano	`2001`
`%z`	Deslocamento ISO 8601 do UTC no fuso horário (1 minuto = 1, 1 hora = 100) Se o fuso horário não puder ser encerrado, nenhum caractere	`+100`
`%Z`	Nome ou abreviatura do fuso horário * Se o fuso horário não puder ser encerrado, nenhum caractere	`CDT`
`%%`	Um `%`sinal	`%`

Vamos verificar o exemplo a seguir para entender o uso -

#!/usr/local/bin/perl
use POSIX qw(strftime);

$datestring = strftime "%a %b %e %H:%M:%S %Y", localtime; printf("date and time - $datestring\n");

# or for GMT formatted appropriately for your locale:
$datestring = strftime "%a %b %e %H:%M:%S %Y", gmtime; printf("date and time - $datestring\n");

Quando o código acima é executado, ele produz o seguinte resultado -

date and time - Sat Feb 16 07:10:23 2013
date and time - Sat Feb 16 14:10:23 2013

Uma sub-rotina ou função Perl é um grupo de instruções que, juntas, executam uma tarefa. Você pode dividir seu código em sub-rotinas separadas. Como você divide seu código entre diferentes sub-rotinas é com você, mas logicamente a divisão geralmente é para que cada função execute uma tarefa específica.

Perl usa os termos sub-rotina, método e função alternadamente.

Definir e chamar uma sub-rotina

A forma geral de definição de uma sub-rotina na linguagem de programação Perl é a seguinte -

sub subroutine_name {
   body of the subroutine
}

A maneira típica de chamar essa sub-rotina Perl é a seguinte -

subroutine_name( list of arguments );

Nas versões do Perl anteriores à 5.0, a sintaxe para chamar sub-rotinas era ligeiramente diferente, conforme mostrado abaixo. Isso ainda funciona nas versões mais recentes do Perl, mas não é recomendado, pois ignora os protótipos da sub-rotina.

&subroutine_name( list of arguments );

Vamos dar uma olhada no exemplo a seguir, que define uma função simples e depois a chama. Como o Perl compila seu programa antes de executá-lo, não importa onde você declara sua sub-rotina.

#!/usr/bin/perl

# Function definition
sub Hello {
   print "Hello, World!\n";
}

# Function call
Hello();

Quando o programa acima é executado, ele produz o seguinte resultado -

Hello, World!

Passando Argumentos para uma Sub-rotina

Você pode passar vários argumentos para uma sub-rotina como você faz em qualquer outra linguagem de programação e eles podem ser acessados dentro da função usando o array especial @_. Assim, o primeiro argumento para a função está em$_[0], the second is in $_ [1] e assim por diante.

Você pode passar arrays e hashes como argumentos como qualquer escalar, mas passar mais de um array ou hash normalmente faz com que percam suas identidades separadas. Portanto, usaremos referências (explicadas no próximo capítulo) para passar qualquer array ou hash.

Vamos tentar o exemplo a seguir, que pega uma lista de números e imprime sua média -

#!/usr/bin/perl

# Function definition
sub Average {
   # get total number of arguments passed.
   $n = scalar(@_); $sum = 0;

   foreach $item (@_) { $sum += $item; } $average = $sum / $n;

   print "Average for the given numbers : $average\n";
}

# Function call
Average(10, 20, 30);

Quando o programa acima é executado, ele produz o seguinte resultado -

Average for the given numbers : 20

Passando listas para sub-rotinas

Como a variável @_ é uma matriz, ela pode ser usada para fornecer listas a uma sub-rotina. No entanto, devido à maneira como o Perl aceita e analisa listas e arrays, pode ser difícil extrair os elementos individuais de @_. Se você tiver que passar uma lista junto com outros argumentos escalares, faça lista como o último argumento como mostrado abaixo -

#!/usr/bin/perl

# Function definition
sub PrintList {
   my @list = @_;
   print "Given list is @list\n";
}
$a = 10;
@b = (1, 2, 3, 4);

# Function call with list parameter
PrintList($a, @b);

Quando o programa acima é executado, ele produz o seguinte resultado -

Given list is 10 1 2 3 4

Passando Hashes para Sub-rotinas

Quando você fornece um hash para uma sub-rotina ou operador que aceita uma lista, o hash é automaticamente traduzido em uma lista de pares de chave / valor. Por exemplo -

#!/usr/bin/perl

# Function definition
sub PrintHash {
   my (%hash) = @_;

   foreach my $key ( keys %hash ) {
      my $value = $hash{$key}; print "$key : $value\n";
   }
}
%hash = ('name' => 'Tom', 'age' => 19);

# Function call with hash parameter
PrintHash(%hash);

Quando o programa acima é executado, ele produz o seguinte resultado -

name : Tom
age : 19

Retornando valor de uma sub-rotina

Você pode retornar um valor da sub-rotina como faria em qualquer outra linguagem de programação. Se você não estiver retornando um valor de uma sub-rotina, qualquer cálculo executado pela última vez em uma sub-rotina também será automaticamente o valor de retorno.

Você pode retornar matrizes e hashes da sub-rotina como qualquer escalar, mas retornar mais de uma matriz ou hash normalmente faz com que percam suas identidades separadas. Portanto, usaremos referências (explicadas no próximo capítulo) para retornar qualquer array ou hash de uma função.

Vamos tentar o exemplo a seguir, que pega uma lista de números e retorna sua média -

#!/usr/bin/perl

# Function definition
sub Average {
   # get total number of arguments passed.
   $n = scalar(@_);
   $sum = 0; foreach $item (@_) {
      $sum += $item;
   }
   $average = $sum / $n; return $average;
}

# Function call
$num = Average(10, 20, 30); print "Average for the given numbers : $num\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

Average for the given numbers : 20

Variáveis privadas em uma sub-rotina

Por padrão, todas as variáveis em Perl são variáveis globais, o que significa que podem ser acessadas de qualquer lugar no programa. Mas você pode criarprivate variáveis chamadas lexical variables a qualquer momento com o my operador.

o myoperador confina uma variável a uma região específica do código na qual ela pode ser usada e acessada. Fora dessa região, esta variável não pode ser usada ou acessada. Esta região é chamada de escopo. Um escopo léxico é geralmente um bloco de código com um conjunto de colchetes ao seu redor, como aqueles que definem o corpo da sub-rotina ou aqueles que marcam os blocos de código de instruções if, while, for, foreach e eval .

A seguir está um exemplo que mostra como definir uma única ou várias variáveis privadas usando my operador -

sub somefunc {
   my $variable; # $variable is invisible outside somefunc()
   my ($another, @an_array, %a_hash); # declaring many variables at once
}

Vamos verificar o exemplo a seguir para distinguir entre variáveis globais e privadas -

#!/usr/bin/perl

# Global variable
$string = "Hello, World!";

# Function definition
sub PrintHello {
   # Private variable for PrintHello function
   my $string; $string = "Hello, Perl!";
   print "Inside the function $string\n"; } # Function call PrintHello(); print "Outside the function $string\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

Inside the function Hello, Perl!
Outside the function Hello, World!

Valores temporários via local ()

o localé usado principalmente quando o valor atual de uma variável deve ser visível para as sub-rotinas chamadas. Um local apenas fornece valores temporários para variáveis globais (significando pacote). Isso é conhecido como escopo dinâmico . O escopo lexical é feito com my, que funciona mais como as declarações automáticas de C.

Se mais de uma variável ou expressão for atribuída a local, elas devem ser colocadas entre parênteses. Este operador funciona salvando os valores atuais dessas variáveis em sua lista de argumentos em uma pilha oculta e restaurando-os ao sair do bloco, sub-rotina ou eval.

Vamos verificar o exemplo a seguir para distinguir entre variáveis globais e locais -

#!/usr/bin/perl

# Global variable
$string = "Hello, World!"; sub PrintHello { # Private variable for PrintHello function local $string;
   $string = "Hello, Perl!"; PrintMe(); print "Inside the function PrintHello $string\n";
}
sub PrintMe {
   print "Inside the function PrintMe $string\n"; } # Function call PrintHello(); print "Outside the function $string\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

Inside the function PrintMe Hello, Perl!
Inside the function PrintHello Hello, Perl!
Outside the function Hello, World!

Variáveis de estado via estado ()

Há outro tipo de variáveis lexicais, que são semelhantes às variáveis privadas, mas mantêm seu estado e não são reinicializadas após várias chamadas das sub-rotinas. Essas variáveis são definidas usando ostate operador e disponível a partir de Perl 5.9.4.

Vamos verificar o exemplo a seguir para demonstrar o uso de state variáveis -

#!/usr/bin/perl

use feature 'state';

sub PrintCount {
   state $count = 0; # initial value print "Value of counter is $count\n";
   $count++;
}

for (1..5) {
   PrintCount();
}

Quando o programa acima é executado, ele produz o seguinte resultado -

Value of counter is 0
Value of counter is 1
Value of counter is 2
Value of counter is 3
Value of counter is 4

Antes do Perl 5.10, você teria que escrever assim -

#!/usr/bin/perl

{
   my $count = 0; # initial value

   sub PrintCount {
      print "Value of counter is $count\n"; $count++;
   }
}

for (1..5) {
   PrintCount();
}

Contexto de chamada de subrotina

O contexto de uma sub-rotina ou instrução é definido como o tipo de valor de retorno esperado. Isso permite que você use uma única função que retorna valores diferentes com base no que o usuário espera receber. Por exemplo, o seguinte localtime () retorna uma string quando é chamado no contexto escalar, mas retorna uma lista quando é chamado no contexto da lista.

my $datestring = localtime( time );

Neste exemplo, o valor de $ timestr agora é uma string composta pela data e hora atuais, por exemplo, Thu Nov 30 15:21:33 2000. Inversamente -

($sec,$min,$hour,$mday,$mon, $year,$wday,$yday,$isdst) = localtime(time);

Agora as variáveis individuais contêm os valores correspondentes retornados pela sub-rotina localtime ().

Uma referência Perl é um tipo de dado escalar que contém a localização de outro valor que pode ser escalar, matrizes ou hashes. Por causa de sua natureza escalar, uma referência pode ser usada em qualquer lugar, um escalar pode ser usado.

Você pode construir listas contendo referências a outras listas, que podem conter referências a hashes e assim por diante. É assim que as estruturas de dados aninhadas são construídas em Perl.

Criar referências

É fácil criar uma referência para qualquer variável, sub-rotina ou valor prefixando-o com uma barra invertida da seguinte maneira -

$scalarref = \$foo; $arrayref  = \@ARGV;
$hashref = \%ENV; $coderef   = \&handler;
$globref   = \*foo;

Você não pode criar uma referência em um identificador de I / O (filehandle ou dirhandle) usando o operador de barra invertida, mas uma referência a uma matriz anônima pode ser criada usando os colchetes da seguinte maneira -

$arrayref = [1, 2, ['a', 'b', 'c']];

De maneira semelhante, você pode criar uma referência a um hash anônimo usando as chaves da seguinte maneira -

$hashref = {
   'Adam'  => 'Eve',
   'Clyde' => 'Bonnie',
};

Uma referência a uma sub-rotina anônima pode ser criada usando sub sem um subnome como segue -

$coderef = sub { print "Boink!\n" };

Desreferenciamento

A desreferenciação retorna o valor de um ponto de referência para o local. Para cancelar a referência de uma referência, simplesmente use $, @ ou% como prefixo da variável de referência, dependendo se a referência está apontando para um escalar, array ou hash. A seguir está o exemplo para explicar o conceito -

#!/usr/bin/perl

$var = 10;

# Now $r has reference to $var scalar.
$r = \$var;

# Print value available at the location stored in $r. print "Value of $var is : ", $$r, "\n"; @var = (1, 2, 3); # Now $r has reference to @var array.
$r = \@var; # Print values available at the location stored in $r.
print "Value of @var is : ",  @$r, "\n"; %var = ('key1' => 10, 'key2' => 20); # Now $r has reference to %var hash.
$r = \%var; # Print values available at the location stored in $r.
print "Value of %var is : ", %$r, "\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

Value of 10 is : 10
Value of 1 2 3 is : 123
Value of %var is : key220key110

Se você não tem certeza sobre um tipo de variável, é fácil saber seu tipo usando ref, que retorna uma das seguintes strings se seu argumento for uma referência. Caso contrário, retorna falso -

SCALAR
ARRAY
HASH
CODE
GLOB
REF

Vamos tentar o seguinte exemplo -

#!/usr/bin/perl

$var = 10;
$r = \$var;
print "Reference type in r : ", ref($r), "\n"; @var = (1, 2, 3); $r = \@var;
print "Reference type in r : ", ref($r), "\n"; %var = ('key1' => 10, 'key2' => 20); $r = \%var;
print "Reference type in r : ", ref($r), "\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

Reference type in r : SCALAR
Reference type in r : ARRAY
Reference type in r : HASH

Referências circulares

Uma referência circular ocorre quando duas referências contêm uma referência uma à outra. Você deve ter cuidado ao criar referências, caso contrário, uma referência circular pode levar a vazamentos de memória. A seguir está um exemplo -

#!/usr/bin/perl

 my $foo = 100;
 $foo = \$foo;
 
 print "Value of foo is : ", $$foo, "\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

Value of foo is : REF(0x9aae38)

Referências a funções

Isso pode acontecer se você precisar criar um manipulador de sinal para que possa produzir uma referência a uma função precedendo esse nome de função com \ & e para desreferenciar essa referência, você simplesmente precisa prefixar a variável de referência usando "e" comercial &. A seguir está um exemplo -

#!/usr/bin/perl

# Function definition
sub PrintHash {
   my (%hash) = @_;
   
   foreach $item (%hash) {
      print "Item : $item\n"; } } %hash = ('name' => 'Tom', 'age' => 19); # Create a reference to above function. $cref = \&PrintHash;

# Function call using reference.
&$cref(%hash);

Quando o programa acima é executado, ele produz o seguinte resultado -

Item : name
Item : Tom
Item : age
Item : 19

Perl usa um modelo de escrita chamado 'formato' para gerar relatórios. Para usar o recurso de formato do Perl, você deve primeiro definir um formato e, em seguida, usar esse formato para gravar dados formatados.

Defina um formato

A seguir está a sintaxe para definir um formato Perl -

format FormatName =
fieldline
value_one, value_two, value_three
fieldline
value_one, value_two
.

Aqui FormatNamerepresenta o nome do formato. ofieldlineé a forma específica, os dados devem ser formatados. As linhas de valores representam os valores que serão inseridos na linha de campo. Você termina o formato com um único ponto.

Próximo fieldlinepode conter qualquer texto ou campos. Os fieldholders mantêm espaço para dados que serão colocados lá em uma data posterior. Um fieldholder tem o formato -

@<<<<

Este campo é justificado à esquerda, com um espaço de campo de 5. Você deve contar o sinal @ e os sinais <para saber o número de espaços no campo. Outros titulares de campo incluem -

@>>>> right-justified
@|||| centered
@####.## numeric field holder
@* multiline field holder

Um exemplo de formato seria -

format EMPLOYEE =
===================================
@<<<<<<<<<<<<<<<<<<<<<< @<< 
$name $age @#####.## $salary
===================================
.

Neste exemplo, $ name seria escrito justificado à esquerda dentro de 22 espaços de caracteres e, após essa idade, seria escrito em dois espaços.

Usando o formato

Para invocar esta declaração de formato, usaríamos o write palavra-chave -

write EMPLOYEE;

O problema é que o nome do formato é geralmente o nome de um identificador de arquivo aberto e a instrução de gravação enviará a saída para esse identificador de arquivo. Como queremos que os dados sejam enviados ao STDOUT, devemos associar EMPLOYEE ao arquivo STDOUT. Primeiro, no entanto, devemos ter certeza de que STDOUT é nosso identificador de arquivo selecionado, usando a função select ().

select(STDOUT);

Em seguida, associaríamos EMPLOYEE a STDOUT definindo o novo nome de formato com STDOUT, usando a variável especial $ ~ ou $ FORMAT_NAME da seguinte maneira -

$~ = "EMPLOYEE";

Quando agora fazemos um write (), os dados seriam enviados para STDOUT. Lembre-se: se você vai escrever seu relatório em qualquer outro identificador de arquivo em vez de STDOUT, então você pode usar a função select () para selecionar esse identificador de arquivo e o resto da lógica permanecerá o mesmo.

Vamos dar o seguinte exemplo. Aqui temos valores embutidos em código apenas para mostrar o uso. No uso real, você lerá valores de um arquivo ou banco de dados para gerar relatórios reais e poderá precisar escrever o relatório final novamente em um arquivo.

#!/usr/bin/perl

format EMPLOYEE =
===================================
@<<<<<<<<<<<<<<<<<<<<<< @<< 
$name $age
@#####.##
$salary =================================== . select(STDOUT); $~ = EMPLOYEE;

@n = ("Ali", "Raza", "Jaffer");
@a  = (20,30, 40);
@s = (2000.00, 2500.00, 4000.000);

$i = 0; foreach (@n) { $name = $_; $age = $a[$i];
   $salary = $s[$i++];
   write;
}

Quando executado, isso produzirá o seguinte resultado -

===================================
Ali                     20
  2000.00
===================================
===================================
Raza                    30
  2500.00
===================================
===================================
Jaffer                  40
  4000.00
===================================

Defina um cabeçalho de relatório

Tudo parece bem. Mas você estaria interessado em adicionar um cabeçalho ao seu relatório. Este cabeçalho será impresso no topo de cada página. É muito simples fazer isso. Além de definir um modelo, você teria que definir um cabeçalho e atribuí-lo à variável $ ^ ou $ FORMAT_TOP_NAME -

#!/usr/bin/perl

format EMPLOYEE =
===================================
@<<<<<<<<<<<<<<<<<<<<<< @<< 
$name $age @#####.## $salary
===================================
.

format EMPLOYEE_TOP =
===================================
Name                    Age
===================================
.

select(STDOUT);
$~ = EMPLOYEE; $^ = EMPLOYEE_TOP;

@n = ("Ali", "Raza", "Jaffer");
@a  = (20,30, 40);
@s = (2000.00, 2500.00, 4000.000);

$i = 0; foreach (@n) { $name = $_; $age = $a[$i];
   $salary = $s[$i++];
   write;
}

Agora o seu relatório será semelhante a -

===================================
Name                    Age
===================================
===================================
Ali                     20
  2000.00
===================================
===================================
Raza                    30
  2500.00
===================================
===================================
Jaffer                  40
  4000.00
===================================

Defina uma paginação

E se o seu relatório ocupar mais de uma página? Você tem uma solução para isso, basta usar$% ou $ FORMAT_PAGE_NUMBER variável junto com o cabeçalho da seguinte forma -

format EMPLOYEE_TOP =
===================================
Name                    Age Page @<
                                 $%
===================================                               
.

Agora, sua saída será a seguinte -

===================================
Name                    Age Page 1
===================================
===================================
Ali                     20
  2000.00
===================================
===================================
Raza                    30
  2500.00
===================================
===================================
Jaffer                  40
  4000.00
===================================

Número de linhas em uma página

Você pode definir o número de linhas por página usando uma variável especial $= (ou $ FORMAT_LINES_PER_PAGE), por padrão $ = será 60.

Definir um rodapé de relatório

Enquanto $ ^ ou $FORMAT_TOP_NAME contains the name of the current header format, there is no corresponding mechanism to automatically do the same thing for a footer. If you have a fixed-size footer, you can get footers by checking variable $- ou $ FORMAT_LINES_LEFT antes de cada write () e imprima o rodapé se necessário usando outro formato definido a seguir -

format EMPLOYEE_BOTTOM =
End of Page @<
            $%
.

Para um conjunto completo de variáveis relacionadas à formatação, consulte a seção Variáveis especiais do Perl .

Os princípios básicos de manipulação de arquivos são simples: você associa um filehandle com uma entidade externa (geralmente um arquivo) e, em seguida, use uma variedade de operadores e funções no Perl para ler e atualizar os dados armazenados no fluxo de dados associado ao filehandle.

Um filehandle é uma estrutura Perl interna nomeada que associa um arquivo físico a um nome. Todos os filehandles são capazes de acesso de leitura / gravação, para que você possa ler e atualizar qualquer arquivo ou dispositivo associado a um filehandle. No entanto, ao associar um identificador de arquivo, você pode especificar o modo no qual o identificador de arquivo é aberto.

Três identificadores básicos de arquivo são - STDIN, STDOUT, e STDERR, que representam entrada padrão, saída padrão e dispositivos de erro padrão, respectivamente.

Abrindo e fechando arquivos

Existem duas funções a seguir com vários formulários, que podem ser usados para abrir qualquer arquivo novo ou existente em Perl.

open FILEHANDLE, EXPR
open FILEHANDLE

sysopen FILEHANDLE, FILENAME, MODE, PERMS
sysopen FILEHANDLE, FILENAME, MODE

Aqui FILEHANDLE é o identificador de arquivo retornado pelo open e EXPR é a expressão com o nome do arquivo e o modo de abertura do arquivo.

Função aberta

A seguir está a sintaxe para abrir file.txtno modo somente leitura. Aqui, menos de <sinal indica que o arquivo deve ser aberto no modo somente leitura.

open(DATA, "<file.txt");

Aqui, DATA é o identificador do arquivo, que será usado para ler o arquivo. Aqui está o exemplo, que abrirá um arquivo e imprimirá seu conteúdo na tela.

#!/usr/bin/perl

open(DATA, "<file.txt") or die "Couldn't open file file.txt, $!"; while(<DATA>) { print "$_";
}

A seguir está a sintaxe para abrir file.txt no modo de escrita. Aqui, o sinal de menos de> indica que o arquivo deve ser aberto no modo de gravação.

open(DATA, ">file.txt") or die "Couldn't open file file.txt, $!";

Na verdade, este exemplo trunca (esvazia) o arquivo antes de abri-lo para gravação, o que pode não ser o efeito desejado. Se você deseja abrir um arquivo para leitura e gravação, pode colocar um sinal de mais antes dos caracteres> ou <.

Por exemplo, para abrir um arquivo para atualização sem truncá-lo -

open(DATA, "+<file.txt"); or die "Couldn't open file file.txt, $!";

Para truncar o arquivo primeiro -

open DATA, "+>file.txt" or die "Couldn't open file file.txt, $!";

Você pode abrir um arquivo no modo de acréscimo. Neste modo, o ponto de gravação será definido para o final do arquivo.

open(DATA,">>file.txt") || die "Couldn't open file file.txt, $!";

Um duplo >> abre o arquivo para anexar, colocando o ponteiro do arquivo no final, para que você possa começar a anexar informações imediatamente. No entanto, você não pode ler a menos que também coloque um sinal de adição na frente dele -

open(DATA,"+>>file.txt") || die "Couldn't open file file.txt, $!";

A seguir está a tabela, que fornece os valores possíveis de diferentes modos

Sr. Não.	Entidades e definição
1	< or r Acesso somente leitura
2	> or w Cria, grava e trunca
3	>> or a Grava, acrescenta e cria
4	+< or r+ Lê e escreve
5	+> or w+ Lê, escreve, cria e trunca
6	+>> or a+ Lê, escreve, acrescenta e cria

Função Sysopen

o sysopen função é semelhante à função aberta principal, exceto que usa o sistema open() função, usando os parâmetros fornecidos a ela como os parâmetros para a função do sistema -

Por exemplo, para abrir um arquivo para atualização, emulando o +<filename formato de aberto -

sysopen(DATA, "file.txt", O_RDWR);

Ou para truncar o arquivo antes de atualizar -

sysopen(DATA, "file.txt", O_RDWR|O_TRUNC );

Você pode usar O_CREAT para criar um novo arquivo e O_WRONLY- para abrir o arquivo no modo somente gravação e O_RDONLY - para abrir o arquivo no modo somente leitura.

o PERMSargumento especifica as permissões de arquivo para o arquivo especificado, se ele tiver que ser criado. Por padrão, leva0x666.

A seguir está a tabela, que fornece os valores possíveis de MODE.

Sr. Não.	Entidades e definição
1	O_RDWR Leia e escreva
2	O_RDONLY Somente leitura
3	O_WRONLY Somente escrita
4	O_CREAT Crie o arquivo
5	O_APPEND Anexar o arquivo
6	O_TRUNC Truncar o arquivo
7	O_EXCL Pára se o arquivo já existe
8	O_NONBLOCK Usabilidade sem bloqueio

Fechar Função

Para fechar um filehandle e, portanto, desassociar o filehandle do arquivo correspondente, você usa o closefunção. Isso esvazia os buffers do manipulador de arquivos e fecha o descritor de arquivo do sistema.

close FILEHANDLE
close

Se nenhum FILEHANDLE for especificado, ele fecha o filehandle atualmente selecionado. Ele retorna verdadeiro apenas se conseguir liberar os buffers e fechar o arquivo.

close(DATA) || die "Couldn't close file properly";

Ler e gravar arquivos

Depois de abrir um filehandle, você precisa ser capaz de ler e gravar informações. Existem várias maneiras diferentes de ler e gravar dados no arquivo.

O operador <FILEHANDL>

O principal método de leitura das informações de um filehandle aberto é o operador <FILEHANDLE>. Em um contexto escalar, ele retorna uma única linha do filehandle. Por exemplo -

#!/usr/bin/perl

print "What is your name?\n";
$name = <STDIN>;
print "Hello $name\n";

Quando você usa o operador <FILEHANDLE> em um contexto de lista, ele retorna uma lista de linhas do filehandle especificado. Por exemplo, para importar todas as linhas de um arquivo para uma matriz -

#!/usr/bin/perl

open(DATA,"<import.txt") or die "Can't open data";
@lines = <DATA>;
close(DATA);

Função getc

A função getc retorna um único caractere do FILEHANDLE especificado ou STDIN se nenhum for especificado -

getc FILEHANDLE
getc

Se houver um erro ou se o filehandle estiver no final do arquivo, undef é retornado.

ler função

A função read lê um bloco de informações do filehandle em buffer: Esta função é usada para ler dados binários do arquivo.

read FILEHANDLE, SCALAR, LENGTH, OFFSET
read FILEHANDLE, SCALAR, LENGTH

O comprimento dos dados lidos é definido por LENGTH e os dados são colocados no início de SCALAR se nenhum OFFSET for especificado. Caso contrário, os dados são colocados após os bytes OFFSET em SCALAR. A função retorna o número de bytes lidos em caso de sucesso, zero no final do arquivo ou undef se houver um erro.

função de impressão

Para todos os diferentes métodos usados para ler informações de filehandles, a função principal para escrever informações de volta é a função de impressão.

print FILEHANDLE LIST
print LIST
print

A função de impressão imprime o valor avaliado de LIST para FILEHANDLE ou para o arquivo de saída atual (STDOUT por padrão). Por exemplo -

print "Hello World!\n";

Copiando arquivos

Aqui está o exemplo, que abre um arquivo existente file1.txt e lê-o linha por linha e gera outro arquivo de cópia file2.txt.

#!/usr/bin/perl

# Open file to read
open(DATA1, "<file1.txt");

# Open new file to write
open(DATA2, ">file2.txt");

# Copy data from one file to another.
while(<DATA1>) {
   print DATA2 $_;
}
close( DATA1 );
close( DATA2 );

Renomeando um arquivo

Aqui está um exemplo, que mostra como podemos renomear um arquivo file1.txt para file2.txt. Assumindo que o arquivo está disponível no diretório / usr / test.

#!/usr/bin/perl

rename ("/usr/test/file1.txt", "/usr/test/file2.txt" );

Esta função renames recebe dois argumentos e apenas renomeia o arquivo existente.

Excluindo um Arquivo Existente

Aqui está um exemplo, que mostra como excluir um arquivo file1.txt usando o unlink função.

#!/usr/bin/perl

unlink ("/usr/test/file1.txt");

Posicionamento dentro de um arquivo

Você pode usar para tell função para saber a posição atual de um arquivo e seek função para apontar uma posição particular dentro do arquivo.

conta a função

O primeiro requisito é encontrar a sua posição dentro de um arquivo, o que você faz usando a função tell -

tell FILEHANDLE
tell

Isso retorna a posição do ponteiro do arquivo, em bytes, dentro de FILEHANDLE se especificado, ou o identificador de arquivo selecionado padrão atual se nenhum for especificado.

função de busca

A função de busca posiciona o ponteiro do arquivo para o número especificado de bytes dentro de um arquivo -

seek FILEHANDLE, POSITION, WHENCE

A função usa a função do sistema fseek, e você tem a mesma capacidade de posicionar em relação a três pontos diferentes: o início, o fim e a posição atual. Você faz isso especificando um valor para WHENCE.

Zero define o posicionamento em relação ao início do arquivo. Por exemplo, a linha define o ponteiro do arquivo para o 256º byte no arquivo.

seek DATA, 256, 0;

Informação do arquivo

Você pode testar certos recursos muito rapidamente dentro do Perl usando uma série de operadores de teste conhecidos coletivamente como testes -X. Por exemplo, para realizar um teste rápido das várias permissões em um arquivo, você pode usar um script como este -

#/usr/bin/perl

my $file = "/usr/test/file1.txt"; my (@description, $size);
if (-e $file) { push @description, 'binary' if (-B _); push @description, 'a socket' if (-S _); push @description, 'a text file' if (-T _); push @description, 'a block special file' if (-b _); push @description, 'a character special file' if (-c _); push @description, 'a directory' if (-d _); push @description, 'executable' if (-x _); push @description, (($size = -s _)) ? "$size bytes" : 'empty'; print "$file is ", join(', ',@description),"\n";
}

Aqui está a lista de recursos, que você pode verificar para um arquivo ou diretório -

Sr. Não.	Operador e definição
1	-A Hora de início do script menos hora do último acesso ao arquivo, em dias.
2	-B É um arquivo binário?
3	-C Horário de início do script menos o tempo de alteração do último inode do arquivo, em dias.
3	-M Hora de início do script menos a hora de modificação do arquivo, em dias.
4	-O O arquivo pertence ao ID de usuário real?
5	-R O arquivo pode ser lido pelo ID de usuário real ou grupo real?
6	-S O arquivo é um soquete?
7	-T É um arquivo de texto?
8	-W O arquivo pode ser gravado pelo ID do usuário real ou pelo grupo real?
9	-X O arquivo é executável pelo ID de usuário real ou grupo real?
10	-b É um arquivo especial de bloco?
11	-c É um arquivo especial de caracteres?
12	-d O arquivo é um diretório?
13	-e O arquivo existe?
14	-f É um arquivo simples?
15	-g O arquivo tem o bit setgid definido?
16	-k O arquivo tem o bit sticky definido?
17	-l O arquivo é um link simbólico?
18	-o O arquivo pertence ao ID de usuário efetivo?
19	-p O arquivo é um pipe nomeado?
20	-r O arquivo pode ser lido pelo usuário efetivo ou ID de grupo?
21	-s Retorna o tamanho do arquivo, tamanho zero = arquivo vazio.
22	-t O filehandle é aberto por um TTY (terminal)?
23	-u O arquivo tem o bit setuid definido?
24	-w O arquivo pode ser gravado pelo usuário efetivo ou ID de grupo?
25	-x O arquivo pode ser executado pelo usuário efetivo ou ID de grupo?
26	-z O tamanho do arquivo é zero?

A seguir estão as funções padrão usadas para brincar com diretórios.

opendir DIRHANDLE, EXPR  # To open a directory
readdir DIRHANDLE        # To read a directory
rewinddir DIRHANDLE      # Positioning pointer to the begining
telldir DIRHANDLE        # Returns current position of the dir
seekdir DIRHANDLE, POS   # Pointing pointer to POS inside dir
closedir DIRHANDLE       # Closing a directory.

Exibir todos os arquivos

Existem várias maneiras de listar todos os arquivos disponíveis em um determinado diretório. Primeiro, vamos usar a maneira simples de obter e listar todos os arquivos usando oglob operador -

#!/usr/bin/perl

# Display all the files in /tmp directory.
$dir = "/tmp/*"; my @files = glob( $dir );

foreach (@files ) {
   print $_ . "\n"; } # Display all the C source files in /tmp directory. $dir = "/tmp/*.c";
@files = glob( $dir ); foreach (@files ) { print $_ . "\n";
}

# Display all the hidden files.
$dir = "/tmp/.*"; @files = glob( $dir );
foreach (@files ) {
   print $_ . "\n"; } # Display all the files from /tmp and /home directories. $dir = "/tmp/* /home/*";
@files = glob( $dir ); foreach (@files ) { print $_ . "\n";
}

Aqui está outro exemplo, que abre um diretório e lista todos os arquivos disponíveis dentro desse diretório.

#!/usr/bin/perl

opendir (DIR, '.') or die "Couldn't open directory, $!"; while ($file = readdir DIR) {
   print "$file\n";
}
closedir DIR;

Mais um exemplo para imprimir a lista de arquivos de origem C que você pode usar é -

#!/usr/bin/perl

opendir(DIR, '.') or die "Couldn't open directory, $!";
foreach (sort grep(/^.*\.c$/,readdir(DIR))) { print "$_\n";
}
closedir DIR;

Criar novo diretório

Você pode usar mkdirfunção para criar um novo diretório. Você precisará ter a permissão necessária para criar um diretório.

#!/usr/bin/perl

$dir = "/tmp/perl"; # This creates perl directory in /tmp directory. mkdir( $dir ) or die "Couldn't create $dir directory, $!";
print "Directory created successfully\n";

Remover um diretório

Você pode usar rmdirfunção para remover um diretório. Você precisará ter a permissão necessária para remover um diretório. Além disso, este diretório deve estar vazio antes de você tentar removê-lo.

#!/usr/bin/perl

$dir = "/tmp/perl"; # This removes perl directory from /tmp directory. rmdir( $dir ) or die "Couldn't remove $dir directory, $!";
print "Directory removed successfully\n";

Mudar um diretório

Você pode usar chdirfunção para alterar um diretório e ir para um novo local. Você precisará ter a permissão necessária para alterar um diretório e entrar no novo diretório.

#!/usr/bin/perl

$dir = "/home"; # This changes perl directory and moves you inside /home directory. chdir( $dir ) or die "Couldn't go inside $dir directory, $!";
print "Your new location is $dir\n";

A execução e os erros sempre andam juntos. Se você estiver abrindo um arquivo que não existe. então, se você não lidou com essa situação adequadamente, seu programa é considerado de má qualidade.

O programa pára se ocorrer um erro. Portanto, um tratamento de erros adequado é usado para lidar com vários tipos de erros, que podem ocorrer durante a execução de um programa e tomar a ação apropriada em vez de interromper completamente o programa.

Você pode identificar e detectar um erro de várias maneiras diferentes. É muito fácil interceptar erros em Perl e, em seguida, tratá-los adequadamente. Aqui estão alguns métodos que podem ser usados.

A declaração if

o if statementé a escolha óbvia quando você precisa verificar o valor de retorno de uma instrução; por exemplo -

if(open(DATA, $file)) {
   ...
} else {
   die "Error: Couldn't open the file - $!";
}

Aqui a variável $! retorna a mensagem de erro real. Como alternativa, podemos reduzir a declaração a uma linha em situações em que faça sentido; por exemplo -

open(DATA, $file) || die "Error: Couldn't open the file $!";

A função menos

o unlessfunction é o oposto lógico de if: as instruções podem ignorar completamente o status de sucesso e apenas ser executadas se a expressão retornar falso. Por exemplo -

unless(chdir("/etc")) {
   die "Error: Can't change directory - $!";
}

o unlessA instrução é melhor usada quando você deseja gerar um erro ou alternativa apenas se a expressão falhar. A declaração também faz sentido quando usada em uma declaração de linha única -

die "Error: Can't change directory!: $!" unless(chdir("/etc"));

Aqui morremos apenas se a operação chdir falhar, e a leitura é boa.

O operador ternário

Para testes muito curtos, você pode usar o operador condicional ?:

print(exists($hash{value}) ? 'There' : 'Missing',"\n");

Não está tão claro aqui o que estamos tentando alcançar, mas o efeito é o mesmo que usar um if ou unlessdeclaração. O operador condicional é mais bem usado quando você deseja retornar rapidamente um dos dois valores em uma expressão ou instrução.

A função warn

A função warn apenas levanta um aviso, uma mensagem é impressa em STDERR, mas nenhuma ação adicional é realizada. Portanto, é mais útil se você quiser apenas imprimir um aviso para o usuário e prosseguir com o resto da operação -

chdir('/etc') or warn "Can't change directory";

A Função Die

A função die funciona como warn, exceto que também chama exit. Em um script normal, essa função tem o efeito de encerrar imediatamente a execução. Você deve usar esta função caso seja inútil prosseguir se houver um erro no programa -

chdir('/etc') or die "Can't change directory";

Erros nos módulos

Existem duas situações diferentes que devemos ser capazes de lidar -

Relatar um erro em um módulo que cita o nome do arquivo do módulo e o número da linha - isso é útil ao depurar um módulo ou quando você deseja especificamente levantar um erro relacionado ao módulo, em vez de relacionado ao script.
Relatando um erro em um módulo que cita as informações do chamador para que você possa depurar a linha do script que causou o erro. Os erros levantados desta forma são úteis para o usuário final, porque destacam o erro em relação à linha de origem do script de chamada.

o warn e diefunções funcionam de maneira ligeiramente diferente do que você esperaria quando chamadas de dentro de um módulo. Por exemplo, o módulo simples -

package T;

require Exporter;
@ISA = qw/Exporter/;
@EXPORT = qw/function/;
use Carp;

sub function {
   warn "Error in module!";
}
1;

Quando chamado de um script como abaixo -

use T;
function();

Isso produzirá o seguinte resultado -

Error in module! at T.pm line 9.

Isso é mais ou menos o que você esperava, mas não necessariamente o que você deseja. Da perspectiva de um programador de módulo, a informação é útil porque ajuda a apontar para um bug dentro do próprio módulo. Para um usuário final, a informação fornecida é bastante inútil, e para todos, exceto o programador experiente, é completamente inútil.

A solução para esses problemas é o módulo Carp, que fornece um método simplificado para relatar erros em módulos que retornam informações sobre o script de chamada. O módulo Carpa oferece quatro funções: carpa, cacarejo, coaxar e confessar. Essas funções são discutidas abaixo.

A função da carpa

A função carp é o equivalente básico de warn e imprime a mensagem para STDERR sem realmente sair do script e imprimir o nome do script.

package T;

require Exporter;
@ISA = qw/Exporter/;
@EXPORT = qw/function/;
use Carp;

sub function {
   carp "Error in module!";
}
1;

Quando chamado de um script como abaixo -

use T;
function();

Isso produzirá o seguinte resultado -

Error in module! at test.pl line 4

A função cluck

A função cluck é uma espécie de carpa sobrecarregada, segue o mesmo princípio básico, mas também imprime um rastreamento de pilha de todos os módulos que levaram à chamada da função, incluindo as informações do script original.

package T;

require Exporter;
@ISA = qw/Exporter/;
@EXPORT = qw/function/;
use Carp qw(cluck);

sub function {
   cluck "Error in module!";
}
1;

Quando chamado de um script como abaixo -

use T;
function();

Isso produzirá o seguinte resultado -

Error in module! at T.pm line 9
   T::function() called at test.pl line 4

A função croak

o croak função é equivalente a die, exceto que relata o chamador um nível acima. Como o dado, esta função também sai do script após relatar o erro para STDERR -

package T;

require Exporter;
@ISA = qw/Exporter/;
@EXPORT = qw/function/;
use Carp;

sub function {
   croak "Error in module!";
}
1;

Quando chamado de um script como abaixo -

use T;
function();

Isso produzirá o seguinte resultado -

Error in module! at test.pl line 4

Como com o carp, as mesmas regras básicas se aplicam em relação à inclusão de informações de linha e arquivo de acordo com as funções de advertência e dado.

A função confessar

o confess função é como cluck; ele chama die e, em seguida, imprime um rastreamento de pilha até o script de origem.

package T;

require Exporter;
@ISA = qw/Exporter/;
@EXPORT = qw/function/;
use Carp;

sub function {
   confess "Error in module!";
}
1;

Quando chamado de um script como abaixo -

use T;
function();

Isso produzirá o seguinte resultado -

Error in module! at T.pm line 9
   T::function() called at test.pl line 4

Existem algumas variáveis que têm um significado predefinido e especial em Perl. Elas são as variáveis que usam caracteres de pontuação após o indicador de variável usual ($, @ ou%), como $ _ (explicado abaixo).

A maioria das variáveis especiais tem um nome longo do tipo inglês, por exemplo, a variável de erro do sistema operacional $! pode ser escrito como $ OS_ERROR. Mas se você vai usar o inglês como nomes, então você terá que colocar uma linhause English;na parte superior do arquivo do programa. Isso orienta o intérprete a captar o significado exato da variável.

A variável especial mais comumente usada é $ _, que contém a entrada padrão e a string de pesquisa de padrões. Por exemplo, nas seguintes linhas -

#!/usr/bin/perl

foreach ('hickory','dickory','doc') {
   print $_;
   print "\n";
}

Quando executado, isso produzirá o seguinte resultado -

hickory
dickory
doc

Novamente, vamos verificar o mesmo exemplo sem usar a variável $ _ explicitamente -

#!/usr/bin/perl

foreach ('hickory','dickory','doc') {
   print;
   print "\n";
}

Quando executado, isso também produzirá o seguinte resultado -

hickory
dickory
doc

Na primeira vez que o loop é executado, "hickory" é impresso. Na segunda vez, "dickory" é impresso e, na terceira vez, "doc" é impresso. Isso porque em cada iteração do loop, a string atual é colocada em$_, and is used by default by print. Here are the places where Perl will assume $_ mesmo se você não especificar -

Várias funções unárias, incluindo funções como ord e int, bem como todos os testes de arquivo (-f, -d), exceto para -t, cujo padrão é STDIN.
Várias funções de lista, como imprimir e desvincular.
As operações de correspondência de padrões m //, s /// e tr /// quando usadas sem um operador = ~.
A variável iteradora padrão em um loop foreach se nenhuma outra variável for fornecida.
A variável iteradora implícita nas funções grep e map.
O local padrão para colocar um registro de entrada quando o resultado de uma operação de entrada de linha é testado por si mesmo como o único critério de um teste while (isto é,). Observe que fora de um teste de tempo, isso não acontecerá.

Tipos de Variáveis Especiais

Com base no uso e na natureza das variáveis especiais, podemos categorizá-las nas seguintes categorias -

Variáveis especiais escalares globais.
Variáveis especiais de matriz global.
Variáveis especiais de hash globais.
Manipuladores de arquivos especiais globais.
Constantes especiais globais.
Variáveis especiais de expressão regular.
Filehandle Special Variables.

Variáveis Especiais Escalares Globais

Aqui está a lista de todas as variáveis especiais escalares. Listamos os nomes correspondentes em inglês junto com os nomes simbólicos.

$ _	A entrada padrão e o espaço de pesquisa de padrões.
$ ARG	A entrada padrão e o espaço de pesquisa de padrões.
$.	O número da linha de entrada atual do último filehandle que foi lido. Um fechamento explícito no filehandle redefine o número da linha.
$ NR
$ /	O separador de registro de entrada; nova linha por padrão. Se definido como string nula, trata as linhas em branco como delimitadores.
$ RS
$,	O separador de campo de saída para o operador de impressão.
$ OFS	O separador de campo de saída para o operador de impressão.
$ \	O separador de registro de saída para o operador de impressão.
$ ORS
$ "	Como "$", exceto que se aplica a valores de lista interpolados em uma string entre aspas (ou string interpretada semelhante). O padrão é um espaço.
$ LIST_SEPARATOR
$;	O separador de subscrito para emulação de array multidimensional. O padrão é "\ 034".
$ SUBSCRIPT_SEPARATOR
$ ^ L	O que um formato produz para realizar um formfeed. O padrão é "\ f".
$ FORMAT_FORMFEED
$:	O conjunto atual de caracteres após o qual uma string pode ser quebrada para preencher os campos de continuação (começando com ^) em um formato. O padrão é "\ n" ".
$ FORMAT_LINE_BREAK_CHARACTERS
$ ^ A	O valor atual do acumulador de gravação para linhas de formato.
$ ACCUMULATOR
$ #	Contém o formato de saída para números impressos (obsoleto).
$ OFMT
$?	O status retornado pelo último fechamento do tubo, comando backtick (``) ou operador do sistema.
$ CHILD_ERROR
$!	Se usado em um contexto numérico, produz o valor atual da variável errno, identificando o último erro de chamada do sistema. Se usado em um contexto de string, produz a string de erro do sistema correspondente.
$OS_ERROR or $ERRNO
$ @	A mensagem de erro de sintaxe Perl do último comando eval.
$ EVAL_ERROR	A mensagem de erro de sintaxe Perl do último comando eval.
$$	O pid do processo Perl executando este script.
$ PROCESS_ID ou $ PID	O pid do processo Perl executando este script.
$ <	O ID do usuário real (uid) deste processo.
$REAL_USER_ID or $UID	O ID do usuário real (uid) deste processo.
$>	O ID de usuário efetivo deste processo.
$ EFFECTIVE_USER_ID ou $ EUID	O ID de usuário efetivo deste processo.
$ (	O ID de grupo real (gid) deste processo.
$REAL_GROUP_ID or $GID	O ID de grupo real (gid) deste processo.
$)	O gid efetivo desse processo.
$ EFFECTIVE_GROUP_ID ou $ EGID	O gid efetivo desse processo.
$ 0	Contém o nome do arquivo que contém o script Perl sendo executado.
$ PROGRAM_NAME
$ [	O índice do primeiro elemento em uma matriz e do primeiro caractere em uma substring. O padrão é 0.
$]	Retorna a versão mais o nível do patch dividido por 1000.
$ PERL_VERSION	Retorna a versão mais o nível do patch dividido por 1000.
$ ^ D	O valor atual dos sinalizadores de depuração.
$ DEBUGGING	O valor atual dos sinalizadores de depuração.
$ ^ E	Mensagem de erro estendida em algumas plataformas.
$ EXTENDED_OS_ERROR	Mensagem de erro estendida em algumas plataformas.
$ ^ F	O descritor máximo de arquivo do sistema, normalmente 2.
$ SYSTEM_FD_MAX	O descritor máximo de arquivo do sistema, normalmente 2.
$ ^ H	Contém dicas do compilador interno habilitadas por certos módulos pragmáticos.
$ ^ I	O valor atual da extensão inplace-edit. Use undef para desabilitar a edição local.
$ INPLACE_EDIT
$ ^ M	O conteúdo de $M can be used as an emergency memory pool in case Perl dies with an out-of-memory error. Use of $M requer uma compilação especial de Perl. Consulte o documento INSTALL para obter mais informações.
$ ^ O	Contém o nome do sistema operacional para o qual o binário Perl atual foi compilado.
$ OSNAME
$ ^ P	O sinalizador interno que o depurador limpa para que não depure a si mesmo.
$ PERLDB
$ ^ T	A hora em que o script começou a ser executado, em segundos desde a época.
$ BASETIME
$ ^ W	O valor atual da opção de aviso, verdadeiro ou falso.
$ AVISO	O valor atual da opção de aviso, verdadeiro ou falso.
$ ^ X	O nome com o qual o binário Perl foi executado.
$ EXECUTABLE_NAME	O nome com o qual o binário Perl foi executado.
$ ARGV	Contém o nome do arquivo atual ao ler de <ARGV>.

Variáveis Especiais de Matriz Global

@ARGV	A matriz que contém os argumentos da linha de comando destinados ao script.
@INC	O array contendo a lista de locais onde procurar scripts Perl para serem avaliados pelas construções do, require ou use.
@F	A matriz na qual as linhas de entrada são divididas quando a opção -a da linha de comando é fornecida.

Variáveis Especiais Hash Globais

% INC	O hash contendo entradas para o nome de arquivo de cada arquivo que foi incluído por meio de do ou require.
% ENV	O hash contendo seu ambiente atual.
% SIG	O hash usado para definir manipuladores de sinal para vários sinais.

Manipuladores de arquivos especiais globais

ARGV	O manipulador de arquivos especial que itera sobre nomes de arquivos de linha de comando em @ARGV. Normalmente escrito como o filehandle nulo em <>.
STDERR	O filehandle especial para erro padrão em qualquer pacote.
STDIN	O filehandle especial para entrada padrão em qualquer pacote.
STDOUT	O filehandle especial para saída padrão em qualquer pacote.
DADOS	O filehandle especial que se refere a qualquer coisa após o token __END__ no arquivo que contém o script. Ou o identificador de arquivo especial para qualquer coisa após o token __DATA__ em um arquivo obrigatório, desde que você esteja lendo dados no mesmo pacote em que __DATA__ foi encontrado.
_ (sublinhado)	O filehandle especial usado para armazenar em cache as informações do último stat, lstat ou operador de teste de arquivo.

Constantes Especiais Globais

__FIM__	Indica o fim lógico do seu programa. Qualquer texto a seguir é ignorado, mas pode ser lido por meio do manipulador de arquivos DATA.
__ARQUIVO__	Representa o nome do arquivo no ponto do programa em que ele é usado. Não interpolado em strings.
__LINHA__	Representa o número da linha atual. Não interpolado em strings.
__PACOTE__	Representa o nome do pacote atual em tempo de compilação ou indefinido se não houver pacote atual. Não interpolado em strings.

Variáveis Especiais de Expressão Regular

$ digito	Contém o texto correspondido pelo conjunto correspondente de parênteses no último padrão correspondido. Por exemplo, $ 1 corresponde a tudo o que estava contido no primeiro conjunto de parênteses na expressão regular anterior.
$ &	A string correspondida pela última correspondência de padrão bem-sucedida.
$ MATCH
$ `	A string anterior foi correspondida pela última correspondência de padrão bem-sucedida.
$ PREMATCH
$ '	A sequência que segue o que foi correspondido pela última correspondência de padrão bem-sucedida.
$ POSTMATCH
$ +	O último colchete correspondente ao último padrão de pesquisa. Isso é útil se você não sabe qual conjunto de padrões alternativos foi correspondido. Por exemplo: / Versão: (. ) \| Revisão: (. ) / && ($rev = $+);
$ LAST_PAREN_MATCH

Variáveis Especiais de Manipulação de Arquivos

$ \|	Se definido como diferente de zero, força um fflush (3) após cada gravação ou impressão no canal de saída atualmente selecionado.
$ OUTPUT_AUTOFLUSH
$%	O número da página atual do canal de saída atualmente selecionado.
$ FORMAT_PAGE_NUMBER
$ =	O comprimento da página atual (linhas imprimíveis) do canal de saída atualmente selecionado. O padrão é 60.
$ FORMAT_LINES_PER_PAGE
$ -	O número de linhas restantes na página do canal de saída atualmente selecionado.
$ FORMAT_LINES_LEFT
$ ~	O nome do formato de relatório atual para o canal de saída atualmente selecionado. O padrão é o nome do filehandle.
$ FORMAT_NAME
$ ^	O nome do formato do topo da página atual para o canal de saída atualmente selecionado. O padrão é o nome do filehandle com _TOP anexado.
$ FORMAT_TOP_NAME

Cada programador terá, é claro, suas próprias preferências em relação à formatação, mas existem algumas diretrizes gerais que tornarão seus programas mais fáceis de ler, entender e manter.

O mais importante é executar seus programas com a opção -w o tempo todo. Você pode desativá-lo explicitamente para partes específicas do código por meio do pragma no warnings ou da variável $ ^ W, se necessário. Você também deve sempre executar sob uso estrito ou saber o motivo. O uso de sigtrap e até mesmo o uso de pragmas de diagnóstico também podem ser úteis.

Com relação à estética do layout do código, a única coisa com a qual Larry se preocupa muito é que a chave de fechamento de um BLOCO de várias linhas deve se alinhar com a palavra-chave que iniciou a construção. Além disso, ele tem outras preferências que não são tão fortes -

Recuo de 4 colunas.
Abrindo curvas na mesma linha da palavra-chave, se possível, caso contrário, alinhe.
Espaço antes da curva de abertura de um BLOCO de várias linhas.
O BLOCO de uma linha pode ser colocado em uma linha, incluindo cachos.
Sem espaço antes do ponto e vírgula.
Ponto-e-vírgula omitido no BLOCO "curto" de uma linha.
Espaço em torno da maioria dos operadores.
Espaço ao redor de um subscrito "complexo" (entre colchetes).
Linhas em branco entre pedaços que fazem coisas diferentes.
Elses relaxados.
Sem espaço entre o nome da função e seu parêntese de abertura.
Espaço após cada vírgula.
Longas linhas interrompidas após um operador (exceto e e ou).
Espaço após a correspondência do último parêntese na linha atual.
Alinhe os itens correspondentes verticalmente.
Omita a pontuação redundante, desde que a clareza não seja prejudicada.

Aqui estão algumas outras questões de estilo mais substantivas para pensar: Só porque você PODE fazer algo de uma maneira particular, não significa que você DEVE fazer dessa maneira. Perl é projetado para fornecer várias maneiras de fazer qualquer coisa, então considere escolher a mais legível. Por exemplo -

open(FOO,$foo) || die "Can't open $foo: $!";

É melhor que -

die "Can't open $foo: $!" unless open(FOO,$foo);

Porque a segunda maneira esconde o ponto principal da instrução em um modificador. Por outro lado,

print "Starting analysis\n" if $verbose;

É melhor que -

$verbose && print "Starting analysis\n";

Porque o ponto principal não é se o usuário digitou -v ou não.

Não faça contorções bobas para sair de um loop no topo ou no fundo, quando Perl fornece o último operador para que você possa sair no meio. Apenas "recorte" um pouco para torná-lo mais visível -

LINE:
for (;;) {
   statements;
   last LINE if $foo;
   next LINE if /^#/;
   statements;
}

Vamos ver mais alguns pontos importantes -

Não tenha medo de usar rótulos de loop - eles estão lá para melhorar a legibilidade e também para permitir quebras de loop em vários níveis. Veja o exemplo anterior.
Evite usar grep () (ou map ()) ou `backticks` em um contexto vazio, ou seja, quando você simplesmente joga fora seus valores de retorno. Todas essas funções têm valores de retorno, então use-os. Caso contrário, use um loop foreach () ou a função system ().
Para portabilidade, ao usar recursos que podem não ser implementados em todas as máquinas, teste a construção em uma avaliação para ver se falha. Se você sabe qual versão ou nível de patch de um recurso específico foi implementado, você pode testar $] ($ PERL_VERSION em inglês) para ver se ele estará lá. O módulo Config também permitirá que você interrogue os valores determinados pelo programa Configure quando o Perl foi instalado.
Escolha identificadores mnemônicos. Se você não consegue lembrar o que significa mnemônico, você tem um problema.
Embora identificadores curtos como $ gotit provavelmente estejam ok, use sublinhados para separar palavras em identificadores mais longos. Geralmente é mais fácil de ler$var_names_like_this than $VarNamesLikeThis, especialmente para falantes não nativos de inglês. É também uma regra simples que funciona de forma consistente com VAR_NAMES_LIKE_THIS.
Os nomes dos pacotes às vezes são uma exceção a esta regra. Perl reserva informalmente nomes de módulos em minúsculas para módulos "pragma" como integer e strict. Outros módulos devem começar com uma letra maiúscula e usar maiúsculas e minúsculas, mas provavelmente sem sublinhados devido às limitações nas representações dos nomes dos módulos dos sistemas de arquivos primitivos como arquivos que devem caber em alguns bytes esparsos.
Se você tiver uma expressão regular realmente complicada, use o modificador / x e coloque alguns espaços em branco para torná-la um pouco menos parecida com ruído de linha. Não use barra como delimitador quando sua regexp tiver barras ou barras invertidas.
Sempre verifique os códigos de retorno das chamadas do sistema. Boas mensagens de erro devem ir para STDERR, incluir o programa que causou o problema, quais foram os argumentos e a chamada do sistema com falha e (MUITO IMPORTANTE) deve conter a mensagem de erro padrão do sistema para o que deu errado. Aqui está um exemplo simples, mas suficiente -

opendir(D, $dir) or die "can't opendir $dir: $!";

Pense na capacidade de reutilização. Por que desperdiçar inteligência em uma tentativa quando você pode querer fazer algo assim novamente? Considere generalizar seu código. Considere escrever um módulo ou classe de objeto. Considere fazer seu código funcionar de forma limpa com use estrito e avisos de uso (ou -w) em vigor. Considere distribuir seu código. Considere mudar toda a sua visão de mundo. Considere ... oh, não importa.
Ser consistente.
Seja legal.

Uma expressão regular é uma sequência de caracteres que define o padrão ou padrões que você está visualizando. A sintaxe das expressões regulares em Perl é muito semelhante ao que você encontrará em outros programas de suporte de expressão regular, comosed, grep, e awk.

O método básico para aplicar uma expressão regular é usar os operadores de associação de padrão = ~ e !~. O primeiro operador é um operador de teste e atribuição.

Existem três operadores de expressão regular em Perl.

Corresponder à expressão regular - m //
Substituir Expressão Regular - s ///
Transliterar Expressão Regular - tr ///

As barras em cada caso atuam como delimitadores para a expressão regular (regex) que você está especificando. Se você se sentir confortável com qualquer outro delimitador, poderá usar no lugar da barra.

O Operador da Partida

O operador de correspondência, m //, é usado para fazer a correspondência de uma string ou instrução com uma expressão regular. Por exemplo, para combinar a sequência de caracteres "foo" com a barra escalar $, você pode usar uma instrução como esta -

#!/usr/bin/perl

$bar = "This is foo and again foo"; if ($bar =~ /foo/) {
   print "First time is matching\n";
} else {
   print "First time is not matching\n";
}

$bar = "foo"; if ($bar =~ /foo/) {
   print "Second time is matching\n";
} else {
   print "Second time is not matching\n";
}

Quando o programa acima é executado, ele produz o seguinte resultado -

First time is matching
Second time is matching

OM // realmente funciona da mesma maneira que a série de operadores q //. Você pode usar qualquer combinação de caracteres naturalmente correspondentes para atuar como delimitadores para a expressão. Por exemplo, m {}, m () e m> <são todos válidos. Portanto, o exemplo acima pode ser reescrito da seguinte forma -

#!/usr/bin/perl

$bar = "This is foo and again foo"; if ($bar =~ m[foo]) {
   print "First time is matching\n";
} else {
   print "First time is not matching\n";
}

$bar = "foo"; if ($bar =~ m{foo}) {
   print "Second time is matching\n";
} else {
   print "Second time is not matching\n";
}

Você pode omitir m de m // se os delimitadores forem barras, mas para todos os outros delimitadores você deve usar o prefixo m.

Observe que toda a expressão de correspondência, ou seja, a expressão à esquerda de = ~ ou! ~ E o operador de correspondência, retorna verdadeiro (em um contexto escalar) se a expressão corresponder. Portanto, a declaração -

$true = ($foo =~ m/foo/);

ajustarei $true to 1 if $foo corresponde ao regex, ou 0 se a correspondência falhar. Em um contexto de lista, a correspondência retorna o conteúdo de quaisquer expressões agrupadas. Por exemplo, ao extrair as horas, minutos e segundos de uma string de tempo, podemos usar -

my ($hours, $minutes, $seconds) = ($time =~ m/(\d+):(\d+):(\d+)/);

Modificadores do operador de correspondência

O operador match suporta seu próprio conjunto de modificadores. O modificador / g permite correspondência global. O modificador / i tornará a correspondência insensível a maiúsculas e minúsculas. Aqui está a lista completa de modificadores

Sr. Não.	Modificador e descrição
1	i Torna a correspondência insensível a maiúsculas e minúsculas.
2	m Especifica que se a string tiver caracteres de nova linha ou de retorno de carro, os operadores ^ e $ agora corresponderão a um limite de nova linha, em vez de um limite de string.
3	o Avalia a expressão apenas uma vez.
4	s Permite o uso de. para corresponder a um caractere de nova linha.
5	x Permite que você use espaço em branco na expressão para maior clareza.
6	g Encontra globalmente todas as correspondências.
7	cg Permite que a pesquisa continue mesmo depois que uma correspondência global falhar.

Correspondência apenas uma vez

Também existe uma versão mais simples do operador de correspondência - o? PATTERN? operador. Ele é basicamente idêntico ao operador m //, exceto que ele corresponde apenas uma vez na string que você está procurando entre cada chamada para redefinir.

Por exemplo, você pode usar isso para obter o primeiro e o último elementos de uma lista -

#!/usr/bin/perl

@list = qw/food foosball subeo footnote terfoot canic footbrdige/;

foreach (@list) {
   $first = $1 if /(foo.*?)/; $last = $1 if /(foo.*)/; } print "First: $first, Last: $last\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

First: foo, Last: footbrdige

Variáveis de Expressão Regular

Variáveis de expressão regular incluem $, que contém a última correspondência de agrupamento correspondida; $&, que contém toda a string combinada; $`, que contém tudo antes da string correspondente; e$', que contém tudo após a string correspondente. O código a seguir demonstra o resultado -

#!/usr/bin/perl

$string = "The food is in the salad bar";
$string =~ m/foo/; print "Before: $`\n";
print "Matched: $&\n"; print "After: $'\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

Before: The
Matched: foo
After: d is in the salad bar

O Operador de Substituição

O operador de substituição, s ///, é apenas uma extensão do operador de correspondência que permite substituir o texto correspondido por algum novo texto. A forma básica do operador é -

s/PATTERN/REPLACEMENT/;

O PADRÃO é a expressão regular para o texto que procuramos. O REPLACEMENT é uma especificação para o texto ou expressão regular que queremos usar para substituir o texto encontrado. Por exemplo, podemos substituir todas as ocorrências dedog com cat usando a seguinte expressão regular -

#/user/bin/perl

$string = "The cat sat on the mat"; $string =~ s/cat/dog/;

print "$string\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

The dog sat on the mat

Modificadores de operador de substituição

Aqui está a lista de todos os modificadores usados com o operador de substituição.

Sr. Não.	Modificador e descrição
1	i Torna a correspondência insensível a maiúsculas e minúsculas.
2	m Especifica que se a string tiver caracteres de nova linha ou de retorno de carro, os operadores ^ e $ agora corresponderão a um limite de nova linha, em vez de um limite de string.
3	o Avalia a expressão apenas uma vez.
4	s Permite o uso de. para corresponder a um caractere de nova linha.
5	x Permite que você use espaço em branco na expressão para maior clareza.
6	g Substitui todas as ocorrências da expressão encontrada pelo texto de substituição.
7	e Avalia a substituição como se fosse uma instrução Perl e usa seu valor de retorno como o texto de substituição.

O operador de tradução

A tradução é semelhante, mas não idêntica, aos princípios da substituição, mas ao contrário da substituição, a tradução (ou transliteração) não usa expressões regulares para sua pesquisa de valores de substituição. Os operadores de tradução são -

tr/SEARCHLIST/REPLACEMENTLIST/cds
y/SEARCHLIST/REPLACEMENTLIST/cds

A tradução substitui todas as ocorrências dos caracteres em SEARCHLIST pelos caracteres correspondentes em REPLACEMENTLIST. Por exemplo, usando o "O gato sentou no tapete". string que temos usado neste capítulo -

#/user/bin/perl

$string = 'The cat sat on the mat'; $string =~ tr/a/o/;

print "$string\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

The cot sot on the mot.

Intervalos Perl padrão também podem ser usados, permitindo que você especifique intervalos de caracteres por letra ou valor numérico. Para alterar o caso da string, você pode usar a seguinte sintaxe no lugar douc função.

$string =~ tr/a-z/A-Z/;

Modificadores de operador de tradução

A seguir está a lista de operadores relacionados à tradução.

Sr. Não.	Modificador e descrição
1	c Complementa SEARCHLIST.
2	d Exclui caracteres encontrados, mas não substituídos.
3	s Squashes duplicam caracteres substituídos.

O modificador / d exclui os caracteres correspondentes a SEARCHLIST que não possuem uma entrada correspondente em REPLACEMENTLIST. Por exemplo -

#!/usr/bin/perl 

$string = 'the cat sat on the mat.'; $string =~ tr/a-z/b/d;

print "$string\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

b b   b.

O último modificador, / s, remove as sequências duplicadas de caracteres que foram substituídos, portanto -

#!/usr/bin/perl

$string = 'food';
$string = 'food'; $string =~ tr/a-z/a-z/s;

print "$string\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

fod

Expressões regulares mais complexas

Você não precisa apenas combinar em strings fixas. Na verdade, você pode corresponder a praticamente qualquer coisa com que sonharia, usando expressões regulares mais complexas. Aqui está uma folha rápida de dicas -

A tabela a seguir lista a sintaxe da expressão regular que está disponível em Python.

Sr. Não.	Padrão e Descrição
1	^ Corresponde ao início da linha.
2	$ Corresponde ao final da linha.
3	. Corresponde a qualquer caractere único, exceto nova linha. Usar a opção m permite que ele corresponda a nova linha também.
4	[...] Corresponde a qualquer caractere único entre colchetes.
5	[^...] Corresponde a qualquer caractere único que não esteja entre colchetes.
6	* Corresponde a 0 ou mais ocorrências da expressão anterior.
7	+ Corresponde a 1 ou mais ocorrências da expressão anterior.
8	? Corresponde a 0 ou 1 ocorrência da expressão anterior.
9	{ n} Corresponde exatamente ao número n de ocorrências da expressão anterior.
10	{ n,} Corresponde a n ou mais ocorrências da expressão anterior.
11	{ n, m} Corresponde a pelo menos n e no máximo m ocorrências da expressão anterior.
12	a\| b Corresponde a a ou b.
13	\w Corresponde a caracteres de palavras.
14	\W Corresponde a caracteres que não sejam palavras.
15	\s Corresponde ao espaço em branco. Equivalente a [\ t \ n \ r \ f].
16	\S Corresponde a espaços não brancos.
17	\d Corresponde a dígitos. Equivalente a [0-9].
18	\D Corresponde a não dígitos.
19	\A Corresponde ao início da string.
20	\Z Corresponde ao final da string. Se houver uma nova linha, ela corresponderá imediatamente antes da nova linha.
21	\z Corresponde ao final da string.
22	\G As partidas apontam onde a última partida terminou.
23	\b Corresponde aos limites da palavra quando fora dos colchetes. Corresponde ao backspace (0x08) quando entre colchetes.
24	\B Corresponde a limites sem palavras.
25	\n, \t, etc. Corresponde a novas linhas, retornos de carro, guias, etc.
26	\1...\9 Corresponde à enésima subexpressão agrupada.
27	\10 Corresponde à enésima subexpressão agrupada se já tiver correspondido. Caso contrário, refere-se à representação octal de um código de caractere.
28	[aeiou] Corresponde a um único caractere no conjunto fornecido
29	[^aeiou] Corresponde a um único caractere fora do conjunto fornecido

O ^ metacaractere casa com o início da string e o $ metasymbol casa com o final da string. Aqui estão alguns exemplos breves.

# nothing in the string (start and end are adjacent)
/^$/   

# a three digits, each followed by a whitespace
# character (eg "3 4 5 ")
/(\d\s) {3}/  

# matches a string in which every
# odd-numbered letter is a (eg "abacadaf")
/(a.)+/  

# string starts with one or more digits
/^\d+/

# string that ends with one or more digits
/\d+$/

Vamos dar uma olhada em outro exemplo.

#!/usr/bin/perl

$string = "Cats go Catatonic\nWhen given Catnip";
($start) = ($string =~ /\A(.*?) /);
@lines = $string =~ /^(.*?) /gm; print "First word: $start\n","Line starts: @lines\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

First word: Cats
Line starts: Cats When

Limites correspondentes

o \bcorresponde a qualquer limite de palavra, conforme definido pela diferença entre a classe \ w e a classe \ W. Como \ w inclui os caracteres de uma palavra e \ W o oposto, isso normalmente significa o término de uma palavra. o\Bassertion corresponde a qualquer posição que não seja um limite de palavra. Por exemplo -

/\bcat\b/ # Matches 'the cat sat' but not 'cat on the mat'
/\Bcat\B/ # Matches 'verification' but not 'the cat on the mat'
/\bcat\B/ # Matches 'catatonic' but not 'polecat'
/\Bcat\b/ # Matches 'polecat' but not 'catatonic'

Selecionando Alternativas

O | caractere é como o padrão ou bit a bit OR em Perl. Ele especifica correspondências alternativas dentro de uma expressão regular ou grupo. Por exemplo, para corresponder a "gato" ou "cachorro" em uma expressão, você pode usar isto -

if ($string =~ /cat|dog/)

Você pode agrupar elementos individuais de uma expressão para oferecer suporte a correspondências complexas. Pesquisar o nome de duas pessoas pode ser feito com dois testes separados, como este -

if (($string =~ /Martin Brown/) ||  ($string =~ /Sharon Brown/)) This could be written as follows if ($string =~ /(Martin|Sharon) Brown/)

Combinação de agrupamento

Do ponto de vista da expressão regular, não há diferença entre, exceto, talvez, que o primeiro seja um pouco mais claro.

$string =~ /(\S+)\s+(\S+)/; and $string =~ /\S+\s+\S+/;

No entanto, o benefício do agrupamento é que ele nos permite extrair uma sequência de uma expressão regular. Os agrupamentos são retornados como uma lista na ordem em que aparecem no original. Por exemplo, no fragmento a seguir, retiramos as horas, minutos e segundos de uma string.

my ($hours, $minutes, $seconds) = ($time =~ m/(\d+):(\d+):(\d+)/);

Além desse método direto, os grupos correspondentes também estão disponíveis nas variáveis especiais $ x, onde x é o número do grupo na expressão regular. Podemos, portanto, reescrever o exemplo anterior da seguinte forma -

#!/usr/bin/perl

$time = "12:05:30";

$time =~ m/(\d+):(\d+):(\d+)/; my ($hours, $minutes, $seconds) = ($1, $2, $3); print "Hours : $hours, Minutes: $minutes, Second: $seconds\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

Hours : 12, Minutes: 05, Second: 30

Quando grupos são usados em expressões de substituição, a sintaxe $ x pode ser usada no texto de substituição. Assim, poderíamos reformatar uma string de data usando este -

#!/usr/bin/perl

$date = '03/26/1999';
$date =~ s#(\d+)/(\d+)/(\d+)#$3/$1/$2#;

print "$date\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

1999/03/26

The \ G Assertion

A asserção \ G permite que você continue pesquisando a partir do ponto onde ocorreu a última correspondência. Por exemplo, no código a seguir, usamos \ G para que possamos pesquisar na posição correta e, em seguida, extrair algumas informações, sem ter que criar uma expressão regular única mais complexa -

#!/usr/bin/perl

$string = "The time is: 12:31:02 on 4/12/00";

$string =~ /:\s+/g; ($time) = ($string =~ /\G(\d+:\d+:\d+)/); $string =~ /.+\s+/g;
($date) = ($string =~ m{\G(\d+/\d+/\d+)});

print "Time: $time, Date: $date\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

Time: 12:31:02, Date: 4/12/00

A asserção \ G é na verdade apenas o meta-símbolo equivalente da função pos, então entre as chamadas de expressões regulares você pode continuar a usar pos e até mesmo modificar o valor de pos (e portanto \ G) usando pos como uma sub-rotina de lvalue.

Exemplos de expressões regulares

Caracteres literais

Sr. Não.	Exemplo e descrição
1	Perl Combine "Perl".

Classes de personagens

Sr. Não.	Exemplo e descrição
1	[Pp]ython Corresponde a "Python" ou "python"
2	rub[ye] Corresponde a "ruby" ou "rube"
3	[aeiou] Corresponde a qualquer vogal minúscula
4	[0-9] Corresponde a qualquer dígito; igual a [0123456789]
5	[a-z] Corresponde a qualquer letra ASCII minúscula
6	[A-Z] Corresponde a qualquer letra ASCII maiúscula
7	[a-zA-Z0-9] Corresponde a qualquer uma das opções acima
8	[^aeiou] Corresponde a qualquer coisa que não seja uma vogal minúscula
9	[^0-9] Corresponde a qualquer coisa diferente de um dígito

Classes de personagens especiais

Sr. Não.	Exemplo e descrição
1	. Corresponde a qualquer caractere, exceto nova linha
2	\d Corresponde a um dígito: [0-9]
3	\D Corresponde a um não dígito: [^ 0-9]
4	\s Corresponde a um caractere de espaço em branco: [\ t \ r \ n \ f]
5	\S Corresponde a espaços não-brancos: [^ \ t \ r \ n \ f]
6	\w Corresponde a um caractere de palavra única: [A-Za-z0-9_]
7	\W Corresponde a um caractere diferente de palavra: [^ A-Za-z0-9_]

Casos de Repetição

Sr. Não.	Exemplo e descrição
1	ruby? Corresponde a "rub" ou "ruby": o y é opcional
2	ruby* Corresponde a "rub" mais 0 ou mais ys
3	ruby+ Corresponde a "esfregar" mais 1 ou mais ys
4	\d{3} Corresponde exatamente a 3 dígitos
5	\d{3,} Corresponde a 3 ou mais dígitos
6	\d{3,5} Corresponde a 3, 4 ou 5 dígitos

Repetição Nongreedy

Isso corresponde ao menor número de repetições -

Sr. Não.	Exemplo e descrição
1	*<.>** Repetição gananciosa: corresponde a "<python> perl>"
2	*<.?>** Nongreedy: corresponde a "<python>" em "<python> perl>"

Agrupando com parênteses

Sr. Não.	Exemplo e descrição
1	\D\d+ Nenhum grupo: + repete-se \ d
2	(\D\d)+ Agrupado: + repete \ D \ d par
3	([Pp]ython(, )?)+ Corresponde a "Python", "Python, python, python" etc.

Referências anteriores

Isso corresponde a um grupo anteriormente correspondido novamente -

Sr. Não.	Exemplo e descrição
1	([Pp])ython&\1ails Corresponde a python e pails ou Python e Pails
2	*(['"])[^\1]\1** String entre aspas simples ou duplas. \ 1 corresponde ao que o primeiro grupo correspondeu. \ 2 corresponde ao que o segundo grupo correspondeu, etc.

Alternativas

Sr. Não.	Exemplo e descrição
1	python\|perl Corresponde a "python" ou "perl"
2	rub(y\|le)) Corresponde a "rubi" ou "rublo"
3	Python(!+\|\?) "Python" seguido por um ou mais! ou um?

Âncoras

Esta necessidade de especificar posições de correspondência.

Sr. Não.	Exemplo e descrição
1	^Python Corresponde a "Python" no início de uma string ou linha interna
2	Python$ Corresponde a "Python" no final de uma string ou linha
3	\APython Corresponde a "Python" no início de uma string
4	Python\Z Corresponde a "Python" no final de uma string
5	\bPython\b Corresponde a "Python" em um limite de palavra
6	\brub\B \ B é um limite sem palavras: corresponde a "esfregar" em "rube" e "ruby", mas não sozinho
7	Python(?=!) Corresponde a "Python", se seguido por um ponto de exclamação
8	Python(?!!) Corresponde a "Python", se não for seguido por um ponto de exclamação

Sintaxe especial com parênteses

Sr. Não.	Exemplo e descrição
1	R(?#comment) Corresponde a "R". Todo o resto é um comentário
2	R(?i)uby Não diferencia maiúsculas de minúsculas enquanto corresponde a "uby"
3	R(?i:uby) O mesmo que acima
4	rub(?:y\|le)) Grupo apenas sem criar \ 1 referência anterior

Usando o utilitário sendmail

Enviando uma mensagem simples

Se você estiver trabalhando em uma máquina Linux / Unix, você pode simplesmente usar sendmailutilitário dentro do seu programa Perl para enviar e-mail. Aqui está um script de amostra que pode enviar um email para um determinado ID de email. Apenas certifique-se de que o caminho fornecido para o utilitário sendmail está correto. Isso pode ser diferente para sua máquina Linux / Unix.

#!/usr/bin/perl
 
$to = '[email protected]';
$from = '[email protected]'; $subject = 'Test Email';
$message = 'This is test email sent by Perl Script'; open(MAIL, "|/usr/sbin/sendmail -t"); # Email Header print MAIL "To: $to\n";
print MAIL "From: $from\n"; print MAIL "Subject: $subject\n\n";
# Email Body
print MAIL $message;

close(MAIL);
print "Email Sent Successfully\n";

Na verdade, o script acima é um script de e-mail do cliente, que redigirá o e-mail e o enviará para o servidor rodando localmente em sua máquina Linux / Unix. Este script não será responsável por enviar e-mail para o destino real. Portanto, você deve ter certeza de que o servidor de e-mail está configurado corretamente e em execução em sua máquina para enviar e-mail para a ID de e-mail fornecida.

Enviando uma mensagem HTML

Se você deseja enviar e-mail formatado em HTML usando sendmail, basta adicionar Content-type: text/html\n na parte do cabeçalho do e-mail da seguinte forma -

#!/usr/bin/perl
 
$to = '[email protected]';
$from = '[email protected]'; $subject = 'Test Email';
$message = '<h1>This is test email sent by Perl Script</h1>'; open(MAIL, "|/usr/sbin/sendmail -t"); # Email Header print MAIL "To: $to\n";
print MAIL "From: $from\n"; print MAIL "Subject: $subject\n\n";
print MAIL "Content-type: text/html\n";
# Email Body
print MAIL $message;

close(MAIL);
print "Email Sent Successfully\n";

Usando o Módulo MIME :: Lite

Se você estiver trabalhando em uma máquina com Windows, não terá acesso ao utilitário sendmail. Mas você tem uma alternativa para escrever seu próprio cliente de e-mail usando o módulo MIME: Lite perl. Você pode baixar este módulo de MIME-Lite-3.01.tar.gz e instalá-lo em sua máquina Windows ou Linux / Unix. Para instalá-lo, siga as etapas simples -

$tar xvfz MIME-Lite-3.01.tar.gz
$cd MIME-Lite-3.01 $perl Makefile.PL
$make $make install

É isso e você terá o módulo MIME :: Lite instalado em sua máquina. Agora você está pronto para enviar seu e-mail com scripts simples explicados a seguir.

Enviando uma mensagem simples

A seguir está um script que se encarregará de enviar e-mail para o ID de e-mail fornecido -

#!/usr/bin/perl
use MIME::Lite;
 
$to = '[email protected]'; $cc = '[email protected]';
$from = '[email protected]'; $subject = 'Test Email';
$message = 'This is test email sent by Perl Script'; $msg = MIME::Lite->new(
                 From     => $from, To => $to,
                 Cc       => $cc, Subject => $subject,
                 Data     => $message ); $msg->send;
print "Email Sent Successfully\n";

Enviando uma mensagem HTML

Se você deseja enviar e-mail formatado em HTML usando sendmail, basta adicionar Content-type: text/html\nna parte do cabeçalho do e-mail. A seguir está o script, que cuidará do envio de e-mail formatado em HTML -

#!/usr/bin/perl
use MIME::Lite;
 
$to = '[email protected]'; $cc = '[email protected]';
$from = '[email protected]'; $subject = 'Test Email';
$message = '<h1>This is test email sent by Perl Script</h1>'; $msg = MIME::Lite->new(
                 From     => $from, To => $to,
                 Cc       => $cc, Subject => $subject,
                 Data     => $message ); $msg->attr("content-type" => "text/html");         
$msg->send;
print "Email Sent Successfully\n";

Enviando um Anexo

Se você deseja enviar um anexo, o script a seguir serve ao propósito -

#!/usr/bin/perl
use MIME::Lite;
 
$to = '[email protected]';
$cc = '[email protected]'; $from = '[email protected]';
$subject = 'Test Email'; $message = 'This is test email sent by Perl Script';

$msg = MIME::Lite->new( From => $from,
                 To       => $to, Cc => $cc,
                 Subject  => $subject, Type => 'multipart/mixed' ); # Add your text message. $msg->attach(Type         => 'text',
             Data         => $message ); # Specify your file as attachement. $msg->attach(Type         => 'image/gif',
             Path         => '/tmp/logo.gif',
             Filename     => 'logo.gif',
             Disposition  => 'attachment'
            );       
$msg->send;
print "Email Sent Successfully\n";

Você pode anexar quantos arquivos desejar em seu e-mail usando o método attach ().

Usando o servidor SMTP

Se a sua máquina não estiver executando um servidor de e-mail, você poderá usar qualquer outro servidor de e-mail disponível no local remoto. Mas para usar qualquer outro servidor de e-mail, você precisará ter um id, sua senha, URL, etc. Depois de ter todas as informações necessárias, você simplesmente precisa fornecer essas informações emsend() método da seguinte forma -

$msg->send('smtp', "smtp.myisp.net", AuthUser=>"id", AuthPass=>"password" );

Você pode entrar em contato com o administrador do servidor de e-mail para obter as informações usadas acima e, se um ID de usuário e senha ainda não estiverem disponíveis, o administrador poderá criá-los em minutos.

O que é um soquete?

Socket é um mecanismo Berkeley UNIX para criar uma conexão duplex virtual entre diferentes processos. Posteriormente, isso foi transferido para todos os sistemas operacionais conhecidos, permitindo a comunicação entre sistemas geográficos em execução em diferentes softwares de sistemas operacionais. Se não fosse pelo soquete, a maior parte da comunicação de rede entre os sistemas nunca teria acontecido.

Olhando mais de perto; um sistema de computador típico em uma rede recebe e envia informações conforme desejado pelos vários aplicativos em execução. Essas informações são encaminhadas ao sistema, uma vez que um endereço IP exclusivo é designado a ele. No sistema, essa informação é fornecida aos aplicativos relevantes, que escutam em portas diferentes. Por exemplo, um navegador da Internet escuta na porta 80 as informações recebidas do servidor da web. Também podemos escrever nossos aplicativos personalizados que podem ouvir e enviar / receber informações em um número de porta específico.

Por enquanto, vamos resumir que um soquete é um endereço IP e uma porta, permitindo a conexão para enviar e receber dados em uma rede.

Para explicar o conceito de socket mencionado acima, vamos dar um exemplo de Programação Cliente - Servidor usando Perl. Para completar uma arquitetura cliente-servidor, teríamos que seguir as seguintes etapas -

Para criar um servidor

Crie um soquete usando socket ligar.
Ligue o soquete a um endereço de porta usando bind ligar.
Ouça o soquete no endereço da porta usando listen ligar.
Aceitar conexões de cliente usando accept ligar.

Para criar um cliente

Crie um soquete com socket ligar.
Conecte (o soquete) ao servidor usando connect ligar.

O diagrama a seguir mostra a sequência completa das chamadas usadas pelo cliente e servidor para se comunicarem -

Chamadas de soquete do lado do servidor

A chamada socket ()

o socket()chamada é a primeira chamada para estabelecer uma conexão de rede está criando um soquete. Esta chamada tem a seguinte sintaxe -

socket( SOCKET, DOMAIN, TYPE, PROTOCOL );

A chamada acima cria um SOCKET e outros três argumentos são inteiros que devem ter os seguintes valores para conexões TCP / IP.

DOMAINdeve ser PF_INET. Provavelmente são 2 no seu computador.
TYPE deve ser SOCK_STREAM para conexão TCP / IP.
PROTOCOL deveria estar (getprotobyname('tcp'))[2]. É o protocolo específico, como o TCP, a ser falado no soquete.

Portanto, a chamada de função de soquete emitida pelo servidor será algo assim -

use Socket     # This defines PF_INET and SOCK_STREAM

socket(SOCKET,PF_INET,SOCK_STREAM,(getprotobyname('tcp'))[2]);

A chamada bind ()

Os sockets criados pela chamada socket () são inúteis até que sejam vinculados a um nome de host e um número de porta. O servidor usa o seguintebind() função para especificar a porta na qual eles aceitarão conexões dos clientes.

bind( SOCKET, ADDRESS );

Aqui SOCKET é o descritor retornado pela chamada de socket () e ADDRESS é um endereço de socket (para TCP / IP) contendo três elementos -

A família de endereços (para TCP / IP, AF_INET, provavelmente 2 em seu sistema).
O número da porta (por exemplo, 21).
O endereço de Internet do computador (por exemplo, 10.12.12.168).

Como o bind () é usado por um servidor, que não precisa saber seu próprio endereço, a lista de argumentos se parece com isto -

use Socket        # This defines PF_INET and SOCK_STREAM

$port = 12345; # The unique port used by the sever to listen requests $server_ip_address = "10.12.12.168";
bind( SOCKET, pack_sockaddr_in($port, inet_aton($server_ip_address)))
   or die "Can't bind to port $port! \n";

o or die cláusula é muito importante porque se um servidor morrer sem conexões pendentes, a porta não será imediatamente reutilizável, a menos que você use a opção SO_REUSEADDR usando setsockopt()função. Aquipack_sockaddr_in() função está sendo usada para empacotar a porta e o endereço IP em formato binário.

A chamada listen ()

Se este for um programa de servidor, será necessário fazer uma chamada para listen()na porta especificada para escutar, ou seja, aguardar as solicitações de entrada. Esta chamada tem a seguinte sintaxe -

listen( SOCKET, QUEUESIZE );

A chamada acima usa o descritor SOCKET retornado pela chamada socket () e QUEUESIZE é o número máximo de solicitações de conexão pendentes permitidas simultaneamente.

A chamada aceita ()

Se este for um programa de servidor, é necessário emitir uma chamada para o access()função para aceitar as conexões de entrada. Esta chamada tem a seguinte sintaxe -

accept( NEW_SOCKET, SOCKET );

O descritor SOCKET de aceitação da chamada recebida retornado pela função socket () e após a conclusão com sucesso, um novo descritor de socket NEW_SOCKET é retornado para todas as comunicações futuras entre o cliente e o servidor. Se a chamada access () falhar, ela retornará FLASE, que é definido no módulo Socket que usamos inicialmente.

Geralmente, accept () é usado em um loop infinito. Assim que uma conexão chega, o servidor cria um processo filho para lidar com ela ou o atende sozinho e então volta para escutar mais conexões.

while(1) {
   accept( NEW_SOCKET, SOCKT );
   .......
}

Agora todas as chamadas relacionadas ao servidor acabaram e vamos ver uma chamada que será solicitada pelo cliente.

Chamadas de socket do lado do cliente

A chamada connect ()

Se você for preparar um programa cliente, primeiro usará socket() chamada para criar um soquete e então você teria que usar connect()ligue para se conectar ao servidor. Você já viu a sintaxe da chamada socket () e ela permanecerá semelhante à chamada socket () do servidor, mas aqui está a sintaxe paraconnect() chamar -

connect( SOCKET, ADDRESS );

Aqui SCOKET é o descritor de socket retornado por socket (chamada) emitido pelo cliente e endereço é um endereço de socket semelhante ao ligamento chamada, exceto que ele contém o endereço IP do servidor remoto.

$port = 21;    # For example, the ftp port
$server_ip_address = "10.12.12.168"; connect( SOCKET, pack_sockaddr_in($port, inet_aton($server_ip_address))) or die "Can't connect to port $port! \n";

Se você se conectar ao servidor com sucesso, poderá começar a enviar seus comandos para o servidor usando o descritor SOCKET, caso contrário, seu cliente aparecerá com uma mensagem de erro.

Cliente - Exemplo de servidor

A seguir está um código Perl para implementar um programa cliente-servidor simples usando o socket Perl. Aqui, o servidor escuta as solicitações de entrada e, uma vez que a conexão é estabelecida, ele simplesmente responde Smile do servidor . O cliente lê aquela mensagem e imprime na tela. Vamos ver como isso foi feito, supondo que temos nosso servidor e cliente na mesma máquina.

Script para criar um servidor

#!/usr/bin/perl -w
# Filename : server.pl

use strict;
use Socket;

# use port 7890 as default
my $port = shift || 7890; my $proto = getprotobyname('tcp');
my $server = "localhost"; # Host IP running the server # create a socket, make it reusable socket(SOCKET, PF_INET, SOCK_STREAM, $proto)
   or die "Can't open socket $!\n"; setsockopt(SOCKET, SOL_SOCKET, SO_REUSEADDR, 1) or die "Can't set socket option to SO_REUSEADDR $!\n";

# bind to a port, then listen
bind( SOCKET, pack_sockaddr_in($port, inet_aton($server)))
   or die "Can't bind to port $port! \n"; listen(SOCKET, 5) or die "listen: $!";
print "SERVER started on port $port\n"; # accepting a connection my $client_addr;
while ($client_addr = accept(NEW_SOCKET, SOCKET)) { # send them a message, close connection my $name = gethostbyaddr($client_addr, AF_INET ); print NEW_SOCKET "Smile from the server"; print "Connection recieved from $name\n";
   close NEW_SOCKET;
}

Para executar o servidor em modo de segundo plano, execute o seguinte comando no prompt do Unix -

$perl sever.pl&

Script para criar um cliente

!/usr/bin/perl -w
# Filename : client.pl

use strict;
use Socket;

# initialize host and port
my $host = shift || 'localhost';
my $port = shift || 7890; my $server = "localhost";  # Host IP running the server

# create the socket, connect to the port
socket(SOCKET,PF_INET,SOCK_STREAM,(getprotobyname('tcp'))[2])
   or die "Can't create a socket $!\n"; connect( SOCKET, pack_sockaddr_in($port, inet_aton($server))) or die "Can't connect to port $port! \n";

my $line; while ($line = <SOCKET>) {
   print "$line\n"; } close SOCKET or die "close: $!";

Agora vamos iniciar nosso cliente no prompt de comando, que irá se conectar ao servidor e ler a mensagem enviada pelo servidor e exibir a mesma na tela da seguinte maneira -

$perl client.pl
Smile from the server

NOTE - Se você estiver fornecendo o endereço IP real em notação de ponto, é recomendável fornecer o endereço IP no mesmo formato no cliente e no servidor para evitar qualquer confusão.

Já estudamos referências em matrizes e hashes anônimos Perl e Perl. O conceito de Orientação a Objetos em Perl é muito baseado em referências e array anônimo e hashes. Vamos começar a aprender os conceitos básicos de Perl Orientado a Objetos.

Object Basics

Existem três termos principais, explicados do ponto de vista de como o Perl trata os objetos. Os termos são objeto, classe e método.

A objectem Perl é apenas uma referência a um tipo de dados que sabe a que classe pertence. O objeto é armazenado como referência em uma variável escalar. Como um escalar contém apenas uma referência ao objeto, o mesmo escalar pode conter objetos diferentes em classes diferentes.
UMA class dentro do Perl está um pacote que contém os métodos correspondentes necessários para criar e manipular objetos.
UMA methoddentro do Perl é uma sub-rotina, definida com o pacote. O primeiro argumento para o método é uma referência de objeto ou um nome de pacote, dependendo se o método afeta o objeto atual ou a classe.

Perl fornece um bless() função, que é usada para retornar uma referência que finalmente se torna um objeto.

Definindo uma classe

É muito simples definir uma classe em Perl. Uma classe corresponde a um pacote Perl em sua forma mais simples. Para criar uma classe em Perl, primeiro construímos um pacote.

Um pacote é uma unidade autocontida de variáveis e sub-rotinas definidas pelo usuário, que pode ser reutilizada continuamente.

Pacotes Perl fornecem um namespace separado dentro de um programa Perl que mantém sub-rotinas e variáveis independentes do conflito com aquelas em outros pacotes.

Para declarar uma classe chamada Person em Perl, fazemos -

package Person;

O escopo da definição do pacote se estende até o final do arquivo ou até que outra palavra-chave do pacote seja encontrada.

Criando e usando objetos

Para criar uma instância de uma classe (um objeto), precisamos de um construtor de objeto. Este construtor é um método definido dentro do pacote. A maioria dos programadores escolhe nomear este método de construtor de objeto como novo, mas em Perl você pode usar qualquer nome.

Você pode usar qualquer tipo de variável Perl como um objeto em Perl. A maioria dos programadores Perl escolhe referências a matrizes ou hashes.

Vamos criar nosso construtor para nossa classe Person usando uma referência de hash Perl. Ao criar um objeto, você precisa fornecer um construtor, que é uma sub-rotina dentro de um pacote que retorna uma referência de objeto. A referência do objeto é criada abençoando uma referência à classe do pacote. Por exemplo -

package Person;
sub new {
   my $class = shift;
   my $self = { _firstName => shift, _lastName => shift, _ssn => shift, }; # Print all the values just for clarification. print "First Name is $self->{_firstName}\n";
   print "Last Name is $self->{_lastName}\n"; print "SSN is $self->{_ssn}\n";
   bless $self, $class;
   return $self;
}

Agora vamos ver como criar um objeto.

$object = new Person( "Mohammad", "Saleem", 23234345);

Você pode usar hash simples em seu construtor se não quiser atribuir nenhum valor a nenhuma variável de classe. Por exemplo -

package Person;
sub new {
   my $class = shift; my $self = {};
   bless $self, $class;
   return $self;
}

Definindo Métodos

Outras linguagens orientadas a objetos têm o conceito de segurança de dados para evitar que um programador altere os dados de um objeto diretamente e fornecem métodos de acesso para modificar os dados do objeto. Perl não possui variáveis privadas, mas ainda podemos usar o conceito de métodos auxiliares para manipular os dados do objeto.

Vamos definir um método auxiliar para obter o primeiro nome da pessoa -

sub getFirstName {
   return $self->{_firstName};
}

Outra função auxiliar para definir o primeiro nome da pessoa -

sub setFirstName {
   my ( $self, $firstName ) = @_;
   $self->{_firstName} = $firstName if defined($firstName); return $self->{_firstName};
}

Agora vamos dar uma olhada em um exemplo completo: Mantenha o pacote Person e as funções auxiliares no arquivo Person.pm.

#!/usr/bin/perl 

package Person;

sub new {
   my $class = shift; my $self = {
      _firstName => shift,
      _lastName  => shift,
      _ssn       => shift,
   };
   # Print all the values just for clarification.
   print "First Name is $self->{_firstName}\n"; print "Last Name is $self->{_lastName}\n";
   print "SSN is $self->{_ssn}\n"; bless $self, $class; return $self;
}
sub setFirstName {
   my ( $self, $firstName ) = @_;
   $self->{_firstName} = $firstName if defined($firstName); return $self->{_firstName};
}

sub getFirstName {
   my( $self ) = @_; return $self->{_firstName};
}
1;

Agora vamos fazer uso do objeto Person no arquivo employee.pl da seguinte maneira -

#!/usr/bin/perl

use Person;

$object = new Person( "Mohammad", "Saleem", 23234345); # Get first name which is set using constructor. $firstName = $object->getFirstName(); print "Before Setting First Name is : $firstName\n";

# Now Set first name using helper function.
$object->setFirstName( "Mohd." ); # Now get first name set by helper function. $firstName = $object->getFirstName(); print "Before Setting First Name is : $firstName\n";

Quando executamos o programa acima, ele produz o seguinte resultado -

First Name is Mohammad
Last Name is Saleem
SSN is 23234345
Before Setting First Name is : Mohammad
Before Setting First Name is : Mohd.

Herança

A programação orientada a objetos tem um conceito muito bom e útil chamado herança. Herança significa simplesmente que as propriedades e métodos de uma classe pai estarão disponíveis para as classes filho. Assim, você não precisa escrever o mesmo código repetidamente, pode simplesmente herdar uma classe pai.

Por exemplo, podemos ter uma classe Employee, que herda de Person. Isso é conhecido como relacionamento "isa" porque um funcionário é uma pessoa. Perl tem uma variável especial, @ISA, para ajudar com isso. @ISA governa a herança (método).

A seguir estão os pontos importantes a serem considerados ao usar a herança -

Perl pesquisa a classe do objeto especificado para o método ou atributo fornecido, ou seja, variável.
Perl pesquisa as classes definidas na matriz @ISA da classe de objeto.
Se nenhum método for encontrado nas etapas 1 ou 2, o Perl usa uma sub-rotina AUTOLOAD, se houver uma na árvore @ISA.
Se um método compatível ainda não puder ser encontrado, o Perl procura o método dentro da classe UNIVERSAL (pacote) que vem como parte da biblioteca Perl padrão.
Se o método ainda não foi encontrado, o Perl desiste e levanta uma exceção de tempo de execução.

Portanto, para criar uma nova classe Employee que herdará métodos e atributos de nossa classe Person, simplesmente codificamos da seguinte maneira: Mantenha este código em Employee.pm.

#!/usr/bin/perl

package Employee;
use Person;
use strict;
our @ISA = qw(Person);    # inherits from Person

Agora, a classe Employee tem todos os métodos e atributos herdados da classe Person e você pode usá-los da seguinte maneira: Use o arquivo main.pl para testá-lo -

#!/usr/bin/perl

use Employee;

$object = new Employee( "Mohammad", "Saleem", 23234345); # Get first name which is set using constructor. $firstName = $object->getFirstName(); print "Before Setting First Name is : $firstName\n";

# Now Set first name using helper function.
$object->setFirstName( "Mohd." ); # Now get first name set by helper function. $firstName = $object->getFirstName(); print "After Setting First Name is : $firstName\n";

Quando executamos o programa acima, ele produz o seguinte resultado -

First Name is Mohammad
Last Name is Saleem
SSN is 23234345
Before Setting First Name is : Mohammad
Before Setting First Name is : Mohd.

Substituição de método

A classe filha Employee herda todos os métodos da classe pai Person. Mas se você deseja sobrescrever esses métodos em sua classe filha, você pode fazer isso fornecendo sua própria implementação. Você pode adicionar suas funções adicionais na classe filha ou você pode adicionar ou modificar a funcionalidade de métodos existentes em sua classe pai. Isso pode ser feito da seguinte maneira: modificar o arquivo Employee.pm.

#!/usr/bin/perl

package Employee;
use Person;
use strict;
our @ISA = qw(Person);    # inherits from Person

# Override constructor
sub new {
   my ($class) = @_; # Call the constructor of the parent class, Person. my $self = $class->SUPER::new( $_[1], $_[2], $_[3] );
   # Add few more attributes
   $self->{_id} = undef; $self->{_title} = undef;
   bless $self, $class;
   return $self; } # Override helper function sub getFirstName { my( $self ) = @_;
   # This is child class function.
   print "This is child class helper function\n";
   return $self->{_firstName}; } # Add more methods sub setLastName{ my ( $self, $lastName ) = @_; $self->{_lastName} = $lastName if defined($lastName);
   return $self->{_lastName}; } sub getLastName { my( $self ) = @_;
   return $self->{_lastName};
}

1;

Agora vamos tentar novamente usar o objeto Employee em nosso arquivo main.pl e executá-lo.

#!/usr/bin/perl

use Employee;

$object = new Employee( "Mohammad", "Saleem", 23234345);
# Get first name which is set using constructor.
$firstName = $object->getFirstName();

print "Before Setting First Name is : $firstName\n"; # Now Set first name using helper function. $object->setFirstName( "Mohd." );

# Now get first name set by helper function.
$firstName = $object->getFirstName();
print "After Setting First Name is : $firstName\n";

Quando executamos o programa acima, ele produz o seguinte resultado -

First Name is Mohammad
Last Name is Saleem
SSN is 23234345
This is child class helper function
Before Setting First Name is : Mohammad
This is child class helper function
After Setting First Name is : Mohd.

Carregamento automático padrão

Perl oferece um recurso que você não encontraria em nenhuma outra linguagem de programação: uma sub-rotina padrão. O que significa que, se você definir uma função chamadaAUTOLOAD(),então, quaisquer chamadas a sub-rotinas indefinidas chamarão a função AUTOLOAD () automaticamente. O nome da sub-rotina ausente está acessível dentro desta sub-rotina como $ AUTOLOAD.

A funcionalidade de carregamento automático padrão é muito útil para tratamento de erros. Aqui está um exemplo para implementar AUTOLOAD, você pode implementar esta função à sua maneira.

sub AUTOLOAD {
   my $self = shift; my $type = ref ($self) || croak "$self is not an object";
   my $field = $AUTOLOAD;
   $field =~ s/.*://; unless (exists $self->{$field}) { croak "$field does not exist in object/class $type"; } if (@_) { return $self->($name) = shift; } else { return $self->($name);
   }
}

Destruidores e coleta de lixo

Se você já programou usando a programação orientada a objetos antes, então você estará ciente da necessidade de criar um destructorpara liberar a memória alocada para o objeto quando você terminar de usá-lo. Perl faz isso automaticamente para você assim que o objeto sai do escopo.

No caso de você querer implementar seu destruidor, que deve se encarregar de fechar arquivos ou fazer algum processamento extra, então você precisa definir um método especial chamado DESTROY. Este método será chamado no objeto antes que o Perl libere a memória alocada para ele. Em todos os outros aspectos, o método DESTROY é como qualquer outro método, e você pode implementar qualquer lógica que quiser dentro desse método.

Um método destruidor é simplesmente uma função de membro (sub-rotina) chamada DESTROY, que será chamada automaticamente nos seguintes casos -

Quando a variável de referência do objeto sai do escopo.
Quando a variável de referência do objeto é indefinida.
Quando o script termina
Quando o interpretador perl termina

Por exemplo, você pode simplesmente colocar o seguinte método DESTROY em sua classe -

package MyClass;
...
sub DESTROY {
   print "MyClass::DESTROY called\n";
}

Exemplo de Perl Orientado a Objetos

Aqui está outro bom exemplo, que o ajudará a entender os Conceitos Orientados a Objetos do Perl. Coloque este código-fonte em qualquer arquivo perl e execute-o.

#!/usr/bin/perl

# Following is the implementation of simple Class.
package MyClass;

sub new {
   print "MyClass::new called\n";
   my $type = shift;            # The package/type name
   my $self = {}; # Reference to empty hash return bless $self, $type; } sub DESTROY { print "MyClass::DESTROY called\n"; } sub MyMethod { print "MyClass::MyMethod called!\n"; } # Following is the implemnetation of Inheritance. package MySubClass; @ISA = qw( MyClass ); sub new { print "MySubClass::new called\n"; my $type = shift;            # The package/type name
   my $self = MyClass->new; # Reference to empty hash return bless $self, $type; } sub DESTROY { print "MySubClass::DESTROY called\n"; } sub MyMethod { my $self = shift;
   $self->SUPER::MyMethod(); print " MySubClass::MyMethod called!\n"; } # Here is the main program using above classes. package main; print "Invoke MyClass method\n"; $myObject = MyClass->new();
$myObject->MyMethod(); print "Invoke MySubClass method\n"; $myObject2 = MySubClass->new();
$myObject2->MyMethod(); print "Create a scoped object\n"; { my $myObject2 = MyClass->new();
}
# Destructor is called automatically here

print "Create and undef an object\n";
$myObject3 = MyClass->new(); undef $myObject3;

print "Fall off the end of the script...\n";
# Remaining destructors are called automatically here

Quando executamos o programa acima, ele produz o seguinte resultado -

Invoke MyClass method
MyClass::new called
MyClass::MyMethod called!
Invoke MySubClass method
MySubClass::new called
MyClass::new called
MyClass::MyMethod called!
MySubClass::MyMethod called!
Create a scoped object
MyClass::new called
MyClass::DESTROY called
Create and undef an object
MyClass::new called
MyClass::DESTROY called
Fall off the end of the script...
MyClass::DESTROY called
MySubClass::DESTROY called

Este capítulo ensina como acessar um banco de dados dentro de seu script Perl. A partir do Perl 5 tornou-se muito fácil escrever aplicativos de banco de dados usandoDBImódulo. DBI significaDatabase Independent Interface para Perl, o que significa que o DBI fornece uma camada de abstração entre o código Perl e o banco de dados subjacente, permitindo que você alterne as implementações do banco de dados com facilidade.

O DBI é um módulo de acesso ao banco de dados para a linguagem de programação Perl. Ele fornece um conjunto de métodos, variáveis e convenções que fornecem uma interface de banco de dados consistente, independente do banco de dados real que está sendo usado.

Arquitetura de um aplicativo DBI

DBI é independente de qualquer banco de dados disponível no backend. Você pode usar DBI se estiver trabalhando com Oracle, MySQL ou Informix, etc. Isso fica claro no seguinte diagrama de arquitetura.

Aqui, o DBI é responsável por obter todos os comandos SQL por meio da API (ou seja, Interface de Programação de Aplicativo) e despachá-los para o driver apropriado para execução real. E, finalmente, DBI é responsável por pegar os resultados do driver e devolvê-los ao scritp de chamada.

Notação e Convenções

Ao longo deste capítulo, as notações a seguir serão usadas e é recomendável que você também siga a mesma convenção.

$dsn Database source name $dbh    Database handle object
$sth Statement handle object $h      Any of the handle types above ($dbh, $sth, or $drh) $rc     General Return Code  (boolean: true=ok, false=error)
$rv General Return Value (typically an integer) @ary List of values returned from the database. $rows   Number of rows processed (if available, else -1)
$fh     A filehandle
undef   NULL values are represented by undefined values in Perl
\%attr  Reference to a hash of attribute values passed to methods

Conexão de banco de dados

Supondo que iremos trabalhar com banco de dados MySQL. Antes de conectar-se a um banco de dados, certifique-se do seguinte. Você pode obter ajuda de nosso tutorial MySQL caso não saiba como criar banco de dados e tabelas em banco de dados MySQL.

Você criou um banco de dados com o nome TESTDB.
Você criou uma tabela com o nome TEST_TABLE em TESTDB.
Esta tabela contém os campos FIRST_NAME, LAST_NAME, AGE, SEX e INCOME.
O ID do usuário "testuser" e a senha "test123" são definidos para acessar o TESTDB.
O Módulo Perl DBI está instalado corretamente em sua máquina.
Você passou pelo tutorial do MySQL para entender os fundamentos do MySQL.

A seguir está o exemplo de conexão com o banco de dados MySQL "TESTDB" -

#!/usr/bin/perl

use DBI
use strict;

my $driver = "mysql"; 
my $database = "TESTDB"; my $dsn = "DBI:$driver:database=$database";
my $userid = "testuser"; my $password = "test123";

my $dbh = DBI->connect($dsn, $userid, $password ) or die $DBI::errstr;

Se uma conexão for estabelecida com a fonte de dados, um identificador de banco de dados é retornado e salvo em $ dbh para uso posterior, caso contrário, $ dbh é definido com o valor undef e $ DBI :: errstr retorna uma string de erro.

Operação INSERT

A operação INSERT é necessária quando você deseja criar alguns registros em uma tabela. Aqui, estamos usando a tabela TEST_TABLE para criar nossos registros. Assim, uma vez que nossa conexão com o banco de dados seja estabelecida, estamos prontos para criar registros em TEST_TABLE. A seguir está o procedimento para criar um único registro em TEST_TABLE. Você pode criar quantos registros quiser usando o mesmo conceito.

A criação do registro segue as seguintes etapas -

Preparando a instrução SQL com a instrução INSERT. Isso será feito usandoprepare() API.
Execução de consulta SQL para selecionar todos os resultados do banco de dados. Isso será feito usandoexecute() API.
Liberando a alça de instrução. Isso será feito usandofinish() API.
Se tudo correr bem então commit esta operação, caso contrário, você pode rollbacktransação completa. Commit e Rollback são explicados nas próximas seções.

my $sth = $dbh->prepare("INSERT INTO TEST_TABLE
                       (FIRST_NAME, LAST_NAME, SEX, AGE, INCOME )
                         values
                       ('john', 'poul', 'M', 30, 13000)");
$sth->execute() or die $DBI::errstr;
$sth->finish(); $dbh->commit or die $DBI::errstr;

Usando Valores Bind

Pode haver um caso em que os valores a serem inseridos não sejam fornecidos com antecedência. Portanto, você pode usar variáveis de ligação que assumirão os valores necessários em tempo de execução. Os módulos Perl DBI usam um ponto de interrogação no lugar do valor real e, em seguida, os valores reais são passados pela API execute () no tempo de execução. A seguir está o exemplo -

my $first_name = "john";
my $last_name = "poul"; my $sex = "M";
my $income = 13000; my $age = 30;
my $sth = $dbh->prepare("INSERT INTO TEST_TABLE
                        (FIRST_NAME, LAST_NAME, SEX, AGE, INCOME )
                          values
                        (?,?,?,?)");
$sth->execute($first_name,$last_name,$sex, $age, $income) 
          or die $DBI::errstr; $sth->finish();
$dbh->commit or die $DBI::errstr;

Operação READ

A operação READ em qualquer banco de dados significa buscar alguma informação útil do banco de dados, ou seja, um ou mais registros de uma ou mais tabelas. Assim, uma vez que nossa conexão de banco de dados seja estabelecida, estamos prontos para fazer uma consulta a este banco de dados. A seguir está o procedimento para consultar todos os registros com IDADE maior que 20. Isso levará quatro etapas -

Preparando a consulta SQL SELECT com base nas condições necessárias. Isso será feito usandoprepare() API.
Execução de consulta SQL para selecionar todos os resultados do banco de dados. Isso será feito usandoexecute() API.
Buscando todos os resultados um por um e imprimindo-os. Isso será feito usando fetchrow_array() API.
Liberando a alça de instrução. Isso será feito usandofinish() API.

my $sth = $dbh->prepare("SELECT FIRST_NAME, LAST_NAME
                        FROM TEST_TABLE 
                        WHERE AGE > 20");
$sth->execute() or die $DBI::errstr;
print "Number of rows found :" + $sth->rows; while (my @row = $sth->fetchrow_array()) {
   my ($first_name, $last_name ) = @row;
   print "First Name = $first_name, Last Name = $last_name\n";
}
$sth->finish();

Usando Valores Bind

Pode haver um caso em que a condição não seja dada com antecedência. Portanto, você pode usar variáveis de ligação, que assumirão os valores necessários no tempo de execução. Os módulos Perl DBI usam um ponto de interrogação no lugar do valor real e, em seguida, os valores reais são passados pela API execute () no tempo de execução. A seguir está o exemplo -

$age = 20;
my $sth = $dbh->prepare("SELECT FIRST_NAME, LAST_NAME
                        FROM TEST_TABLE
                        WHERE AGE > ?");
$sth->execute( $age ) or die $DBI::errstr; print "Number of rows found :" + $sth->rows;
while (my @row = $sth->fetchrow_array()) { my ($first_name, $last_name ) = @row; print "First Name = $first_name, Last Name = $last_name\n"; } $sth->finish();

Operação ATUALIZAR

UPDATE Operação em qualquer banco de dados significa atualizar um ou mais registros já disponíveis nas tabelas do banco de dados. A seguir está o procedimento para atualizar todos os registros que têm SEXO como 'M'. Aqui, aumentaremos a IDADE de todos os homens em um ano. Isso levará três etapas -

Preparando a consulta SQL com base nas condições exigidas. Isso será feito usandoprepare() API.
Execução de consulta SQL para selecionar todos os resultados do banco de dados. Isso será feito usandoexecute() API.
Liberando a alça de instrução. Isso será feito usandofinish() API.
Se tudo correr bem então commit esta operação, caso contrário, você pode rollbacktransação completa. Consulte a próxima seção para APIs de confirmação e reversão.

my $sth = $dbh->prepare("UPDATE TEST_TABLE
                        SET   AGE = AGE + 1 
                        WHERE SEX = 'M'");
$sth->execute() or die $DBI::errstr;
print "Number of rows updated :" + $sth->rows; $sth->finish();
$dbh->commit or die $DBI::errstr;

Usando Valores Bind

$sex = 'M'; my $sth = $dbh->prepare("UPDATE TEST_TABLE SET AGE = AGE + 1 WHERE SEX = ?"); $sth->execute('$sex') or die $DBI::errstr;
print "Number of rows updated :" + $sth->rows; $sth->finish();
$dbh->commit or die $DBI::errstr;

Em alguns casos, você gostaria de definir um valor, que não é fornecido com antecedência, para que possa usar o valor de vinculação da seguinte maneira. Neste exemplo, a renda de todos os homens será definida como 10.000.

$sex = 'M'; $income = 10000;
my $sth = $dbh->prepare("UPDATE TEST_TABLE
                        SET   INCOME = ?
                        WHERE SEX = ?");
$sth->execute( $income, '$sex') or die $DBI::errstr;
print "Number of rows updated :" + $sth->rows; $sth->finish();

Operação DELETE

A operação DELETE é necessária quando você deseja excluir alguns registros de seu banco de dados. A seguir está o procedimento para excluir todos os registros de TEST_TABLE onde AGE é igual a 30. Esta operação executará as seguintes etapas.

Preparando a consulta SQL com base nas condições exigidas. Isso será feito usandoprepare() API.
Execução de consulta SQL para excluir registros necessários do banco de dados. Isso será feito usandoexecute() API.
Liberando a alça de instrução. Isso será feito usandofinish() API.
Se tudo correr bem então commit esta operação, caso contrário, você pode rollback transação completa.

$age = 30; my $sth = $dbh->prepare("DELETE FROM TEST_TABLE WHERE AGE = ?"); $sth->execute( $age ) or die $DBI::errstr;
print "Number of rows deleted :" + $sth->rows; $sth->finish();
$dbh->commit or die $DBI::errstr;

Usando fazer declaração

Se você estiver fazendo um UPDATE, INSERT ou DELETE, não haverá dados que retornem do banco de dados, portanto, há um atalho para executar esta operação. Você pode usardo para executar qualquer um dos comandos a seguir.

$dbh->do('DELETE FROM TEST_TABLE WHERE age =30');

doretorna um valor verdadeiro se tiver êxito e um valor falso se falhar. Na verdade, se for bem-sucedido, ele retorna o número de linhas afetadas. No exemplo, ele retornaria o número de linhas que foram realmente excluídas.

Operação COMMIT

Commit é a operação que dá um sinal verde ao banco de dados para finalizar as alterações e após esta operação nenhuma alteração pode ser revertida para sua posição original.

Aqui está um exemplo simples para chamar commit API.

$dbh->commit or die $dbh->errstr;

Operação ROLLBACK

Se você não estiver satisfeito com todas as alterações ou se encontrar um erro no meio de qualquer operação, você pode reverter essas alterações para usar rollback API.

Aqui está um exemplo simples para chamar rollback API.

$dbh->rollback or die $dbh->errstr;

Iniciar transação

Muitos bancos de dados oferecem suporte a transações. Isso significa que você pode fazer um monte de consultas que modificam os bancos de dados, mas nenhuma das alterações é realmente feita. Então, no final, você emite a consulta SQL especialCOMMIT, e todas as alterações são feitas simultaneamente. Como alternativa, você pode emitir a consulta ROLLBACK, caso em que todas as alterações são descartadas e o banco de dados permanece inalterado.

Módulo Perl DBI fornecido begin_workAPI, que ativa as transações (desativando o AutoCommit) até a próxima chamada para confirmar ou reverter. Após o próximo commit ou rollback, o AutoCommit será automaticamente ativado novamente.

$rc  = $dbh->begin_work or die $dbh->errstr;

Opção AutoCommit

Se suas transações são simples, você pode evitar o trabalho de ter que emitir muitos commits. Ao fazer a chamada de conexão, você pode especificar umAutoCommitopção que executará uma operação de confirmação automática após cada consulta bem-sucedida. Aqui está o que parece -

my $dbh = DBI->connect($dsn, $userid, $password,
              {AutoCommit => 1}) 
              or die $DBI::errstr;

Aqui, o AutoCommit pode assumir o valor 1 ou 0, onde 1 significa que o AutoCommit está ativado e 0 significa que o AutoCommit está desativado.

Tratamento automático de erros

Ao fazer a chamada de conexão, você pode especificar uma opção RaiseErrors que trata os erros para você automaticamente. Quando ocorre um erro, o DBI aborta seu programa em vez de retornar um código de falha. Se tudo o que você deseja é abortar o programa em um erro, isso pode ser conveniente. Aqui está o que parece -

my $dbh = DBI->connect($dsn, $userid, $password, {RaiseError => 1}) or die $DBI::errstr;

Aqui, RaiseError pode assumir o valor 1 ou 0.

Desconectando banco de dados

Para desconectar a conexão do banco de dados, use disconnect API da seguinte forma -

$rc = $dbh->disconnect  or warn $dbh->errstr;

O comportamento da transação do método de desconexão é, infelizmente, indefinido. Alguns sistemas de banco de dados (como Oracle e Ingres) confirmarão automaticamente todas as alterações pendentes, mas outros (como Informix) reverterão todas as mudanças pendentes. Os aplicativos que não usam o AutoCommit devem chamar explicitamente o commit ou rollback antes de chamar a desconexão.

Usando valores NULL

Valores indefinidos, ou undef, são usados para indicar valores NULL. Você pode inserir e atualizar colunas com um valor NULL como faria com um valor não NULL. Estes exemplos inserem e atualizam a idade da coluna com um valor NULL -

$sth = $dbh->prepare(qq { INSERT INTO TEST_TABLE (FIRST_NAME, AGE) VALUES (?, ?) }); $sth->execute("Joe", undef);

Aqui qq{} é usado para retornar uma string entre aspas para prepareAPI. No entanto, deve-se ter cuidado ao tentar usar valores NULL em uma cláusula WHERE. Considere -

SELECT FIRST_NAME FROM TEST_TABLE WHERE age = ?

Ligar um undef (NULL) ao espaço reservado não selecionará linhas, que têm uma idade NULL! Pelo menos para mecanismos de banco de dados que estejam em conformidade com o padrão SQL. Consulte o manual SQL do seu mecanismo de banco de dados ou qualquer livro SQL para obter as razões para isso. Para selecionar explicitamente NULLs, você deve dizer "WHERE age IS NULL".

Um problema comum é fazer com que um fragmento de código manipule um valor que pode ser definido ou undef (não NULL ou NULL) em tempo de execução. Uma técnica simples é preparar a instrução apropriada conforme necessário e substituir o espaço reservado para casos não NULL -

$sql_clause = defined $age? "age = ?" : "age IS NULL";
$sth = $dbh->prepare(qq {
         SELECT FIRST_NAME FROM TEST_TABLE WHERE $sql_clause }); $sth->execute(defined $age ? $age : ());

Algumas outras funções DBI

drivers_disponíveis

@ary = DBI->available_drivers;
@ary = DBI->available_drivers($quiet);

Retorna uma lista de todos os drivers disponíveis procurando por módulos DBD :: * através dos diretórios em @INC. Por padrão, um aviso é dado se alguns drivers forem ocultados por outros com o mesmo nome em diretórios anteriores. Passar um valor verdadeiro para $ quiet inibirá o aviso.

installed_drivers

%drivers = DBI->installed_drivers();

Retorna uma lista de nomes de driver e pares de identificadores de driver para todos os drivers 'instalados' (carregados) no processo atual. O nome do driver não inclui o prefixo 'DBD ::'.

fontes de dados

@ary = DBI->data_sources($driver);

Retorna uma lista de fontes de dados (bancos de dados) disponíveis por meio do driver nomeado. Se $ driver estiver vazio ou undef, o valor da variável de ambiente DBI_DRIVER será usado.

citar

$sql = $dbh->quote($value); $sql = $dbh->quote($value, $data_type);

Cite uma string literal para usar como valor literal em uma instrução SQL, escapando de quaisquer caracteres especiais (como aspas) contidos na string e adicionando o tipo necessário de aspas externas.

$sql = sprintf "SELECT foo FROM bar WHERE baz = %s",
                $dbh->quote("Don't");

Para a maioria dos tipos de banco de dados, aspas retornariam 'Não' (incluindo as aspas externas). É válido para o método quote () retornar uma expressão SQL avaliada como a string desejada. Por exemplo -

$quoted = $dbh->quote("one\ntwo\0three")

may produce results which will be equivalent to

CONCAT('one', CHAR(12), 'two', CHAR(0), 'three')

Métodos comuns a todos os manipuladores

errar

$rv = $h->err; or $rv = $DBI::err or $rv = $h->err

Retorna o código de erro do mecanismo de banco de dados nativo do último método de driver chamado. O código é normalmente um número inteiro, mas você não deve presumir isso. Isso é equivalente a $ DBI :: err ou $ h-> err.

errstr

$str = $h->errstr; or $str = $DBI::errstr or $str = $h->errstr

Retorna a mensagem de erro do mecanismo de banco de dados nativo do último método DBI chamado. Isso tem os mesmos problemas de vida útil do método "errar" descrito acima. Isso é equivalente a $ DBI :: errstr ou $ h-> errstr.

filas

$rv = $h->rows; or $rv = $DBI::rows

Isso retorna o número de linhas afetadas pela instrução SQL anterior e equivalente a $ DBI :: linhas.

vestígio

$h->trace($trace_settings);

O DBI possui uma capacidade extremamente útil de gerar informações de rastreamento de tempo de execução do que está fazendo, o que pode economizar muito tempo ao tentar rastrear problemas estranhos em seus programas DBI. Você pode usar valores diferentes para definir o nível de rastreamento. Esses valores variam de 0 a 4. O valor 0 significa desabilitar o rastreamento e 4 significa gerar o rastreamento completo.

Declarações interpoladas são proibidas

É altamente recomendável não usar instruções interpoladas da seguinte forma -

while ($first_name = <>) { my $sth = $dbh->prepare("SELECT * FROM TEST_TABLE WHERE FIRST_NAME = '$first_name'");
   $sth->execute();
   # and so on ...
}

Portanto, não use declaração interpolada em vez de usar bind value para preparar a instrução SQL dinâmica.

O que é CGI?

A Common Gateway Interface, ou CGI, é um conjunto de padrões que define como as informações são trocadas entre o servidor da web e um script personalizado.
As especificações CGI são atualmente mantidas pela NCSA e a NCSA define CGI como segue -
A Common Gateway Interface, ou CGI, é um padrão para programas de gateway externo fazerem interface com servidores de informações, como servidores HTTP.
A versão atual é CGI / 1.1 e CGI / 1.2 está em andamento.

Navegação na web

Para entender o conceito de CGI, vamos ver o que acontece quando clicamos em um hiper link disponível em uma página da web para navegar em uma determinada página da web ou URL.

Seu navegador entra em contato com o servidor da web usando o protocolo HTTP e exige a URL, ou seja, o nome do arquivo da página da web.
O servidor da Web verificará a URL e procurará o nome do arquivo solicitado. Se o servidor da web encontrar esse arquivo, ele o enviará de volta ao navegador sem qualquer outra execução, caso contrário, enviará uma mensagem de erro indicando que você solicitou um arquivo errado.
O navegador da web recebe a resposta do servidor da web e exibe o conteúdo do arquivo recebido ou uma mensagem de erro caso o arquivo não seja encontrado.

Porém, é possível configurar o servidor HTTP de forma que sempre que um arquivo em um determinado diretório for solicitado esse arquivo não seja enviado de volta; em vez disso, ele é executado como um programa, e tudo o que esse programa produzir como resultado, será enviado de volta para o seu navegador exibir. Isso pode ser feito usando uma funcionalidade especial disponível no servidor web e é chamadaCommon Gateway Interfaceou CGI e tais programas que são executados pelo servidor para produzir o resultado final, são chamados de scripts CGI. Estes programas CGI podem ser PERL Script, Shell Script, programa C ou C ++, etc.

Diagrama de Arquitetura CGI

Suporte e configuração de servidor web

Antes de prosseguir com a Programação CGI, certifique-se de que seu servidor da Web oferece suporte à funcionalidade CGI e está configurado para lidar com programas CGI. Todos os programas CGI a serem executados pelo servidor web são mantidos em um diretório pré-configurado. Este diretório é denominado diretório CGI e por convenção é denominado / cgi-bin. Por convenção, os arquivos Perl CGI terão extensão como.cgi.

Primeiro Programa CGI

Aqui está um link simples que está vinculado a um script CGI chamado hello.cgi . Este arquivo foi mantido em/cgi-bin/diretório e tem o seguinte conteúdo. Antes de executar seu programa CGI, certifique-se de alterar o modo de arquivo usandochmod 755 hello.cgi Comando UNIX.

#!/usr/bin/perl

print "Content-type:text/html\r\n\r\n";
print '<html>';
print '<head>';
print '<title>Hello Word - First CGI Program</title>';
print '</head>';
print '<body>';
print '<h2>Hello Word! This is my first CGI program</h2>';
print '</body>';
print '</html>';

1;

Agora, se você clicar hello.cgi o link e a solicitação vai para o servidor web que procura hello.cgi no diretório / cgi-bin, executa-o e qualquer resultado gerado, o servidor web envia o resultado de volta para o navegador, que é o seguinte -

Hello Word! This is my first CGI program

Este script hello.cgi é um script Perl simples que grava sua saída no arquivo STDOUT, ou seja, na tela. Há um recurso importante e extra disponível que é a primeira linha a ser impressaContent-type:text/html\r\n\r\n. Essa linha é enviada de volta ao navegador e especifica o tipo de conteúdo a ser exibido na tela do navegador. Agora você deve ter entendido o conceito básico de CGI e pode escrever muitos programas CGI complicados usando Perl. Este script pode interagir com qualquer outro sistema externo também para trocar informações como um banco de dados, serviços da web ou qualquer outra interface complexa.

Compreendendo o cabeçalho HTTP

A primeira linha Content-type:text/html\r\n\r\né uma parte do cabeçalho HTTP, que é enviado ao navegador para que ele possa entender o conteúdo de entrada do servidor. Todo o cabeçalho HTTP estará no seguinte formato -

HTTP Field Name: Field Content

Por exemplo -

Content-type:text/html\r\n\r\n

Existem alguns outros cabeçalhos HTTP importantes, que você usará com freqüência em sua programação CGI.

Sr. Não.	Cabeçalho e Descrição
1	Content-type: String Uma string MIME que define o formato do conteúdo que está sendo retornado. O exemplo é Content-type: text / html
2	Expires: Date String A data em que as informações se tornam inválidas. Isso deve ser usado pelo navegador para decidir quando uma página precisa ser atualizada. Uma string de data válida deve estar no formato 01 de janeiro de 1998 12:00:00 GMT.
3	Location: URL String O URL que deve ser retornado em vez do URL solicitado. Você pode usar este campo para redirecionar uma solicitação para qualquer outro local.
4	Last-modified: String A data da última modificação do arquivo.
5	Content-length: String O comprimento, em bytes, dos dados que estão sendo retornados. O navegador usa esse valor para relatar o tempo estimado de download de um arquivo.
6	Set-Cookie: String Defina o cookie passado pela string

Variáveis de ambiente CGI

Todo o programa CGI terá acesso às seguintes variáveis de ambiente. Essas variáveis desempenham um papel importante ao escrever qualquer programa CGI.

Sr. Não.	Nomes e descrição das variáveis
1	CONTENT_TYPE O tipo de dados do conteúdo. Usado quando o cliente está enviando conteúdo anexado ao servidor. Por exemplo, upload de arquivo, etc.
2	CONTENT_LENGTH O comprimento das informações da consulta. Está disponível apenas para solicitações POST
3	HTTP_COOKIE Retorna os cookies definidos na forma de par chave e valor.
4	HTTP_USER_AGENT O campo de cabeçalho de solicitação do Agente do Usuário contém informações sobre o agente do usuário que originou a solicitação. É o nome do navegador da web.
5	PATH_INFO O caminho para o script CGI.
6	QUERY_STRING As informações codificadas por URL que são enviadas com a solicitação do método GET.
7	REMOTE_ADDR O endereço IP do host remoto que está fazendo a solicitação. Isso pode ser útil para registro ou autenticação.
8	REMOTE_HOST O nome totalmente qualificado do host que está fazendo a solicitação. Se esta informação não estiver disponível, REMOTE_ADDR pode ser usado para obter o endereço de IR.
9	REQUEST_METHOD O método usado para fazer a solicitação. Os métodos mais comuns são GET e POST.
10	SCRIPT_FILENAME O caminho completo para o script CGI.
11	SCRIPT_NAME O nome do script CGI.
12	SERVER_NAME O nome do host ou endereço IP do servidor.
13	SERVER_SOFTWARE O nome e a versão do software que o servidor está executando.

Aqui está um pequeno programa CGI para listar todas as variáveis CGI suportadas pelo seu servidor web. Clique neste link para ver o resultado Get Environment

#!/usr/bin/perl

print "Content-type: text/html\n\n";
print "<font size=+1>Environment</font>\n";
foreach (sort keys %ENV) {
   print "<b>$_</b>: $ENV{$_}<br>\n";
}

1;

Abrir uma caixa de diálogo "Download de arquivo"?

Às vezes, é desejável que você dê a opção de o usuário clicar em um link e abrir uma caixa de diálogo "Download de arquivo" para o usuário, em vez de exibir o conteúdo real. Isso é muito fácil e será obtido através do cabeçalho HTTP.

Este cabeçalho HTTP será diferente do cabeçalho mencionado na seção anterior. Por exemplo, se você quiser fazer umFileName arquivo para download de um determinado link, sua sintaxe será a seguinte -

#!/usr/bin/perl

# HTTP Header
print "Content-Type:application/octet-stream; name = \"FileName\"\r\n";
print "Content-Disposition: attachment; filename = \"FileName\"\r\n\n";

# Actual File Content will go hear.
open( FILE, "<FileName" );
while(read(FILE, $buffer, 100) ) { print("$buffer");
}

Métodos GET e POST

Você deve ter se deparado com muitas situações em que precisa passar algumas informações de seu navegador para o servidor da web e, finalmente, para seu Programa CGI que trata de suas solicitações. Na maioria das vezes, o navegador usa dois métodos para passar essas informações ao servidor da web. Esses métodos sãoGET Método e POSTMétodo. Vamos verificá-los um por um.

Passando informações usando o método GET

O método GET envia as informações codificadas do usuário anexadas ao próprio URL da página. A página e as informações codificadas são separadas por? personagem da seguinte forma -

http://www.test.com/cgi-bin/hello.cgi?key1=value1&key2=value2

O método GET é o método padrão para passar informações de um navegador para o servidor da web e produz uma longa string que aparece na caixa Location: do seu navegador. Você nunca deve usar o método GET se tiver uma senha ou outras informações confidenciais para passar para o servidor. O método GET tem limitação de tamanho: apenas 1024 caracteres podem ser passados em uma string de solicitação.

Esta informação é passada usando QUERY_STRING cabeçalho e estará acessível em seu programa CGI através da variável de ambiente QUERY_STRING que você pode analisar e usar em seu programa CGI.

Você pode passar informações simplesmente concatenando pares de chave e valor junto com qualquer URL ou pode usar tags HTML <FORM> para passar informações usando o método GET.

Exemplo de URL simples: Método Get

Aqui está uma URL simples que passará dois valores para o programa hello_get.cgi usando o método GET.

http://www.tutorialspoint.com/cgi-bin/hello_get.cgi?first_name=ZARA&last_name=ALI

Abaixo está hello_get.cgi script para lidar com a entrada fornecida pelo navegador da web.

#!/usr/bin/perl

local ($buffer, @pairs, $pair, $name, $value, %FORM);
# Read in text
$ENV{'REQUEST_METHOD'} =~ tr/a-z/A-Z/; if ($ENV{'REQUEST_METHOD'} eq "GET") {
   $buffer = $ENV{'QUERY_STRING'};
}
# Split information into name/value pairs
@pairs = split(/&/, $buffer); foreach $pair (@pairs) {
   ($name, $value) = split(/=/, $pair); $value =~ tr/+/ /;
   $value =~ s/%(..)/pack("C", hex($1))/eg;
   $FORM{$name} = $value; } $first_name = $FORM{first_name}; $last_name  = $FORM{last_name}; print "Content-type:text/html\r\n\r\n"; print "<html>"; print "<head>"; print "<title>Hello - Second CGI Program</title>"; print "</head>"; print "<body>"; print "<h2>Hello $first_name $last_name - Second CGI Program</h2>";
print "</body>";
print "</html>";

1;

Exemplo de FORM Simples: Método GET

Aqui está um exemplo simples, que passa dois valores usando HTML FORM e botão de envio. Vamos usar o mesmo script CGI hello_get.cgi para lidar com essa entrada.

<FORM action = "/cgi-bin/hello_get.cgi" method = "GET">
First Name: <input type = "text" name = "first_name">  <br>

Last Name: <input type = "text" name = "last_name">
<input type = "submit" value = "Submit">
</FORM>

Aqui está a saída real da codificação de formulário acima. Agora você pode inserir o nome e o sobrenome e clicar no botão enviar para ver o resultado.

Passando informações usando o método POST

Um método mais confiável de passar informações para um programa CGI é o POSTmétodo. Isso empacota as informações exatamente da mesma maneira que os métodos GET, mas em vez de enviá-las como uma string de texto após um?no URL, ele a envia como uma mensagem separada como parte do cabeçalho HTTP. O servidor da Web fornece essa mensagem ao script CGI na forma de entrada padrão.

Abaixo está o modificado hello_post.cgiscript para lidar com a entrada fornecida pelo navegador da web. Este script irá lidar com o método GET e também com o método POST.

#!/usr/bin/perl

local ($buffer, @pairs, $pair, $name, $value, %FORM); # Read in text $ENV{'REQUEST_METHOD'} =~ tr/a-z/A-Z/;
if ($ENV{'REQUEST_METHOD'} eq "POST") { read(STDIN, $buffer, $ENV{'CONTENT_LENGTH'}); } else { $buffer = $ENV{'QUERY_STRING'}; } # Split information into name/value pairs @pairs = split(/&/, $buffer);
foreach $pair (@pairs) { ($name, $value) = split(/=/, $pair);
   $value =~ tr/+/ /; $value =~ s/%(..)/pack("C", hex($1))/eg; $FORM{$name} = $value;
}
$first_name = $FORM{first_name};
$last_name = $FORM{last_name};

print "Content-type:text/html\r\n\r\n";
print "<html>";
print "<head>";
print "<title>Hello - Second CGI Program</title>";
print "</head>";
print "<body>";
print "<h2>Hello $first_name $last_name - Second CGI Program</h2>";
print "</body>";
print "</html>";

1;

Tomemos novamente o mesmo exemplo acima, que passa dois valores usando HTML FORM e o botão submit. Vamos usar o script CGI hello_post.cgi para lidar com essa entrada.

<FORM action = "/cgi-bin/hello_post.cgi" method = "POST">
First Name: <input type = "text" name = "first_name">  <br>

Last Name: <input type = "text" name = "last_name">

<input type = "submit" value = "Submit">
</FORM>

Aqui está o resultado real da codificação do formulário acima. Você insere o nome e o sobrenome e, a seguir, clica no botão enviar para ver o resultado.

Passando os dados da caixa de seleção para o programa CGI

As caixas de seleção são usadas quando mais de uma opção deve ser selecionada. Aqui está um exemplo de código HTML para um formulário com duas caixas de seleção.

<form action = "/cgi-bin/checkbox.cgi" method = "POST" target = "_blank">
<input type = "checkbox" name = "maths" value = "on"> Maths
<input type = "checkbox" name = "physics" value = "on"> Physics
<input type = "submit" value = "Select Subject">
</form>

O resultado deste código é o seguinte formato -

Abaixo está checkbox.cgi script para lidar com a entrada fornecida pelo navegador da web para o botão de rádio.

#!/usr/bin/perl

local ($buffer, @pairs, $pair, $name, $value, %FORM);
# Read in text
$ENV{'REQUEST_METHOD'} =~ tr/a-z/A-Z/; if ($ENV{'REQUEST_METHOD'} eq "POST") {
   read(STDIN, $buffer, $ENV{'CONTENT_LENGTH'});
} else {
   $buffer = $ENV{'QUERY_STRING'};
}
# Split information into name/value pairs
@pairs = split(/&/, $buffer); foreach $pair (@pairs) {
   ($name, $value) = split(/=/, $pair); $value =~ tr/+/ /;
   $value =~ s/%(..)/pack("C", hex($1))/eg;
   $FORM{$name} = $value; } if( $FORM{maths} ) {
   $maths_flag ="ON"; } else { $maths_flag ="OFF";
}
if( $FORM{physics} ) { $physics_flag ="ON";
} else {
   $physics_flag ="OFF"; } print "Content-type:text/html\r\n\r\n"; print "<html>"; print "<head>"; print "<title>Checkbox - Third CGI Program</title>"; print "</head>"; print "<body>"; print "<h2> CheckBox Maths is : $maths_flag</h2>";
print "<h2> CheckBox Physics is : $physics_flag</h2>";
print "</body>";
print "</html>";

1;

Passando Dados do Botão de Rádio para o Programa CGI

Os botões de rádio são usados quando apenas uma opção deve ser selecionada. Aqui está um exemplo de código HTML para um formulário com dois botões de opção -

<form action = "/cgi-bin/radiobutton.cgi" method = "POST" target = "_blank">
<input type = "radio" name = "subject" value = "maths"> Maths
<input type = "radio" name = "subject" value = "physics"> Physics
<input type = "submit" value = "Select Subject">
</form>

O resultado deste código é o seguinte formato -

Abaixo está radiobutton.cgi script para lidar com a entrada fornecida pelo navegador da web para o botão de rádio.

#!/usr/bin/perl

local ($buffer, @pairs, $pair, $name, $value, %FORM); # Read in text $ENV{'REQUEST_METHOD'} =~ tr/a-z/A-Z/;
if ($ENV{'REQUEST_METHOD'} eq "POST") { read(STDIN, $buffer, $ENV{'CONTENT_LENGTH'}); } else { $buffer = $ENV{'QUERY_STRING'}; } # Split information into name/value pairs @pairs = split(/&/, $buffer);
foreach $pair (@pairs) { ($name, $value) = split(/=/, $pair);
   $value =~ tr/+/ /; $value =~ s/%(..)/pack("C", hex($1))/eg; $FORM{$name} = $value;
}
$subject = $FORM{subject};

print "Content-type:text/html\r\n\r\n";
print "<html>";
print "<head>";
print "<title>Radio - Fourth CGI Program</title>";
print "</head>";
print "<body>";
print "<h2> Selected Subject is $subject</h2>";
print "</body>";
print "</html>";

1;

Passando dados da área de texto para o programa CGI

Um elemento textarea é usado quando o texto de várias linhas deve ser passado para o programa CGI. Aqui está um exemplo de código HTML para um formulário com uma caixa TEXTAREA -

<form action = "/cgi-bin/textarea.cgi" method = "POST" target = "_blank">
<textarea name = "textcontent" cols = 40 rows = 4>
Type your text here...
</textarea>
<input type = "submit" value = "Submit">
</form>

O resultado deste código é o seguinte formato -

Abaixo está o textarea.cgi script para lidar com a entrada fornecida pelo navegador da web.

#!/usr/bin/perl

local ($buffer, @pairs, $pair, $name, $value, %FORM); # Read in text $ENV{'REQUEST_METHOD'} =~ tr/a-z/A-Z/;
if ($ENV{'REQUEST_METHOD'} eq "POST") { read(STDIN, $buffer, $ENV{'CONTENT_LENGTH'}); } else { $buffer = $ENV{'QUERY_STRING'}; } # Split information into name/value pairs @pairs = split(/&/, $buffer);
foreach $pair (@pairs) { ($name, $value) = split(/=/, $pair);
   $value =~ tr/+/ /; $value =~ s/%(..)/pack("C", hex($1))/eg; $FORM{$name} = $value;
}
$text_content = $FORM{textcontent};

print "Content-type:text/html\r\n\r\n";
print "<html>";
print "<head>";
print "<title>Text Area - Fifth CGI Program</title>";
print "</head>";
print "<body>";
print "<h2> Entered Text Content is $text_content</h2>";
print "</body>";
print "</html>";

1;

Passando os dados da caixa suspensa para o programa CGI

Uma caixa suspensa é usada quando temos muitas opções disponíveis, mas apenas uma ou duas serão selecionadas. Aqui está um exemplo de código HTML para um formulário com uma caixa suspensa

<form action = "/cgi-bin/dropdown.cgi" method = "POST" target = "_blank">
<select name = "dropdown">
<option value = "Maths" selected>Maths</option>
<option value = "Physics">Physics</option>
</select>
<input type = "submit" value = "Submit">
</form>

O resultado deste código é o seguinte formato -

Abaixo está o dropdown.cgi script para lidar com a entrada fornecida pelo navegador da web.

#!/usr/bin/perl

local ($buffer, @pairs, $pair, $name, $value, %FORM); # Read in text $ENV{'REQUEST_METHOD'} =~ tr/a-z/A-Z/;
if ($ENV{'REQUEST_METHOD'} eq "POST") { read(STDIN, $buffer, $ENV{'CONTENT_LENGTH'}); } else { $buffer = $ENV{'QUERY_STRING'}; } # Split information into name/value pairs @pairs = split(/&/, $buffer);
foreach $pair (@pairs) { ($name, $value) = split(/=/, $pair);
   $value =~ tr/+/ /; $value =~ s/%(..)/pack("C", hex($1))/eg; $FORM{$name} = $value;
}
$subject = $FORM{dropdown};

print "Content-type:text/html\r\n\r\n";
print "<html>";
print "<head>";
print "<title>Dropdown Box - Sixth CGI Program</title>";
print "</head>";
print "<body>";
print "<h2> Selected Subject is $subject</h2>";
print "</body>";
print "</html>";

1;

Usando Cookies em CGI

O protocolo HTTP é um protocolo sem estado. Mas, para um site comercial, é necessário manter as informações da sessão entre as diferentes páginas. Por exemplo, o registro de um usuário termina após transações que se estendem por muitas páginas. Mas como manter as informações da sessão do usuário em todas as páginas da web?

Em muitas situações, o uso de cookies é o método mais eficiente de lembrar e rastrear preferências, compras, comissões e outras informações necessárias para uma melhor experiência do visitante ou estatísticas do site.

Como funciona

Seu servidor envia alguns dados para o navegador do visitante na forma de um cookie. O navegador pode aceitar o cookie. Em caso afirmativo, ele é armazenado como um registro de texto simples no disco rígido do visitante. Agora, quando o visitante chega a outra página do seu site, o cookie fica disponível para recuperação. Uma vez recuperado, seu servidor sabe / lembra o que foi armazenado.

Cookies são um registro de dados de texto simples de 5 campos de comprimento variável -

Expires- A data em que o cookie irá expirar. Se estiver em branco, o cookie irá expirar quando o visitante sair do navegador.
Domain - O nome de domínio do seu site.
Path- O caminho para o diretório ou página da web que definiu o cookie. Isso pode ficar em branco se você quiser recuperar o cookie de qualquer diretório ou página.
Secure- Se este campo contiver a palavra "seguro", o cookie só poderá ser recuperado com um servidor seguro. Se este campo estiver em branco, não existe tal restrição.
Name = Value - Os cookies são definidos e visualizados novamente na forma de pares de chave e valor.

Configurando Cookies

É muito fácil enviar cookies para o navegador. Esses cookies serão enviados junto com o cabeçalho HTTP. Presumindo que você deseja definir a ID do usuário e a senha como cookies. Então, será feito da seguinte maneira -

#!/usr/bin/perl

print "Set-Cookie:UserID = XYZ;\n";
print "Set-Cookie:Password = XYZ123;\n";
print "Set-Cookie:Expires = Tuesday, 31-Dec-2007 23:12:40 GMT";\n";
print "Set-Cookie:Domain = www.tutorialspoint.com;\n";
print "Set-Cookie:Path = /perl;\n";
print "Content-type:text/html\r\n\r\n";
...........Rest of the HTML Content goes here....

Aqui usamos Set-CookieCabeçalho HTTP para definir cookies. É opcional definir atributos de cookies como Expires, Domain e Path. É importante notar que os cookies são definidos antes de enviar a linha mágica"Content-type:text/html\r\n\r\n.

Recuperando Cookies

É muito fácil recuperar todos os cookies configurados. Os cookies são armazenados na variável de ambiente CGI HTTP_COOKIE e terão a seguinte forma.

key1 = value1;key2 = value2;key3 = value3....

Aqui está um exemplo de como recuperar cookies.

#!/usr/bin/perl
$rcvd_cookies = $ENV{'HTTP_COOKIE'}; @cookies = split /;/, $rcvd_cookies;
foreach $cookie ( @cookies ) { ($key, $val) = split(/=/, $cookie); # splits on the first =.
   $key =~ s/^\s+//; $val =~ s/^\s+//;
   $key =~ s/\s+$//;
   $val =~ s/\s+$//;
   if( $key eq "UserID" ) { $user_id = $val; } elsif($key eq "Password") {
      $password = $val;
   }
}
print "User ID  = $user_id\n"; print "Password = $password\n";

Isso produzirá o seguinte resultado, desde que os cookies acima tenham sido configurados antes de chamar o script de cookies de recuperação.

User ID = XYZ
Password = XYZ123

Módulos e bibliotecas CGI

Você encontrará muitos módulos integrados na Internet que fornecem funções diretas para usar em seu programa CGI. A seguir estão os importantes uma vez.

Módulo CGI
Berkeley cgi-lib.pl

O que são pacotes?

o packageinstrução muda o contexto de nomenclatura atual para um namespace especificado (tabela de símbolos). Assim -

Um pacote é uma coleção de código que reside em seu próprio namespace.
Um namespace é uma coleção nomeada de nomes de variáveis exclusivos (também chamada de tabela de símbolos).
Os namespaces evitam colisões de nomes de variáveis entre pacotes.
Os pacotes permitem a construção de módulos que, quando usados, não afetarão variáveis e funções fora do próprio namespace dos módulos.
O pacote permanece em vigor até que outra instrução de pacote seja chamada ou até o final do bloco ou arquivo atual.
Você pode referir-se explicitamente a variáveis dentro de um pacote usando o :: qualificador de pacote.

A seguir está um exemplo com os pacotes principal e Foo em um arquivo. Aqui, a variável especial __PACKAGE__ foi usada para imprimir o nome do pacote.

#!/usr/bin/perl

# This is main package
$i = 1; print "Package name : " , __PACKAGE__ , " $i\n"; 

package Foo;
# This is Foo package
$i = 10; print "Package name : " , __PACKAGE__ , " $i\n"; 

package main;
# This is again main package
$i = 100; print "Package name : " , __PACKAGE__ , " $i\n"; 
print "Package name : " , __PACKAGE__ ,  " $Foo::i\n"; 

1;

Quando o código acima é executado, ele produz o seguinte resultado -

Package name : main 1
Package name : Foo 10
Package name : main 100
Package name : main 10

Blocos BEGIN e END

Você pode definir qualquer número de blocos de código chamados BEGIN e END, que atuam como construtores e destruidores, respectivamente.

BEGIN { ... }
END { ... }
BEGIN { ... }
END { ... }

Cada BEGIN bloco é executado depois que o script perl é carregado e compilado, mas antes que qualquer outra instrução seja executada.
Cada bloco END é executado logo antes da saída do interpretador perl.
Os blocos BEGIN e END são particularmente úteis ao criar módulos Perl.

O exemplo a seguir mostra seu uso -

#!/usr/bin/perl

package Foo;
print "Begin and Block Demo\n";

BEGIN { 
   print "This is BEGIN Block\n" 
}

END { 
   print "This is END Block\n" 
}

1;

Quando o código acima é executado, ele produz o seguinte resultado -

This is BEGIN Block
Begin and Block Demo
This is END Block

O que são módulos Perl?

Um módulo Perl é um pacote reutilizável definido em um arquivo de biblioteca cujo nome é igual ao nome do pacote com uma extensão .pm.

Um arquivo de módulo Perl chamado Foo.pm pode conter declarações como esta.

#!/usr/bin/perl

package Foo;
sub bar { 
   print "Hello $_[0]\n" 
}

sub blat { 
   print "World $_[0]\n" 
}
1;

Alguns pontos importantes sobre os módulos Perl

As funções require e use irá carregar um módulo.
Ambos usam a lista de caminhos de pesquisa em @INC para encontrar o módulo.
Ambas as funções require e use Ligar para eval função para processar o código.
o 1; na parte inferior faz com que eval seja avaliado como TRUE (e, portanto, não falhe).

A Função Requerer

Um módulo pode ser carregado chamando o require funcionar da seguinte forma -

#!/usr/bin/perl

require Foo;

Foo::bar( "a" );
Foo::blat( "b" );

Você deve ter notado que os nomes das sub-rotinas devem ser totalmente qualificados para chamá-los. Seria bom habilitar a sub-rotinabar e blat para ser importado em nosso próprio namespace, para que não tenhamos que usar o qualificador Foo ::.

A Função de Uso

Um módulo pode ser carregado chamando o use função.

#!/usr/bin/perl

use Foo;

bar( "a" );
blat( "b" );

Observe que não precisamos qualificar totalmente os nomes das funções do pacote. ouse A função exportará uma lista de símbolos de um módulo, dadas algumas instruções adicionadas dentro de um módulo.

require Exporter;
@ISA = qw(Exporter);

Em seguida, forneça uma lista de símbolos (escalares, listas, hashes, sub-rotinas, etc) preenchendo a variável de lista chamada @EXPORT: Por exemplo -

package Module;

require Exporter;
@ISA = qw(Exporter);
@EXPORT = qw(bar blat);

sub bar { print "Hello $_[0]\n" }
sub blat { print "World $_[0]\n" } sub splat { print "Not $_[0]\n" }  # Not exported!

1;

Crie a árvore de módulos Perl

Quando você estiver pronto para enviar seu módulo Perl, existe uma maneira padrão de criar uma Árvore de Módulos Perl. Isso é feito usandoh2xsUtilitário. Este utilitário vem junto com o Perl. Aqui está a sintaxe para usar h2xs -

$h2xs -AX -n  ModuleName

Por exemplo, se o seu módulo está disponível em Person.pm arquivo, então simplesmente emita o seguinte comando -

$h2xs -AX -n Person

Isso produzirá o seguinte resultado -

Writing Person/lib/Person.pm
Writing Person/Makefile.PL
Writing Person/README
Writing Person/t/Person.t
Writing Person/Changes
Writing Person/MANIFEST

Aqui está a descrição dessas opções -

-A omite o código do Autoloader (melhor usado por módulos que definem um grande número de sub-rotinas usadas com pouca frequência).
-X omite elementos XS (sub-rotina eXternal, onde eXternal significa externo ao Perl, ou seja, C).
-n especifica o nome do módulo.

Portanto, o comando acima cria a seguinte estrutura dentro do diretório Person. O resultado real é mostrado acima.

Changes
Makefile.PL
MANIFEST (contém a lista de todos os arquivos do pacote)
README
t / (arquivos de teste)
lib / (o código-fonte real vai aqui

Então finalmente, você taresta estrutura de diretório em um arquivo Person.tar.gz e você pode enviá-lo. Você terá que atualizar o arquivo README com as instruções adequadas. Você também pode fornecer alguns arquivos de exemplos de teste no diretório t.

Instalando Módulo Perl

Baixe um módulo Perl no arquivo tar.gz do formato. Use a seguinte sequência para instalar qualquer Módulo PerlPerson.pm que foi baixado como Person.tar.gz Arquivo.

tar xvfz Person.tar.gz
cd Person
perl Makefile.PL
make
make install

O interpretador Perl tem uma lista de diretórios em que procura por módulos (array global @INC).

Você pode usar Perl de várias maneiras para criar novos processos de acordo com seus requisitos. Este tutorial listará alguns métodos importantes e usados com mais frequência para criar e gerenciar processos Perl.

Você pode usar variáveis especiais $$ ou $PROCESS_ID para obter o ID do processo atual.
Cada processo criado usando qualquer um dos métodos mencionados, mantém seu próprio ambiente virtual dentro %ENV variável.
o exit() A função sempre sai apenas do processo filho que executa esta função e o processo principal como um todo não sairá a menos que todos os processos filho em execução tenham saído.
Todos os identificadores abertos são dup () - ed em processos filho, de forma que o fechamento de qualquer identificador em um processo não afeta os outros.

Operador Backstick

A maneira mais simples de executar qualquer comando Unix é usando o operador backstick. Você simplesmente coloca seu comando dentro do operador backstick, o que resultará na execução do comando e retorna seu resultado, que pode ser armazenado da seguinte maneira -

#!/usr/bin/perl

@files = `ls -l`;

foreach $file (@files) { print $file;
}

1;

Quando o código acima é executado, ele lista todos os arquivos e diretórios disponíveis no diretório atual -

drwxr-xr-x 3 root root 4096 Sep 14 06:46 9-14
drwxr-xr-x 4 root root 4096 Sep 13 07:54 android
-rw-r--r-- 1 root root  574 Sep 17 15:16 index.htm
drwxr-xr-x 3  544  401 4096 Jul  6 16:49 MIME-Lite-3.01
-rw-r--r-- 1 root root   71 Sep 17 15:16 test.pl
drwx------ 2 root root 4096 Sep 17 15:11 vAtrJdy

O sistema () Função

Você também pode usar system()função para executar qualquer comando Unix, cuja saída irá para a saída do script perl. Por padrão, é a tela, ou seja, STDOUT, mas você pode redirecioná-lo para qualquer arquivo usando o operador de redirecionamento> -

#!/usr/bin/perl

system( "ls -l")

1;

Quando o código acima é executado, ele lista todos os arquivos e diretórios disponíveis no diretório atual -

drwxr-xr-x 3 root root 4096 Sep 14 06:46 9-14
drwxr-xr-x 4 root root 4096 Sep 13 07:54 android
-rw-r--r-- 1 root root  574 Sep 17 15:16 index.htm
drwxr-xr-x 3  544  401 4096 Jul  6 16:49 MIME-Lite-3.01
-rw-r--r-- 1 root root   71 Sep 17 15:16 test.pl
drwx------ 2 root root 4096 Sep 17 15:11 vAtrJdy

Tenha cuidado quando o seu comando contém variáveis de ambiente de shell como $PATH or $CASA. Tente seguir três cenários -

#!/usr/bin/perl

$PATH = "I am Perl Variable"; system('echo $PATH');  # Treats $PATH as shell variable system("echo $PATH");  # Treats $PATH as Perl variable system("echo \$PATH"); # Escaping $ works.

1;

Quando o código acima é executado, ele produz o seguinte resultado dependendo do que está definido na variável de shell $ PATH.

/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/sbin
I am Perl Variable
/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/sbin

A função fork ()

Perl fornece um fork()função que corresponde à chamada de sistema Unix de mesmo nome. Na maioria das plataformas do tipo Unix onde a chamada de sistema fork () está disponível, o fork () do Perl simplesmente a chama. Em algumas plataformas, como Windows, onde a chamada de sistema fork () não está disponível, o Perl pode ser construído para emular fork () no nível do interpretador.

A função fork () é usada para clonar um processo atual. Essa chamada cria um novo processo executando o mesmo programa no mesmo ponto. Ele retorna o pid filho para o processo pai, 0 para o processo filho ou undef se a bifurcação não for bem-sucedida.

Você pode usar exec() dentro de um processo para lançar o executável solicitado, que será executado em uma área de processo separada e exec () esperará que ele seja concluído antes de sair com o mesmo status de saída desse processo.

#!/usr/bin/perl

if(!defined($pid = fork())) { # fork returned undef, so unsuccessful die "Cannot fork a child: $!";
} elsif ($pid == 0) { print "Printed by child process\n"; exec("date") || die "can't exec date: $!";
  
} else {
   # fork returned 0 nor undef
   # so this branch is parent
   print "Printed by parent process\n";
   $ret = waitpid($pid, 0);
   print "Completed process id: $ret\n";

}

1;

Quando o código acima é executado, ele produz o seguinte resultado -

Printed by parent process
Printed by child process
Tue Sep 17 15:41:08 CDT 2013
Completed process id: 17777

o wait() e waitpid()pode ser passado como um ID de pseudo-processo retornado por fork (). Essas chamadas aguardarão corretamente o término do pseudo-processo e retornarão seu status. Se você bifurca sem nunca esperar por seus filhos usandowaitpid()função, você acumulará zumbis. Em sistemas Unix, você pode evitar isso definindo $ SIG {CHLD} como "IGNORE" da seguinte maneira -

#!/usr/bin/perl

local $SIG{CHLD} = "IGNORE"; if(!defined($pid = fork())) {
   # fork returned undef, so unsuccessful
   die "Cannot fork a child: $!"; } elsif ($pid == 0) {
   print "Printed by child process\n";
   exec("date") || die "can't exec date: $!"; } else { # fork returned 0 nor undef # so this branch is parent print "Printed by parent process\n"; $ret = waitpid($pid, 0); print "Completed process id: $ret\n";

}

1;

Quando o código acima é executado, ele produz o seguinte resultado -

Printed by parent process
Printed by child process
Tue Sep 17 15:44:07 CDT 2013
Completed process id: -1

A função kill ()

Perl kill('KILL', (Process List)) pode ser usada para encerrar um pseudo-processo passando-lhe o ID retornado por fork ().

Observe que o uso de kill ('KILL', (Lista de Processos)) em um pseudo-processo () pode normalmente causar vazamentos de memória, porque a thread que implementa o pseudo-processo não tem a chance de limpar seus recursos.

Você pode usar kill() função para enviar qualquer outro sinal para processos alvo, por exemplo, a seguir irá enviar SIGINT para um processo IDs 104 e 102 -

#!/usr/bin/perl

kill('INT', 104, 102);
 
1;

Você pode incorporar a documentação do Pod (Texto Antigo Simples) em seus módulos e scripts Perl. A seguir está a regra para usar a documentação embutida em seu código Perl -

Comece sua documentação com uma linha vazia, a =head1 comando no início e termine-o com a =cut

O Perl irá ignorar o texto do Pod que você inseriu no código. A seguir está um exemplo simples de uso de documentação incorporada dentro de seu código Perl -

#!/usr/bin/perl

print "Hello, World\n";

=head1 Hello, World Example
This example demonstrate very basic syntax of Perl.
=cut

print "Hello, Universe\n";

Quando o código acima é executado, ele produz o seguinte resultado -

Hello, World
Hello, Universe

Se você vai colocar seu pod no final do arquivo e está usando uma marca de corte __END__ ou __DATA__, certifique-se de colocar uma linha vazia antes do primeiro comando do pod como segue, caso contrário, sem uma linha vazia antes o =head1, muitos tradutores não teriam reconhecido o =head1 como iniciar um bloco de pod.

#!/usr/bin/perl

print "Hello, World\n";

while(<DATA>) {
  print $_;
}

__END__

=head1 Hello, World Example
This example demonstrate very basic syntax of Perl.
print "Hello, Universe\n";

Quando o código acima é executado, ele produz o seguinte resultado -

Hello, World

=head1 Hello, World Example
This example demonstrate very basic syntax of Perl.
print "Hello, Universe\n";

Vamos dar mais um exemplo para o mesmo código sem ler a parte DATA -

#!/usr/bin/perl

print "Hello, World\n";

__END__

=head1 Hello, World Example
This example demonstrate very basic syntax of Perl.
print "Hello, Universe\n";

Quando o código acima é executado, ele produz o seguinte resultado -

Hello, World

O que é POD?

Pod é uma linguagem de marcação simples de usar usada para escrever documentação para Perl, programas Perl e módulos Perl. Existem vários tradutores disponíveis para converter o Pod em vários formatos, como texto simples, HTML, páginas de manual e muito mais. A marcação de pod consiste em três tipos básicos de parágrafos -

Ordinary Paragraph - Você pode usar códigos de formatação em parágrafos comuns, para negrito, itálico, estilo de código, hiperlinks e muito mais.
Verbatim Paragraph - Parágrafos literais são geralmente usados para apresentar um bloco de código ou outro texto que não requer nenhuma análise ou formatação especial e que não deve ser quebrado.
Command Paragraph- Um parágrafo de comando é usado para tratamento especial de pedaços inteiros de texto, geralmente como títulos ou partes de listas. Todos os parágrafos de comando começam com =, seguido por um identificador, seguido por um texto arbitrário que o comando pode usar como quiser. Os comandos atualmente reconhecidos são -

=pod
=head1 Heading Text
=head2 Heading Text
=head3 Heading Text
=head4 Heading Text
=over indentlevel
=item stuff
=back
=begin format
=end format
=for format text...
=encoding type
=cut

Exemplos POD

Considere o seguinte POD -

=head1 SYNOPSIS
Copyright 2005 [TUTORIALSOPOINT].
=cut

Você pode usar pod2html utilitário disponível no Linux para converter POD acima em HTML, portanto, produzirá o seguinte resultado -

Em seguida, considere o seguinte exemplo -

=head2 An Example List

=over 4
=item * This is a bulleted list.
=item * Here's another item.
=back
=begin html
<p>
Here's some embedded HTML.  In this block I can
include images, apply <span style="color: green">
styles</span>, or do anything else I can do with
HTML.  pod parsers that aren't outputting HTML will
completely ignore it.
</p>

=end html

Quando você converte o POD acima em HTML usando pod2html, ele produzirá o seguinte resultado -

An Example List
   This is a bulleted list.
   Here's another item.
Here's some embedded HTML. In this block I can include images, apply 
styles, or do anything else I can do with HTML. pod parsers that aren't 
outputting HTML will completely ignore it.

Aqui está a lista de todas as funções importantes suportadas pelo Perl padrão.

abs - função de valor absoluto
aceitar - aceitar uma conexão de soquete de entrada
alarme - agende um SIGALRM
atan2 - arco tangente de Y / X no intervalo -PI a PI
bind - liga um endereço a um soquete
binmode - prepara arquivos binários para I / O
abençoe - crie um objeto
chamador - obtém o contexto da chamada de sub-rotina atual
chdir - muda seu diretório de trabalho atual
chmod - altera as permissões em uma lista de arquivos
chomp - remove um separador de registro final de uma string
chop - remove o último caractere de uma string
chown - altera o poder em uma lista de arquivos
chr - obtém o caractere que este número representa
chroot - torna o diretório uma nova raiz para pesquisas de caminho
close - fechar arquivo (ou tubo ou soquete) identificador
closedir - identificador de diretório fechado
conectar - conectar a uma tomada remota
continue - bloco à direita opcional daqui a pouco ou foreach
cos - função cosseno
crypt - criptografia de estilo passwd unilateral
dbmclose - quebra a ligação em um arquivo dbm vinculado
dbmopen - cria ligação em um arquivo dbm vinculado
definido - teste se um valor, variável ou função está definido ou não
delete - exclui um valor de um hash
morrer - levantar uma exceção ou resgatar
fazer - transforme um BLOCO em um TERM
dump - cria um dump de núcleo imediato
each - recupera o próximo par chave / valor de um hash
endgrent - ser feito usando o arquivo de grupo
endhostent - ser feito usando o arquivo hosts
endnetent - ser feito usando o arquivo de redes
endprotoent - ser feito usando o arquivo de protocolos
endpwent - ser feito usando o arquivo passwd
endservent - ser feito usando o arquivo de serviços
eof - testar um filehandle para o seu fim
eval - captura exceções ou compila e executa o código
exec - abandone este programa para executar outro
existe - testa se uma chave hash está presente
sair - termina este programa
exp - aumento I para um poder
fcntl - chamada do sistema de controle de arquivos
fileno - retorna descritor de arquivo de filehandle
flock - bloqueia um arquivo inteiro com um bloqueio consultivo
fork - cria um novo processo como este
format - declara um formato de imagem com uso pela função write ()
formline - função interna usada para formatos
getc - obtém o próximo caractere do filehandle
getgrent - obter o próximo registro do grupo
getgrgid - obtém o registro do grupo dado o ID do usuário do grupo
getgrnam - obter registro de grupo dado o nome do grupo
gethostbyaddr - obtém o registro do host dado seu endereço
gethostbyname - obtém o registro do host com o nome dado
gethostent - obter o próximo registro de hosts
getlogin - retorna quem logou neste tty
getnetbyaddr - obter registro de rede dado seu endereço
getnetbyname - obtém o registro de redes dado o nome
getnetent - obter o próximo registro de rede
getpeername - encontre a outra extremidade de uma conexão de soquete
getpgrp - obter grupo de processos
getppid - obter ID do processo pai
getpriority - obtém o valor atual agradável
getprotobyname - obter registro de protocolo com nome dado
getprotobynumber - obter protocolo numérico de registro de protocolo
getprotoent - obter o próximo registro de protocolos
getpwent - obter o próximo registro passwd
getpwnam - obtém o registro passwd dado o nome de login do usuário
getpwuid - obtém o registro passwd dado o ID do usuário
getervbyname - obtém registro de serviços dado seu nome
getservbyport - obtém o registro dos serviços dada a porta numérica
getervent - obter o próximo registro de serviços
getockname - recupera o sockaddr para um determinado soquete
getockopt - obtém opções de soquete em um determinado soquete
glob - expande os nomes dos arquivos usando curingas
gmtime - converte a hora UNIX em registro ou string usando o formato de hora de Greenwich.
goto - criar código espaguete
grep - localizar elementos em um teste de lista verdadeiro em relação a um determinado critério
hex - converte uma string em um número hexadecimal
import - corrige o namespace de um módulo em seu próprio
index - encontre uma substring dentro de uma string
int - obtém a parte inteira de um número
ioctl - chamada de sistema de controle de dispositivo dependente do sistema
join - junta uma lista em uma string usando um separador
keys - recupera a lista de índices de um hash
kill - envia um sinal para um processo ou grupo de processos
último - sai de um bloco prematuramente
lc - retorna a versão em minúsculas de uma string
lcfirst - retorna uma string com apenas a próxima letra em minúsculas
comprimento - retorna o número de bytes em uma string
link - cria um link físico no sistema de arquivos
escute - registre seu soquete como um servidor
local - cria um valor temporário para uma variável global (escopo dinâmico)
localtime - converte a hora UNIX em registro ou string usando a hora local
lock - obtém um bloqueio de thread em uma variável, sub-rotina ou método
log - recupera o logaritmo natural de um número
lstat - um link simbólico estatístico
m - corresponde a uma string com um padrão de expressão regular
mapa - aplique uma alteração a uma lista para obter uma nova lista com as alterações
mkdir - cria um diretório
msgctl - operações de controle de mensagens SysV IPC
msgget - obter fila de mensagens SysV IPC
msgrcv - recebe uma mensagem SysV IPC de uma fila de mensagens
msgsnd - envia uma mensagem SysV IPC para uma fila de mensagens
my - declara e atribui uma variável local (escopo léxico)
próximo - itera um bloco prematuramente
não - desimportar alguns símbolos de módulo ou semântica em tempo de compilação
oct - converte uma string em um número octal
abrir - abre um arquivo, canal ou descritor
opendir - abre um diretório
ord - encontre a representação numérica de um caractere
nosso - declara e atribui uma variável de pacote (escopo léxico)
pack - converte uma lista em uma representação binária
pacote - declara um namespace global separado
pipe - abre um par de manipuladores de arquivos conectados
pop - remove o último elemento de uma matriz e o retorna
pos - encontrar ou definir o deslocamento para a última / próxima pesquisa m // g
print - envia uma lista para um filehandle
printf - envia uma lista formatada para um filehandle
protótipo - obtenha o protótipo (se houver) de uma sub-rotina
push - anexa um ou mais elementos a uma matriz
q - citar isoladamente uma string
qq - citar duplamente uma string
qr - padrão de compilação
quotemeta - cita caracteres mágicos de expressão regular
qw - citar uma lista de palavras
qx - backquote cita uma string
rand - recupera o próximo número pseudo-aleatório
read - entrada em buffer de comprimento fixo de um filehandle
readdir - obtém um diretório de um identificador de diretório
readline - busca um registro de um arquivo
readlink - determina para onde um link simbólico está apontando
readpipe - executa um comando do sistema e coleta a saída padrão
recv - recebe uma mensagem através de um Socket
refazer - iniciar esta iteração de loop novamente
ref - descubra o tipo de coisa sendo referenciada
renomear - mudar um nome de arquivo
requerem - carregue em funções externas de uma biblioteca em tempo de execução
redefinir - limpar todas as variáveis de um determinado nome
retorno - saia de uma função mais cedo
reverso - inverte uma string ou uma lista
rewinddir - redefinir o identificador do diretório
rindex - pesquisa de substring da direita para a esquerda
rmdir - remove um diretório
s - substitua um padrão por uma string
escalar - força um contexto escalar
buscar - reposicionar o ponteiro do arquivo para E / S de acesso aleatório
searchdir - reposicionar o ponteiro do diretório
selecionar - redefinir a saída padrão ou fazer multiplexação de E / S
semctl - operações de controle de semáforo SysV
semget - obtém o conjunto de semáforos SysV
semop - operações de semáforo SysV
enviar - enviar uma mensagem através de um soquete
setgrent - prepara o arquivo do grupo para uso
sethostent - prepara o arquivo hosts para uso
setnetent - prepara o arquivo de rede para uso
setpgrp - define o grupo de processos de um processo
setpriority - define o valor legal de um processo
setprotoent - prepara o arquivo de protocolos para uso
setpwent - prepara o arquivo passwd para uso
setservent - prepara o arquivo de serviços para uso
setsockopt - define algumas opções de socket
shift - remove o primeiro elemento de uma matriz e o retorna
shmctl - operações de memória compartilhada SysV
shmget - obter identificador de segmento de memória compartilhada SysV
shmread - lê a memória compartilhada SysV
shmwrite - escrever memória compartilhada SysV
desligamento - fecha apenas metade de uma conexão de soquete
sin - retorna o seno de um número
dormir - bloquear por alguns segundos
socket - cria um socket
socketpair - cria um par de sockets
sort - classifica uma lista de valores
splice - adicione ou remova elementos em qualquer lugar em uma matriz
split - divide uma string usando um delimitador regexp
sprintf - impressão formatada em uma string
sqrt - função de raiz quadrada
srand - semeia o gerador de número aleatório
stat - obtém as informações de status de um arquivo
estudo - otimizar dados de entrada para pesquisas repetidas
sub - declara uma sub-rotina, possivelmente anonimamente
substr - obter ou alterar uma parte de uma agitação
symlink - cria um link simbólico para um arquivo
syscall - executa uma chamada de sistema arbitrária
sysopen - abre um arquivo, canal ou descritor
sysread - entrada sem buffer de comprimento fixo de um filehandle
sysseek - ponteiro de I / O de posição no identificador usado com sysread e syswrite
sistema - execute um programa separado
syswrite - saída sem buffer de comprimento fixo para um filehandle
tell - obtém o buscador atual em um filehandle
telldir - obtém o buscador atual em um identificador de diretório
tie - vincula uma variável a uma classe de objeto
amarrado - obtém uma referência ao objeto subjacente a uma variável ligada
tempo - retorna o número de segundos desde 1970
times - retorna o tempo decorrido para processos próprios e filhos
tr - transliterar uma string
truncar - encurtar um arquivo
uc - retorna a versão em maiúsculas de uma string
ucfirst - retorna uma string com apenas a próxima letra em maiúscula
umask - definir máscara de modo de criação de arquivo
undef - remove uma variável ou definição de função
desvincular - remove um link para um arquivo
desempacotar - converter a estrutura binária em variáveis normais de perl
unshift - adiciona mais elementos ao início de uma lista
desamarrar - desempate vinculando a uma variável
use - carrega em um módulo em tempo de compilação
utime - define o último acesso de um arquivo e modifica os horários
valores - retorna uma lista dos valores em um hash
vec - testar ou definir bits específicos em uma string
espere - espere que qualquer processo filho morra
waitpid - espera que um determinado processo filho morra
wantarray - obtém o contexto void vs escalar vs lista da chamada de sub-rotina atual
warn - imprime informações de depuração
escrever - imprimir um registro de imagem
-X - um teste de arquivo (-r, -x, etc)
y - transliterar uma string

Sr. Não.	Exemplo e descrição
1	python\|perl Corresponde a "python" ou "perl"
2	rub(y\|le)) Corresponde a "rubi" ou "rublo"
3	Python(!+\|\?) "Python" seguido por um ou mais! ou um?

Perl - Guia Rápido

O que é Perl?

Recursos Perl

Perl e a web

Perl é interpretado

Obtendo a instalação do Perl

Instale Perl

Instalação Unix e Linux

Instalação Windows

Instalação Macintosh

Executando Perl

Intérprete Interativo

Script da linha de comando

Ambiente de desenvolvimento integrado

Primeiro Programa Perl

Programação de modo interativo

Programação em modo script

Extensão de arquivo Perl

Comentários em Perl

Espaços em branco em Perl

Aspas simples e duplas em Perl

Documentos "Aqui"

Personagens em fuga

Identificadores Perl

Literais Numéricos

Literais de string

Exemplo

Criação de variáveis

Variáveis ​​Escalares

Variáveis ​​de matriz

Variáveis ​​de hash

Contexto Variável

Escalares Numéricos

Escalares de corda

Operações Escalares

Multiline Strings

V-Strings

Literais Especiais

Criação de Array

Acessando Elementos de Matriz

Matrizes de números sequenciais

Tamanho da Matriz

Adicionando e removendo elementos na matriz

Elementos de matriz de fatias

Substituindo Elementos de Matriz

Transforme Strings em Arrays

Transforme Arrays em Strings

Classificando matrizes

Mesclando matrizes

Selecionando Elementos de Listas

Criando Hashes

Acessando Elementos Hash

Extraindo fatias

Extraindo chaves e valores

Verificando a existência

Obtendo o tamanho do hash

Adicionar e remover elementos em hash

O ? : Operador

Declarações de controle de loop

The Infinite Loop

O que é um operador?

Operadores Aritméticos Perl

Operadores de igualdade Perl

Operadores de atribuição Perl

Operadores Perl Bitwise

Operadores lógicos Perl

Operadores de orçamento

Operadores diversos

Precedência de operadores Perl

Data e hora atuais

Hora GMT

Formato de data e hora

Tempo de época

Função POSIX strftime ()

Definir e chamar uma sub-rotina

Passando Argumentos para uma Sub-rotina

Passando listas para sub-rotinas

Passando Hashes para Sub-rotinas

Retornando valor de uma sub-rotina

Variáveis ​​privadas em uma sub-rotina

Variáveis Escalares

Variáveis de matriz

Variáveis de hash

Variáveis privadas em uma sub-rotina

Variáveis de estado via estado ()

Tipos de Variáveis Especiais

Variáveis Especiais Escalares Globais

Variáveis Especiais de Matriz Global

Variáveis Especiais Hash Globais

Variáveis Especiais de Expressão Regular

Variáveis Especiais de Manipulação de Arquivos

Variáveis de Expressão Regular