perlfaq6 - Online sa Cloud

PROGRAMA:

NAME

perlfaq6 - Mga Regular na Ekspresyon

VERSION

bersyon 5.021009

DESCRIPTION

Ang seksyong ito ay nakakagulat na maliit dahil ang natitirang bahagi ng FAQ ay puno ng mga sagot
kinasasangkutan ng mga regular na expression. Halimbawa, ang pag-decode ng isang URL at pagsuri kung mayroon
ay isang numero ay maaaring pangasiwaan gamit ang mga regular na expression, ngunit ang mga sagot na iyon ay matatagpuan sa ibang lugar
sa dokumentong ito (sa perlfaq9: "Paano ako magde-decode o gagawa ng mga %-encoding na iyon sa web"
at perlfaq4: "Paano ko matutukoy kung ang isang scalar ay isang numero/buo/integer/float", upang maging
tumpak).

Gaano maaari I inaasahan sa gamitin regular mga expression wala paglikha hindi nababasa at hindi mapapanatili code?
Tatlong pamamaraan ang maaaring gawing mapanatili at mauunawaan ang mga regular na expression.

Mga Komento sa Labas ng Regex
Ilarawan kung ano ang iyong ginagawa at kung paano mo ito ginagawa, gamit ang mga normal na komento ng Perl.

# gawing unang salita ang linya, isang tutuldok, at ang
# bilang ng mga character sa natitirang linya
s/^(\w+)(.*)/ lc($1) . ":" . haba($2) /meg;

Mga Komento sa Loob ng Regex
Ang "/x" modifier ay nagdudulot ng pagbalewala sa whitespace sa isang regex pattern (maliban sa a
klase ng character at ilang iba pang mga lugar), at nagbibigay-daan din sa iyo na gumamit ng mga normal na komento
doon din. Gaya ng maiisip mo, malaking tulong ang whitespace at mga komento.

Hinahayaan ka ng "/x" na i-on ito:

