Gustavo Roberto

Olá Pessoal,

Para aqueles que sempre tiveram vontade de aprender a programar em Perl, para os mais variados motivos, eis aqui um mini-curso, que dá uma pequena noção sobre como fazê-lo. O Curso foi originalmente escrito pela “lucix at linuxchix org br ( Lucia )”. Vamos ao trabalho, e espero que gostem.

ATUALIZAÇÃO :

Cometi o sacrilégio de esquecer as fontes de consulta, Obrigado Lucia e Sulamita.

O curso também pode ser acessado em

http://www.linuxchix.org.br/?q=node/99

E também um link para a lista:

http://listas.linuxchix.org.br/mailman/listinfo/cursos

Nota, se você não tem acesso a um UNIX para fazer os exercícios ( Ou windows + cygwin ), baixe o programa Perl Active State em http://activestate.com

Introdução

É uma linguagem de programação usada com vários propósitos: Administração de sistemas, desenvolvimento Web, administração de redes, manipulação de dados, textos, e assim por diante.

Documentação

Na linha de comando:

$ man perl

$perldoc -f nome_da_funcao

Na Web :

http://perldoc.perl.org

http://www.google.com.br ( O google sempre ajuda, é só perguntar a ele ).

Rodando programas escritos em Perl na linha de comando.

Obs : Ao escrever um programa em Perl, é interessante que coloquemos a extensão .pl, mas só por enquanto, para podermos lembrar.

Para rodar o programa é simples, basta digitar o nome do interpretador, seguido do nome do programa , exemplo:

$ perl programa1.pl

Sintaxe

Todos os statements terminam com um “;”

Exemplo:

print “Blah, blah, blah”;

Para comentar uma linha, use “#”

Exemplo:

# Isso é um comentario

print “Blah, blah, blah”; # isso também é um comentário

Variáveis

Em perl, existe basicamente 3 tipos de variáveis: scalar, array e hash.

Importante: Você não precisa especificar o tipo de dado que você está guardando dentro de uma variável. Você pode, por exemplo guardar um número e depois guardar um texto que o Perl vai saber como lidar com isso.

scalar : É representado pelo símbolo “$” e é usado para guardar valores simples, como por exemplo: uma palavra, um texto ou números, uma data, etc.

my $fruta = “laranja”;
print “$fruta\n”;

my $total = 24;
my $resultado = $total / 2;
print “$resultado\n”;

array : É representado pelo símbolo “@” e é usado para guardar uma lista de valores.

my @frutas = (“laranja”, “manga”, “banana”);
my @numeros = (10, 45, 20, -78, 99.9, 14);
my @tudo = (“laranja”, 100, 24, “manga”, 5);

my @numeros;
$numero[0] = 10;
$numero[1] = 45;
$numero[2] = 20;
$numero[3] = -78;

Para acessar os elementos de um array, são usados os índices:

print $frutas[0]; # vai imprimir laranja
print $frutas[1]; # vai imprimir manga

Para acessar o último elemento de um array, use $#array_name:

print $frutas[$#frutas]; # vai imprimir banana, que eh o ultimo elemento do
array

hash: É representado pelo simbolo “%” e é usado para guardar uma lista
de valores, assim como o array. O diferencial é que o indice de um array
tem que ser um número. E o indice do hash pode ser um número ou um texto.

Exemplo:

my %idades = ();

$idades{Fulano} = 21;
$idades{Beltrano} = 59;
print “O Fulano tem $idades{Fulano} anos, mas o Beltrano tem
$idades{Beltrano}\n”;

Agora o famoso programa Hello World ! Escrito em Perl:

#!/usr/bin/perl
use strict;
use warnings;

my $texto = “Hello, World!”;
print $texto,”\n”; # imprime Hello, World!

Notas:

1. Tente rodar o programa hello world descrito acima.

2. Sempre começe seu programa em Perl com as seguintes três linhas:

#!/usr/bin/perl
use strict;
use warnings;

Sempre declare as variáveis usando o “my” antes de usa-las ou na primeira
vez que usa-las, exemplo:

my $variavel;
$variavel = “123 testando”;
print “$variavel\n”;

ou então:

my $variavel = “123 testando”;
print “$variavel\n”;

NÃO declare a variável mais de uma vez, como por exemplo:

my $variavel;
my $variavel = “123 testando”;

3. Exercícios:

Crie programas simples de declaração e impressão de variáveis, como por
exemplo:

a) crie um array de 5 elementos e imprima o primeiro e o último elemento;
b) crie um hash cujos indices sejam países e os valores sejam as suas
respectivas capitais. Imprima alguns dos valores;

