• Perl é uma linguagem de programação multiplataforma estável.

  • Embora Perl não seja oficialmente um acrônimo, mas 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 é 5.16.2

  • Perl está listado no Oxford English Dictionary .

  • 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 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 comércio eletrônico.

  • Perl pode ser embutido em servidores web para acelerar o processamento em até 2.000%.

  • O mod_perl do Perl permite que o servidor da web Apache incorpore um interpretador Perl.

  • O pacote DBI do Perl facilita a integração do banco de dados da web.

Sim! Perl é uma linguagem de programação que diferencia maiúsculas de minúsculas.

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 tem três tipos de dados básicos - escalares, arrays de escalares e hashes de escalares, também conhecidos como arrays associativos.

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.

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" (@).

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 (%).

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.

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

A atribuição a uma variável escalar avalia o lado direito em um contexto escalar.

A atribuição a uma matriz ou hash avalia o lado direito em um contexto de lista.

O contexto booleano é simplesmente qualquer lugar onde uma expressão está sendo avaliada para ver se ela é verdadeira ou falsa.

Esse contexto não só não se importa com o valor de retorno, como nem mesmo deseja um valor de retorno.

Este contexto só acontece entre aspas, ou coisas que funcionam como aspas.

A string entre aspas simples imprime a variável perl como uma string, enquanto a string entre aspas duplas avalia a variável e é usada para obter o valor da variável.

#!/usr/bin/perl

$var = "This is string scalar!";
$quote = 'I m inside single quote - $var';
$double = "This is inside double 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 double quote - This is string scalar!
escape = This example of escape - Hello, World!

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}".

É usado para obter o nome do arquivo atual.

É usado para obter o número da linha atual.

É usado para obter o nome do pacote atual.

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 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";

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

operador de intervalo (..) é usado para criar matrizes sequenciais.

#!/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 de operador de intervalo. 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

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.

push @ARRAY, LIST - Coloca os valores da lista no final da 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";

Isso produzirá o seguinte resultado -

1. @coins = Quarter Dime Nickel
2. @coins = Quarter Dime Nickel Penny

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 beginning of the array
unshift(@coins, "Dollar");
print "2. \@coins  = @coins\n";

Isso produzirá o seguinte resultado -

1. @coins = Quarter Dime Nickel
2. @coins = Dollar Quarter Dime Nickel

pop @ARRAY - Aparece e retorna o último valor da matriz.

#!/usr/bin/perl

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

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

Isso produzirá o seguinte resultado -

1. @coins = Quarter Dime Nickel
2. @coins = Quarter Dime

shift @ARRAY - Desloca o primeiro valor do array e o retorna, encurtando o array em 1 e movendo tudo para baixo.

#!/usr/bin/perl

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

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

Isso produzirá o seguinte resultado -

1. @coins = Quarter Dime Nickel
2. @coins = Dime Nickel

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 função splice () removerá os elementos de @ARRAY designados por OFFSET e LENGTH, e os substituirá por LIST, se especificado. Finalmente, ele retorna os elementos removidos da matriz.

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

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

split () divide uma string em um array 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.

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

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

A função join () une as strings separadas de LIST em uma única string com campos separados pelo valor de EXPR e retorna a string.

join EXPR, LIST

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";
print "$string[3]\n";  # This will print Roses
print "$names[4]\n";   # This will print Michael

Isso produzirá o seguinte resultado -

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

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

sort [ SUBROUTINE ] LIST

Esta função classifica o 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

