Básico
Olá Mundo
use strict/warnings é a melhor prática
#!/usr/bin/perl
use strict;
use warnings;
print "Hello, World!\n";
# variables: scalar ($), array (@), hash (%)
my $name = "Alice";
my @nums = (1, 2, 3);
my %ages = (Alice => 30, Bob => 25);
print "Name: $name\n";Comentários
=pod =cut para comentários de várias linhas
#!/usr/bin/perl
# This is a single-line comment
print "Hello\n"; # inline comment
=pod
This is a multi-line
comment using POD (Plain Old Documentation)
=cut
print "After POD\n";Executar Script
opções de linha de comando do perl
my $str = "Hello";
my $num = 42;
my $float = 3.14;
my $bool = 1; # true (0, "", "0", undef are false)
# String repetition
my $line = "-" x 20;
# String concatenation
my $greeting = "Hello, " . $str;
print "$greeting\n"; # Hello, HelloFunção say
say adiciona automaticamente uma nova linha
my $name = "Alice";
my $age = 30;
print "Name: $name\n"; # interpolates
print 'Name: $name\n'; # literal (no interpolation)
# Disambiguate variable name with braces
my $fruit = "apple";
print "I have many ${fruit}s.\n"; # I have many apples.
# Array interpolation (joins with $")
my @arr = (1, 2, 3);
print "Array: @arr\n"; # Array: 1 2 3shebang
env perl é mais portável
use strict;
use warnings;
# Without strict, this would create a global:
# $foo = 42; # ERROR under strict
my $foo = 42; # OK with my
# Warnings catch common mistakes
my $undef_var;
# print $undef_var; # warns: uninitialized value
# Modern bundle (v5.36+ enables strict, warnings, features)
use v5.36;
# Disable specific warnings locally
no warnings 'uninitialized';say e features
say é como print, mas acrescenta uma quebra de linha. Habilite recursos com 'use feature' ou um bundle de versão como 'use v5.36'. Signatures fornecem parâmetros nomeados em vez de desempacotar @_.
use v5.10;
use feature 'say';
say "Hello!"; # adds newline automatically
say "No need for \n";
# Equivalent to:
print "Hello!\n";
# Signatures (v5.20+, not default)
use feature 'signatures';
no warnings 'experimental::signatures';
sub greet ($name) {
say "Hi, $name";
}Escalares
Variáveis Escalares
o prefixo $ denota um escalar
my $sum = 5 + 3; # 8
my $diff = 10 - 4; # 6
my $prod = 6 * 7; # 42
my $div = 10 / 3; # 3.3333...
my $int = int(10 / 3); # 3
my $mod = 10 % 3; # 1
my $pow = 2 ** 10; # 1024
# Augmented assignment
my $x = 5;
$x += 3; # $x = 8
$x **= 2; # $x = 64
$x++; # $x = 65
$x--; # $x = 64Operações de String
Funções comuns de string
my $a = "Hello";
my $b = "World";
# Concatenation
my $combined = $a . ", " . $b; # Hello, World
# Repetition
my $line = "=" x 30;
# Augmented concatenation
my $str = "abc";
$str .= "def"; # abcdef
# Numeric vs string comparison
print "match" if "abc" eq "abc"; # string equal
print "match" if 123 == 123; # numeric equalInterpolação de String
Aspas duplas interpolam, aspas simples não
my $x; # undef
print "undef\n" if !defined $x;
$x = undef; # explicitly undef
undef $x; # another way
# Defined-or operator
my $val = $x // "default";
# Warning if used as string:
# print $x; # Use of uninitialized value
if (defined $val) {
print "Defined: $val\n";
}Operações Numéricas
Funções numéricas
my $name = "Alice";
# q() = single quote (no interpolation)
my $s1 = q(Hello $name); # Hello $name
# qq() = double quote (interpolation)
my $s2 = qq(Hello $name); # Hello Alice
# qw() = quoted words (produces a list)
my @words = qw(apple banana cherry);
# equivalent to ("apple", "banana", "cherry")
# Custom delimiters
my $s3 = q{don't worry};
my $s4 = q!bang!;undef
undef significa indefinido
my $name = "Alice";
# Single-quote style (no interpolation)
my $text = <<'END';
Hello $name,
This is literal.
END
# Double-quote style (interpolation)
my $msg = <<"EOF";
Hello $name,
Interpolated here.
EOF
print $msg;
# Indented heredoc (v5.26+)
my $code = <<~EOT;
line 1
line 2
EOTVeracidade Booleana
Apenas undef, 0, '' e '0' são falsos; mesmo '00' e '0.0' são verdadeiros! Use || para padrões truthy e // para padrões defined. Referências (mesmo arrays vazios) são sempre verdadeiras.
# False values: undef, 0, "", "0"
# Everything else is true
print "true\n" if 1; # true
print "true\n" if "hello"; # true
print "true\n" if "0"; # NOT printed (false!)
print "true\n" if ""; # NOT printed (false)
print "true\n" if []; # true (reference is true)
# Logical operators
my $x = 0 || "default"; # default (|| tests truthiness)
my $y = 0 // "default"; # default (// tests definedness)
my $z = "a" && "b"; # b (returns last evaluated)Arrays
Operações de Array
prefixo @ para arrays, $ para acesso a elemento
my @nums = (1, 2, 3, 4, 5);
my @strs = qw(a b c);
my @mixed = (1, "two", 3.14);
# Access by index (0-based)
print $nums[0]; # 1
print $nums[-1]; # 5 (last element)
# Modify an element
$nums[0] = 100;
# Range operator
my @range = (1 .. 10); # 1 to 10
# Length in scalar context
my $count = scalar @nums; # 5
my $count2 = @nums; # 5Funções de Array
push/pop/unshift/shift
my @stack = (1, 2, 3);
# push/pop operate on the END
push @stack, 4, 5; # (1, 2, 3, 4, 5)
my $last = pop @stack; # 5
# unshift/shift operate on the START
unshift @stack, 0; # (0, 1, 2, 3, 4)
my $first = shift @stack; # 0
# @stack is now (1, 2, 3, 4)
print "@stack\n";
# splice is the general-purpose tool
splice(@stack, 1, 0, 'x'); # insert at index 1Fatiamento de Array
@ slice retorna uma lista
my @nums = (10, 20, 30, 40, 50);
# Array slice (returns a list)
my @slice = @nums[1, 3]; # (20, 40)
my @range = @nums[0 .. 2]; # (10, 20, 30)
# Modify multiple elements via slice
@nums[1, 3] = (200, 400);
# Last index
my $last_idx = $#nums; # 4
# Negative indices count from the end
print $nums[-1]; # 50
print $nums[-2]; # 400Ordenação
<=> comparação numérica, cmp comparação de string
my @arr = (1, 2, 3, 4, 5);
# splice ARRAY, OFFSET, LENGTH, LIST
my @removed = splice(@arr, 1, 2); # removes (2, 3)
# @arr is now (1, 4, 5)
# Insert without removing (LENGTH = 0)
splice(@arr, 1, 0, 'a', 'b'); # (1, 'a', 'b', 4, 5)
# Replace elements
splice(@arr, 0, 2, 'x'); # replace first 2 with 'x'
# Remove everything from offset to end
my @rest = splice(@arr, 2);map e grep
map transforma, grep filtra
my @nums = (3, 1, 4, 1, 5, 9);
# Default sort is lexicographic (string)
my @s1 = sort @nums;
# Numeric ascending
my @s2 = sort { $a <=> $b } @nums;
# Numeric descending
my @desc = sort { $b <=> $a } @nums;
# String sort
my @words = qw(banana apple Cherry);
my @alpha = sort { lc($a) cmp lc($b) } @words;
# Schwartzian transform (sort by computed key)
my @sorted = map { $_->[0] }
sort { $a->[1] <=> $b->[1] }
map { [$_, length($_)] } @words;Comprimento do array e contexto escalar
O comportamento de um array depende do contexto: contexto escalar dá o comprimento; contexto de lista/string dá os elementos unidos por $" (espaço por padrão). Use scalar() para forçar contexto escalar quando necessário.
my @arr = (1, 2, 3, 4, 5);
# Scalar context returns length
my $len = @arr; # 5
print "Length: $len\n";
# String context joins with $"
print "Array: @arr\n"; # 1 2 3 4 5
# Change separator
local $" = ", ";
print "@arr\n"; # 1, 2, 3, 4, 5
# Last index
print "Last index: $#arr\n"; # 4
# Force scalar context
print scalar(@arr); # 5Hashes
Operações de Hash
o prefixo % denota um hash
my %ages = (Alice => 30, Bob => 25, Carol => 35);
# Fat comma => auto-quotes the left side
my %h2 = (name => 'Alice', age => 30);
# Same as list of pairs:
my %h3 = ('name', 'Alice', 'age', 30);
# Access / modify a value
print $ages{Alice}; # 30
$ages{Dave} = 40; # add
$ages{Alice} = 31; # modify
# Delete a key
delete $ages{Bob};Iterando Hashes
each/keys/values
my %h = (a => 1, b => 2, c => 3);
# Iterate keys
for my $k (keys %h) {
print "$k => $h{$k}\n";
}
# Get all values
my @vals = values %h;
# each() returns key/value pairs iteratively
while (my ($k, $v) = each %h) {
print "$k = $v\n";
}
# Sorted keys
for my $k (sort keys %h) { ... }Funções de Hash
exists/delete/keys/values
my %h = (name => 'Alice', age => 30);
# exists checks if a key is present
if (exists $h{name}) {
print "Name exists\n";
}
# defined checks if the value is defined
if (defined $h{age}) { ... }
# delete removes a key, returns its value
my $removed = delete $h{age};
# Delete multiple keys (slice)
delete @h{qw(name age)};
# Empty a hash
%h = ();Fatiamento de Hash
@ slice de hash
my %h = (a => 1, b => 2, c => 3);
# Hash slice (returns list of values)
my @vals = @h{qw(a b)}; # (1, 2)
# Modify slice
@h{qw(a b)} = (10, 20);
# Key/value slice (v5.20+)
my @pairs = %h{qw(a b)}; # (a, 10, b, 20)
# Index/value slice
my @iv = %h{qw(a b)};
# Check multiple keys
my @present = grep { exists $h{$_} } qw(a x b);Hashes Multidimensionais
Hashes Perl guardam valores escalares, então estruturas aninhadas usam referências de hash/array. A auto-vivification cria automaticamente referências intermediárias quando você atribui a uma chave profunda, o que é prático mas pode esconder bugs.
my %people = (
alice => { age => 30, city => 'NYC' },
bob => { age => 25, city => 'LA' },
);
# Access nested values
print $people{alice}{age}; # 30
print $people{bob}{city}; # LA
# Add new nested entry
$people{carol}{age} = 35;
$people{carol}{city} = 'SF';
# Auto-vivification creates intermediate refs
$people{dave}{hobbies}[0] = 'reading';
# %people{dave} created automaticallyOperações Comuns de Hash
scalar keys %h dá a contagem. reverse %h troca chaves/valores (com perda se os valores não forem únicos). Mesclar com (%a, %b) achata e depois reconstrói. List::Util fornece min/max sobre os valores.
my %h = (a => 1, b => 2, c => 3);
# Number of keys
my $count = scalar keys %h;
# Reverse a hash (values become keys)
my %rev = reverse %h; # (1 => a, 2 => b, 3 => c)
# Merge hashes
my %merged = (%h, d => 4);
# Check if empty
print "empty\n" if !keys %h;
# Reset each() iterator
keys %h; # resets iterator (v5.18+)
# Get min/max value
use List::Util qw(min max);
my ($min, $max) = (min(values %h), max(values %h));Referências
Criando Referências
\ cria uma referência, [] {} criam referências anônimas
my $score = 85;
if ($score >= 90) {
print "A\n";
} elsif ($score >= 80) {
print "B\n";
} elsif ($score >= 70) {
print "C\n";
} else {
print "F\n";
}
# Statement modifier form
print "Pass\n" if $score >= 60;
# Note: it is 'elsif', NOT 'elseif'Desreferenciamento
-> desreferenciamento por seta
my $logged_in = 0;
unless ($logged_in) {
print "Please log in\n";
}
# Equivalent: if (!$logged_in) { ... }
# Statement modifier
print "Error\n" unless $ok;
# unless/else (often avoid for readability)
unless ($ok) {
print "fail\n";
} else {
print "pass\n";
}Estruturas Aninhadas
A seta pode ser omitida entre subscritos adjacentes
# while loop
my $i = 0;
while ($i < 5) {
print "$i\n";
$i++;
}
# until = while NOT
my $done = 0;
until ($done) {
$done = check_something();
}
# do-while style (runs at least once)
my $n = 0;
do {
print $n++;
} while ($n < 3);
# Infinite loop
while (1) { last if $done; }Array de Referências de Array
Array bidimensional
# C-style for loop
for (my $i = 0; $i < 5; $i++) {
print "$i\n";
}
# foreach over a list (for and foreach are interchangeable)
foreach my $item (1, 2, 3) {
print "$item\n";
}
# Range operator
for my $n (1 .. 10) {
print "$n ";
}
# Uses default $_ variable
for (1 .. 5) {
print "$_\n";
}last/next/redo
last sai do loop (como break), next pula para a próxima iteração (como continue), redo reinicia a iteração atual sem reavaliar a condição. Labels permitem controlar loops externos.
# last = break out of loop
for my $i (1 .. 10) {
last if $i == 5;
print "$i ";
}
# prints: 1 2 3 4
# next = skip to next iteration
for my $i (1 .. 5) {
next if $i % 2 == 0;
print "$i "; # 1 3 5
}
# redo = re-run current iteration without re-checking
my $count = 0;
while (<$fh>) {
$count++;
redo if $count < 3;
}
# Labeled loops for nested control
OUTER: for my $i (1..3) {
for my $j (1..3) {
last OUTER if $i == 2 && $j == 2;
}
}given/when (switch)
given/when fornece semântica de switch/case usando smart matching. É experimental, então desative o aviso ou prefira cadeias explícitas if/elsif em código de produção. O match pode comparar com valores, arrays ou regexes.
use feature 'switch';
no warnings 'experimental::smartmatch';
my $val = 2;
given ($val) {
when (1) { print "one\n" }
when (2) { print "two\n" }
when ([3, 4]) { print "three or four\n" }
when (/^\d+$/) { print "a number\n" }
default { print "something else\n" }
}
# given/when is experimental; many prefer if/elsif
if ($val == 1) { print "one\n" }
elsif ($val == 2) { print "two\n" }Fluxo de Controle
if-elsif-else
elsif e não elseif
my $str = "Hello, World";
# =~ binding operator applies a regex
if ($str =~ /World/) {
print "Matched\n";
}
# Negated match
if ($str !~ /foo/) {
print "No foo\n";
}
# Case-insensitive with /i
if ($str =~ /hello/i) {
print "Found hello\n";
}
# Implicit match against $_
for ("cat", "dog", "bat") {
print "$_\n" if /at/; # cat, bat
}unless
unless é a negação de if
my $str = "Hello, World";
# Replace first occurrence
$str =~ s/World/Perl/; # Hello, Perl
# Replace all (g = global)
my $text = "a-b-c";
$text =~ s/-/_/g; # a_b_c
# Case-insensitive replace
$str =~ s/hello/hi/i;
# Evaluate replacement as code (e)
my $s = "2+3";
$s =~ s/(\d+)\+(\d+)/$1 + $2/e; # 5
# tr/// transliteration (character mapping)
my $dna = "ACGT";
$dna =~ tr/ACGT/TGCA/; # TGCAwhile e until
until é a negação de while
my $str = "2024-01-15";
# Numbered capture groups
if ($str =~ /(\d{4})-(\d{2})-(\d{2})/) {
print "Year: $1\n"; # 2024
print "Month: $2\n"; # 01
print "Day: $3\n"; # 15
}
# Named captures (v5.10+)
if ($str =~ /(?<year>\d{4})-(?<month>\d{2})/) {
print $+{year}; # 2024
print $+{month}; # 01
}
# Capture all matches globally
my @nums = ($str =~ /(\d+)/g); # (2024, 01, 15)for e foreach
for/foreach são intercambiáveis
# Quantifiers
/a/ # exactly one
/a?/ # 0 or 1
/a*/ # 0 or more
/a+/ # 1 or more
/a{3}/ # exactly 3
/a{2,4}/ # 2 to 4
/a{3,}/ # 3 or more
# Greedy vs non-greedy (lazy)
/a.*/ # greedy (matches as much as possible)
/a.*?/ # non-greedy (matches as little as possible)
# Anchors
/^start/ # beginning of string
/end$/ # end of string
/\bword\b/ # word boundary
/\A/ # absolute start of string
/\z/ # absolute end of stringlast e next
last=break, next=continue
# Predefined classes
/\d/ # digit [0-9]
/\D/ # non-digit
/\w/ # word char [a-zA-Z0-9_]
/\W/ # non-word char
/\s/ # whitespace
/\S/ # non-whitespace
/./ # any char except newline
# Custom classes
/[aeiou]/ # any vowel
/[^0-9]/ # NOT a digit
/[a-z]/i # case-insensitive range
# POSIX classes
/[[:alpha:]]/ # letters
/[[:digit:]]/ # digits
/[[:space:]]/ # whitespace
/[[:upper:]]/ # uppercasegiven-when
Similar a switch-case (experimental)
# Common modifiers
/abc/i # case-insensitive
/abc/g # global (all matches)
/abc/m # multiline (^/$ match line boundaries)
/abc/s # single-line (. matches newline)
/abc/x # extended (whitespace and comments)
# Extended mode for readability
my $re = qr{
^\d{4} # year
-
\d{2} # month
-
\d{2} # day
}x;
# qr// pre-compiles a regex
my $pattern = qr/\bword\b/i;
if ($str =~ $pattern) { ... }Sub-rotinas
Definindo Sub-rotinas
@_ é o array de argumentos
my $s = "Hello, World";
# length
print length($s); # 12
# substr STRING, OFFSET, LENGTH, REPLACEMENT
print substr($s, 0, 5); # Hello
print substr($s, 7); # World
print substr($s, -5); # World (negative offset)
# 4-argument substr (replace in place)
my $str = "Hello, World";
substr($str, 0, 5) = "Hi"; # Hi, World
# Lvalue form modifies original
substr($s, 0, 1) = "J";Desestruturação de Argumentos
my ($a, $b) = @_ desestrutura argumentos
my $s = "Hello, World";
# index STRING, SUBSTR, POSITION
my $pos = index($s, "World"); # 7
my $pos2 = index($s, "o"); # 4 (first)
my $pos3 = index($s, "o", 5); # 8 (from position 5)
my $not = index($s, "xyz"); # -1 (not found)
# rindex searches from the end
my $last = rindex($s, "o"); # 8
# Count occurrences of 'l'
my $count = 0;
my $p = 0;
while (($p = index($s, "l", $p)) >= 0) {
$count++;
$p++;
}Argumentos Variádicos
@_ contém todos os argumentos
my $line = "Hello\n";
# chomp removes the line terminator (safe)
chomp $line; # $line = "Hello", returns 1
# chomp a whole array at once
my @lines = ("a\n", "b\n", "c\n");
chomp @lines; # removes \n from all
# chop removes the last character (any char, risky)
my $s = "abc";
chop $s; # "ab"
# chomp returns the count removed
my $cnt = chomp(my $x = "test\n"); # $cnt = 1
# chop returns the removed character
my $c = chop my $y = "xyz"; # $c = 'z'Valores de Retorno
Pode retornar múltiplos valores (lista)
# split /PATTERN/, EXPR, LIMIT
my @parts = split /,/, "a,b,c"; # (a, b, c)
my @lim = split /,/, "a,b,c", 2; # (a, "b,c")
# Split on whitespace
my @words = split /\s+/, "one two three";
# Split into characters
my @chars = split //, "abc"; # (a, b, c)
# join SEPARATOR, LIST
my $csv = join(",", "a", "b", "c"); # a,b,c
my $str = join(" - ", @parts);
# Empty separator joins without delimiter
my $joined = join("", @chars); # abcReferências de Sub-rotina
Sub-rotina anônima
my $s = "Hello World";
print lc($s); # hello world
print uc($s); # HELLO WORLD
print lcfirst($s); # hello World
print ucfirst($s); # Hello World (already capped)
# In-string case modifiers (\L \U \u \l \E)
my $name = "Alice";
print "\L$name\E"; # alice (\L starts, \E ends)
print "\U$name\E"; # ALICE
print "\u$name"; # Alice (capitalize first char)
print "\l$name"; # alice (lowercase first char)
# Title-case each word via regex
$s =~ s/(\w+)/\u\L$1/g; # Hello Worldsprintf e printf
printf imprime texto formatado; sprintf o retorna. Especificadores de formato: %s string, %d inteiro, %f float, %x hex, %o octal, %b binário. Largura e precisão controlam o preenchimento: %5d, %05d, %.2f.
# printf FORMAT, LIST (prints)
printf "Name: %s, Age: %d\n", "Alice", 30;
printf "Pi: %.2f\n", 3.14159; # 3.14
printf "%5d\n", 42; # ' 42' (right-aligned)
printf "%-5d|\n", 42; # '42 |' (left-aligned)
printf "%05d\n", 42; # '00042' (zero-padded)
# sprintf returns the formatted string
my $date = sprintf("%04d-%02d-%02d", 2024, 1, 15);
# "2024-01-15"
# Common specifiers: %s %d %f %x %o %b %%
printf "Hex: %x, Oct: %o, Bin: %b\n", 255, 8, 5;Expressões Regulares
Correspondência Básica
operador de vinculação =~
sub greet {
my $name = shift; # default: shifts from @_
print "Hello, $name!\n";
}
greet("Alice"); # Hello, Alice!
# Subs are global by default
sub add {
my ($a, $b) = @_; # unpack arguments
return $a + $b;
}
print add(2, 3); # 5
# Forward declaration (define later)
sub compute;
print compute(4);Captura
$1 $2 ou $+{name}
sub sum {
my $total = 0;
$total += $_ for @_; # iterate all args
return $total;
}
print sum(1, 2, 3, 4); # 10
# Named arguments via hash
sub info {
my %args = @_;
print "Name: $args{name}\n";
print "Age: $args{age}\n";
}
info(name => "Alice", age => 30);
# Pass arrays/hashes by reference
sub total {
my $arr = shift;
my $sum = 0;
$sum += $_ for @$arr;
return $sum;
}Substituição
substituição s///, transliteração tr///
# Single return value
sub square { return $_[0] ** 2; }
# Return a list
sub min_max {
my @nums = @_;
my ($min, $max) = ($nums[0], $nums[0]);
for (@nums) {
$min = $_ if $_ < $min;
$max = $_ if $_ > $max;
}
return ($min, $max);
}
my ($lo, $hi) = min_max(3, 1, 4, 1, 5);
# Implicit return (last expression)
sub name { "Alice" } # returns "Alice"
# Void context (no return needed)
sub log_msg { print "log: $_[0]\n"; }Quantificadores de Regex
Quantificadores de regex
sub get_data {
if (wantarray) {
return (1, 2, 3); # list context
} elsif (defined wantarray) {
return "scalar"; # scalar context
} else {
return; # void context
}
}
my @list = get_data(); # (1, 2, 3)
my $scalar = get_data(); # "scalar"
get_data(); # void
# localtime is context-sensitive
my $t = localtime(); # scalar: "Mon Jan 1 12:00:00 2024"
my @t = localtime(); # list: (sec, min, hour, mday, ...)
# scalar() forces scalar context
print scalar(localtime());Classes de Caracteres
Classes de caracteres predefinidas e personalizadas
# Anonymous sub (coderef)
my $greet = sub {
my $name = shift;
return "Hi, $name";
};
print $greet->("Alice"); # Hi, Alice (preferred)
print &$greet("Bob"); # older syntax
# Closure: captures outer variable
sub make_counter {
my $count = 0;
return sub { return ++$count; };
}
my $c = make_counter();
print $c->(); # 1
print $c->(); # 2 (count persists)
# Pass subs as arguments
sub apply { my ($f, $x) = @_; return $f->($x); }
print apply(sub { $_ * 2 }, 21); # 42Argumentos Nomeados e Padrões
Colete argumentos nomeados num hash e aplique padrões com //= (defined-or). Você pode misturar argumentos posicionais e nomeados colocando o hash por último. Retornar uma referência é comum para pacotes de opções.
sub create_user {
my %args = @_;
# Apply defaults with defined-or
$args{role} //= 'user';
$args{active} //= 1;
return \%args;
}
my $user = create_user(
name => 'Alice',
email => '[email protected]',
);
print $user->{role}; # user (default applied)
# Mix positional + named (named must come last)
sub point {
my ($x, $y, %opts) = @_;
print "($x, $y) color=$opts{color}\n";
}
point(1, 2, color => 'red');Funções de String
Operações de String
Conversão de maiúsculas e minúsculas
# 3-argument open (recommended)
open(my $fh, '<', 'input.txt')
or die "Cannot open input.txt: $!";
# Read the whole file
my @lines = <$fh>;
close $fh;
# Modes: < read, > write (truncate), >> append,
# +< read/write, +> read/write (truncate)
open(my $out, '>', 'output.txt')
or die "Cannot write: $!";
open(my $app, '>>', 'log.txt')
or die "Cannot append: $!";Substring
substr pode ser usado para substituição
open(my $fh, '<', 'file.txt') or die $!;
# Line by line (memory efficient)
while (my $line = <$fh>) {
chomp $line;
print "Read: $line\n";
}
# Slurp entire file (undef the record separator)
local $/;
my $content = <$fh>;
# Read all lines into an array
my @lines = <$fh>;
close $fh;
# $. holds the current line number
open(my $f2, '<', 'file.txt') or die $!;
while (<$f2>) { print "$.: $_"; }Dividir e Juntar
split/join
open(my $fh, '>', 'out.txt') or die $!;
print $fh "Hello, File!\n";
print $fh "Second line\n";
# Formatted write
printf $fh "%d: %s\n", 1, "first";
# Autoflush (no buffering)
use IO::Handle;
$fh->autoflush(1);
# Or via select
my $old = select($fh); $| = 1; select($old);
close $fh; # flushes and closesBuscar
index/rindex/sprintf
# <> reads from files in @ARGV, or STDIN if none
while (<>) {
print "$.: $_";
}
# Equivalent to: while (my $line = <ARGV>) { ... }
# Read all of stdin (or all arg files)
my @input = <>;
# Specify files programmatically
@ARGV = ('file1.txt', 'file2.txt');
while (<>) {
chomp;
print ">> $_\n";
}
# In-place editing
$^I = '.bak'; # backup extension
while (<>) { s/foo/bar/g; print; }chomp e chop
chomp remove nova linha, chop remove o último caractere
# Lexical filehandle (modern, recommended)
open(my $fh, '<', $file) or die $!;
# Bareword filehandle (legacy, avoid)
open(IN, '<', $file) or die $!;
my $line = <IN>;
close IN;
# Standard handles: STDIN, STDOUT, STDERR
print STDOUT "to stdout\n";
my $err = <STDIN>;
warn "to stderr\n"; # STDERR is unbuffered
# Duplicate a handle
open(my $log, '>&', STDERR) or die $!;
# Open a filehandle to a string (in-memory)
open(my $mem, '>', \my $buffer) or die $!;
print $mem "stored\n";File::Slurper
File::Slurper é a forma moderna e eficiente de ler/escrever arquivos inteiros. Ele trata codificações e binmode corretamente, diferentemente de código de slurp feito à mão. Prefira-o a do { local $/; <$fh> } em código novo.
use File::Slurper qw(read_text write_text append_text read_lines);
# Read entire file as a string
my $text = read_text('file.txt');
# Write a string to a file
write_text('out.txt', "Hello\n");
# Append to a file
append_text('log.txt', "New entry\n");
# Read all lines (without newlines by default)
my @lines = read_lines('data.csv');
# Binary files
use File::Slurper qw(read_binary write_binary);
my $bytes = read_binary('image.png');
write_binary('copy.png', $bytes);E/S de Arquivo
Abrir Arquivo
$! é a mensagem de erro do sistema
opendir(my $dh, '.') or die "Cannot open dir: $!";
while (my $entry = readdir($dh)) {
next if $entry =~ /^\./; # skip dotfiles
print "$entry\n";
}
# Or get all entries at once
rewinddir($dh);
my @entries = readdir($dh);
closedir $dh;
# Filter to only subdirectories
opendir(my $d, '.') or die $!;
my @dirs = grep { -d $_ } readdir($d);
closedir $d;Escrever em Arquivo
> sobrescreve, >> anexa
# glob expands filename wildcards
my @files = glob('*.txt');
my @perl = glob('*.pl *.pm');
# Angle-bracket form (legacy)
my @same = <*.txt>;
# With a path
my @logs = glob('/var/log/*.log');
# Recursive globbing
use File::Glob qw(:bsd_glob);
my @all = bsd_glob('**/*.pm'); # needs :bsd_glob
# Capture flags: GLOB_ERR, GLOB_MARK (trailing / on dirs)
my @marked = bsd_glob('*', GLOB_MARK);Operador Diamante
operador diamante <>
# Create a directory (default perms modified by umask)
mkdir 'newdir' or die $!;
mkdir 'newdir', 0755; # explicit permissions
# Create nested directories
use File::Path qw(make_path remove_tree);
make_path('a/b/c');
make_path('x/y', { mode => 0755 });
# Remove a directory (must be empty)
rmdir 'emptydir' or die $!;
# Remove recursively
remove_tree('a');
# Change working directory
chdir '/tmp' or die $!;
# Get current directory
use Cwd qw(getcwd);
print getcwd();Testes de Arquivo
Operadores de teste de arquivo
use File::Find;
my @found;
find(sub {
return if -d; # skip directories
push @found, $File::Find::name
if /\.pm\z/;
}, '.');
# finddepth visits directories after their contents
finddepth(sub {
unlink $_ if -f and -M $_ > 30; # delete old files
}, '/tmp/old');
# Multiple starting directories
find(\&wanted, qw(src lib t));
sub wanted {
my $path = $File::Find::name;
print "$path\n" if -f $path;
}File::Slurper
Módulo moderno de leitura/escrita de arquivo
use Path::Tiny;
# Create a path object
my $path = path('/tmp/test.txt');
# File operations
$path->touch;
$path->spew("content\n");
my $content = $path->slurp;
my @lines = $path->lines;
# Path manipulations
my $parent = $path->parent;
my $child = $path->child('sub.txt');
my $abs = $path->absolute;
my $rel = $abs->relative('/tmp');
# Iterate directory contents
for my $f (path('.')->children) {
print $f, "\n" if $f->is_file;
}File::Copy e unlink
File::Copy fornece copy e move entre sistemas de arquivos. File::Spec constrói caminhos portáveis sem separadores fixados no código. unlink deleta arquivos (retorna a quantidade removida); não pode deletar diretórios.
use File::Copy qw(copy move);
# Copy a file
copy('src.txt', 'dst.txt') or die $!;
copy('src.txt', 'dst.txt', 8192); # buffer size
# Move / rename
move('old.txt', 'new.txt') or die $!;
# Portable paths via File::Spec
use File::Spec;
my $path = File::Spec->catfile('dir', 'file.txt');
my ($vol, $dir, $file) = File::Spec->splitpath($path);
# Delete files
unlink qw(a.txt b.txt c.txt);
my $removed = unlink grep { -f } glob('*.tmp');Diretórios
Abrir Diretório
readdir lê entradas de diretório
my $scalar = 42;
my @arr = (1, 2, 3);
my %h = (a => 1);
# Backslash creates a reference
my $sref = \$scalar;
my $aref = \@arr;
my $href = \%h;
my $cref = \&some_sub;
# Check what a reference points to
print ref($aref); # ARRAY
print ref($href); # HASH
print ref($sref); # SCALAR
print ref($cref); # CODE
# A non-reference returns ''
print ref("hi"); # (empty string)glob
curinga de nome de arquivo glob
my $aref = [1, 2, 3];
my $href = { a => 1, b => 2 };
# Whole array
my @arr = @$aref; # or @{ $aref }
my $len = scalar @$aref;
# Single element via arrow
print $aref->[0]; # 1
print $#$aref; # last index (2)
# Whole hash
my %h = %$href;
my @keys = keys %$href;
# Single value via arrow
print $href->{a}; # 1
# Block form for clarity
my @arr2 = @{ $aref };Operações de Diretório
Operações de diretório e arquivo
# Anonymous array reference: [ ]
my $arr = [1, 2, 3];
print $arr->[0]; # 1
# Anonymous hash reference: { }
my $h = { name => 'Alice', age => 30 };
print $h->{name};
# Nested anonymous structures
my $data = {
users => [ { name => 'a' }, { name => 'b' } ],
count => 2,
};
# Anonymous subroutine
my $code = sub { print "hi\n" };File::Find
Percorre recursivamente a árvore de diretórios
# Array of arrays (2D)
my $matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
];
print $matrix->[1][2]; # 6 (second arrow optional)
# Hash of hashes
my $config = {
db => { host => 'localhost', port => 3306 },
app => { name => 'MyApp', debug => 1 },
};
print $config->{db}{host}; # localhost
# Auto-vivification creates intermediate refs
my %tree;
$tree{a}{b}{c} = 1; # builds the path automaticallyOperador Seta
A seta -> desreferencia: $ref->[idx] para arrays, $ref->{key} para hashes, $ref->() para código, $obj->method para objetos. Entre subscritos consecutivos a seta é opcional, por legibilidade.
my $arr = [[1, 2], [3, 4]];
my $h = { users => [{ name => 'a' }] };
# Arrow between subscripts (second is optional)
print $arr->[0][1]; # 2
print $h->{users}[0]{name}; # a
# Arrow for coderef calls
my $greet = sub { "hi $_[0]" };
print $greet->("Bob"); # hi Bob
# Method calls on objects
$obj->method($arg);
# Slicing a dereferenced array
my @vals = @{ $h->{users} };Tipos de Referência
ref() retorna o nome da classe para referências blessed (objetos), o que pode esconder o tipo subjacente. Scalar::Util::reftype() sempre retorna o tipo estrutural real. Use weaken() para quebrar ciclos de referência.
use Scalar::Util qw(reftype weaken);
my $aref = [];
my $href = {};
my $cref = sub {};
print ref($aref); # ARRAY
print reftype($aref); # ARRAY
# A blessed reference (object)
my $obj = bless {}, 'MyClass';
print ref($obj); # MyClass
print reftype($obj); # HASH (the underlying type)
# Type checks
if (ref($r) eq 'ARRAY') { ... }
if (ref($r) eq 'HASH') { ... }
# weaken avoids circular-reference memory leaks
weaken($r);Formatos
Definir Formato
format define o formato de saída
# use: runs at compile time, calls the module's import()
use strict;
use warnings;
use Data::Dumper;
# require: runs at runtime, does NOT call import()
require MyModule;
# Conditional loading (runtime)
if ($DEBUG) {
require Carp;
Carp->import('confess');
}
# use with version and import list
use v5.36;
use List::Util 1.33 qw(first sum max);
# use MODULE VERSION LIST
use Data::Dumper qw(Dumper);Especificadores de Formato
Especificadores de campo de formato
# Add directories to the module search path
use lib '/home/me/lib';
use lib 'lib', 'local/lib';
# Locate a path relative to the script
use FindBin;
use lib "$FindBin::Bin/lib";
# Inspect the search path
print join("\n", @INC);
# Add at runtime (then require)
push @INC, '/path/to/lib';
require MyModule;
# Remove an entry
@INC = grep { !/local/ } @INC;Exporter
Exporter controla o que um módulo expõe. @EXPORT força exportações (geralmente desencorajado); @EXPORT_OK deixa quem chama optar por elas (preferido). %EXPORT_TAGS agrupa exportações para importação prática, como ':all'.
package MyModule;
use parent 'Exporter';
our @EXPORT = qw(func1); # exported by default
our @EXPORT_OK = qw(func2 func3); # exported on request
our %EXPORT_TAGS = (
all => [qw(func1 func2 func3)],
);
sub func1 { return "one"; }
sub func2 { return "two"; }
sub func3 { return "three"; }
1; # a module must return a true value
# Usage in another file:
# use MyModule; # gets func1
# use MyModule qw(func2); # gets func2 only
# use MyModule ':all'; # gets all threeBEGIN e END
Blocos BEGIN rodam em tempo de compilação (útil para configuração que precisa acontecer antes do resto compilar). Blocos END rodam na saída do programa (para limpeza). CHECK e INIT rodam entre compilação e execução.
# BEGIN runs at compile time
BEGIN {
print "Compiled\n";
require MyModule;
}
# END runs at exit (in LIFO order)
END {
print "Cleaning up\n";
}
# Other phases: UNITCHECK, CHECK, INIT
INIT { print "Running\n"; }
# Compile-time constant definition
use constant DEBUG => 1;
# BEGIN to push a custom lib path early
BEGIN { push @INC, '/custom' }package
package declara um namespace. Um arquivo de módulo (MyModule.pm) geralmente contém um package com o mesmo nome. O arquivo deve terminar com um valor verdadeiro (1;) para que 'use' saiba que carregou com sucesso.
package MyModule;
use strict;
use warnings;
our $VERSION = '1.00';
sub new {
my $class = shift;
return bless {}, $class;
}
sub method {
my $self = shift;
return "called";
}
1; # required: modules must return a true value
# Switch back to the main package
package main;
my $obj = MyModule->new;
print $obj->method;Constantes
use constant cria constantes inlináveis (sem sigil). Readonly e Const::Fast oferecem escalares/arrays/hashes imutáveis com escopo léxico. Constantes são, na verdade, subs com protótipo (), o que permite inliná-las.
# use constant (compile-time)
use constant {
PI => 3.14159,
MAX => 100,
DEBUG => 0,
};
print PI; # 3.14159
# Readonly (lexically scoped, immutable)
use Readonly;
Readonly my $NAME => 'Alice';
# Const::Fast
use Const::Fast;
const my $count => 5;
# A constant is just a sub with an empty prototype
sub MAX_CONNECTIONS () { 10 }
print MAX_CONNECTIONS; # 10Pacotes
Definir Pacote
package declara um namespace
package Animal;
use strict;
use warnings;
sub new {
my ($class, %args) = @_;
my $self = { name => $args{name}, sound => 'generic' };
return bless $self, $class;
}
sub name { shift->{name} }
1;
# bless associates a reference with a package (the class).
# $self is a hash ref blessed into Animal.Usando Pacotes
use carrega e importa
package Point;
use strict;
use warnings;
sub new {
my ($class, $x, $y) = @_;
my $self = { x => $x, y => $y };
return bless $self, $class;
}
# Usage (arrow syntax preferred)
my $p = Point->new(3, 4);
# Indirect syntax ( discouraged)
my $p2 = new Point(3, 4);
# Named-argument constructor
sub new_named {
my ($class, %args) = @_;
return bless \%args, $class;
}Exporter
Exporter controla exportações
package Point;
sub new { ... }
# Instance method: first arg is the object
sub distance {
my ($self, $other) = @_;
my $dx = $self->{x} - $other->{x};
my $dy = $self->{y} - $other->{y};
return sqrt($dx**2 + $dy**2);
}
# Getter
sub x { my $self = shift; return $self->{x}; }
# Setter (chainable)
sub set_x {
my ($self, $x) = @_;
$self->{x} = $x;
return $self;
}
# Class method
sub count { our $count; return ++$count }Herança (use parent)
use parent define @ISA de forma limpa e chama o import do pai. Use SUPER::method para chamar uma função do pai sobrescrita. Herança múltipla é suportada, mas a ordem de resolução de chamadas (MRO) pode ser sutil; use mro::get_linear_isa para inspecionar.
package Dog;
use parent 'Animal';
sub new {
my ($class, %args) = @_;
my $self = $class->SUPER::new(%args); # call parent
$self->{breed} = $args{breed};
return $self;
}
sub speak {
my $self = shift;
return "Woof!";
}
# Direct @ISA (lower-level)
package Cat;
our @ISA = ('Animal');
# Multiple inheritance
package Duck;
use parent qw(Flyable Animal);Accessors
Você pode escrever accessors à mão (uma sub cuida de get e set). Módulos como Class::Accessor, Class::Tiny, Moo ou Moose os geram, reduzindo código repetitivo. A escolha depende do seu orçamento de dependências.
# Hand-written accessor (getter + setter)
sub name {
my $self = shift;
if (@_) { $self->{name} = shift; return $self; }
return $self->{name};
}
# Class::Accessor generates them
package User;
use parent 'Class::Accessor';
__PACKAGE__->mk_accessors(qw(name email age));
# Usage
my $u = User->new({ name => 'Alice' });
$u->name; # get
$u->name('Bob'); # set
# Moo / Moose generate accessors declaratively
has name => (is => 'rw');DESTROY e AUTOLOAD
DESTROY é chamada automaticamente quando a contagem de referências de um objeto chega a zero (use para limpeza, como fechar handles). AUTOLOAD intercepta chamadas a funções indefinidas, permitindo accessors dinâmicos ou delegação, mas use com moderação.
package FileHandle::Custom;
sub new {
my ($class, $file) = @_;
open(my $fh, '<', $file) or die $!;
return bless { fh => $fh }, $class;
}
sub DESTROY {
my $self = shift;
close $self->{fh} if $self->{fh};
# auto-called when refcount reaches 0
}
# AUTOLOAD catches undefined method calls
sub AUTOLOAD {
my $self = shift;
our $AUTOLOAD;
my $method = $AUTOLOAD;
$method =~ s/.*:://;
return $self->{$method}; # treat as accessor
}Módulos
Carregando Módulos
use vs require
my $f = 'file.txt';
print "exists\n" if -e $f; # exists
print "regular\n" if -f $f; # plain file
print "dir\n" if -d $f; # directory
print "symlink\n" if -l $f; # symbolic link
print "socket\n" if -S $f; # socket
print "pipe\n" if -p $f; # named pipe (FIFO)
print "char dev\n" if -c $f; # character device
print "block dev\n" if -b $f; # block device
# Stack tests (uses the same stat cache)
print "regular file\n" if -f -e $f;
# _ reuses the last stat result
print "size: ", -s _ if -e $f;Caminho de Módulo
use lib adiciona caminho de busca
my $f = 'script.pl';
print "readable\n" if -r $f; # effective uid can read
print "writable\n" if -w $f; # effective uid can write
print "executable\n" if -x $f; # effective uid can exec
print "owned\n" if -o $f; # owned by effective uid
# Real uid variants (rarely needed)
print "real read\n" if -R $f;
print "real write\n" if -W $f;
print "real exec\n" if -X $f;
# setuid / setgid / sticky
print "setuid\n" if -u $f;
print "setgid\n" if -g $f;
print "sticky\n" if -k $f;Módulos CPAN
cpanm instala módulos CPAN
my $f = 'data.bin';
# -s returns size in bytes (or undef if missing)
my $size = -s $f;
print "Size: $size bytes\n";
# Empty file
if (-z $f) { print "empty\n"; }
# Non-empty (size > 0)
if (-s $f) { print "has data\n"; }
# Human-readable size
use Number::Bytes::Human qw(format_bytes);
print format_bytes(-s $f), "\n";
# stat() for full detail
my @st = stat($f);
print "Size: $st[7] bytes\n"; # index 7 is sizeTempo (-M/-A/-C)
-M, -A, -C retornam a idade do arquivo em dias relativa a $^T (o horário de início do script), então valores são positivos para arquivos mais antigos. Para segundos desde a época, use stat() índices 9 (mtime), 8 (atime), 10 (ctime).
my $f = 'file.txt';
# All return age in days since script start ($^T)
print -M $f; # modification age (days)
print -A $f; # access age (days)
print -C $f; # inode-change age (days)
# Older than 30 days?
if (-M $f > 30) { print "old file\n"; }
# Modified today?
if (-M $f < 1) { print "modified today\n"; }
# Epoch seconds via stat
my @st = stat($f);
my $mtime = $st[9]; # mtime (epoch)
my $atime = $st[8]; # atime (epoch)
my $ctime = $st[10]; # ctime (epoch)Texto/Binário (-T/-B)
-T/-B adivinham texto vs binário heuristicamente, examinando os primeiros bytes (bytes nulos, caracteres de controle). Arquivos vazios contam como texto. Para tipos MIME reais, use um módulo como File::MimeInfo::Magic.
my $f = 'file.txt';
# -T text file, -B binary file
if (-T $f) { print "text\n"; }
if (-B $f) { print "binary\n"; }
# Perl heuristically decides from the first block
# Filter a directory to text files only
opendir(my $dh, '.');
my @text_files = grep { -f && -T } readdir($dh);
closedir $dh;
# Note: empty files count as text
# Proper MIME detection
use File::MimeInfo::Magic;
print mimetype($f);stat e lstat
stat() retorna 13 campos; os mais usados são tamanho (7), modo (2), mtime (9). lstat() é como stat, mas não segue symlinks (então você pode inspecionar o próprio link). O operador _ reutiliza o resultado em cache para testes encadeados.
my $f = 'file.txt';
# stat returns a 13-element list
my @s = stat($f);
# 0 dev, 1 ino, 2 mode, 3 nlink, 4 uid, 5 gid,
# 6 rdev, 7 size, 8 atime, 9 mtime, 10 ctime,
# 11 blksize, 12 blocks
my $size = $s[7];
my $perms = sprintf "%04o", $s[2] & 07777;
# lstat does NOT follow symlinks
my @ls = lstat($f);
# stat on an open filehandle
my @sf = stat($fh);
# _ reuses the last stat result (no new syscall)
print -s _ if -e $f;POO
POO Tradicional
bless associa uma referência a um pacote
# Install a module from the command line:
# cpanm DBI
# cpanm Mojolicious
# cpanm --interactive Module::Name
# Install a specific version range
# cpanm DBI~">=1.6"
# Install from a git repository
# cpanm https://github.com/user/Mod.git
# Install dependencies from a cpanfile
# cpanm --installdeps .
# Install into a local directory
# cpanm -l extlib DBI
# Verbose output
# cpanm -v DBIInvocação de Método
-> sintaxe de invocação de método
# cpanfile declares runtime and test dependencies
requires 'perl', '5.014';
requires 'DBI' => '1.6';
requires 'Mojolicious' => '9.0';
# Phase-specific dependencies
on develop => sub {
requires 'Test::Pod';
requires 'Test::Perl::Critic';
};
on test => sub {
requires 'Test::More' => '0.98';
requires 'Test::Exception';
};
recommends 'JSON::XS';
conflicts 'Old::Module';Herança
use parent declara herança
# Carton manages a locked dependency tree
# Install Carton: cpanm Carton
# Commands (shell):
# carton install # install from cpanfile
# carton install DBI # add a module
# carton exec ./app.pl # run with local deps
# carton bundle # vendor tarballs
# carton show # list installed
# cpanfile.snapshot locks exact versions
# local/ holds the installed modules
# In your code, ensure the lib path:
use lib 'local/lib/perl5';
use DBI;Acessores
Implementar manualmente getter/setter
# Install into a local directory
# cpanm -l extlib DBI
# Then use it in your script:
use lib 'extlib/lib/perl5';
use DBI;
# Bootstrap local::lib
# cpanm --local-lib=~/perl5 local::lib
use local::lib '~/perl5';
# Find a module's installed path
use Module::Util qw(module_path);
my $path = module_path('DBI');
# Check an installed version from the CLI:
# perl -MDBI -e 'print $DBI::VERSION'perlbrew
perlbrew permite instalar e alternar entre várias versões do Perl no seu diretório home sem tocar no Perl do sistema. 'perlbrew use' define o perl para o shell atual; 'switch' define o padrão.
# App::perlbrew manages multiple perl installations
# Shell commands:
# perlbrew init
# perlbrew install perl-5.38.0
# perlbrew switch perl-5.38.0
# perlbrew use perl-5.36.0
# perlbrew list
# perlbrew install-cpanm
# Install a CPAN module into a specific perl
# perlbrew exec --with perl-5.38 cpanm DBI
# Use a specific perl in a script's shebang:
# #!/home/user/perl5/perlbrew/perls/perl-5.38/bin/perl
use v5.38;
use strict;
use warnings;Local::lib
local::lib configura variáveis de ambiente (PATH, PERL5LIB, etc.) para que os módulos sejam instalados num diretório privado sem root. Use 'use local::lib' em scripts ou avalie a linha de bootstrap no arquivo rc do seu shell.
# Bootstrap local::lib (shell):
# cpanm --local-lib=~/perl5 local::lib
# In your script, use the local library:
use local::lib;
# Or specify a path explicitly
use local::lib '/path/to/libs';
# Set up environment in your shell rc:
# eval "$(perl -I$HOME/perl5/lib/perl5 -Mlocal::lib)"
# Verify @INC includes your local path
print "$_\n" for @INC;
# Now install modules locally:
# cpanm -l ~/perl5 Some::ModuleMoose
Classe Moose
Moose é um framework moderno de POO para Perl
# die throws an exception
open(my $fh, '<', 'missing.txt')
or die "Cannot open: $!"; # $! is the system error
# A trailing newline suppresses "at file line N"
die "Custom error\n";
# die with a reference (object exception)
die MyException->new(message => 'oops');
# Default die appends location info
die "Something bad happened";
# prints: Something bad happened at script.pl line 3.Criando Objetos
rw leitura-escrita, ro somente leitura
# warn prints to STDERR but continues
warn "This is a warning: $!";
# Trailing newline omits location
warn "Just a note\n";
# Disable a warning category locally
{
no warnings 'uninitialized';
print $undefined; # no warning
}
# Custom __WARN__ handler
$SIG{__WARN__} = sub {
my $msg = shift;
log_warning($msg);
print STDERR $msg;
};Restrições de Tipo
isa especifica o tipo
# eval BLOCK (modern, recommended)
eval {
risky_operation();
die "failed";
};
if ($@) {
print "Caught: $@\n";
}
# eval STRING parses and runs code (avoid; slow & unsafe)
eval '\$x = 1 + 2';
# eval returns the last expression on success
my $result = eval { compute() };
my $error = $@; # check immediately
# Always check $@ right after eval
# (or use Try::Tiny for safety)Herança Moose
extends para herança, override para sobrescrita
# $@ - the last eval error
eval { die "boom" };
print $@ if $@;
# $! - errno (system errors)
open(my $fh, '<', 'x') or die "open: $!";
# $! in numeric vs string context
print int($!); # errno number (e.g. 2)
print "$!"; # error string (e.g. "No such file")
# $? - child process status
system("ls");
print $? >> 8; # exit code
# $^E - extended error (platform-specific)
print $^E;Roles Moose
Role é similar a interface/Mixin
use Try::Tiny;
try {
risky_code();
die "explicit fail";
} catch {
warn "caught: $_"; # $_ is the error, not $@
} finally {
cleanup(); # always runs
};
# Return value flows through
my $val = try {
compute_value();
} catch {
default_value();
};
# Note: inside catch use $_, not $@Exceções Personalizadas
die pode lançar uma referência (objeto) em vez de uma string. Sobrecarregue a stringificação para que o objeto seja impresso de forma agradável. Verifique o tipo com ref/isa. Exception::Class fornece uma hierarquia de exceções mais completa, com campos.
package MyException;
use overload '""' => sub { $_[0]->{message} };
sub new {
my ($class, %args) = @_;
return bless { message => $args{message} }, $class;
}
1;
# Usage
eval {
die MyException->new(message => 'Custom error');
};
if (ref($@) && ref($@)->isa('MyException')) {
print "Custom: $@\n";
}
# Or use Exception::Class for richer features
use Exception::Class ('MyEx' => { fields => ['detail'] });
MyEx->throw(detail => 'something');Exceções
die para Lançar
die lança uma exceção
use DBI;
my $dbh = DBI->connect(
'DBI:mysql:database=test;host=localhost',
'user', 'password',
{ RaiseError => 1, AutoCommit => 1 }
) or die "Connect failed: $DBI::errstr";
# Always disconnect when done
$dbh->disconnect;
# Other drivers
# DBI:mysql: DBI:Pg: DBI:SQLite: DBI:Oracle:
my $sqlite = DBI->connect('DBI:SQLite:dbname=test.db');
eval para Capturar
bloco eval captura exceções, $@ armazena o erro
my $sth = $dbh->prepare('SELECT id, name FROM users WHERE age > ?');
$sth->execute(18);
# Fetch one row at a time as an array
while (my @row = $sth->fetchrow_array) {
print "id=$row[0], name=$row[1]\n";
}
# Fetch as a hashref
while (my $row = $sth->fetchrow_hashref) {
print $row->{name}, "\n";
}
# Fetch all rows
my $rows = $sth->fetchall_arrayref;
$sth->finish; # release statement handle earlyTry::Tiny
Try::Tiny fornece sintaxe mais limpa
# All rows as an array of arrays
my $rows = $dbh->selectall_arrayref('SELECT * FROM users');
# All rows keyed by a column
my $by_id = $dbh->selectall_hashref(
'SELECT * FROM users', 'id'
);
# Single value
my $count = $dbh->selectrow_array('SELECT COUNT(*) FROM users');
# Single row as a hash
my $row = $dbh->selectrow_hashref(
'SELECT * FROM users WHERE id = ?', undef, 5
);Exceção Personalizada
Sobrecarregar stringificação
# Disable AutoCommit to begin a transaction
$dbh->{AutoCommit} = 0;
eval {
$dbh->do('INSERT INTO accounts ...');
$dbh->do('UPDATE accounts SET balance = ...');
$dbh->commit;
};
if ($@) {
$dbh->rollback;
die "Transaction failed: $@";
}
# begin_work is cleaner (auto-resets AutoCommit)
$dbh->begin_work;
eval { ...; $dbh->commit; };
$dbh->rollback if $@;Placeholders
Placeholders (?) separam a estrutura SQL dos dados, prevenindo SQL injection e permitindo reuso da instrução. Nunca interpole valores em strings SQL. quote() escapa um valor, mas placeholders são mais limpos e geralmente mais rápidos.
# ALWAYS use placeholders to prevent SQL injection
my $sth = $dbh->prepare(
'INSERT INTO users (name, age) VALUES (?, ?)'
);
$sth->execute('Alice', 30);
$sth->execute('Bob', 25);
# Named placeholders (some drivers)
# :name, :age
$dbh->do('INSERT ... VALUES (:name, :age)', undef,
{ name => 'Alice', age => 30 });
# Bulk insert
my @rows = (['a', 1], ['b', 2]);
$sth->execute(@$_) for @rows;
# quote() exists but prefer placeholders
my $q = $dbh->quote("O'Brien");Tratamento de Erros
Com RaiseError ativado, o DBI morre em erros, então você pode usar eval/Try::Tiny. Sem ele, verifique os valores de retorno e inspecione $dbh->err/errstr. HandleError permite interceptar erros para registro ou recuperação.
# RaiseError: die on error (recommended)
my $dbh = DBI->connect($dsn, $u, $p,
{ RaiseError => 1, PrintError => 0 });
# Manual checking (without RaiseError)
my $rv = $dbh->do('UPDATE ...');
unless ($rv) { die $dbh->errstr; }
# Error info: $dbh->err, errstr, state
print $dbh->err; # error code
print $dbh->errstr; # error message
print $dbh->state; # SQLSTATE
# HandleError callback for custom handling
$dbh->{HandleError} = sub {
my $msg = shift;
log_error($msg);
return 0; # 0 = propagate (die)
};CPAN
Instalar Módulos
cpanm é App::cpanminus
# @ARGV holds command-line args (script name NOT included)
my $file = $ARGV[0];
my @args = @ARGV;
# Number of arguments
my $n = scalar @ARGV;
# Process args one at a time
while (@ARGV) {
my $arg = shift @ARGV;
print "Arg: $arg\n";
}
# Capture all remaining args
my @rest = @ARGV;
# The script's own name is in $0
print "Running $0\n";cpanfile
cpanfile declara dependências
use Getopt::Long;
my ($verbose, $name, $count, @files, $help);
GetOptions(
'verbose|v' => \$verbose,
'name=s' => \$name,
'count=i' => \$count,
'files=s@' => \@files,
'help|h' => \$help,
) or die "Usage: $0 [--verbose] [--name=X]\n";
exit print_usage() if $help;
print "verbose=$verbose name=$name count=$count\n";
# Run: perl script.pl -v --name=Alice --count=3 file1 file2Carton
Carton gerencia o bloqueio de dependências
# <> reads from files in @ARGV, or STDIN if empty
while (my $line = <>) {
chomp $line;
print "processed: $line\n";
}
# Run: perl script.pl file1.txt file2.txt
# Run: cat file | perl script.pl
# $ARGV is the current filename being read
# @ARGV is consumed as files are processed
# Reset to read a new set of files
@ARGV = @new_files;
while (<>) { ... }
# In-place edit with backup
$^I = '.bak';
while (<>) { s/foo/bar/g; print; }Códigos de Saída
exit termina o programa com um código de status (0 = sucesso para shells). $? guarda o status do filho após system/backticks: bits 0-6 são o sinal, bit 7 é core dump, bits 8+ são o código de saída.
# exit with a status (0 = success)
exit 0; # success
exit 1; # general error
exit 255; # out-of-range wraps (255 == -1)
# die sets a non-zero exit
eval { die "error\n" };
exit 1 if $@;
# Check a child's exit status
system("ls");
my $code = $? >> 8; # exit value
my $signal = $? & 127; # signal that killed it
my $core = ($? & 128); # core dump flag
print "exit=$code signal=$signal\n";
# END blocks still run on exit
END { cleanup(); }__DATA__
__DATA__ / __END__ separa código de dados num único arquivo; o filehandle DATA lê o que vem depois. Útil para embutir fixtures, templates ou configuração. Em módulos, use __DATA__ para que quem chama possa lê-lo.
# __DATA__ (or __END__) marks the end of code
# <DATA> reads from this section in the same file
while (my $line = <DATA>) {
chomp $line;
print "[$line]\n";
}
__DATA__
line 1
line 2
line 3
# __END__ behaves the same in a script;
# in a module use __DATA__ so the section is accessible.
# Data::Section supports multiple named sections.One-liners
Perl é famoso pelos one-liners via flags: -e código, -n/-p loop sobre a entrada, -i edição in-place, -a autosplit para @F, -F delimitador, -l auto-chomp/quebra de linha. Isso transforma o Perl num poderoso substituto de sed/awk.
# -e execute code
# perl -e 'print "hello\n"'
# -n loop over input (no auto-print)
# perl -ne 'print if /pattern/' file.txt
# -p loop and auto-print (like sed)
# perl -pe 's/foo/bar/g' file.txt
# -i in-place edit (with optional backup suffix)
# perl -i.bak -pe 's/old/new/g' *.txt
# -l auto chomp + add newline on print
# -a autosplit into @F (default whitespace)
# -F set the delimiter for -a
# perl -F, -ane 'print "$F[1]\n"' data.csvOne-Liners
One-Liner Básico
-e executa, -p auto-imprime, -n auto-loop
# printf FORMAT, LIST
printf "Name: %s\n", "Alice";
printf "Age: %d\n", 30;
printf "Pi: %.2f\n", 3.14159; # 3.14
printf "Hex: %x\n", 255; # ff
printf "Oct: %o\n", 8; # 10
printf "Bin: %b\n", 5; # 101
printf "Sci: %e\n", 123456; # 1.234560e+05
# Width and alignment
printf "%10s|\n", "hi"; # ' hi|' (right)
printf "%-10s|\n", "hi"; # 'hi |' (left)
printf "%05d\n", 42; # '00042' (zero-pad)
printf "%+d\n", 42; # '+42' (force sign)Opções Comuns
Opções de linha de comando
# sprintf returns the formatted string
my $date = sprintf("%04d-%02d-%02d", 2024, 1, 15);
# "2024-01-15"
my $log = sprintf("[%s] %s: %s",
scalar localtime, "INFO", "message");
# String padding
my $right = sprintf("%20s", "hi");
my $left = sprintf("%-20s|", "hi");
# Multiple formatted values
my $row = sprintf("%-10s %5d %8.2f",
"apple", 3, 1.50);
# Literal percent
my $pct = sprintf("%d%%", 50); # "50%"Exemplos Práticos
Comandos práticos one-liner
# Define a report format for STDOUT
format STDOUT =
@<<<<<<<<<<<<<< @>>>>>>
$name, $amount
.
my $name = "Alice";
my $amount = 1234.56;
write; # outputs the formatted line: Alice 1234.56
# Optional top-of-page (header) format
format STDOUT_TOP =
Name Amount
----------------------
.
# $~ sets the format name, $^ sets the top-of-page formatSuportes de Campo
Suportes de campo definem alinhamento e largura nos formats: @< esquerda, @> direita, @| centro, @# numérico. ~ suprime linhas em branco; ~~ repete até um campo se esgotar; ^ permite quebra de palavra para texto multilinha.
# Format field holders:
# @<<< left-justified (min width = number of chars)
# @>>> right-justified
# @||| centered
# @###.## numeric (right-justified, with decimals)
# @* multiline (takes whole lines)
format REPORT =
@<<<<<<<<<<<<<<<< @>>>>.##
$text, $num
.
# ~ suppresses a blank line if fields are empty
# ~~ repeats the line until a field is exhausted
format BLOCK =
~~ ^<<<<<<<<<<<<<<<<<
$text
.
# ^ enables word-wrap into the fieldEspecificadores de Formato
Especificadores mapeiam valores para texto: %s strings, %d/%u inteiros, %f floats, %e/%E científico, %x/%o/%b bases numéricas. Flags ajustam a formatação; largura e precisão (N.M) controlam tamanho do campo e casas decimais.
# printf / sprintf specifiers
%% literal percent
%s string
%c character (from code point)
%d signed integer
%u unsigned integer
%f floating point
%e scientific (lowercase)
%E scientific (uppercase)
%x hex (lowercase) %X hex (uppercase)
%o octal
%b binary
# Flags: - + 0 space #
printf "%-10s|%+d|%05d| %#x", "x", 5, 5, 255;
# Width and precision: %N.M
printf "%.3f", 3.14159; # 3.142
printf "%8.2f", 3.14159; # ' 3.14'Preenchimento e Alinhamento
Use %-Ns para alinhar à esquerda, %Ns para alinhar à direita, %0Nd para preencher números com zeros. Não há especificador de centralização embutido; calcule o preenchimento manualmente ou pós-processe com tr/// para trocar espaços por outro caractere.
# Right-align (default for numbers)
my $r = sprintf("%10s", "hi"); # ' hi'
# Left-align with '-'
my $l = sprintf("%-10s|", "hi"); # 'hi |'
# Zero-pad numbers
my $z = sprintf("%05d", 42); # '00042'
# Center manually
sub center {
my ($s, $w) = @_;
my $pad = int(($w - length($s)) / 2);
return ' ' x $pad . $s . ' ' x ($w - $pad - length($s));
}
print center("Title", 20);
# Replace spaces with another char
my $dashed = sprintf("%20s", "x");
$dashed =~ tr/ /-/; # '-------------------x'Snippets de Perl relacionados
Copy-paste ready code for common tasks.
Scalars, Arrays e Hashes
Os três tipos de dados principais do Perl com sigilos.
Expressões Regulares
Perl é famoso por seu poderoso suporte a regex.
Subrotinas e Referências
Definir subs e usar referências para dados complexos.
Estruturas de Dados Complexas
Construir estruturas aninhadas com referências.
Módulos e Packages
Criar módulos reutilizáveis com a keyword package.
E/S de Arquivos
Ler e escrever arquivos com filehandles.
OOP com Moose
Programação orientada a objetos moderna em Perl.
One-Liners e Truques de CLI
One-liners Perl comuns para processamento de texto.
Was this helpful?