Operadores, condições e estruturas de repetição – Introdução

Operadores

O Perl tem inúmeros operadores. Os mais comumente usados são:

Matemática:

+ adição
- subtração
* multiplicação
/ divisão
% resto da divisão

Exemplos:

my $x = 5;
my $y = 1.9;
my $z = $y / 2;
my $soma = $x + $y * 3 / $z;
print “Soma: $soma\n”;

my $x = 22;
my $y = 5;
my $resto = 22 % 5;
print “Resto: $resto\n”;

Operadores para comparação numérica:

== igual
!= diferente
maior que
= maior ou igual a

Sintaxe:

if ($numero1 == $numero2) {
…
}

Operadores para comparação de texto:

eq equivalente
ne diferente

Sintaxe:

if ($texto1 eq $texto2) {
…
}

Operadores para comparação lógica:

&& e
|| ou
! negação

Exemplo:

if ( ($numero1 == $numero1) && ($texto1 eq $texto2) ) {
…
}

if ( !($numero1 == $numero2) ) {
…
}

Condições

IF ELSIF ELSE

if (condicao) {

…

} elsif (outra condicao) {

…
} else {

…
}

OU

… if condicao;

Exemplo:

my $sisop = ‘linux’;

if ($sisop eq “solaris”) {

print “Solaris\n”;

} elsif ($sisop eq “linux”) {

print “Linux\n”;

} else {

print “Outro sistema operacional\n”;
}

OU

my $valor = 30;
print $valor if ($valor = 30); #imprime valor SE o valor for igual a 30

UNLESS – eh a negativa do IF.

Sintaxe:

… unless (condicao);

Exemplo:

my $valor = 30;
print $valor unless ($valor = 30); #imprime valor A NÃO SER QUE valor seja
igual a 30

Estruturas de repetição

WHILE: a repeticao continua enquanto “condicao” não for verdade.

Sintaxe:

while (condicao) {
…
}

OU

… while condicao;

Exemplo:

my $contador = 0;
while ($contador 10) {
print “Contando ate 10 com until… $contador\n”;
$contador++; #incrementa contador
}

FOR: é exatamente como na linguagem C. Geralmente nao é muito usado em
Perl, já que o Perl tem uma outra estrutura – o FOREACH – que é muito mais
pratica que o FOR.

for (inicia contador; condicao; incrementa contador) {
…
}

Exemplo:

my $fim = 10;
for ( my $contador=0; $contador “MySQL”,
linguagem => “Perl”,
webserver => “Apache”,
);
foreach my $ferramenta (keys %desenvolvimento) {
print “O Conteudo de $ferramenta eh
$desenvolvimento{$ferramenta}\n”;
}

Exercícios

Para se familiarizar com as estruturas e sintaxes do Perl, crie programas
simples com loops, condições e comparações como por exemplo:

a) crie um array com vários elementos numéricos e imprima somente os números
maiores que 10;

b) crie um array com vários elementos numéricos e imprima somente os números
pares e maiores que 10;

c) crie um array com varios elementos do tipo texto e use foreach para
imprimi-los.

d) crie um programa que contenha as seguintes linhas:

my $resultado = “linux ” x 5;
print “O resultado de linux x 5 eh igual a $resultado\n”;

e veja como funciona a multiplicação de texto.

Tratamento de arquivos e expressões regulares:

ATENÇÃO: Esta aula de forma alguma cobre todas as informações disponíveis
sobre os assuntos: “tratamento de arquivos” e “expressões regulares”. Esses
assuntos serão abordados por várias outras aulas no decorrer do curso. Quem
precisa desesperadamente de mais informações e não pode esperar até que eles
sejam abordados, pode acessar os manuais do Perl, conforme descrito na
primeira aula.

Tratamento de arquivos:

Basicamente o tratamento de arquivos segue a estrutura:

- abre arquivo para escrita e/ou leitura E testa se o arquivo foi aberto
- escreve e/ou le o arquivo
- fecha arquivo

A função open() é utilizada para abrir arquivos, tanto para leitura como
para escrita. E a função close() é usada para fechar os arquivos que foram
previamente abertos.

ABRINDO ARQUIVOS:

Para abrir um arquivo para leitura, pode-se usar algo como:

open(my $arquivo, “/path/do/arquivo.txt”)

NOTA: O símbolo “>” indica que o arquivo está sendo aberto para escrita, e
que o programa vai escrever por cima do que já estiver escrito dentro do
arquivo.

Para abrir um arquivo para escrita (concatenando no final), pode-se usar
algo como:

open(my $arquivo, “>>/path/do/arquivo.txt”)

NOTA: O símbolo “>>” indica que o arquivo está sendo aberto para escrita, e
que o programa vai escrever concatenando o texto no final no arquivo.

TESTANDO SE O ARQUIVO FOI ABERTO:

Para testar se o arquivo foi aberto, pode-se usar algo como:

open(my $arquivo, “) { # le cada linha do arquivo e grava o
conteudo na variavel $linha
print $linha; # imprime o conteudo de $linha
}

Ou então:

while () { # faz um loop lendo uma linha do arquivo de cada vez
e gravando na variavel especial $_
print; # o “print” sozinho eh a mesma coisa que “print $_”
}

Não é magica. Quando nenhuma variavel eh especificada, o Perl usa a
variável especial $_

Sendo assim, na linha do while esta implícito, mas o Perl está gravando cada
linha linha na variável $_ e na linha do print, também está implícito, o Perl
está dando um print na variável $_

ESCREVENDO EM UM ARQUIVO:

Quando um arquivo eh aberto para escrita, como nos exemplos:

open(my $arquivo, “>/path/do/arquivo.txt”);

ou:

open(my $arquivo, “>>/path/do/arquivo.txt”);

Para escrever algo nesse arquivo, pode-se usar algo como:

print $arquivo “1 \n”;
print $arquivo “2 \n”;
print $arquivo “3 \n”;
print $arquivo “4 \n”;

Ou, melhor:

foreach my $numero (1..4) {
print $arquivo “$numero\n”;
}

FECHANDO UM ARQUIVO:

— A função close() é usada para fechar o arquivo que foi aberto tanto
para leitura, como para escrita.

close $arquivo;

Exemplo 1: Lendo o conteúdo de um arquivo:

- Crie um arquivo chamado paises.txt, com o seguinte conteúdo (um país em
cada linha):

Alemanha
Brasil
Dinamarca
Estados Unidos
Inglaterra

- Crie no mesmo diretório onde está o arquivo paises.txt, um programa
chamado paises.pl e copie o seguinte código dentro dele:

#!/usr/bin/perl

use warnings;
use strict;

open (my $arquivo, “) {
print “Nome do pais: $_\n”;
}
close $arquivo;

- Rode o programa na linha de comando:

perl paises.pl

- O programa irá gerar o seguinte output:

Nome do país: Alemanha

Nome do país: Brasil

Nome do país: Dinamarca

Nome do país: Estados Unidos

Nome do país: Inglaterra

Exemplo 2: Escrevendo em um arquivo:

- Para escrever em um arquivo, crie um programa chamado esportes.pl, com o
seguinte conteúdo:

#!/usr/bin/perl

use warnings;
use strict;

open (my $arquivo, “>esportes.txt”) or die “Nao consegui abrir esportes.txt:
$!”;
my @esportes = (“hockey”, “futebol”, “tennis”, “levantamento de peso”,
“baseball”);
print $arquivo “Criando um arquivo em Perl… \n”;
foreach my $esporte (@esportes) {
print $arquivo “Nome do esporte: $esporte\n”;
}
print $arquivo “Fim do arquivo… \n\n”;
close $arquivo;

- Rode o programa na linha de comando:

perl paises.pl

Confira o conteúdo de esportes.txt, que será algo como:

Criando um arquivo em Perl…
Nome do esporte: hockey
Nome do esporte: futebol
Nome do esporte: tennis
Nome do esporte: levantamento de peso
Nome do esporte: baseball
Fim do arquivo…

Expressões Regulares – ou simplesmente “regexp”:

Muita calma nessa hora: Regexps tem fama de serem difíceis e muito
complicadas. Mas a partir do momento que você entende a idéia geral e as
coisas básicas sobre regexps, fica bem mais fácil ir acrescentando
informações e conseguir fazer regexps mais elaboradas.

O que eh uma regexp?