Esta variável especial é um escalar contendo o primeiro índice de todos os arrays. Como os arrays Perl têm indexação baseada em zero, $ [quase sempre será 0. Mas se você definir $ [para 1, todos os seus arrays usarão a indexação baseada em. Recomenda-se não usar qualquer outra indexação diferente de zero. No entanto, vamos dar um exemplo para mostrar o uso de $ [variável -

#!/usr/bin/perl

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

# Let's reset first index of all the arrays.
$[ = 1;

print "Food at \@foods[1]: $foods[1]\n";
print "Food at \@foods[2]: $foods[2]\n";

Isso produzirá o seguinte resultado -

Foods: pizza steak chicken burgers
Food at @foods[1]: pizza
Food at @foods[2]: steak

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

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);

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

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

keys %HASH

Esta função retorna uma matriz 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

Você pode obter uma lista de todos os valores de um hash usando a função de valores, que tem a seguinte sintaxe -

values %HASH

Esta função retorna uma matriz de 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

Usando a função exists, que retorna verdadeiro se a chave nomeada existe, independentemente de qual possa ser 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 enquanto, você apenas assume que a parte if (condição) será executada somente quando a condição fornecida for verdadeira, caso contrário, a parte será executada. Então, quando executamos o programa acima, ele produz o seguinte resultado porque aqui existe a condição dada ($ data {'Lisa'} retorna verdadeiro -

Lisa is 30 years old

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 maneira -

#!/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 um novo par chave / valor pode ser feito com uma linha de código usando o operador de atribuição simples.

#!/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";

Isso produzirá o seguinte resultado -

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

Para remover um elemento do hash, você precisa usar a função delete como 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";

# delete the same element from the hash;
delete $data{'John Paul'};
@keys = keys %data;
$size = @keys;
print "2 - Hash size:  is $size\n";

Isso produzirá o seguinte resultado -

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

Isso faz com que o loop pule o restante de seu corpo e teste novamente sua condição imediatamente antes de reiterar. última declaração.

Ele termina a instrução de loop e transfere a execução para a instrução imediatamente após o loop. continuar declaração.

Um bloco de continuação, é sempre executado um pouco antes de a condicional estar prestes a ser avaliada novamente.

O comando redo reinicia o bloco de loop sem avaliar a condicional novamente. O bloco de continuação, se houver, não é executado.

O formulário goto LABEL salta para a instrução rotulada com LABEL e retoma a execução a partir daí.

O formulário goto EXPR é apenas uma generalização de goto LABEL. Ele espera que a expressão retorne um nome de rótulo e, em seguida, salta para essa instrução rotulada.

Ele substitui uma chamada à sub-rotina nomeada pela sub-rotina em execução no momento.

Expoente - Executa cálculo exponencial (potência) nos operadores. Suponha que a variável $ a tenha 10 e a variável $ b tenha 20, então $ a ** $ b dará 10 à potência 20.

Ele 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. Assuma que a variável $ a contém 10 e a variável $ b contém 20, então ($ a <=> $ b) retorna -1.

Ele retorna verdadeiro se o argumento esquerdo for menor que o argumento direito. Assuma que a variável $ a contém "abc" e a variável $ b contém "xyz" então ($ a lt $ b) é verdadeiro.

Retorna verdadeiro se o argumento esquerdo for stringwise maior que o argumento direito. Assuma que a variável $ a contém "abc" e a variável $ b contém "xyz", então ($ a gt $ b) é falsa.

Retorna verdadeiro se o argumento esquerdo for stringwise menor ou igual ao argumento direito. Assuma que a variável $ a contém "abc" e a variável $ b contém "xyz", então ($ a le $ b) é verdadeiro.

Retorna verdadeiro se o argumento esquerdo for stringwise maior ou igual ao argumento direito. Assuma que a variável $ a contém "abc" e a variável $ b contém "xyz", então ($ a ge $ b) é falsa.

Retorna verdadeiro se o argumento esquerdo for stringwise igual ao argumento direito. Assuma que a variável $ a contém "abc" e a variável $ b contém "xyz", então ($ a eq $ b) é falsa.

Retorna verdadeiro se o argumento esquerdo for stringwise diferente do argumento direito. Assuma que a variável $ a contém "abc" e a variável $ b contém "xyz" então ($ a ne $ b) é verdadeiro.

Ele retorna -1, 0 ou 1, dependendo se o argumento esquerdo é stringwise menor, igual ou maior que o argumento direito. Assuma que a variável $ a contém "abc" e a variável $ b contém "xyz" então ($ a cmp $ b) é -1.

Exponente E operador de atribuição, Executa cálculo exponencial (potência) nos operadores e atribui valor ao operando esquerdo. $ c ** = $ a é equivalente a $ c = $ c ** $ a

Ele inclui uma string entre aspas simples. q {abcd} dá 'abcd'

Ele inclui uma string entre aspas duplas. qq {abcd} dá "abcd"

Ele inclui uma string com aspas invertidas. qx {abcd} dá `abcd`

O operador binário ponto (.) Concatena duas strings. Se $ a = "abc", $ b = "def" então $ a. $ B dará "abcdef"

O operador de repetição x retorna uma string que consiste no operando esquerdo repetido o número de vezes especificado pelo operando direito. ('-' x 3) dará ---.

O operador de intervalo .. retorna uma lista de valores contados (em unidades) do valor esquerdo para o valor direito. (2..5) dará (2, 3, 4, 5).

O operador de incremento automático aumenta o valor inteiro em um. $ a ++ dará 11.

O operador Auto Decrement diminui o valor inteiro em um. $ a−− dará 9

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. $ obj -> $ a é um exemplo para acessar a variável $ a do objeto $ obj.

função localtime (), que retorna valores para a data e hora atuais se não houver argumentos.

#!/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

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 em GMT.

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).

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.

Você pode usar a função POSIX strftime () para formatar a data e a hora.

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 );

eles podem ser acessados ​​dentro da função usando o array especial @_. Portanto, o primeiro argumento para a função está em $ _ [0], o segundo está em $ _ [1] e assim por diante.

usando escalar (@_), podemos obter o número total de argumentos passados.

O operador my 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.

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.

Variáveis ​​lexicais são variáveis ​​privadas criadas usando meu operador.

O local é usado 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 meu operador. Um escopo léxico geralmente é um bloco de código com um conjunto de colchetes ao redor dele, 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. O operador my 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.

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 o operador de estado e disponíveis a partir do Perl 5.9.4.

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 dados 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 criar uma referência para qualquer variável prefixando-a com uma barra invertida da seguinte forma -

$scalarref = \$foo;

Você pode criar uma referência para qualquer array prefixando-o com uma barra invertida da seguinte maneira -

$arrayref  = \@ARGV;

Você pode criar uma referência para qualquer hash prefixando-o com uma barra invertida da seguinte forma -

$hashref   = \%ENV;

Você pode criar uma referência para qualquer sub-roteamento prefixando-o com uma barra invertida da seguinte forma -

$cref = \&PrintHash;

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.

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)

A seguir está a sintaxe para abrir file.txt no 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 de arquivo que será usado para ler o arquivo.

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, $!";

A seguir está a sintaxe para abrir file.txt no modo de escrita sem truncá-lo. Aqui, menos de + <indica que o arquivo deve ser aberto no modo de gravação sem truncá-lo.

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

Para fechar um filehandle e, portanto, desassociar o filehandle do arquivo correspondente, use a função close. Isso esvazia os buffers do manipulador de arquivos e fecha o descritor de arquivo do sistema.

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

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.