s{<(?:[^>'"]*|".*?"|'.*?')+>}{}gs;

sa ito:

s{ < # pambungad na anggulo bracket
(?: # Non-backreffing grouping paren
[^>'"] * # 0 o higit pang mga bagay na hindi > o ' o "
| # kung hindi
".*?" # isang seksyon sa pagitan ng dobleng panipi (kuripot na tugma)
| # kung hindi
'.*?' # isang seksyon sa pagitan ng mga solong panipi (kuripot na tugma)
) + # lahat ay nangyayari nang isa o higit pang beses
> # pagsasara ng anggulo bracket
}{}gsx; # palitan ng wala, ibig sabihin, tanggalin

Hindi pa rin ito masyadong malinaw gaya ng prosa, ngunit ito ay lubhang kapaki-pakinabang para sa paglalarawan ng
kahulugan ng bawat bahagi ng pattern.

Iba't ibang Delimiter
Bagama't karaniwan naming iniisip na ang mga pattern ay nililimitahan ng mga "/" na character, maaari nila
malilimitahan ng halos anumang karakter. inilalarawan ito ni perlre. Halimbawa, ang "s///"
sa itaas ay gumagamit ng mga braces bilang mga delimiter. Ang pagpili ng isa pang delimiter ay maaaring maiwasan ang pagsipi ng
delimiter sa loob ng pattern:

s/\/ usr\/lokal/\/ usr\/share/g; # masamang pagpipilian sa delimiter
s#/ usr / lokal#/ usr / ibahagi#g; # mas mabuti

Ang paggamit ng mga lohikal na ipinares na mga delimiter ay maaaring maging mas nababasa:

s{/ usr / local /}{/ usr / ibahagi}g; #mabuti pa

Ako ay pagkakaroon gulo pagtutugma sa ibabaw mas marami pang kaysa isa linya. Ano ang mali?
Alinman sa wala kang higit sa isang linya sa string na iyong tinitingnan (marahil), o
kung hindi, hindi mo ginagamit ang tamang (mga) modifier sa iyong pattern (maaaring).

Mayroong maraming mga paraan upang makakuha ng multiline na data sa isang string. Kung gusto mo mangyari
awtomatikong habang nagbabasa ng input, gugustuhin mong itakda ang $/ (marahil sa '' para sa mga talata o
"undef" para sa buong file) upang payagan kang magbasa ng higit sa isang linya sa isang pagkakataon.

Basahin ang perlre upang matulungan kang magpasya kung alin sa "/s" at "/m" (o pareho) ang maaari mong gamitin:
Ang "/s" ay nagbibigay-daan sa tuldok na magsama ng bagong linya, at ang "/m" ay nagbibigay-daan sa caret at dolyar na tumugma sa tabi ng a
newline, hindi lang sa dulo ng string. Kailangan mong tiyakin na ikaw talaga
may multiline string doon.

Halimbawa, nakita ng program na ito ang mga duplicate na salita, kahit na sumasaklaw ang mga ito sa mga line break (ngunit
hindi mga talata). Para sa halimbawang ito, hindi namin kailangan ang "/s" dahil hindi kami gumagamit ng tuldok sa a
regular na expression na gusto naming tumawid sa mga hangganan ng linya. Hindi rin natin kailangan ng "/m" dahil
hindi namin gustong tumugma ang caret o dollar sa anumang punto sa loob ng record sa tabi ng mga bagong linya.
Ngunit kailangang-kailangan na ang $/ ay itakda sa isang bagay maliban sa default, o kung hindi, hindi namin gagawin
talagang may nabasang multiline record.

$/ = ''; # basahin sa buong talata, hindi lang isang linya
habang ( <> ) {
habang ( /\b([\w'-]+)(\s+\g1)+\b/gi ) { # salita ang nagsisimula sa alpha
i-print ang "Duplicate $1 sa talata $.\n";
}
}

Narito ang ilang code na nakakahanap ng mga pangungusap na nagsisimula sa "Mula sa " (na guguluhin ng
maraming mailers):

$/ = ''; # basahin sa buong talata, hindi lang isang linya
habang ( <> ) {
habang ang ( /^From /gm ) { # /m ay gumagawa ng ^ tugma sa tabi ng \n
print "nangunguna mula sa talata $.\n";
}
}

Narito ang code na nakakahanap ng lahat sa pagitan ng START at END sa isang talata:

undef $/; # basahin sa buong file, hindi lamang isang linya o talata
habang ( <> ) {
habang ang ( /START(.*?)END/sgm ) { # /s ay gumagawa ng . cross line na mga hangganan
i-print ang "$1\n";
}
}

Gaano maaari I paghila Palabas linya sa pagitan ng dalawa pattern na ay kanilang sarili on iba mga linya?
Maaari mong gamitin ang medyo kakaibang ".." operator ng Perl (nakadokumento sa perlop):

perl -ne 'i-print kung /START/ .. /END/' file1 file2 ...

Kung gusto mo ng teksto at hindi mga linya, gagamitin mo

perl -0777 -ne 'print "$1\n" habang /START(.*?)END/gs' file1 file2 ...

Ngunit kung gusto mo ng mga nested na paglitaw ng "START" hanggang "END", makakalaban mo ang
problemang inilarawan sa tanong sa seksyong ito sa pagtutugma ng balanseng teksto.

Narito ang isa pang halimbawa ng paggamit ng "..":

habang (<>) {
aking $in_header = 1 .. /^$/;
my $in_body = /^$/ .. eof;
# ngayon pumili sa pagitan nila
} magpatuloy {
$. = 0 kung eof; # ayusin $.
}

Gaano do I tumugma XML, HTML, or iba pangit, pangit bagay sa a regex?
Huwag gumamit ng mga regex. Gumamit ng isang module at kalimutan ang tungkol sa mga regular na expression. Ang
XML::LibXML, HTML::TokeParser at HTML::Ang mga module ng TreeBuilder ay magandang simula, bagaman ang bawat isa
Ang namespace ay may iba pang mga module sa pag-parse na dalubhasa para sa ilang mga gawain at iba't ibang paraan ng
ginagawa na. Magsimula sa CPAN Search (http://metacpan.org/> ) at nagtataka sa lahat ng gawain
nagawa na ng mga tao para sa iyo! :)

I ilagay a regular pagpapahayag sa $/ pero it May ginawang hindi gumagana. Ano ang mali?
Ang $/ ay kailangang isang string. Maaari mong gamitin ang mga halimbawang ito kung talagang kailangan mong gawin ito.

Kung mayroon kang File::Stream, madali lang ito.

gamitin ang File::Stream;

my $stream = File::Stream->new(
$filehandle,
separator => qr/\s*,\s*/,
);

i-print ang "$_\n" habang <$stream>;

Kung wala kang File::Stream, kailangan mong gumawa ng kaunti pang trabaho.

Maaari mong gamitin ang apat na argumentong anyo ng sysread upang patuloy na magdagdag sa isang buffer. Pagkatapos mong
idagdag sa buffer, tingnan mo kung mayroon kang kumpletong linya (gamit ang iyong regular na expression).

lokal na $_ = "";
habang( sysread FH, $_, 8192, haba ) {
habang( s/^((?s).*?)iyong_pattern// ) {
aking $record = $1;
# gawin ang mga bagay-bagay dito.
}
}

Maaari mong gawin ang parehong bagay sa foreach at isang tugma gamit ang c flag at ang \G anchor, kung
hindi mo iniisip na ang iyong buong file ay nasa memorya sa dulo.

lokal na $_ = "";
habang( sysread FH, $_, 8192, haba ) {
foreach my $record ( m/\G((?s).*?)your_pattern/gc ) {
# gawin ang mga bagay-bagay dito.
}
substr( $_, 0, pos ) = "" kung pos;
}

Gaano do I kapalit case-insensitively on ang LHS habang pinangalagaan kaso on ang RHS?
Narito ang isang magandang Perlish na solusyon ni Larry Rosler. Pinagsasamantalahan nito ang mga katangian ng bitwise xor on
Mga string ng ASCII.

$_= "ito ay isang TEsT case";

$old = 'test';
$new = 'tagumpay';

s{(\Q$old\E)}
{ uc $bago | (uc $1 ^ $1) .
(uc(substr $1, -1) ^ substr $1, -1) x
(haba($bago) - haba $1)
}egi;

i-print;

At narito ito bilang isang subroutine, na itinulad sa itaas:

sub preserve_case {
my ($old, $new) = @_;
ang aking $mask = uc $old ^ $old;

uc $bago | $mask .
substr($mask, -1) x (haba($bago) - haba($luma))
}

$string = "ito ay isang kaso ng TEsT";
$string =~ s/(test)/preserve_case($1, "tagumpay")/egi;
i-print ang "$string\n";

Ito ay nagpi-print ng:

ito ay isang kaso ng TAGUMPAY

Bilang kahalili, panatilihin ang case ng kapalit na salita kung mas mahaba ito kaysa sa
orihinal, maaari mong gamitin ang code na ito, ni Jeff Pinyan:

sub preserve_case {
aking ($mula, $to) = @_;
my ($lf, $lt) = haba ng mapa, @_;

if ($lt < $lf) { $from = substr $from, 0, $lt }
else { $from .= substr $to, $lf }

ibalik ang uc $sa | ($mula sa ^ uc $mula);
}

Binabago nito ang pangungusap sa "ito ay isang SUcCess case."

Para lamang ipakita na ang mga C programmer ay maaaring magsulat ng C sa anumang programming language, kung gusto mo a
higit pang solusyong tulad ng C, ginagawa ng sumusunod na script ang pagpapalit na magkaroon ng parehong kaso,
letra sa liham, gaya ng orihinal. (Ito rin ay nangyayari na tumakbo nang humigit-kumulang 240% na mas mabagal kaysa sa
Ang Perlish solution ay tumatakbo.) Kung ang pagpapalit ay may mas maraming character kaysa sa string
palitan, ang kaso ng huling karakter ay ginagamit para sa natitirang bahagi ng pagpapalit.

# Orihinal ni Nathan Torkington, minasahe ni Jeffrey Friedl
#
sub preserve_case
{
my ($old, $new) = @_;
aking $estado = 0; # 0 = walang pagbabago; 1 = lc; 2 = uc
my ($i, $oldlen, $newlen, $c) = (0, length($old), length($new));
aking $len = $oldlen < $newlen ? $oldlen : $newlen;

para sa ($i = 0; $i < $len; $i++) {
if ($c = substr($old, $i, 1), $c =~ /[\W\d_]/) {
$estado = 0;
} elsif (lc $c eq $c) {
substr($new, $i, 1) = lc(substr($new, $i, 1));
$estado = 1;
} Iba pa {
substr($new, $i, 1) = uc(substr($new, $i, 1));
$estado = 2;
}
}
# tapusin ang anumang natitirang bago (para kapag ang bago ay mas mahaba kaysa sa luma)
kung ($newlen > $oldlen) {
kung ($estado == 1) {
substr($new, $oldlen) = lc(substr($new, $oldlen));
} elsif ($estado == 2) {
substr($new, $oldlen) = uc(substr($new, $oldlen));
}
}
ibalik ang $bago;
}

Gaano maaari I gumawa "\w" tumugma pambansa katangian set?
Ilagay ang "use locale;" sa iyong script. Ang klase ng karakter na \w ay kinuha mula sa kasalukuyang lokal.

Tingnan ang perllocale para sa mga detalye.

Gaano maaari I tumugma a lokal-matalino bersyon of "/[a-zA-Z]/"?
Maaari mong gamitin ang POSIX character class syntax na "/[[:alpha:]]/" na nakadokumento sa perlre.

Saang lugar ka man naroroon, ang mga alphabetic na character ay ang mga character sa \w
nang walang mga digit at salungguhit. Bilang isang regex, mukhang "/[^\W\d_]/". Nito
complement, ang non-alphabetics, ay ang lahat sa \W kasama ang mga digit at ang
salungguhit, o "/[\W\d_]/".

Gaano maaari I sipi a nagbabago sa gamitin in a regex?
Ang Perl parser ay magpapalawak ng $variable at @variable na mga sanggunian sa mga regular na expression
maliban kung ang delimiter ay isang solong quote. Tandaan din, na ang kanang bahagi ng a
Ang "s///" substitution ay itinuturing na isang double-quoted string (tingnan ang perlop para sa higit pang mga detalye).
Tandaan din na ang anumang mga espesyal na character ng regex ay aaksyunan maliban kung mauuna ka sa
pagpapalit ng \Q. Narito ang isang halimbawa:

$string = "Placido P. Octopus";
$regex = "P.";

$string =~ s/$regex/Polyp/;
Ang # $string ay "Polypacido P. Octopus" na ngayon

Dahil "." ay espesyal sa mga regular na expression, at maaaring tumugma sa anumang solong karakter, ang
regex "P." dito ay tumugma sa sa orihinal na string.

Upang takasan ang espesyal na kahulugan ng ".", ginagamit namin ang "\Q":

$string = "Placido P. Octopus";
$regex = "P.";

$string =~ s/\Q$regex/Polyp/;
Ang # $string ay "Placido Polyp Octopus" na ngayon

Ang paggamit ng "\Q" ay nagiging sanhi ng <.> sa regex na ituring bilang isang regular na character, kaya't
"P." tumutugma sa isang "P" na sinusundan ng isang tuldok.

Ano is "/o" Talaga para sa?
(kontribusyon ni brian d foy)

Ang opsyon na "/o" para sa mga regular na expression (nakadokumento sa perlop at perlreref) ay nagsasabi kay Perl na
i-compile ang regular na expression nang isang beses lamang. Ito ay kapaki-pakinabang lamang kapag ang pattern ay naglalaman ng a
variable. Awtomatikong pinangangasiwaan ito ng Perls 5.6 at mas bago kung hindi magbabago ang pattern.

Dahil ang operator ng tugma na "m//", ang operator ng pagpapalit na "s///", at ang regular
expression quoting operator "qr//" ay double-quotish constructs, maaari mong interpolate
mga variable sa pattern. Tingnan ang sagot sa "Paano ko masisipi ang isang variable na gagamitin sa a
regex?" para sa higit pang mga detalye.

Ang halimbawang ito ay kumukuha ng isang regular na expression mula sa listahan ng argumento at nagpi-print ng mga linya ng
input na tumutugma dito:

ang aking $pattern = shift @ARGV;

habang( <> ) {
i-print kung m/$pattern/;
}

Ang mga bersyon ng Perl bago ang 5.6 ay muling magko-compile ng regular na expression para sa bawat pag-ulit,
kahit na hindi nagbago ang $pattern. Pipigilan ito ng "/o" sa pamamagitan ng pagsasabi kay Perl na mag-compile
ang pattern sa unang pagkakataon, pagkatapos ay muling gamitin iyon para sa kasunod na mga pag-ulit:

ang aking $pattern = shift @ARGV;

habang( <> ) {
i-print kung m/$pattern/o; # kapaki-pakinabang para sa Perl < 5.6
}

Sa mga bersyon 5.6 at mas bago, hindi muling iko-compile ng Perl ang regular na expression kung ang variable
ay hindi nagbago, kaya malamang na hindi mo kailangan ang "/o" na opsyon. Hindi masakit, pero ito
hindi rin nakakatulong. Kung gusto mo ng anumang bersyon ng Perl na i-compile ang regular na expression
isang beses lang kahit na nagbabago ang variable (kaya, gamit lang ang initial value nito), ikaw pa rin
kailangan ang "/o".

Maaari mong panoorin ang regular na expression engine ng Perl sa trabaho upang i-verify para sa iyong sarili kung si Perl ay
muling pag-compile ng isang regular na expression. Ang "use re 'debug'" pragma (kasama ang Perl 5.005 at
mamaya) ay nagpapakita ng mga detalye. Sa Perls bago ang 5.6, dapat mong makita ang "muling" pag-uulat na ito
pag-compile ng regular na expression sa bawat pag-ulit. Sa Perl 5.6 o mas bago, dapat
tingnan lamang ang "muling" na ulat na para sa unang pag-ulit.

gumamit muli ng 'debug';

aking $regex = 'Perl';
foreach ( qw(Perl Java Ruby Python) ) {
i-print ang STDERR "-" x 73, "\n";
print STDERR "Sinusubukan $_...\n";
print STDERR "\t$_ is good!\n" if m/$regex/;
}

Gaano do I gamitin a regular pagpapahayag sa alisan ng C-style Tingnan ang mga komento mula a file?
Bagama't talagang magagawa ito, mas mahirap ito kaysa sa inaakala mo. Halimbawa, ito
isang-liner

perl -0777 -pe 's{/\*.*?\*/}{}gs' foo.c

gagana sa marami ngunit hindi sa lahat ng kaso. Nakikita mo, ito ay masyadong simple ang pag-iisip para sa ilang mga uri ng
C programs, sa partikular, ang mga may tila mga komento sa mga naka-quote na string. Para sa
na, kakailanganin mo ng ganito, na ginawa ni Jeffrey Friedl at kalaunan ay binago ni Fred
Curtis.

$/ = undef;
$_ = <>;
s#/\*[^*]*\*+([^/*][^*]*\*+)*/|("(\\.|[^"\\])*"|'( \\.|[^'\\])*'|.[^/"'\\]*)#defined $2 ? $2 : ""#gse;
i-print;

Siyempre, ito ay maaaring mas madaling mabasa gamit ang "/x" modifier, na nagdaragdag ng whitespace
at mga komento. Dito ito pinalawak, sa kagandahang-loob ni Fred Curtis.

s{
/\* ## Simula ng /* ... */ komento
[^*]*\*+ ## Hindi-* na sinusundan ng 1-o-higit pang mga *
(
[^/*][^*]*\*+
)* ## 0-o-higit pang mga bagay na hindi nagsisimula sa /
## ngunit magtatapos sa '*'
/ ## Katapusan ng /* ... */ komento

| ## O iba't ibang bagay na hindi mga komento:

(
" ## Simula ng " ... " string
(
\\. ## Escaped char
| ## O
[^"\\] ## Hindi "\
)*
" ## Katapusan ng " ... " string

| ## O

' ## Simula ng ' ... ' string
(
\\. ## Escaped char
| ## O
[^'\\] ## Hindi '\
)*
' ## Katapusan ng ' ... ' string

| ## O

. ## Kahit ano pang char
[^/"'\\]* ## Mga character na hindi nagsisimula ng komento, string o escape
)
}{defined $2 ? $2 : ""}gxse;

Ang isang bahagyang pagbabago ay nag-aalis din ng mga komento sa C++, posibleng sumasaklaw sa maraming linya gamit ang a
karakter ng pagpapatuloy:

s#/\*[^*]*\*+([^/*][^*]*\*+)*/|//([^\\]|[^\n][\n]? )*?\n|("(\\.|[^"\\])*"|'(\\.|[^'\\])*'|.[^/"'\\]*) #defined $3 ? $3 : ""#gse;

Maaari I gamitin Perl regular mga expression sa tumugma timbang text?
(kontribusyon ni brian d foy)

Ang iyong unang pagsubok ay malamang na ang Text::Balanced module, na nasa Perl standard
library mula noong Perl 5.8. Mayroon itong iba't ibang mga pag-andar upang harapin ang nakakalito na teksto. Ang
Regexp::Maaari ding makatulong ang karaniwang module sa pamamagitan ng pagbibigay ng mga de-latang pattern na magagamit mo.

Mula sa Perl 5.10, maaari mong itugma ang balanseng teksto sa mga regular na expression gamit ang recursive
mga pattern. Bago ang Perl 5.10, kailangan mong gumamit ng iba't ibang mga trick tulad ng paggamit ng Perl code
"(??{})" sequence.

Narito ang isang halimbawa gamit ang isang recursive na regular na expression. Ang layunin ay makuha ang lahat ng
text sa loob ng angle bracket, kasama ang text sa nested angle bracket. Ang sample na text na ito
ay may dalawang "pangunahing" pangkat: isang pangkat na may isang antas ng nesting at isang pangkat na may dalawang antas ng
pugad. Mayroong limang kabuuang pangkat sa mga anggulong bracket:

meron ako > at
> >
at yun lang.

Ang regular na expression upang tumugma sa balanseng teksto ay gumagamit ng dalawang bago (sa Perl 5.10) na regular
mga tampok ng pagpapahayag. Ang mga ito ay sakop sa perlre at ang halimbawang ito ay isang binagong bersyon ng
isa sa dokumentasyong iyon.

Una, ang pagdaragdag ng bagong possessive na "+" sa anumang quantifier ay hahanapin ang pinakamahabang tugma at ginagawa
hindi backtrack. Mahalaga iyon dahil gusto mong pangasiwaan ang anumang mga anggulong bracket sa pamamagitan ng
recursion, hindi backtracking. Nakahanap ang pangkat na "[^<>]++" ng isa o higit pang mga bracket na hindi anggulo
nang walang pag-urong.

Pangalawa, ang bagong "(?PARNO)" ay tumutukoy sa sub-pattern sa partikular na pangkat ng pagkuha na ibinigay
ni "PARNO". Sa sumusunod na regex, ang unang pangkat ng pagkuha ay nahahanap (at naaalala) ang
balanseng teksto, at kailangan mo ang parehong pattern sa loob ng unang buffer upang malagpasan ang
nested text. Iyan ang recursive na bahagi. Ginagamit ng "(?1)" ang pattern sa panlabas na pagkuha
pangkat bilang isang independiyenteng bahagi ng regex.

Pagsasama-sama ng lahat, mayroon kang:

#!/usr/local/bin/perl5.10.0

ang aking $string =<<"DITO";
meron ako > at
> >
at yun lang.
HERE

aking @groups = $string =~ m/
( # simula ng pagkuha ng pangkat 1
< # tumugma sa isang pambungad na anggulo bracket
(?:
[^<>]++ # isa o higit pang mga hindi anggulo na bracket, hindi nag-backtrack
|
(?1) # ang nakitang < o >, kaya't muli upang makuha ang pangkat 1
)*
> # tumugma sa isang pagsasara ng anggulo bracket
) # dulo ng pangkat ng pagkuha 1
/xg;

$" = "\n\t";
print "Natagpuan:\n\t@groups\n";

Ipinapakita ng output na natagpuan ni Perl ang dalawang pangunahing grupo:

nahanap:
>
> >

Sa kaunting dagdag na trabaho, maaari mong makuha ang lahat ng grupo sa mga anggulong bracket kahit na sila
sa ibang mga anggulo bracket din. Sa tuwing makakakuha ka ng balanseng tugma, alisin ang panlabas nito
delimiter (iyan ang kakatugma mo lang kaya huwag mo nang itugma muli) at idagdag ito sa isang pila
ng mga string upang iproseso. Patuloy na gawin iyon hanggang sa wala kang makuhang tugma:

#!/usr/local/bin/perl5.10.0

my @queue =<<"DITO";
meron ako > at
> >
at yun lang.
HERE

aking $regex = qr/
( # simula ng bracket 1
< # tumugma sa isang pambungad na anggulo bracket
(?:
[^<>]++ # isa o higit pang mga hindi anggulo na bracket, hindi nag-backtrack
|
(?1) # recurse sa bracket 1
)*
> # tumugma sa isang pagsasara ng anggulo bracket
) # dulo ng bracket 1
/x;

$" = "\n\t";

habang( @queue ) {
aking $string = shift @queue;

aking @groups = $string =~ m/$regex/g;
i-print ang "Natagpuan:\n\t@groups\n\n" kung @groups;

i-unshift ang @queue, mapa { s/^ $//; $_ } @mga pangkat;
}

Ipinapakita ng output ang lahat ng mga pangkat. Ang mga pinakamalabas na tugma ay unang lalabas at ang nested
lalabas ang mga laban mamaya:

nahanap:
>
> >

nahanap:


nahanap:
>

nahanap:


Ano ang it ibig sabihin na mga regex ay matakaw? Gaano maaari I makuha sa paligid ito?
Ibig sabihin ng karamihan sa mga tao na ang mga matakaw na regex ay tumutugma sa abot ng kanilang makakaya. Sa teknikal na pagsasalita,
ito talaga ang mga quantifier ("?", "*", "+", "{}") na matakaw kaysa sa kabuuan
pattern; Mas gusto ni Perl ang lokal na kasakiman at agarang kasiyahan kaysa sa pangkalahatang kasakiman. Para makuha
mga di-matakaw na bersyon ng parehong mga quantifier, gumamit ng ("??", "*?", "+?", "{}?").

Isang halimbawa:

my $s1 = my $s2 = "I am very very cold";
$s1 =~ s/ve.*y //; # Nilalamig ako
$s2 =~ s/ve.*?y //; # Masyado akong malamig

Pansinin kung paano huminto sa pagtutugma ang pangalawang pagpapalit sa sandaling makatagpo ito ng "y". Ang
"*?" Ang quantifier ay epektibong nagsasabi sa regular na expression engine upang makahanap ng isang tugma nang mabilis
hangga't maaari at ipasa ang kontrol sa anumang susunod sa linya, tulad ng gagawin mo kung ikaw ay
naglalaro ng mainit na patatas.

Gaano do I paraan bawat salita on bawat linya?
Gamitin ang split function:

habang (<>) {
foreach my $word ( split ) {
# gumawa ng isang bagay sa $word dito
}
}

Tandaan na ito ay hindi talaga isang salita sa Ingles na kahulugan; ito ay mga tipak na magkasunod
mga character na hindi whitespace.

Upang gumana sa mga alphanumeric sequence lamang (kabilang ang mga underscore), maaari mong isaalang-alang

habang (<>) {
sa bawat $salita (m/(\w+)/g) {
# gumawa ng isang bagay sa $word dito
}
}

Gaano maaari I i-print Palabas a dalas ng salita or dalas ng linya buod?
Upang gawin ito, kailangan mong i-parse ang bawat salita sa input stream. Magpapanggap kami na sa pamamagitan ng
salitang iyong ibig sabihin ay tipak ng mga alpabeto, gitling, o kudlit, sa halip na ang hindi-
whitespace chunk ideya ng isang salita na ibinigay sa nakaraang tanong:

aking (%seen);
habang (<>) {
habang ( /(\b[^\W_\d][\w'-]+\b)/g ) { # namimiss ang "`tupa'"
$nakita{$1}++;
}
}

habang ( my ($word, $count) = bawat %nakikita ) {
print "$count $word\n";
}

Kung gusto mong gawin ang parehong bagay para sa mga linya, hindi mo kakailanganin ang isang regular na expression:

aking (%seen);

habang (<>) {
$nakita{$_}++;
}

habang ( my ($line, $count) = bawat %nakikita ) {
i-print ang "$count $line";
}

Kung gusto mo ang mga output na ito sa isang pinagsunod-sunod na pagkakasunud-sunod, tingnan ang perlfaq4: "Paano ako mag-uuri ng hash
(opsyonal ayon sa halaga sa halip na susi)?".

Gaano maaari I do tinatayang tugma?
Tingnan ang module String::Approx available mula sa CPAN.

Gaano do I mahusay tumugma marami regular mga expression at minsan?
(kontribusyon ni brian d foy)

Kung mayroon kang Perl 5.10 o mas bago, ito ay halos walang halaga. Matalino ka lang laban sa isang
hanay ng mga regular na expression na bagay:

my @patterns = ( qr/Fr.d/, qr/B.rn.y/, qr/W.lm./ );

kung( $string ~~ @patterns ) {
...
};

Hihinto ang matalinong tugma kapag nakahanap ito ng katugma, kaya hindi nito kailangang subukan ang bawat expression.

Mas maaga kaysa sa Perl 5.10, mayroon kang kaunting trabaho na dapat gawin. Gusto mong iwasan ang pagsasama-sama ng a
regular na expression sa tuwing gusto mong itugma ito. Sa halimbawang ito, dapat na muling mag-compile ang perl
ang regular na expression para sa bawat pag-ulit ng "foreach" na loop dahil wala itong paraan
alamin kung ano ang magiging $pattern:

my @patterns = qw(foo bar baz );

LINE: habang( ) {
foreach $pattern ( @patterns ) {
kung( /\b$pattern\b/i ) {
i-print;
susunod na LINE;
}
}
}

Ang "qr//" operator ay nagpakita sa perl 5.005. Nag-compile ito ng isang regular na expression, ngunit hindi
ilapat ito. Kapag ginamit mo ang pre-compiled na bersyon ng regex, hindi gaanong gumagana ang perl. Dito sa
halimbawa, nagpasok ako ng "mapa" upang gawing pre-compiled na form ang bawat pattern. Ang natitirang bahagi ng
ang script ay pareho, ngunit mas mabilis:

my @patterns = mapa {qr/\b$_\b/i } qw(foo bar baz );

LINE: habang( <> ) {
foreach $pattern ( @patterns ) {
kung( /$pattern/ ) {
i-print;
susunod na LINE;
}
}
}

Sa ilang mga kaso, maaari kang gumawa ng ilang mga pattern sa isang solong regular na expression.
Mag-ingat sa mga sitwasyon na nangangailangan ng backtracking bagaman.

my $regex = sumali sa '|', qw( foo bar baz );

LINE: habang( <> ) {
i-print kung /\b(?:$regex)\b/i;
}

Para sa higit pang mga detalye sa kahusayan ng regular na expression, tingnan Mastering regular expression by
Jeffrey Friedl. Ipinapaliwanag niya kung paano gumagana ang makina ng mga regular na expression at kung bakit ang ilang mga pattern
ay nakakagulat na hindi epektibo. Kapag naunawaan mo kung paano inilalapat ng perl ang mga regular na expression,
maaari mong ibagay ang mga ito para sa mga indibidwal na sitwasyon.

Bakit huwag salita-hangganan paghahanap sa "\b" trabaho para Ako?
(kontribusyon ni brian d foy)

Tiyaking alam mo kung ano talaga ang \b: ito ang hangganan sa pagitan ng isang character na salita, \w,
at isang bagay na hindi isang character na salita. Maaaring iyon ang bagay na hindi isang character na salita
\W, ngunit maaari rin itong maging simula o dulo ng string.

Hindi ito (hindi!) ang hangganan sa pagitan ng whitespace at non-whitespace, at hindi ito ang bagay
sa pagitan ng mga salitang ginagamit natin sa pagbuo ng mga pangungusap.

Sa regex speak, ang word boundary (\b) ay isang "zero width assertion", ibig sabihin ay hindi
kumakatawan sa isang character sa string, ngunit isang kundisyon sa isang tiyak na posisyon.

Para sa regular na expression, /\bPerl\b/, kailangang may hangganan ng salita bago ang "P" at
pagkatapos ng "l". Hangga't ang isang bagay maliban sa isang character na salita ay nauuna sa "P" at
nagtagumpay ang "l", ang pattern ay tutugma. Ang mga string na ito ay tumutugma sa /\bPerl\b/.

"Perl" # walang salitang char bago ang P o pagkatapos ng l
"Perl " # katulad ng dati (ang espasyo ay hindi isang word char)
"'Perl'" # ang ' char ay hindi isang salitang char
"Perl's" # walang salitang char bago ang P, hindi salitang char pagkatapos ng "l"

Ang mga string na ito ay hindi tumutugma sa /\bPerl\b/.

"Perl_" # _ ay isang word char!
"Perler" # walang salitang char bago ang P, ngunit isa pagkatapos ng l

Hindi mo kailangang gumamit ng \b upang tumugma sa mga salita bagaman. Maaari kang maghanap ng mga hindi salita na character
napapaligiran ng mga tauhan ng salita. Ang mga string na ito ay tumutugma sa pattern /\b'\b/.

"huwag" # ang ' char ay napapalibutan ng "n" at "t"
"qep'a'" # ang ' char ay napapalibutan ng "p" at "a"

Ang mga string na ito ay hindi tumutugma sa /\b'\b/.

"foo'" # walang salitang char pagkatapos ng hindi salitang '

Maaari mo ring gamitin ang pandagdag ng \b, \B, upang tukuyin na hindi dapat magkaroon ng isang salita
hangganan.

Sa pattern /\Bam\B/, dapat mayroong isang character na salita bago ang "a" at pagkatapos ng "m".
Ang mga pattern na ito ay tumutugma sa /\Bam\B/:

"llama" # "am" na napapalibutan ng mga character na salita
"Samuel" # pareho

Ang mga string na ito ay hindi tumutugma sa /\Bam\B/

"Sam" # walang salitang hangganan bago ang "a", ngunit isa pagkatapos ng "m"
"Ako si Sam" # "am" na napapalibutan ng mga hindi salitang karakter

Bakit ang paggamit $&, $`, or $' pabagalin my programa pababa?
(kontribusyon ni Anno Siegel)

Kapag nakita ni Perl na kailangan mo ng isa sa mga variable na ito saanman sa programa, nagbibigay ito
ang mga ito sa bawat at bawat pattern na tugma. Nangangahulugan iyon na sa bawat pattern ay tumutugma sa kabuuan
string ay kokopyahin, bahagi nito sa $`, bahagi sa $&, at bahagi sa $'. Kaya ang parusa ay
pinakamalubha na may mahabang mga string at pattern na madalas tumutugma. Iwasan ang $&, $', at $` kung ikaw
maaari, ngunit kung hindi mo kaya, kapag ginamit mo na ang mga ito, gamitin ang mga ito nang kusa dahil nagawa mo na
binayaran na ang presyo. Tandaan na ang ilang mga algorithm ay talagang pinahahalagahan ang mga ito. Bilang ng
5.005, ang $& variable ay hindi na "mahal" gaya ng dalawa.

Dahil ang Perl 5.6.1 ang mga espesyal na variable @- at @+ ay maaaring gumana nang palitan ang $`, $& at $'.
Ang mga array na ito ay naglalaman ng mga pointer sa simula at dulo ng bawat tugma (tingnan ang perlvar para sa
buong kuwento), kaya binibigyan ka nila ng parehong impormasyon, ngunit walang panganib ng
labis na pagkopya ng string.

Nagdagdag ang Perl 5.10 ng tatlong espesyal, "${^MATCH}", "${^PREMATCH}", at "${^POSTMATCH}" para gawin ang
parehong trabaho ngunit walang pandaigdigang parusa sa pagganap. Itinatakda lamang ng Perl 5.10 ang mga variable na ito
kung mag-compile o mag-execute ka ng regular na expression gamit ang "/p" modifier.

Ano mahusay is "\G" in a regular pagpapahayag?
Ginagamit mo ang "\G" anchor upang simulan ang susunod na tugma sa parehong string kung saan ang huling tugma
naiwan. Ang regular na expression engine ay hindi maaaring laktawan ang anumang mga character upang mahanap ang susunod
tumugma sa anchor na ito, kaya ang "\G" ay katulad ng simula ng string anchor, "^". Ang
Ang "\G" anchor ay karaniwang ginagamit kasama ng "g" na flag. Ginagamit nito ang halaga ng "pos()" bilang ang
posisyon upang simulan ang susunod na laban. Habang ang operator ng tugma ay gumagawa ng sunud-sunod na mga laban, ito
ina-update ang "pos()" na may posisyon ng susunod na character na lampas sa huling laban (o ang una
karakter ng susunod na laban, depende sa kung paano mo ito gustong tingnan). Ang bawat string ay mayroon nito
sariling "pos()" na halaga.

Ipagpalagay na gusto mong itugma ang lahat ng magkakasunod na pares ng mga digit sa isang string tulad ng "1122a44"
at huminto sa pagtutugma kapag nakatagpo ka ng mga hindi digit. Gusto mong tumugma sa 11 at 22 ngunit ang
lumilitaw ang liham sa pagitan ng 22 at 44 at gusto mong huminto sa "a". Simpleng pagtutugma ng mga pares
ng mga digit ay lumalampas sa "a" at tumutugma pa rin sa 44.

$_ = "1122a44";
aking @pares = m/(\d\d)/g; # qw( 11 22 44 )

Kung gagamitin mo ang "\G" anchor, pipilitin mong magsimula sa "a" ang laban pagkalipas ng 22. Ang
ang regular na expression ay hindi maaaring tumugma doon dahil wala itong mahanap na digit, kaya ang susunod na tugma
nabigo at ibinalik ng operator ng tugma ang mga pares na nahanap na nito.

$_ = "1122a44";
aking @pares = m/\G(\d\d)/g; # qw( 11 22 )

Maaari mo ring gamitin ang "\G" anchor sa scalar na konteksto. Kailangan mo pa rin ang flag na "g".

$_ = "1122a44";
habang( m/\G(\d\d)/g ) {
i-print ang "Nakahanap ng $1\n";
}

Pagkatapos mabigo ang tugma sa letrang "a", nire-reset ni perl ang "pos()" at ang susunod na tugma sa
ang parehong string ay nagsisimula sa simula.

$_ = "1122a44";
habang( m/\G(\d\d)/g ) {
i-print ang "Nakahanap ng $1\n";
}

i-print ang "Nakahanap ng $1 pagkatapos ng ilang sandali" kung m/(\d\d)/g; # nakahanap ng "11"

Maaari mong i-disable ang "pos()" resets kapag nabigo gamit ang flag na "c", na nakadokumento sa perlop at
perlreref. Magsisimula ang mga kasunod na laban kung saan natapos ang huling matagumpay na laban (ang halaga ng
"pos()") kahit na ang isang tugma sa parehong string ay nabigo sa pansamantala. Sa kasong ito, ang
tugma pagkatapos ng loop na "while()" ay magsisimula sa "a" (kung saan huminto ang huling laban), at mula noon
hindi ito gumagamit ng anumang anchor na maaari nitong laktawan ang "a" upang mahanap ang 44.

$_ = "1122a44";
habang( m/\G(\d\d)/gc ) {
i-print ang "Nakahanap ng $1\n";
}

i-print ang "Nakahanap ng $1 pagkatapos ng ilang sandali" kung m/(\d\d)/g; # nakahanap ng "44"

Karaniwang ginagamit mo ang "\G" anchor na may "c" na flag kapag gusto mong sumubok ng ibang tugma
kung ang isa ay nabigo, tulad ng sa isang tokenizer. Iniaalok ni Jeffrey Friedl ang halimbawang ito na gumagana sa
5.004 o mas bago.

habang (<>) {
chomp;
PARSER: {
m/ \G( \d+\b )/gcx && do { print "number: $1\n"; gawing muli; };
m/ \G( \w+ )/gcx && do { print "word: $1\n"; gawing muli; };
m/ \G( \s+ )/gcx && do { print "space: $1\n"; gawing muli; };
m/ \G( [^\w\d]+ )/gcx && do { print "other: $1\n"; gawing muli; };
}
}

Para sa bawat linya, ang "PARSER" na loop ay unang sumusubok na tumugma sa isang serye ng mga digit na sinusundan ng a
hangganan ng salita. Ang laban na ito ay kailangang magsimula sa lugar kung saan natigil ang huling laban (o ang
simula ng string sa unang tugma). Dahil ang "m/ \G( \d+\b )/gcx" ay gumagamit ng "c" na bandila,
kung hindi tumutugma ang string sa regular na expression na iyon, hindi nagre-reset ang perl pos() at ang
magsisimula ang susunod na laban sa parehong posisyon upang subukan ang ibang pattern.

Sigurado Perl mga regex Mga DFA or mga NFA? Sigurado sila POSIX sumusunod?
Bagama't totoo na ang mga regular na expression ng Perl ay kahawig ng mga DFA (deterministic finite
automata) ng egrep(1) programa, ang mga ito sa katunayan ay ipinatupad bilang mga NFA (non-deterministic
finite automata) upang payagan ang backtracking at backreferencing. At hindi sila POSIX-style
alinman, dahil ginagarantiyahan ng mga iyon ang pinakamasamang pag-uugali para sa lahat ng kaso. (Mukhang may ilan
mas gusto ng mga tao ang mga garantiya ng pare-pareho, kahit na ang ginagarantiyahan ay kabagalan.) Tingnan ang
aklat na "Mastering Regular Expressions" (mula sa O'Reilly) ni Jeffrey Friedl para sa lahat ng detalye
maaari mong pag-asa na malaman ang tungkol sa mga bagay na ito (isang buong pagsipi ay lilitaw sa perlfaq2).

Ano ang mali sa paggamit grep in a walang bisa konteksto?
Ang problema ay ang grep ay bumubuo ng isang listahan ng pagbabalik, anuman ang konteksto. Ibig sabihin nito
pinapahirapan mo si Perl sa paggawa ng listahan na itatapon mo lang. Kung
malaki ang listahan, mag-aaksaya ka ng oras at espasyo. Kung ang iyong layunin ay umulit sa
list, pagkatapos ay gumamit ng for loop para sa layuning ito.

Sa mga perls na mas matanda sa 5.8.1, ang mapa ay dumaranas din ng problemang ito. Ngunit mula noong 5.8.1, ito
ay naayos na, at ang mapa ay may kamalayan sa konteksto - sa walang bisang konteksto, walang mga listahang ginawa.

Gaano maaari I tumugma string sa multibyte character?
Simula sa Perl 5.6 Ang Perl ay nagkaroon ng ilang antas ng multibyte na suporta sa character. Perl 5.8 o
mamaya ay inirerekomenda. Kasama sa mga sinusuportahang multibyte na repertoire ng character ang Unicode, at
mga legacy na encoding sa pamamagitan ng Encode module. Tingnan ang perluniintro, perlunicode, at Encode.

Kung natigil ka sa mas lumang Perls, maaari mong gawin ang Unicode gamit ang Unicode:: String module, at
mga conversion ng character gamit ang Unicode::Map8 at Unicode::Map modules. Kung ikaw ay gumagamit
Japanese encodings, maaari mong subukang gamitin ang jperl 5.005_03.

Sa wakas, ang sumusunod na hanay ng mga diskarte ay inaalok ni Jeffrey Friedl, na ang artikulo sa
Ang isyu #5 ng The Perl Journal ay nag-uusap tungkol sa bagay na ito.

Ipagpalagay nating mayroon kang kakaibang pag-encode ng Martian kung saan ang mga pares ng malalaking titik ng ASCII
i-encode ang mga solong titik ng Martian (ibig sabihin, ang dalawang byte na "CV" ay gumagawa ng isang titik ng Martian, tulad ng ginagawa
ang dalawang byte na "SG", "VS", "XX", atbp.). Ang iba pang mga byte ay kumakatawan sa mga solong character, tulad ng
ASCII.

Kaya, ang string ng Martian "Ako ay CVSGXX!" gumagamit ng 12 byte upang i-encode ang siyam na character na 'I',
' ', 'a', 'm', ' ', 'CV', 'SG', 'XX', '!'.

Ngayon, sabihin nating gusto mong hanapin ang nag-iisang character na "/GX/". Hindi alam ni Perl
Martian, kaya makikita nito ang dalawang byte na "GX" sa "I am CVSGXX!" string, kahit na iyon
wala doon ang character: parang katabi lang ng "SG" ang "XX", pero meron
walang totoong "GX". Ito ay isang malaking problema.

Narito ang ilang paraan, lahat ng masakit, para harapin ito:

# Siguraduhin na ang mga katabing "martian" na byte ay hindi na magkatabi.
$martian =~ s/([AZ][AZ])/ $1 /g;

i-print ang "Natagpuan ang GX!\n" kung $martian =~ /GX/;

O ganito:

my @chars = $martian =~ m/([AZ][AZ]|[^AZ])/g;
# sa itaas ay conceptually katulad sa: my @chars = $text =~ m/(.)/g;
#
foreach my $char (@chars) {
i-print ang "nahanap GX!\n", huling kung $char eq 'GX';
}

O ganito:

habang ($martian =~ m/\G([AZ][AZ]|.)/gs) { # \G malamang na hindi kailangan
kung ($1 eq 'GX') {
print "nahanap GX!\n";
huling;
}
}

Narito ang isa pa, medyo hindi gaanong masakit, paraan upang gawin ito mula kay Benjamin Goldberg, na gumagamit ng a
zero-width na negatibong pagtingin sa likod ng paninindigan.

i-print ang "Natagpuan ang GX!\n" kung $martian =~ m/
(?
(?:[AZ][AZ])*?
GX
/x;

Magtatagumpay ito kung ang "martian" na character na GX ay nasa string, at mabibigo kung hindi. kung ikaw
ayaw gumamit ng (?
(?

Mayroon itong disbentaha ng paglalagay ng maling bagay sa $-[0] at $+[0], ngunit karaniwan itong
maaaring magtrabaho sa paligid.

Gaano do I tumugma a regular pagpapahayag iyan in a variable?
(kontribusyon ni brian d foy)

Hindi namin kailangang mag-hard-code ng mga pattern sa operator ng tugma (o anumang bagay na gumagana
na may mga regular na expression). Maaari naming ilagay ang pattern sa isang variable para magamit sa ibang pagkakataon.

Ang operator ng tugma ay isang double quote na konteksto, kaya maaari mong i-interpolate lang ang iyong variable
parang double quoted string. Sa kasong ito, binabasa mo ang regular na expression bilang input ng user
at iimbak ito sa $regex. Kapag mayroon ka nang pattern sa $regex, gagamitin mo ang variable na iyon sa
operator ng tugma.

chomp( aking $regex = );

kung( $string =~ m/$regex/ ) { ... }

Ang anumang regular na expression na mga espesyal na character sa $regex ay espesyal pa rin, at ang pattern
kailangan pa ring maging wasto o magrereklamo si Perl. Halimbawa, sa pattern na ito mayroong isang
walang kaparehas na panaklong.

my $regex = "Walang kaparis ( paren";

"Dalawang pare upang itali silang lahat" =~ m/$regex/;

Kapag pinagsama-sama ng Perl ang regular na expression, tinatrato nito ang panaklong bilang simula ng a
tugma ng memorya. Kapag hindi nito nakita ang pansarang panaklong, nagrereklamo ito:

Walang kaparis ( sa regex; minarkahan ng <-- HERE sa m/Unmatched ( <-- HERE paren/ sa script line 3.

Maaari mong lampasan ito sa maraming paraan depende sa aming sitwasyon. Una, kung ayaw mo
gusto mong maging espesyal ang alinman sa mga character sa string, maaari mong takasan ang mga ito
"quotemeta" bago mo gamitin ang string.

chomp( aking $regex = );
$regex = quotemeta( $regex );

kung( $string =~ m/$regex/ ) { ... }

Magagawa mo rin ito nang direkta sa operator ng tugma gamit ang mga sequence na "\Q" at "\E". Ang
"\Q" ay nagsasabi kay Perl kung saan magsisimulang tumakas sa mga espesyal na character, at ang "\E" ay nagsasabi dito kung saan
huminto (tingnan ang perlop para sa higit pang mga detalye).

chomp( aking $regex = );

kung( $string =~ m/\Q$regex\E/ ) { ... }

Bilang kahalili, maaari mong gamitin ang "qr//", ang regular na expression quote operator (tingnan ang perlop para sa
higit pang mga detalye). Sinipi nito at marahil ay pinagsama-sama ang pattern, at maaari kang mag-apply nang regular
mga flag ng expression sa pattern.

chomp( aking $input = );

ang aking $regex = qr/$input/is;

$string =~ m/$regex/ # katulad ng m/$input/is;

Maaari mo ring i-trap ang anumang mga error sa pamamagitan ng pagbabalot ng isang "eval" na bloke sa buong bagay.

chomp( aking $input = );

eval {
if( $string =~ m/\Q$input\E/ ) { ... }
};
bigyan ng babala ang $@ kung $@;

O ...

aking $regex = eval { qr/$input/is };
kung( tinukoy $regex ) {
$string =~ m/$regex/;
}
tao {
bigyan ng babala ang $@;
}

AUTHOR AT COPYRIGHT

Copyright (c) 1997-2010 Tom Christiansen, Nathan Torkington, at iba pang mga may-akda gaya ng nabanggit.
Lahat ng karapatan ay nakareserba.

Ang dokumentasyong ito ay libre; maaari mo itong muling ipamahagi at/o baguhin ito sa ilalim ng parehong mga tuntunin
bilang Perl mismo.

Anuman ang pamamahagi nito, lahat ng mga halimbawa ng code sa file na ito ay inilalagay sa
ang pampublikong domain. Ikaw ay pinahihintulutan at hinihikayat na gamitin ang code na ito sa iyong sariling mga programa
para masaya o para kumita ayon sa nakikita mong akma. Ang isang simpleng komento sa code na nagbibigay ng kredito ay
magalang ngunit hindi kinakailangan.

Gamitin ang perlfaq6 online gamit ang mga serbisyo ng onworks.net