Regexp é um texto que descreve um padrão, um modelo. Por exemplo, é comum
usarmos na linha de comando do linux, algo como: “ls *.pdf”, o que vai
retornar todos os arquivos com extensão “.pdf”. Em Perl existem as chamadas
expressões regulares, que servem para (entre outras coisas que serão
abordadas nas próximas aulas) procurar um determinado padrão dentro de um
texto.

Vejamos através de exemplos:

Vamos pegar o primeiro dos programas de exemplo citado acima:

#!/usr/bin/perl

use warnings;
use strict;

open (my $arquivo, “) {
print “Nome do pais: $_\n”;
}
close $arquivo;

Imagine que você não sabe qual é o conteúdo do arquivo paises.txt, e você quer
imprimir apenas os países cujo nome contem a letra “m”. Para isso,
poderíamos transformar o programa acima em algo como:

#!/usr/bin/perl
use warnings;
use strict;

open (my $arquivo, “) {
if ($_ =~ /m/) { # verifica se o nome do pais contem a letra
m
print “Pais que contem a letra m: $_ \n”;
} else {
print “Pais que NAO contem a letra m: $_ \n\n”;
}
}
close $arquivo;

Analisando o programa de exemplo:

if ($_ =~ /m/) {

O $_ ja foi descrito no começo dessa aula: é uma variável especial do Perl,
muito útil e bastante usada. No caso do programa acima, o conteúdo de $_ é
a linha do arquivo previamente lida durante o statement “while
()”.

=~ é o operador usado para comparar o conteúdo da variavel com a regexp

m eh a regexp (nesse caso, a regex é um texto simples, mas uma regexp pode
ser muito mais complicada do que isso)

Os // no começo e no fim da regexp indica que a letra m será procurada no
conteúdo da variável $_

Em outras palavras o que o programa faz é: verificar se a variável $_
contem a palavra “m”.

Outros exemplos:

my $texto = “Ola Mundo”;
$texto =~ /mundo/; # nao vai dar match pq regexps sao case sensitive.
$texto =~ /a M/; # vai dar match pq espacos sao tratados como qq
outro caractere.
$texto =~ /aM/; # nao vai dar match pq esta faltando o espaco
$texto =~ /Mundo /; # nao vai dar match por causa do espaco no final

Exercicios:

a) Utilizando o programa de exemplo 2: troque a linha:

open (my $arquivo, “>esportes.txt”) or die “Nao consegui abrir esportes.txt:
$!”;

por:

open (my $arquivo, “>>esportes.txt”) or die “Nao consegui abrir esportes.txt:
$!”;

Rode o programa várias vezes. Veja o que acontece com o conteúdo do arquivo
esportes.txt.

b) Exercício terapeutico: Seguindo o programa de exemplo 1 como modelo, crie
um arquivo chamado chatos.txt e coloque nesse arquivo o nome de vários
chatos, um por linha. Faça um programa (chatos.pl) que imprima os nomes dos
chatos.

c) Em Perl, em alguns casos, é possível se imaginar para que serve uma
função baseado no nome da função. Por exemplo: função die – mata o programa;
função use – carrega um módulo, avisa o Perl para “usar” um determinado
módulo. Existe uma função muito útil para ser usada, entre outras coisas,
quando se lê um dado de um arquivo: chomp. Utilizando o programa de chatos
que vc acabou de criar, tente descobrir para que serve o chomp. Tente, por
exemplo:

troque as linhas:

while () {
print “Esse fulano eh um chato: $_ \n”;

por:

while () {
chomp;
print “Esse fulano eh um chato: $_ \n”;

NOTA: Obviamente, só faça esse exercício se você não sabe para que serve o
chomp. Para quem quiser mais informações sobre o chomp: digite na linha de
comando: perldoc -f chomp

d) Ainda utilizando o seu programa de chatos, faça testes com ele: imprima
somente os nomes dos chatos que contém um espaço, que contem a letra m
(maiúscula, depois minúscula), etc.

e) Tente abrir para leitura ( ou >>) um arquivo que não existe. Use o
programa de esportes, por exemplo: apague o arquivo esportes.txt e tente
rodar o programa esportes.pl. Veja o que acontece.

Tratamento de Arquivos, Expressões Regulares e Subrotinas/Funções

ATENÇÃO: Esta aula de forma alguma cobre todas as informações disponíveis
sobre os assuntos: “tratamento de arquivos”, “expressões regulares” e
“subrotinas/funções”. Esses assuntos serão abordados também em outras aulas
no decorrer do curso. Quem precisa desesperadamente de mais informações,
pode acessar os manuais do Perl, conforme descrito na primeira aula.

Ainda sobre o tratamento de arquivos.

Na última aula foi descrito como manipular arquivos para leitura e escrita.
Foram descritas algumas funções nativas do Perl que podem ser usadas para o
tratamento de arquivos, como as funções open e close.

RELEMBRANDO:

- O símbolo é usado para abrir o arquivo para escrita, sobrescrevendo o
conteúdo do arquivo

- O simbolo >> é usado para abrir o arquivo para escrita, acresentando ao
final do arquivo.

ACRESCENTANDO MAIS ALGUMAS INFORMAÇÕES:

- Se o simbolo é omitido, o Perl interpreta que o arquivo está sendo aberto
para leitura.

Exemplo:

open(my $arquivo, “/path/do/arquivo.txt”)

O trecho de código acima, abre o arquivo arquivo.txt para leitura, ou seja,
é a mesma coisa que:

open(my $arquivo, ”
=

Os operadores para comparacao de strings:

eq
ne

Os operadores para comparação lógica:

&&
||
!

As estruturas de condição:

if
elsif
else
unless

As estruturas de repetição:

while
until
for
foreach

Tratamento de arquivos:

- como abrir e ler o conteudo de um arquivo
- como criar/abrir e escrever em um arquivo
- como alterar o conteudo de um arquivo
- como testar se o arquivo foi aberto
- como fechar o arquivo

Expressões regulares:

- como procurar por um padrao em um texto
- como substituir um padrao em um texto

Subrotinas/funções:

- como criar funcoes
- como executar funcoes

NOTA: Quem acompanhou o curso até aqui, supostamente já conhece pelo menos o
básico do que foi descrito acima. Caso você não se lembre de alguma coisa,
revise o conteúdo das aulas anteriores.

Mais informacões sobre expressões regulares:

Back Reference

Back references sao usadas para pegar informacoes especificas de um texto.

Exemplo 1:

Digamos que um programa recebe a seguinte informação:
“hora=10:20,data=25/12/2005″ e que precisamos isolar o dia o mês e o ano em
variáveis diferentes. Podemos usar algo como:

my $info = “horario=10:20,data=25/12/2005″;
my ($dia, $mes, $ano);

if ( $info =~ m|^.*data=(\d{2})/(\d{2})/(\d{4})| ) {

$dia = $1;
$mes = $2;
$ano = $3;
print “Dia = $dia\n”;
print “Mes = $mes\n”;
print “Ano = $ano\n”;
}

Ou então:

my $info = “horario=10:20,data=25/12/2005″;
my ($dia, $mes, $ano);

if ( $info =~ m|^.*data=(\d{2})/(\d{2})/(\d{4})| ) {

print “Dia = $1\n”;
print “Mes = $2\n”;
print “Ano = $3\n”;
}

Ou ainda:

my $info = “horario=10:20,data=25/12/2005″;

if ( my($dia, $mes, $ano) = $info =~ m|^.*data=(\d{2})/(\d{2})/(\d{4})| ) {

print “Dia = $dia\n”;
print “Mes = $mes\n”;
print “Ano = $ano\n”;
}

Analisando trechos do programa:

if ( $info =~ m|^.*data=(\d{2})/(\d{2})/(\d{4})| ) {

Esse trecho de código verifica se o conteúdo da variável $info eh um match
para a regexp dada, e guarda os valores entre parentêses nas back
references. Ou seja, o conteúdo da variável $info que da match nas regexps
entre parentêses, são gravadas nas variáveis especiais $1, $2 e $3
respectivamente.

if ( my($dia, $mes, $ano) = $info =~ m|^.*data=(\d{2})/(\d{2})/(\d{4})| ) {

Esse trecho de código verifica se o conteúdo da variável $info eh um match
para a regexp dada, e atribui os valores referentes as regexps entre
parentêses para as variáveis $dia, $mes, $ano respectivamente.

Escopo das variáveis: observe que o “my” foi usado dentro de um “if”. Nesse
caso, as variáveis $dia, $mes e $ano, só existem dentro daquele “if”.

Traduzindo a regexp:

m|^.*data=(\d{2})/(\d{2})/(\d{4})|

m|| é o delimitador da regexp, ou seja, indica começo e fim.

^ indica que é o começo da string.

.* “ponto” eh qualquer caractere; “asterisco” indica nenhuma ou mais
ocorrências do caractere anterior. Ou seja, nessa regexp de exemplo, .*
significa: nenhuma ou mais ocorrências de qualquer caractere.

data= neste exemplo, é literalmente o texto “data=”

\d{2} significa a ocorrência de 2 números.

(\d{2}) colocar \d{2} (ou qualquer outro trecho da regexp) entre parentêses,
significa que o conteúdo de variável que der match nesse trecho, estará
acessivel através das back references: $1, $2, $3, $4. etc.

Em outras palavras, essa regexp verifica se:

A string começa com nenhum ou mais quaisquer caracteres seguida de: “data=”,
2 números, uma barra, 2 números, uma barra, 4 números.

Exemplo 2:

Digamos que um programa recebe a seguinte informação: “email=
cursos at linuxchix.org.br” e que precisamos isolar o usuário e o dominio.
Podemos usar algo como:

my $info = ‘email=cursos at linuxchix.org.br’;

if ( $info =~ m|^e-?mail=(.+)@(.+)| ) {

print “Usuario = $1\n”;
print “Dominio = $2\n”;
}

Analisando trechos do programa:

my $info = ‘email=cursos at linuxchix.org.br’;

Note que aqui foi usado ‘ (aspas simples) ao invés de ” (aspas). Isso
porque, em Perl, quando usamos “, significa que o Perl vai interpretar tudo
o que esta dentro de ” (aspas), inclusive variáveis. Então, no exemplo
acima, se fizermos algo como:

my $info = “email=cursos at linuxchix.org.br”;

O Perl vai interpretar o @linuxchix como se isso fosse um array e nao como
se isso fosse um texto qualquer.

Quando usamos ‘ o Perl não tenta interpretar o conteudo entre ‘ (aspas
simples), então podemos usar o sinal @ sem problemas.

Traduzindo a regexp:

m|^e-?mail=(.+)@(.+)|

m|| é o delimitador da regexp, ou seja, indica começo e fim.

^ indica que é o começo da string.

e- neste exemplo, é literalmente a string “e-”

? indica zero ou uma ocorrência do caractere anterior, no caso do exemplo
dado, indica 0 ou uma ocorrência do “-”. Ou seja, vai dar match se a string
começar com “email” ou “e-mail”.

. É qualquer caractere;
+ indica uma ou mais ocorrências do caractere anterior;

Logo:
.+ siginifica: ocorrência de uma ou mais vezes de qualquer caracter

Em outras palavras, essa regexp verifica se:

A string começa com o caractere “e” seguida ou não de um “-”, seguida do
texto “mail=”, seguida de: ocorrência de 1 ou mais quaisquer caracteres, uma
arroba, ocorrência de 1 ou mais quaisquer caracteres.

NOTA: Os exemplos dados são apenas para explicar de forma simples o que é e
como usar back references. Na vida real, para tratamento de datas, emails e
outros tipos de informação padrão, a melhor opção é usar os módulos criados
especificamente para esses fins e disponíveis no CPAN: cpan.perl.org. Não
tente “reinventar a roda”, a não ser, é claro, com o objetivo de aprender.

Exercícios

Antes de começar: se você não sabe do que se trata o arquivo /etc/services,
leia o conteúdo dele e tente entender que tipo de informações são aquelas.

a) Faça um programa que lê o conteúdo do arquivo /etc/services, guarde
somente os nomes dos serviços dentro de um array, somente os números das
portas em outro array e somente o protocolo em um terceiro array. Imprima o
conteúdo dos arrays de forma que a saída do programa seja algo como:

Serviço: telnet – Porta: 23 – Protocolo: TCP
Serviço: http – Porta: 80 – Protocolo: TCP

b) Altere o programa do exercício “a” para que ele imprima a informação
apenas se o protocolo for TCP. Depois altere para que ele só imprima
informação se a porta que o serviço usa for um número par.

c) Faça um programa que lê o conteúdo do arquivo /etc/services. Guarde as
informações de serviços e portas em um hash onde o servico será a key do
hash e a porta que o servico usa sera o value. Imprima o conteúdo do hash no
formato:

Serviço: telnet – Porta: 23
Serviço: http – Porta: 80

d)Altere o programa do exercicio “c” para que ele imprima informação somente
se o nome do serviço não começa com a letra “t” ou “h”.

e) Altere novamente o programa do exercício “c” para que ele imprima
informação somente se a porta na qual o servico escuta seja maior do que
500.