perlfaq6 - ອອນລາຍໃນຄລາວ

ໂຄງການ:

NAME

perlfaq6 - ການສະແດງອອກປົກກະຕິ

ເວີຊັ່ນ

5.021009 Version

ລາຍລະອຽດ

ພາກນີ້ເປັນເລື່ອງແປກທີ່ເລັກນ້ອຍເພາະວ່າສ່ວນທີ່ເຫຼືອຂອງ FAQ ແມ່ນເຕັມໄປດ້ວຍຄໍາຕອບ
ກ່ຽວຂ້ອງກັບການສະແດງອອກເປັນປົກກະຕິ. ຕົວຢ່າງ, ການຖອດລະຫັດ URL ແລະກວດເບິ່ງວ່າບາງສິ່ງບາງຢ່າງ
ແມ່ນຕົວເລກສາມາດຈັດການກັບການສະແດງອອກເປັນປົກກະຕິ, ແຕ່ຄໍາຕອບເຫຼົ່ານັ້ນແມ່ນພົບເຫັນຢູ່ບ່ອນອື່ນ
ໃນເອກະສານນີ້ (ໃນ perlfaq9: "ຂ້ອຍຈະຖອດລະຫັດ ຫຼືສ້າງ %-encodings ເຫຼົ່ານັ້ນຢູ່ໃນເວັບໄດ້ແນວໃດ"
ແລະ perlfaq4: "ຂ້ອຍຈະກໍານົດໄດ້ແນວໃດວ່າ scalar ເປັນຕົວເລກ / ທັງຫມົດ / integer / float", ຈະເປັນ.
ຊັດເຈນ).

ວິທີການ ສາມາດເຮັດໄດ້ I ຫວັງວ່າ to ການນໍາໃຊ້ ປົກກະຕິ expressions ໂດຍບໍ່ມີການ ການສ້າງ ຜິດກົດ ໝາຍ ແລະ ບໍ່ສາມາດຮັກສາໄດ້ ລະຫັດ?
ສາມເຕັກນິກສາມາດເຮັດໃຫ້ການສະແດງອອກເປັນປົກກະຕິຮັກສາແລະເຂົ້າໃຈໄດ້.

ຄໍາເຫັນນອກ Regex
ອະທິບາຍສິ່ງທີ່ທ່ານກໍາລັງເຮັດແລະວິທີທີ່ທ່ານກໍາລັງເຮັດມັນ, ໂດຍໃຊ້ຄໍາຄິດເຫັນ Perl ປົກກະຕິ.

# ປ່ຽນເສັ້ນເປັນຄໍາທໍາອິດ, ຈໍ້າສອງເມັດ, ແລະ
# ຕົວເລກຂອງຕົວອັກສອນໃນສ່ວນທີ່ເຫຼືອຂອງແຖວ
s/^(\w+)(.*)/ lc($1). " : " . length($2) /meg;

ຄໍາເຫັນພາຍໃນ Regex
ຕົວແກ້ໄຂ "/x" ເຮັດໃຫ້ຊ່ອງຫວ່າງຖືກລະເລີຍໃນຮູບແບບ regex (ຍົກເວັ້ນໃນ a
ຫ້ອງຮຽນຕົວອັກສອນແລະສະຖານທີ່ອື່ນໆຈໍານວນຫນ້ອຍ), ແລະຍັງອະນຸຍາດໃຫ້ທ່ານສາມາດນໍາໃຊ້ຄໍາເຫັນປົກກະຕິ
ຢູ່ທີ່ນັ້ນ. ຕາມທີ່ທ່ານສາມາດຈິນຕະນາການ, ຊ່ອງຫວ່າງແລະຄໍາເຫັນຊ່ວຍຫຼາຍ.

"/x" ໃຫ້ທ່ານເປີດອັນນີ້:

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

ເຂົ້າໄປໃນນີ້:

s{ < # ວົງເລັບມຸມເປີດ
(?: # non-backreffing grouping paren
[^>'"] * # 0 ຫຼືຫຼາຍກວ່າສິ່ງທີ່ບໍ່ແມ່ນ > ຫຼື ' ຫຼື "
| # ຫຼືອື່ນໆ
".*?" # ສ່ວນລະຫວ່າງວົງຢືມຄູ່ (ການຈັບຄູ່ທີ່ຂີ້ຄ້ານ)
| # ຫຼືອື່ນໆ
'.*?' # ສ່ວນລະຫວ່າງຄຳເວົ້າດຽວ (ກົງກັນທີ່ຂີ້ຄ້ານ)
) + # ທັງຫມົດທີ່ເກີດຂຶ້ນຫນຶ່ງຫຼືຫຼາຍຄັ້ງ
> # ວົງເລັບປິດ
}{}gsx; # ແທນທີ່ບໍ່ມີຫຍັງ, ie ລຶບ

ມັນຍັງບໍ່ຊັດເຈນຫຼາຍເປັນ prose, ແຕ່ມັນເປັນປະໂຫຍດຫຼາຍສໍາລັບການອະທິບາຍ
ຄວາມຫມາຍຂອງແຕ່ລະສ່ວນຂອງຮູບແບບ.

ຕົວຂັ້ນທີ່ແຕກຕ່າງກັນ
ໃນຂະນະທີ່ປົກກະຕິແລ້ວພວກເຮົາຄິດເຖິງຮູບແບບທີ່ຖືກຈໍາກັດດ້ວຍຕົວອັກສອນ "/", ພວກມັນສາມາດເຮັດໄດ້
ຖືກຈໍາກັດໂດຍເກືອບທຸກຕົວອັກສອນ. perlre ອະທິບາຍນີ້. ຕົວຢ່າງ, "s///"
ຂ້າງເທິງໃຊ້ວົງເລັບເປັນຕົວຂັ້ນ. ການເລືອກຕົວຂັ້ນອື່ນສາມາດຫຼີກເວັ້ນການອ້າງອີງ
ຕົວຂັ້ນພາຍໃນຮູບແບບ:

s/\/ usr\/ທ້ອງຖິ່ນ/\/ usr\/share/g; # ທາງເລືອກຕົວຂັ້ນທີ່ບໍ່ດີ
s#/ usr / ທ້ອງຖິ່ນ#/ usr / share#g; # ດີກວ່າ

ການນໍາໃຊ້ຕົວກໍານົດການຈັບຄູ່ຢ່າງມີເຫດຜົນສາມາດອ່ານໄດ້ຫຼາຍກວ່າເກົ່າ:

s{/ usr / ທ້ອງຖິ່ນ /}{/ usr / share}g; # ຍັງດີກວ່າ

ຂ້ອຍ ມີ ບັນຫາໃນການ ການຈັບຄູ່ ໃນໄລຍະ ເພີ່ມເຕີມ ກ່ວາ ຫນຶ່ງ ເສັ້ນ. ແມ່ນຫຍັງ ຜິດບໍ?
ບໍ່ວ່າເຈົ້າບໍ່ມີຫຼາຍກວ່າໜຶ່ງເສັ້ນໃນສະຕຣິງທີ່ເຈົ້າກຳລັງເບິ່ງຢູ່ (ອາດຈະເປັນ), ຫຼື
ອື່ນ, ເຈົ້າບໍ່ໄດ້ໃຊ້ຕົວແກ້ໄຂທີ່ຖືກຕ້ອງຕາມຮູບແບບຂອງເຈົ້າ (ອາດຈະເປັນ).

ມີຫຼາຍວິທີທີ່ຈະເອົາຂໍ້ມູນຫຼາຍແຖວເຂົ້າໃນສະຕຣິງ. ຖ້າທ່ານຕ້ອງການໃຫ້ມັນເກີດຂຶ້ນ
ອັດຕະໂນມັດໃນຂະນະທີ່ອ່ານການປ້ອນຂໍ້ມູນ, ທ່ານຕ້ອງການຕັ້ງ $/ (ອາດຈະເປັນ '' ສໍາລັບວັກຫຼື
"undef" ສໍາລັບໄຟລ໌ທັງຫມົດ) ເພື່ອເຮັດໃຫ້ທ່ານສາມາດອ່ານຫຼາຍກວ່າຫນຶ່ງແຖວໃນເວລານັ້ນ.

ອ່ານ perlre ເພື່ອຊ່ວຍໃຫ້ທ່ານຕັດສິນໃຈວ່າ "/s" ແລະ "/m" (ຫຼືທັງສອງ) ທີ່ທ່ານອາດຈະຕ້ອງການໃຊ້:
"/s" ອະນຸຍາດໃຫ້ຈຸດເພື່ອລວມເອົາເສັ້ນໃຫມ່, ແລະ "/m" ອະນຸຍາດໃຫ້ cart ແລະເງິນໂດລາກົງກັນກັບ a.
newline, ບໍ່ພຽງແຕ່ຢູ່ໃນຕອນທ້າຍຂອງສາຍ. ທ່ານ ຈຳ ເປັນຕ້ອງຮັບປະກັນວ່າທ່ານໄດ້ຕົວຈິງແລ້ວ
ມີສາຍຫຼາຍແຖວຢູ່ໃນນັ້ນ.

ຕົວຢ່າງ, ໂຄງການນີ້ກວດພົບຄໍາທີ່ຊ້ໍາກັນ, ເຖິງແມ່ນວ່າໃນເວລາທີ່ພວກເຂົາຂະຫຍາຍເສັ້ນແບ່ງ (ແຕ່
ບໍ່ແມ່ນວັກ). ຕົວຢ່າງນີ້, ພວກເຮົາບໍ່ຕ້ອງການ "/s" ເພາະວ່າພວກເຮົາບໍ່ໄດ້ໃຊ້ຈຸດໃນ a
ການສະແດງອອກປົກກະຕິທີ່ພວກເຮົາຕ້ອງການທີ່ຈະຂ້າມເສັ້ນຊາຍແດນ. ພວກເຮົາບໍ່ຕ້ອງການ "/m" ເພາະວ່າ
ພວກ​ເຮົາ​ບໍ່​ຕ້ອງ​ການ cart ຫຼື​ເງິນ​ໂດ​ລາ​ທີ່​ຈະ​ກົງ​ກັນ​ໃນ​ຈຸດ​ໃດ​ຫນຶ່ງ​ໃນ​ບັນ​ທຶກ​ການ​ຕໍ່​ໄປ​ກັບ​ສາຍ​ໃຫມ່​.
ແຕ່ມັນຈໍາເປັນທີ່ $/ ຖືກຕັ້ງເປັນສິ່ງອື່ນທີ່ບໍ່ແມ່ນຄ່າເລີ່ມຕົ້ນ, ຖ້າບໍ່ດັ່ງນັ້ນພວກເຮົາຈະບໍ່
ຕົວຈິງແລ້ວເຄີຍມີບັນທຶກຫຼາຍແຖວອ່ານຢູ່ໃນ.

$/ = ''; # ອ່ານທັງຫຍໍ້ໜ້າ, ບໍ່ແມ່ນແຕ່ແຖວດຽວ
ໃນຂະນະທີ່ ( <> ) {
ໃນຂະນະທີ່ ( /\b([\w'-]+)(\s+\g1)+\b/gi ) { # ຄໍາເລີ່ມຕົ້ນ alpha
ພິມ "ຊໍ້າກັນ $1 ຢູ່ວັກ $.\n";
}
}

ນີ້ແມ່ນລະຫັດບາງຢ່າງທີ່ຊອກຫາປະໂຫຍກທີ່ເລີ່ມຕົ້ນດ້ວຍ "ຈາກ" (ເຊິ່ງຈະຖືກທໍາລາຍໂດຍ
mailers ຫຼາຍ):

$/ = ''; # ອ່ານທັງຫຍໍ້ໜ້າ, ບໍ່ແມ່ນແຕ່ແຖວດຽວ
ໃນຂະນະທີ່ ( <> ) {
ໃນຂະນະທີ່ ( /^From /gm ) { # /m ເຮັດໃຫ້ ^ ກົງກັບ \n
ພິມ "ນໍາມາຈາກວັກ $.\n";
}
}

ນີ້ແມ່ນລະຫັດທີ່ຊອກຫາທຸກຢ່າງລະຫວ່າງ START ແລະ END ໃນວັກ:

undef $/; # ອ່ານໃນໄຟລ໌ທັງຫມົດ, ບໍ່ພຽງແຕ່ຫນຶ່ງແຖວຫຼືວັກ
ໃນຂະນະທີ່ ( <> ) {
ໃນຂະນະທີ່ ( /START.*?)END/sgm ) { # /s ເຮັດໃຫ້ . ເສັ້ນ​ຊາຍ​ແດນ​ຂ້າມ​
ພິມ "$1\n";
}
}

ວິທີການ ສາມາດເຮັດໄດ້ I ດຶງ ອອກ ສາຍ ລະຫວ່າງ ສອງ ຮູບແບບການ ທີ່ ມີ ດ້ວຍຕົນເອງ on ທີ່ແຕກຕ່າງກັນ ສາຍ?
ທ່ານສາມາດໃຊ້ Perl's exotic ".." operator (ບັນທຶກໄວ້ໃນ perlop):

perl -ne 'ພິມຖ້າ /START/ .. /END/' file1 file2 ...

ຖ້າທ່ານຕ້ອງການຂໍ້ຄວາມແລະບໍ່ແມ່ນເສັ້ນ, ທ່ານຈະໃຊ້

perl -0777 -ne 'ພິມ "$1\n" ໃນຂະນະທີ່ /START.*?)END/gs' file1 file2 ...

ແຕ່ຖ້າທ່ານຕ້ອງການການປະກົດຕົວແບບຊ້ອນກັນຂອງ "START" ຈົນເຖິງ "END", ທ່ານຈະແລ່ນຂຶ້ນຕໍ່ຕ້ານ
ບັນຫາທີ່ອະທິບາຍໄວ້ໃນຄໍາຖາມໃນພາກນີ້ກ່ຽວກັບການຈັບຄູ່ຂໍ້ຄວາມທີ່ສົມດູນ.

ນີ້ແມ່ນຕົວຢ່າງອື່ນຂອງການໃຊ້ "..":

ໃນຂະນະທີ່ (<>) {
$in_header ຂອງຂ້ອຍ = 1 .. /^$/;
$in_body ຂອງຂ້ອຍ = /^$/ .. eof;
# ດຽວນີ້ເລືອກລະຫວ່າງພວກມັນ
} ສືບຕໍ່ {
$. = 0 ຖ້າ eof; # ແກ້ໄຂ $.
}

ວິທີການ do I ການແຂ່ງຂັນ XML, HTML, or ອື່ນໆ ຂີ້ຮ້າຍ, ugly ສິ່ງທີ່ ກັບ a regex?
ຢ່າໃຊ້ regexes. ໃຊ້ໂມດູນແລະລືມກ່ຽວກັບການສະແດງອອກປົກກະຕິ. ໄດ້
XML::LibXML, HTML::TokeParser ແລະ HTML::ໂມດູນ TreeBuilder ແມ່ນການເລີ່ມຕົ້ນທີ່ດີ, ເຖິງແມ່ນວ່າແຕ່ລະອັນ.
namespace ມີໂມດູນ parsing ອື່ນໆພິເສດສໍາລັບວຽກງານສະເພາະໃດຫນຶ່ງແລະວິທີການທີ່ແຕກຕ່າງກັນຂອງ
ເຮັດມັນ. ເລີ່ມຕົ້ນທີ່ CPAN Search (http://metacpan.org/> ) ແລະສິ່ງມະຫັດໃນການເຮັດວຽກທັງຫມົດ
ປະຊາຊົນໄດ້ເຮັດສໍາລັບທ່ານແລ້ວ! :)

I ເອົາໃຈໃສ່ a ປົກກະຕິ ການສະແດງອອກ ເຂົ້າໄປໃນ $/ ແຕ່ it ບໍ່ໄດ້ ເຮັດວຽກ. ແມ່ນຫຍັງ ຜິດບໍ?
$/ ຕ້ອງເປັນສະຕຣິງ. ທ່ານສາມາດນໍາໃຊ້ຕົວຢ່າງເຫຼົ່ານີ້ຖ້າທ່ານຕ້ອງການເຮັດແນວນີ້ແທ້ໆ.

ຖ້າ​ຫາກ​ທ່ານ​ມີ File::Stream, ນີ້​ແມ່ນ​ງ່າຍ​ດາຍ.

ໃຊ້ File::Stream;

$stream = ໄຟລ໌::ສະຕຣີມ->ໃໝ່(
$filehandle,
ຕົວແຍກ => qr/\s*,\s*/,
);

ພິມ "$_\n" ໃນຂະນະທີ່ <$stream>;

ຖ້າ​ຫາກ​ວ່າ​ທ່ານ​ບໍ່​ມີ File::Stream, ທ່ານ​ຈະ​ຕ້ອງ​ເຮັດ​ວຽກ​ຫຼາຍ​ເລັກ​ນ້ອຍ​.

ທ່ານສາມາດນໍາໃຊ້ຮູບແບບສີ່ການໂຕ້ຖຽງຂອງ sysread ເພື່ອສືບຕໍ່ເພີ່ມໃສ່ buffer. ຫຼັງ​ຈາກ​ທີ່​ທ່ານ
ເພີ່ມໃສ່ buffer, ທ່ານກວດເບິ່ງວ່າທ່ານມີເສັ້ນຄົບຖ້ວນສົມບູນ (ໂດຍນໍາໃຊ້ການສະແດງອອກປົກກະຕິຂອງທ່ານ).

ທ້ອງຖິ່ນ $_ = "";
while(sysread FH, $_, 8192, length ) {
ໃນຂະນະທີ່(s/^((?s).*?) your_pattern// ) {
$record ຂອງຂ້ອຍ = $1;
#ເຮັດສິ່ງຂອງຢູ່ນີ້.
}
}

ທ່ານສາມາດເຮັດສິ່ງດຽວກັນກັບ foreach ແລະການແຂ່ງຂັນໂດຍໃຊ້ທຸງ c ແລະສະມໍ \ G, ຖ້າ
ທ່ານບໍ່ສົນໃຈໄຟລ໌ທັງຫມົດຂອງທ່ານຢູ່ໃນຫນ່ວຍຄວາມຈໍາໃນຕອນທ້າຍ.

ທ້ອງຖິ່ນ $_ = "";
while(sysread FH, $_, 8192, length ) {
foreach my $record ( m/\G((?s).*?)your_pattern/gc ) {
#ເຮັດສິ່ງຂອງຢູ່ນີ້.
}
substr($_, 0, pos ) = "" ຖ້າ pos;
}

ວິທີການ do I ທົດແທນ case-insensitively on ໄດ້ LHS ໃນຂະນະທີ່ ປົກປັກຮັກສາ ກໍລະນີ on ໄດ້ RHS?
ນີ້ແມ່ນການແກ້ໄຂ Perlish ທີ່ຫນ້າຮັກໂດຍ Larry Rosler. ມັນຂຸດຄົ້ນຄຸນສົມບັດຂອງ bitwise xor on
ສະຕຣິງ ASCII.

$_= "ນີ້ແມ່ນກໍລະນີ TEsT";

$old = 'ທົດສອບ';
$new = 'ຄວາມສຳເລັດ';

s{(\Q$old\E)}
{ uc $ ໃຫມ່ | (uc $1 ^ $1).
(uc(substr $1, -1) ^ substr $1, -1) x
(ຄວາມຍາວ($ໃໝ່) - ຄວາມຍາວ $1)
}ເຊັ່ນ;

ພິມ;

ແລະນີ້ແມ່ນເປັນ subroutine, modeled ຫຼັງຈາກຂ້າງເທິງນີ້:

sub preserve_case {
ຂອງຂ້ອຍ ($old, $new) = @_;
my $mask = uc $old ^ $old;

uc $ ໃຫມ່ | $ໜ້າກາກ.
substr($mask, -1) x (length($new) - length($old))
}

$string = "ນີ້ແມ່ນກໍລະນີ TEsT";
$string =~ s/(test)/preserve_case($1, "success")/egi;
ພິມ "$string\n";

ນີ້ພິມ:

ນີ້ແມ່ນກໍລະນີ SucCESS

ໃນ​ຖາ​ນະ​ເປັນ​ທາງ​ເລືອກ​, ເພື່ອ​ຮັກ​ສາ​ກໍ​ລະ​ນີ​ຂອງ​ຄໍາ​ທົດ​ແທນ​ຖ້າ​ຫາກ​ວ່າ​ມັນ​ແມ່ນ​ຍາວ​ກວ່າ​
ຕົ້ນສະບັບ, ທ່ານສາມາດນໍາໃຊ້ລະຫັດນີ້, ໂດຍ Jeff Pinyan:

sub preserve_case {
ຂອງຂ້ອຍ ($from, $to) = @_;
my ($lf, $lt) = ຄວາມຍາວແຜນທີ່, @_;

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

ກັບຄືນ uc $to | ($from ^uc $from);
}

ນີ້ປ່ຽນປະໂຫຍກເປັນ "ນີ້ແມ່ນກໍລະນີ SUcCess."

ພຽງແຕ່ສະແດງໃຫ້ເຫັນວ່ານັກຂຽນໂປລແກລມ C ສາມາດຂຽນ C ໃນພາສາການຂຽນໂປຼແກຼມໃດກໍ່ຕາມ, ຖ້າທ່ານຕ້ອງການ a
ການແກ້ໄຂ C-like ຫຼາຍ, script ຕໍ່ໄປນີ້ເຮັດໃຫ້ການທົດແທນມີກໍລະນີດຽວກັນ,
ຈົດຫມາຍສະບັບໂດຍຈົດຫມາຍ, ເປັນຕົ້ນສະບັບ. (ມັນຍັງເກີດຂຶ້ນທີ່ຈະດໍາເນີນການປະມານ 240% ຊ້າກວ່າ
ການແກ້ໄຂ Perlish ແລ່ນ.) ຖ້າການທົດແທນມີຕົວອັກສອນຫຼາຍກວ່າສະຕຣິງ
ແທນ, ກໍລະນີຂອງຕົວອັກສອນສຸດທ້າຍແມ່ນໃຊ້ສໍາລັບສ່ວນທີ່ເຫຼືອຂອງການທົດແທນ.

# ຕົ້ນສະບັບໂດຍ Nathan Torkington, ນວດໂດຍ Jeffrey Friedl
#
sub preserve_case
{
ຂອງຂ້ອຍ ($old, $new) = @_;
$state ຂອງຂ້ອຍ = 0; # 0 = ບໍ່ມີການປ່ຽນແປງ; 1 = lc; 2 = ອຄ
ຂອງຂ້ອຍ ($i, $oldlen, $newlen, $c) = (0, length($old), length($new));
$len ຂອງຂ້ອຍ = $oldlen < $newlen ? $oldlen : $newlen;

ສໍາລັບ ($i = 0; $i < $len; $i++) {
ຖ້າ ($c = substr($old, $i, 1), $c =~ /[\W\d_]/) {
$state = 0;
} elsif (lc $c eq $c) {
substr($new, $i, 1) = lc(substr($new, $i, 1));
$state = 1;
} else {
substr($new, $i, 1) = uc(substr($new, $i, 1));
$state = 2;
}
}
# ຈົບກັບອັນໃໝ່ທີ່ຍັງເຫຼືອ (ເພາະອັນໃໝ່ຍາວກວ່າເກົ່າ)
ຖ້າ ($newlen> $oldlen) {
ຖ້າ ($state == 1) {
substr($new, $oldlen) = lc(substr($new, $oldlen));
} elsif ($state == 2) {
substr($new, $oldlen) = uc(substr($new, $oldlen));
}
}
ກັບຄືນ $new;
}

ວິທີການ ສາມາດເຮັດໄດ້ I ເຮັດໃຫ້ "\w" ການແຂ່ງຂັນ ແຫ່ງຊາດ ລັກສະນະ ຊຸດ?
ໃສ່ "ໃຊ້ທ້ອງຖິ່ນ;" ໃນ script ຂອງທ່ານ. ຫ້ອງຮຽນຕົວອັກສອນ \w ຖືກເອົາມາຈາກທ້ອງຖິ່ນປະຈຸບັນ.

ເບິ່ງ perlocale ສໍາລັບລາຍລະອຽດ.

ວິທີການ ສາມາດເຮັດໄດ້ I ການແຂ່ງຂັນ a locale-smart ສະບັບພາສາ of "/[a-zA-Z]/"?
ທ່ານສາມາດນໍາໃຊ້ syntax ປະເພດຕົວອັກສອນ POSIX "/[[:alpha:]]/" ທີ່ບັນທຶກໄວ້ໃນ perlre.

ບໍ່ວ່າເຈົ້າຈະຢູ່ໃນທ້ອງຖິ່ນໃດ, ຕົວໜັງສືແມ່ນຕົວໜັງສືໃນ \w
ໂດຍບໍ່ມີການຕົວເລກແລະ underscore ໄດ້. ໃນຖານະເປັນ regex, ມັນຄ້າຍຄື "/[^\W\d_]/". ຂອງມັນ
ການເສີມ, ທີ່ບໍ່ແມ່ນຕົວອັກສອນ, ຫຼັງຈາກນັ້ນທຸກສິ່ງທຸກຢ່າງຢູ່ໃນ \W ພ້ອມກັບຕົວເລກແລະ
ຂີດກ້ອງ, ຫຼື "/[\W\d_]/".

ວິທີການ ສາມາດເຮັດໄດ້ I quote a ຕົວແປ to ການນໍາໃຊ້ in a regex?
Perl parser ຈະຂະຫຍາຍການອ້າງອີງ $variable ແລະ @variable ໃນການສະແດງອອກປົກກະຕິ
ເວັ້ນເສຍແຕ່ວ່າຕົວຂັ້ນແມ່ນເປັນວົງຢືມດຽວ. ຈືຂໍ້ມູນການ, ເຊັ່ນດຽວກັນ, ດ້ານຂວາມືຂອງ a
"s///" ການທົດແທນແມ່ນຖືວ່າເປັນສະຕຣິງທີ່ອ້າງອີງສອງເທົ່າ (ເບິ່ງ perlop ສໍາລັບລາຍລະອຽດເພີ່ມເຕີມ).
ຈື່ໄວ້ວ່າຕົວລະຄອນພິເສດ regex ໃດໆຈະຖືກປະຕິບັດເວັ້ນເສຍແຕ່ວ່າທ່ານໄດ້ນໍາຫນ້າ
ການທົດແທນດ້ວຍ \Q. ນີ້ແມ່ນຕົວຢ່າງ:

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

$string =~ s/$regex/Polyp/;
# $string ດຽວນີ້ແມ່ນ "Polypacido P. Octopus"

ເນື່ອງຈາກວ່າ "." ແມ່ນພິເສດໃນການສະແດງອອກປົກກະຕິ, ແລະສາມາດກົງກັບຕົວອັກສອນດຽວ, ໄດ້
regex "P." ທີ່ນີ້ໄດ້ຈັບຄູ່ກັບ ໃນສາຍຕົ້ນສະບັບ.

ເພື່ອຫລົບຫນີຄວາມຫມາຍພິເສດຂອງ ".", ພວກເຮົາໃຊ້ "\Q":

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

$string =~ s/\Q$regex/Polyp/;
# $string ດຽວນີ້ແມ່ນ "Placido Polyp Octopus"

ການໃຊ້ "\Q" ເຮັດໃຫ້ <.> ໃນ regex ຖືກປະຕິບັດເປັນລັກສະນະປົກກະຕິ, ດັ່ງນັ້ນ.
"ປ." ກົງກັບ "P" ຕາມດ້ວຍຈຸດ.

ແມ່ນ​ຫຍັງ is "/o" ກໍ່ ສໍາລັບ?
(ປະກອບສ່ວນໂດຍ brian d foy)

ຕົວເລືອກ "/o" ສໍາລັບການສະແດງອອກປົກກະຕິ (ເອກະສານໃນ perlop ແລະ perlreref) ບອກ Perl ກັບ
ລວບລວມການສະແດງອອກປົກກະຕິພຽງແຕ່ຄັ້ງດຽວ. ນີ້ແມ່ນເປັນປະໂຫຍດພຽງແຕ່ໃນເວລາທີ່ຮູບແບບປະກອບມີ a
ຕົວແປ. Perls 5.6 ແລະຕໍ່ມາຈັດການນີ້ໂດຍອັດຕະໂນມັດຖ້າຮູບແບບບໍ່ປ່ຽນແປງ.

ນັບຕັ້ງແຕ່ຕົວປະຕິບັດການຈັບຄູ່ "m//", ຕົວປະຕິບັດການທົດແທນ "s///", ແລະປົກກະຕິ
expression quoting operator "qr//" ແມ່ນໂຄງສ້າງ double-quotish, ທ່ານສາມາດ interpolate
ຕົວແປເຂົ້າໄປໃນຮູບແບບ. ເບິ່ງຄໍາຕອບຂອງ "ຂ້ອຍສາມາດອ້າງອີງຕົວແປເພື່ອໃຊ້ໃນ a
regex?" ສໍາລັບລາຍລະອຽດເພີ່ມເຕີມ.

ຕົວຢ່າງນີ້ໃຊ້ເວລາການສະແດງອອກປົກກະຕິຈາກບັນຊີລາຍຊື່ການໂຕ້ຖຽງແລະພິມເສັ້ນຂອງ
ການ​ປ້ອນ​ຂໍ້​ມູນ​ທີ່​ກົງ​ກັບ​ມັນ​:

$pattern ຂອງຂ້ອຍ = shift @ARGV;

ໃນຂະນະທີ່ ( <> ) {
ພິມຖ້າ m/$pattern/;
}

ເວີຊັນຂອງ Perl ກ່ອນ 5.6 ຈະລວບລວມການສະແດງອອກປົກກະຕິສໍາລັບແຕ່ລະ iteration,
ເຖິງແມ່ນວ່າ $pattern ບໍ່ໄດ້ປ່ຽນແປງ. "/o" ຈະປ້ອງກັນສິ່ງນີ້ໂດຍບອກ Perl ໃຫ້ລວບລວມ
ຮູບ​ແບບ​ການ​ຄັ້ງ​ທໍາ​ອິດ​, ຫຼັງ​ຈາກ​ນັ້ນ​ນໍາ​ໃຊ້​ຄືນ​ໃຫມ່​ສໍາ​ລັບ​ການ​ຕໍ່​ໄປ​ນີ້​:

$pattern ຂອງຂ້ອຍ = shift @ARGV;

ໃນຂະນະທີ່ ( <> ) {
ພິມຖ້າ m/$pattern/o; # ມີປະໂຫຍດສຳລັບ Perl < 5.6
}

ໃນຮຸ່ນ 5.6 ແລະຕໍ່ມາ, Perl ຈະບໍ່ລວບລວມການສະແດງອອກປົກກະຕິຖ້າຕົວແປ
ບໍ່ໄດ້ປ່ຽນແປງ, ດັ່ງນັ້ນທ່ານອາດຈະບໍ່ຕ້ອງການທາງເລືອກ "/o". ມັນບໍ່ເຈັບປວດ, ແຕ່ມັນ
ບໍ່ໄດ້ຊ່ວຍຄືກັນ. ຖ້າທ່ານຕ້ອງການສະບັບໃດໆຂອງ Perl ເພື່ອລວບລວມການສະແດງອອກປົກກະຕິ
ພຽງແຕ່ຄັ້ງດຽວເຖິງແມ່ນວ່າການປ່ຽນແປງຕົວແປ (ດັ່ງນັ້ນ, ພຽງແຕ່ໃຊ້ມູນຄ່າເບື້ອງຕົ້ນຂອງມັນ), ທ່ານຍັງ
ຕ້ອງການ "/o".

ທ່ານສາມາດເບິ່ງເຄື່ອງຈັກການສະແດງອອກປົກກະຕິຂອງ Perl ຢູ່ບ່ອນເຮັດວຽກເພື່ອກວດສອບຕົວເອງວ່າ Perl ແມ່ນບໍ
recompiling ການສະແດງອອກປົກກະຕິ. The "use re 'debug'" pragma (ມາພ້ອມກັບ Perl 5.005 ແລະ
ຕໍ່ມາ) ສະແດງໃຫ້ເຫັນລາຍລະອຽດ. ດ້ວຍ Perls ກ່ອນ 5.6, ທ່ານຄວນເຫັນ "re" ລາຍງານວ່າມັນ
ລວບລວມການສະແດງອອກປົກກະຕິໃນແຕ່ລະ iteration. ດ້ວຍ Perl 5.6 ຫຼືຫຼັງຈາກນັ້ນ, ທ່ານຄວນ
ພຽງແຕ່ເບິ່ງ "re" ລາຍງານວ່າສໍາລັບການ iteration ທໍາອິດ.

ໃຊ້ re 'debug';

$regex ຂອງຂ້ອຍ = 'Perl';
foreach ( qw(Perl Java Ruby Python) ) {
ພິມ STDERR "-" x 73, "\n";
ພິມ STDERR "ກຳລັງພະຍາຍາມ $_...\n";
ພິມ STDERR "\t$_ ແມ່ນດີ!\n" ຖ້າ m/$regex/;
}

ວິທີການ do I ການນໍາໃຊ້ a ປົກກະຕິ ການສະແດງອອກ to ອອກ ແບບ C ຄໍາ​ເຫັນ ຈາກ a ແຟ້ມ?
ໃນ​ຂະ​ນະ​ທີ່​ນີ້​ຕົວ​ຈິງ​ແລ້ວ​ສາ​ມາດ​ເຮັດ​ໄດ້, ມັນ​ເປັນ​ຫຼາຍ​ຍາກ​ກ​່​ວາ​ທີ່​ທ່ານ​ຄິດ. ຕົວຢ່າງ, ນີ້
ໜຶ່ງ ເສັ້ນ

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

ຈະເຮັດວຽກຢູ່ໃນຫຼາຍແຕ່ບໍ່ແມ່ນທຸກກໍລະນີ. ເຈົ້າເຫັນ, ມັນງ່າຍເກີນໄປໃນໃຈສໍາລັບບາງປະເພດ
ໂຄງການ C, ໂດຍສະເພາະ, ຜູ້ທີ່ມີສິ່ງທີ່ເບິ່ງຄືວ່າເປັນຄໍາຄິດຄໍາເຫັນໃນສາຍທີ່ອ້າງອີງ. ສໍາລັບ
ວ່າ, ທ່ານຕ້ອງການບາງສິ່ງບາງຢ່າງເຊັ່ນນີ້, ສ້າງໂດຍ Jeffrey Friedl ແລະຕໍ່ມາດັດແກ້ໂດຍ Fred
Curtis

$/ = undef;
$_ = <> ;
s#/\*[^*]*\*+([^/*][^*]*\*+)*/|("(\\.|[^"\\])*"|'( \\.|[^'\\])*'|.[^/"'\\]*)#ກໍານົດ $2 ? $2: "" #gse;
ພິມ;

ນີ້, ແນ່ນອນ, ອາດຈະຖືກຂຽນຢ່າງຖືກຕ້ອງກັບຕົວແກ້ໄຂ "/x", ເພີ່ມຊ່ອງຫວ່າງ
ແລະຄໍາເຫັນ. ໃນທີ່ນີ້ມັນໄດ້ຖືກຂະຫຍາຍ, ມາລະຍາດຂອງ Fred Curtis.

s{
/\* ## ເລີ່ມຕົ້ນຂອງ /* ... */ ຄໍາເຫັນ
[^*]*\*+ ## ບໍ່ແມ່ນ* ຕາມດ້ວຍ 1 ຫຼືຫຼາຍກວ່າ *'s
(
[^/*][^*]*\*+
)* ## 0-or-more ສິ່ງທີ່ບໍ່ເລີ່ມຕົ້ນດ້ວຍ /
## ແຕ່ລົງທ້າຍດ້ວຍ '*'
/ ## ສິ້ນສຸດ /* ... */ comment

| ## ຫຼືສິ່ງຕ່າງໆທີ່ບໍ່ແມ່ນຄໍາເຫັນ:

(
" ## ເລີ່ມຕົ້ນຂອງ " ... " string
(
\\. ## ໜີ char
| ## ຫຼື
[^"\\] ## ບໍ່ "\
)*
" ## ສິ້ນສຸດຂອງ " ... " string

| ## ຫຼື

' ## ເລີ່ມຕົ້ນຂອງ ' ... ' string
(
\\. ## ໜີ char
| ## ຫຼື
[^'\\] ## ບໍ່ແມ່ນ '\
)*
' ## ສິ້ນສຸດຂອງ ' ... ' string

| ## ຫຼື

. ## ອັນໃດອັນໜຶ່ງ char
[^/"'\\]* ## ຕົວອັກຂະລະທີ່ບໍ່ເລີ່ມຄຳເຫັນ, ສະຕຣິງ ຫຼື ໜີ
)
}{ກຳນົດ $2 ? $2 : ""}gxse;

ການ​ດັດ​ແກ້​ເລັກ​ນ້ອຍ​ຍັງ​ເອົາ​ຄໍາ​ຄິດ​ເຫັນ C ++​, ອາດ​ຈະ​ຂະ​ຫຍາຍ​ຫຼາຍ​ແຖວ​ໂດຍ​ການ​ນໍາ​ໃຊ້ a
ລັກສະນະຕໍ່ເນື່ອງ:

s#/\*[^*]*\*+([^/*][^*]*\*+)*/|//([^\\]|[^\n][\n]? )*?\n|("(\\.|[^"\\])*"|'(\\.|[^'\\])*'|.[^/"'\\]*) #ກຳນົດ $3 ? $3: "" #gse;

ສາມາດເຮັດໄດ້ I ການນໍາໃຊ້ Perl ປົກກະຕິ expressions to ການແຂ່ງຂັນ ສົມດຸນ ຂໍ້​ຄວາມ?
(ປະກອບສ່ວນໂດຍ brian d foy)

ຄວາມພະຍາຍາມທໍາອິດຂອງທ່ານອາດຈະເປັນຂໍ້ຄວາມ::ໂມດູນທີ່ສົມດຸນ, ເຊິ່ງຢູ່ໃນມາດຕະຖານ Perl
ຫ້ອງສະຫມຸດນັບຕັ້ງແຕ່ Perl 5.8. ມັນມີຫນ້າທີ່ຫລາກຫລາຍເພື່ອຈັດການກັບຂໍ້ຄວາມທີ່ຫຍຸ້ງຍາກ. ໄດ້
Regexp::ໂມດູນທົ່ວໄປສາມາດຊ່ວຍໄດ້ໂດຍການສະຫນອງຮູບແບບກະປ໋ອງທີ່ທ່ານສາມາດນໍາໃຊ້.

ໃນຖານະເປັນ Perl 5.10, ທ່ານສາມາດຈັບຄູ່ຂໍ້ຄວາມທີ່ສົມດູນກັບການສະແດງອອກປົກກະຕິໂດຍໃຊ້ recursive
ຮູບແບບ. ກ່ອນທີ່ຈະ Perl 5.10, ທ່ານຕ້ອງໄດ້ resort ກັບ tricks ຕ່າງໆເຊັ່ນ: ການນໍາໃຊ້ລະຫັດ Perl ໃນ
"(??{})" ລຳດັບ.

ນີ້ແມ່ນຕົວຢ່າງທີ່ໃຊ້ການສະແດງອອກປົກກະຕິ recursive. ເປົ້າຫມາຍແມ່ນເພື່ອເກັບກໍາທັງຫມົດຂອງ
ຂໍ້ຄວາມພາຍໃນວົງເລັບມຸມ, ລວມທັງຂໍ້ຄວາມໃນວົງເລັບມຸມທີ່ຊ້ອນກັນ. ຂໍ້ຄວາມຕົວຢ່າງນີ້
ມີສອງກຸ່ມ "ທີ່ສໍາຄັນ": ກຸ່ມທີ່ມີລະດັບຫນຶ່ງຂອງຮັງແລະກຸ່ມທີ່ມີສອງລະດັບຂອງ
ຮັງ. ມີຫ້າກຸ່ມທັງໝົດໃນວົງເລັບມຸມ:

ຂ້ອຍມີບາງ > ແລະ
> >
ແລະນັ້ນແມ່ນມັນ.

ການສະແດງອອກປົກກະຕິເພື່ອໃຫ້ກົງກັບຂໍ້ຄວາມທີ່ສົມດູນໃຊ້ສອງໃຫມ່ (ເຖິງ Perl 5.10) ປົກກະຕິ
ລັກສະນະການສະແດງອອກ. ເຫຼົ່ານີ້ແມ່ນໄດ້ກວມເອົາໃນ perlre ແລະຕົວຢ່າງນີ້ແມ່ນສະບັບດັດແກ້ຂອງ
ຫນຶ່ງໃນເອກະສານນັ້ນ.

ທໍາອິດ, ການເພີ່ມ "+" ທີ່ຄອບຄອງໃຫມ່ໃສ່ກັບຕົວກໍານົດປະລິມານໃດໆທີ່ຊອກຫາຄໍາທີ່ຍາວທີ່ສຸດແລະເຮັດໄດ້
ບໍ່ backtrack. ທີ່ສໍາຄັນນັບຕັ້ງແຕ່ທ່ານຕ້ອງການທີ່ຈະຈັດການວົງເລັບມຸມໃດໂດຍຜ່ານການ
recursion, ບໍ່ backtracking. ກຸ່ມ "[^<>]++" ຊອກຫາໜຶ່ງ ຫຼື ຫຼາຍວົງເລັບທີ່ບໍ່ແມ່ນມຸມ
ໂດຍບໍ່ມີການ backtracking.

ອັນທີສອງ, "(?PARNO)" ໃໝ່ຫມາຍເຖິງຮູບແບບຍ່ອຍໃນກຸ່ມການຈັບພາບສະເພາະທີ່ມອບໃຫ້
ໂດຍ "PARNO". ໃນ regex ຕໍ່ໄປນີ້, ກຸ່ມ capture ທໍາອິດຊອກຫາ (ແລະຈື່) ໄດ້
ຂໍ້ຄວາມທີ່ສົມດູນ, ແລະທ່ານຕ້ອງການຮູບແບບດຽວກັນນັ້ນພາຍໃນ buffer ທໍາອິດເພື່ອຜ່ານ
ຂໍ້ຄວາມທີ່ຊ້ອນກັນ. ນັ້ນແມ່ນພາກສ່ວນ recursive. "(?1)" ໃຊ້ຮູບແບບໃນການຈັບພາບພາຍນອກ
ກຸ່ມເປັນພາກສ່ວນເອກະລາດຂອງ regex.

ເອົາມັນທັງຫມົດຮ່ວມກັນ, ທ່ານມີ:

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

$string ຂອງຂ້ອຍ =<<"ທີ່ນີ້";
ຂ້ອຍມີບາງ > ແລະ
> >
ແລະນັ້ນແມ່ນມັນ.
ທີ່ນີ້

@groups ຂອງຂ້ອຍ = $string =~ m/
(#ເລີ່ມຈັບກຸ່ມ 1
< # ກົງກັບວົງເລັບມຸມເປີດ
(?:
[^<>]++ # ວົງເລັບທີ່ບໍ່ແມ່ນມຸມໜຶ່ງ ຫຼືຫຼາຍອັນ, ບໍ່ແມ່ນການຕິດຕາມຫຼັງ
|
(?1) # ພົບ < ຫຼື >, ສະນັ້ນ recurse ເພື່ອຈັບກຸ່ມ 1
)*
> # ຈັບຄູ່ວົງເລັບມຸມປິດ
) # ສິ້ນສຸດການຈັບກຸ່ມ 1
/xg;

$" = "\n\t";
ພິມ "ພົບ:\n\t@groups\n";

ຜົນໄດ້ຮັບສະແດງໃຫ້ເຫັນວ່າ Perl ພົບເຫັນສອງກຸ່ມໃຫຍ່:

ພົບ:
>
> >

ດ້ວຍວຽກພິເສດເລັກນ້ອຍ, ເຈົ້າສາມາດເອົາກຸ່ມທັງໝົດໃນວົງເລັບມຸມໄດ້ເຖິງແມ່ນວ່າເຂົາເຈົ້າຢູ່ກໍຕາມ
ໃນວົງເລັບມຸມອື່ນໆເຊັ່ນກັນ. ແຕ່ລະຄັ້ງທີ່ທ່ານໄດ້ຮັບການແຂ່ງຂັນທີ່ສົມດູນ, ເອົາດ້ານນອກຂອງມັນອອກ
ຕົວຂັ້ນ (ນັ້ນແມ່ນອັນທີ່ເຈົ້າຫາກໍຈັບຄູ່ກັນແລ້ວ ຢ່າຈັບຄູ່ມັນອີກ) ແລະເພີ່ມໃສ່ຄິວ.
ຂອງສາຍທີ່ຈະປະມວນຜົນ. ສືບຕໍ່ເຮັດມັນຈົນກວ່າເຈົ້າຈະບໍ່ມີການແຂ່ງຂັນ:

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

@queue ຂອງຂ້ອຍ =<< "ທີ່ນີ້";
ຂ້ອຍມີບາງ > ແລະ
> >
ແລະນັ້ນແມ່ນມັນ.
ທີ່ນີ້

$regex ຂອງຂ້ອຍ = qr/
(# ຈຸດເລີ່ມຕົ້ນຂອງວົງເລັບ 1
< # ກົງກັບວົງເລັບມຸມເປີດ
(?:
[^<>]++ # ວົງເລັບທີ່ບໍ່ແມ່ນມຸມໜຶ່ງ ຫຼືຫຼາຍອັນ, ບໍ່ແມ່ນການຕິດຕາມຫຼັງ
|
(?1) # recurse ກັບວົງເລັບ 1
)*
> # ຈັບຄູ່ວົງເລັບມຸມປິດ
) # ທ້າຍຂອງວົງເລັບ 1
/x;

$" = "\n\t";

ໃນຂະນະທີ່ ( @queue ) {
$string ຂອງຂ້ອຍ = shift @queue;

@groups ຂອງຂ້ອຍ = $string =~ m/$regex/g;
ພິມ "ພົບ:\n\t@groups\n\n" ຖ້າ @groups;

unshift @queue, ແຜນທີ່ { s/^ $//; $_ } @groups;
}

ຜົນໄດ້ຮັບສະແດງໃຫ້ເຫັນທັງຫມົດຂອງກຸ່ມ. ການ​ແຂ່ງ​ຂັນ​ພາຍ​ນອກ​ສຸດ​ສະ​ແດງ​ໃຫ້​ເຫັນ​ເຖິງ​ທໍາ​ອິດ​ແລະ​ຮັງ​
ການແຂ່ງຂັນປະກົດຂຶ້ນພາຍຫຼັງ:

ພົບ:
>
> >

ພົບ:


ພົບ:
>

ພົບ:


ແມ່ນ​ຫຍັງ ບໍ່ it ຫມາຍຄວາມວ່າ ທີ່ regexes ມີ ໂລບ? ວິທີການ ສາມາດເຮັດໄດ້ I ໄດ້ຮັບ ປະມານ ມັນບໍ່?
ຄົນສ່ວນໃຫຍ່ຫມາຍຄວາມວ່າ regexes greedy ກົງກັບຫຼາຍເທົ່າທີ່ເຂົາເຈົ້າສາມາດເຮັດໄດ້. ເວົ້າທາງວິຊາການ,
ຕົວຈິງແລ້ວມັນແມ່ນຕົວກໍານົດປະລິມານ ("?", "*", "+", "{}") ທີ່ມີຄວາມໂລບມາກກວ່າທັງໝົດ.
ຮູບແບບ; Perl ມັກຄວາມໂລບໃນທ້ອງຖິ່ນແລະຄວາມພໍໃຈໃນທັນທີຕໍ່ກັບຄວາມໂລບໂດຍລວມ. ໄດ້​ຮັບ
ສະບັບທີ່ບໍ່ແມ່ນ greedy ຂອງປະລິມານດຽວກັນ, ໃຊ້ ("??", "*?", "+?", "{}?").

ຕົວຢ່າງ:

my $s1 = my $s2 = "ຂ້ອຍໜາວຫຼາຍ";
$s1 =~ s/ve.*y //; #ຂ້ອຍໜາວ
$s2 =~ s/ve.*?y //; #ຂ້ອຍໜາວຫຼາຍ

ສັງເກດເຫັນວິທີການປ່ຽນແທນທີສອງຢຸດການຈັບຄູ່ທັນທີທີ່ມັນພົບກັບ "y". ໄດ້
"*?" quantifier ປະສິດທິຜົນບອກເຄື່ອງຈັກການສະແດງອອກປົກກະຕິເພື່ອຊອກຫາການຈັບຄູ່ໄດ້ໄວ
ເປັນ​ໄປ​ໄດ້​ແລະ​ຜ່ານ​ການ​ຄວບ​ຄຸມ​ໃນ​ອັນ​ໃດ​ກໍ​ຕາມ​ຕໍ່​ໄປ​ໃນ​ເສັ້ນ​, ດັ່ງ​ທີ່​ທ່ານ​ຈະ​ຖ້າ​ຫາກ​ວ່າ​ທ່ານ​ເປັນ​
ມັກຫຼີ້ນມັນຕົ້ນ.

ວິທີການ do I ຂະບວນການ ແຕ່ລະຄົນ ຄໍາ on ແຕ່ລະຄົນ ສາຍ?
ໃຊ້ຟັງຊັນການແບ່ງປັນ:

ໃນຂະນະທີ່ (<>) {
foreach my $word (ແຍກ) {
# ເຮັດບາງຢ່າງດ້ວຍ $word ທີ່ນີ້
}
}

ໃຫ້ສັງເກດວ່ານີ້ບໍ່ແມ່ນຄໍາສັບໃນຄວາມຫມາຍພາສາອັງກິດແທ້ໆ; ມັນເປັນພຽງແຕ່ chunks ຂອງຕິດຕໍ່ກັນ
ຕົວອັກສອນທີ່ບໍ່ແມ່ນຍະຫວ່າງ.

ເພື່ອເຮັດວຽກກັບລໍາດັບຕົວເລກແລະຕົວເລກເທົ່ານັ້ນ (ລວມທັງເຄື່ອງຂຽນ), ທ່ານອາດຈະພິຈາລະນາ

ໃນຂະນະທີ່ (<>) {
foreach $word (m/(\w+)/g) {
# ເຮັດບາງຢ່າງດ້ວຍ $word ທີ່ນີ້
}
}

ວິທີການ ສາມາດເຮັດໄດ້ I ພິມ ອອກ a ຄວາມຖີ່ຂອງຄໍາ or ຄວາມຖີ່ເສັ້ນ ສະຫຼຸບ?
ເພື່ອເຮັດສິ່ງນີ້, ທ່ານຕ້ອງແຍກອອກແຕ່ລະຄໍາໃນກະແສການປ້ອນຂໍ້ມູນ. ພວກເຮົາຈະທໍາທ່າວ່າໂດຍ
ຄໍາທີ່ທ່ານຫມາຍເຖິງ chunk ຂອງຕົວອັກສອນ, hyphens, ຫຼື apostrophes, ແທນທີ່ຈະກ່ວາທີ່ບໍ່ແມ່ນ.
whitespace chunk ແນວ​ຄວາມ​ຄິດ​ຂອງ​ຄໍາ​ທີ່​ໄດ້​ຮັບ​ໃນ​ຄໍາ​ຖາມ​ທີ່​ຜ່ານ​ມາ​:

ຂອງຂ້ອຍ (% ເຫັນ);
ໃນຂະນະທີ່ (<>) {
ໃນຂະນະທີ່ (/(\b[^\W_\d][\w'-]+\b)/g ) { # ຄິດຮອດ "`ແກະ"
$seen{$1}++;
}
}

ໃນຂະນະທີ່ ($word, $count) ຂອງຂ້ອຍ = ແຕ່ລະ % ເຫັນ ) {
ພິມ "$count $word\n";
}

ຖ້າທ່ານຕ້ອງການເຮັດສິ່ງດຽວກັນສໍາລັບເສັ້ນ, ທ່ານບໍ່ຕ້ອງການການສະແດງອອກປົກກະຕິ:

ຂອງຂ້ອຍ (% ເຫັນ);

ໃນຂະນະທີ່ (<>) {
$seen{$_}++;
}

ໃນຂະນະທີ່ (ຂອງຂ້ອຍ ($line, $count) = ແຕ່ລະ % ເຫັນ ) {
ພິມ "$count $line";
}

ຖ້າທ່ານຕ້ອງການໃຫ້ຜົນຜະລິດເຫຼົ່ານີ້ຢູ່ໃນລໍາດັບ, ເບິ່ງ perlfaq4: "ຂ້ອຍຈະຈັດລຽງ hash ແນວໃດ.
(ທາງເລືອກໂດຍມູນຄ່າແທນທີ່ຈະເປັນລະຫັດ)?".

ວິທີການ ສາມາດເຮັດໄດ້ I do ປະມານ ກົງກັນ?
ເບິ່ງໂມດູນ String:: ປະມານສາມາດໃຊ້ໄດ້ຈາກ CPAN.

ວິທີການ do I ປະສິດທິຜົນ ການແຂ່ງຂັນ ຈໍານວນຫຼາຍ ປົກກະຕິ expressions at ຄັ້ງດຽວ?
(ປະກອບສ່ວນໂດຍ brian d foy)

ຖ້າທ່ານມີ Perl 5.10 ຫຼືຫຼັງຈາກນັ້ນ, ນີ້ແມ່ນເກືອບບໍ່ສໍາຄັນ. ທ່ານພຽງແຕ່ smart match ກັບ
array ຂອງ object expression ປົກກະຕິ:

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

ຖ້າ ( $string ~~ @patterns ) {
...
};

ການຈັບຄູ່ທີ່ສະຫຼາດຈະຢຸດເມື່ອມັນພົບການຈັບຄູ່, ສະນັ້ນມັນບໍ່ຈໍາເປັນຕ້ອງພະຍາຍາມທຸກການສະແດງ.

ກ່ອນໜ້ານີ້ກວ່າ Perl 5.10, ທ່ານມີວຽກເຮັດໜ້ອຍໜຶ່ງ. ທ່ານຕ້ອງການທີ່ຈະຫຼີກເວັ້ນການລວບລວມ a
ການສະແດງອອກເປັນປົກກະຕິທຸກຄັ້ງທີ່ທ່ານຕ້ອງການທີ່ຈະຈັບຄູ່ມັນ. ໃນຕົວຢ່າງນີ້, perl ຕ້ອງ recompile
ການສະແດງອອກປົກກະຕິສໍາລັບທຸກໆ iteration ຂອງ "foreach" loop ເນື່ອງຈາກວ່າມັນບໍ່ມີທາງທີ່ຈະ
ຮູ້ວ່າ $pattern ຈະເປັນແນວໃດ:

my @patterns = qw(foo bar baz );

LINE: ໃນຂະນະທີ່( ) {
foreach $pattern ( @patterns ) {
ຖ້າ( /\b$ແບບ\b/i ) {
ພິມ;
ແຖວຕໍ່ໄປ;
}
}
}

ຕົວປະຕິບັດການ "qr//" ສະແດງໃຫ້ເຫັນໃນ perl 5.005. ມັນລວບລວມການສະແດງອອກປົກກະຕິ, ແຕ່ບໍ່ແມ່ນ
ນຳໃຊ້ມັນ. ເມື່ອທ່ານໃຊ້ regex ສະບັບທີ່ລວບລວມກ່ອນ, perl ເຮັດວຽກຫນ້ອຍລົງ. ໃນ​ນີ້
ຕົວຢ່າງ, ຂ້າພະເຈົ້າໄດ້ໃສ່ "ແຜນທີ່" ເພື່ອຫັນແຕ່ລະຮູບແບບເຂົ້າໄປໃນແບບຟອມທີ່ລວບລວມໄວ້ກ່ອນ. ສ່ວນທີ່ເຫຼືອຂອງ
script ແມ່ນຄືກັນ, ແຕ່ໄວກວ່າ:

my @patterns = ແຜນທີ່ { qr/\b$_\b/i } qw( foo bar baz );

LINE: ໃນຂະນະທີ່( <> ) {
foreach $pattern ( @patterns ) {
ຖ້າ( /$pattern/ ) {
ພິມ;
ແຖວຕໍ່ໄປ;
}
}
}

ໃນ​ບາງ​ກໍ​ລະ​ນີ​, ທ່ານ​ອາດ​ຈະ​ສາ​ມາດ​ເຮັດ​ໃຫ້​ຫຼາຍ​ຮູບ​ແບບ​ເຂົ້າ​ໄປ​ໃນ​ການ​ສະ​ແດງ​ອອກ​ປົກ​ກະ​ຕິ​ດຽວ​.
ລະວັງສະຖານະການທີ່ຮຽກຮ້ອງໃຫ້ມີການຕິດຕາມຄືນ.

$regex ຂອງຂ້ອຍ = ເຂົ້າຮ່ວມ '|', qw( foo bar baz );

LINE: ໃນຂະນະທີ່( <> ) {
ພິມຖ້າ /\b(?:$regex)\b/i;
}

ສໍາລັບລາຍລະອຽດເພີ່ມເຕີມກ່ຽວກັບປະສິດທິພາບການສະແດງອອກເປັນປົກກະຕິ, ເບິ່ງ Mastering ເປັນປົກກະຕິ ສຳ ນວນ by
Jeffrey Friedl. ລາວອະທິບາຍວ່າເຄື່ອງຈັກການສະແດງອອກປົກກະຕິເຮັດວຽກແນວໃດແລະເປັນຫຍັງບາງຮູບແບບ
ເປັນເລື່ອງແປກທີ່ບໍ່ມີປະສິດທິພາບ. ເມື່ອທ່ານເຂົ້າໃຈວິທີການ perl ໃຊ້ການສະແດງອອກປົກກະຕິ,
ທ່ານສາມາດປັບໃຫ້ເຂົາເຈົ້າສໍາລັບສະຖານະການສ່ວນບຸກຄົນ.

ເປັນຫຍັງ ບໍ່ໄດ້ ຂອບ​ເຂດ​ຄໍາ​ສັບ​ຕ່າງໆ​ ການຊອກຫາ ກັບ "\b" ການເຮັດວຽກ ສໍາລັບການ ຂ້ອຍບໍ?
(ປະກອບສ່ວນໂດຍ brian d foy)

ໃຫ້​ແນ່​ໃຈວ່​າ​ທ່ານ​ຮູ້​ວ່າ \b ເຮັດ​ແນວ​ໃດ​ແທ້​: ມັນ​ເປັນ​ເຂດ​ແດນ​ລະ​ຫວ່າງ​ລັກ​ສະ​ນະ​ຄໍາ​ສັບ​ຕ່າງໆ​, \w​,
ແລະບາງສິ່ງບາງຢ່າງທີ່ບໍ່ແມ່ນລັກສະນະຄໍາສັບ. ສິ່ງທີ່ບໍ່ແມ່ນລັກສະນະຄໍາສັບອາດຈະເປັນ
\W, ແຕ່ມັນສາມາດເປັນຈຸດເລີ່ມຕົ້ນ ຫຼືຈຸດສິ້ນສຸດຂອງສະຕຣິງໄດ້.

ມັນ​ບໍ່​ແມ່ນ (ບໍ່!) ຂອບ​ເຂດ​ລະ​ຫວ່າງ whitespace ແລະ non-whitespace, ແລະ​ມັນ​ບໍ່​ແມ່ນ​ສິ່ງ​ຂອງ
ລະຫວ່າງຄໍາທີ່ພວກເຮົາໃຊ້ເພື່ອສ້າງປະໂຫຍກ.

ໃນ regex ເວົ້າ, ຂອບເຂດຄໍາສັບ (\b) ແມ່ນ "ການຢືນຢັນຄວາມກວ້າງສູນ", ຊຶ່ງຫມາຍຄວາມວ່າມັນບໍ່ແມ່ນ.
ເປັນຕົວແທນຂອງຕົວອັກສອນໃນສະຕຣິງ, ແຕ່ເງື່ອນໄຂຢູ່ໃນຕໍາແຫນ່ງທີ່ແນ່ນອນ.

ສໍາລັບການສະແດງອອກປົກກະຕິ, /\bPerl\b/, ຕ້ອງມີຂອບເຂດຄໍາສັບກ່ອນ "P" ແລະ.
ຫຼັງຈາກ "l". ຕາບໃດທີ່ບາງສິ່ງບາງຢ່າງນອກເໜືອໄປຈາກຕົວລະຄອນຄຳສັບກ່ອນໜ້າ "P" ແລະ
ສໍາເລັດ "l", ຮູບແບບຈະກົງກັນ. ສະຕຣິງເຫຼົ່ານີ້ກົງກັບ /\bPerl\b/.

"Perl" # ບໍ່ມີຄໍາສັບ char ກ່ອນ P ຫຼືຫຼັງຈາກ l
"Perl" # ຄືກັນກັບທີ່ຜ່ານມາ (ຍະຫວ່າງບໍ່ແມ່ນຄໍາສັບ char)
"'Perl'" # the 'char ບໍ່ແມ່ນຄຳວ່າ char
"Perl's" # ບໍ່ມີຄໍາສັບ char ກ່ອນ P, ບໍ່ແມ່ນຄໍາສັບ char ຫຼັງຈາກ "l"

ສະຕຣິງເຫຼົ່ານີ້ບໍ່ກົງກັບ /\bPerl\b/.

"Perl_" # _ ເປັນຄໍາ char!
"Perler" # ບໍ່ມີຄໍາສັບ char ກ່ອນ P, ແຕ່ຫນຶ່ງຫຼັງຈາກ l

ທ່ານບໍ່ຈໍາເປັນຕ້ອງໃຊ້ \b ເພື່ອຈັບຄູ່ຄໍາສັບຕ່າງໆ. ທ່ານສາມາດຊອກຫາຕົວອັກສອນທີ່ບໍ່ແມ່ນຄໍາສັບ
ອ້ອມຮອບດ້ວຍຕົວອັກສອນຄໍາສັບ. ສະຕຣິງເຫຼົ່ານີ້ກົງກັບຮູບແບບ /\b'\b/.

"ຢ່າ" # 'char ແມ່ນອ້ອມຮອບດ້ວຍ "n" ແລະ "t"
"qep'a'" # the 'char ແມ່ນອ້ອມຮອບດ້ວຍ "p" ແລະ "a"

ສະຕຣິງເຫຼົ່ານີ້ບໍ່ກົງກັບ /\b'\b/.

"foo'" # ບໍ່ມີຄໍາສັບ char ຫຼັງຈາກບໍ່ແມ່ນຄໍາສັບ '

ທ່ານຍັງສາມາດໃຊ້ການເສີມຂອງ \b, \B, ເພື່ອລະບຸວ່າບໍ່ຄວນມີຄໍາ
ເຂດແດນ.

ໃນຮູບແບບ /\Bam\B/, ຕ້ອງມີຕົວອັກສອນກ່ອນ "a" ແລະຫຼັງຈາກ "m".
ຮູບແບບເຫຼົ່ານີ້ກົງກັບ /\Bam\B/:

"llama" # "am" ອ້ອມຮອບດ້ວຍຕົວອັກສອນຄໍາສັບ
"ຊາມູເອນ" # ຄືກັນ

ສະຕຣິງເຫຼົ່ານີ້ບໍ່ກົງກັນ /\Bam\B/

"ແຊມ" # ບໍ່ມີຄຳວ່າເຂດແດນກ່ອນ "ກ", ແຕ່ມີຄຳໜຶ່ງຫຼັງ "ມ"
"ຂ້າພະເຈົ້າ Sam" # "am" ອ້ອມຮອບດ້ວຍຕົວອັກສອນທີ່ບໍ່ແມ່ນຄໍາສັບ

ເປັນຫຍັງ ບໍ່ ການນໍາໃຊ້ $&, $`, or $' ຊ້າ my ໂຄງການ ລົງ?
(ປະກອບສ່ວນໂດຍ Anno Siegel)

ເມື່ອ Perl ເຫັນວ່າທ່ານຕ້ອງການຫນຶ່ງໃນຕົວແປເຫຼົ່ານີ້ຢູ່ທຸກບ່ອນໃນໂຄງການ, ມັນສະຫນອງ
ພວກມັນຢູ່ໃນແຕ່ລະຮູບແບບທີ່ກົງກັນ. ນັ້ນ ໝາຍ ຄວາມວ່າໃນທຸກໆຮູບແບບກົງກັນທັງ ໝົດ
string ຈະຖືກຄັດລອກ, ສ່ວນຂອງມັນເປັນ $`, ສ່ວນເປັນ $&, ແລະສ່ວນເປັນ $'. ດັ່ງນັ້ນການລົງໂທດແມ່ນ
ຮ້າຍແຮງທີ່ສຸດດ້ວຍສາຍຍາວ ແລະຮູບແບບທີ່ກົງກັນເລື້ອຍໆ. ຫຼີກເວັ້ນ $&, $', ແລະ $` ຖ້າທ່ານ
ສາມາດ, ແຕ່ຖ້າທ່ານເຮັດບໍ່ໄດ້, ເມື່ອທ່ານໄດ້ໃຊ້ພວກມັນທັງຫມົດ, ໃຫ້ໃຊ້ພວກມັນຕາມຄວາມຕັ້ງໃຈເພາະວ່າທ່ານໄດ້
ຈ່າຍຄ່າລາຄາແລ້ວ. ຈື່ໄວ້ວ່າບາງອັນກໍຣິທຶມຮູ້ຈັກເຂົາເຈົ້າແທ້ໆ. ເປັນຂອງ
5.005 ປ່ອຍ, $& variable ແມ່ນບໍ່ "ແພງ" ແບບທີ່ສອງອື່ນໆ.

ນັບຕັ້ງແຕ່ Perl 5.6.1 ຕົວແປພິເສດ @- ແລະ @+ ສາມາດປ່ຽນແທນ $`, $& ແລະ $'.
array ເຫຼົ່ານີ້ມີຕົວຊີ້ໄປຫາຈຸດເລີ່ມຕົ້ນ ແລະຈຸດສິ້ນສຸດຂອງແຕ່ລະການແຂ່ງຂັນ (ເບິ່ງ perlvar ສໍາລັບ
ເຕັມເລື່ອງ), ດັ່ງນັ້ນເຂົາເຈົ້າໃຫ້ທ່ານເປັນຂໍ້ມູນດຽວກັນທີ່ສໍາຄັນ, ແຕ່ບໍ່ມີຄວາມສ່ຽງຂອງ
ການຄັດລອກສະຕຣິງຫຼາຍເກີນໄປ.

Perl 5.10 ເພີ່ມສາມພິເສດ, "${^MATCH}", "${^PREMATCH}", ແລະ "${^POSTMATCH}" ເພື່ອເຮັດ
ວຽກດຽວກັນແຕ່ບໍ່ມີການລົງໂທດການປະຕິບັດທົ່ວໂລກ. Perl 5.10 ພຽງແຕ່ກໍານົດຕົວແປເຫຼົ່ານີ້
ຖ້າທ່ານລວບລວມຫຼືປະຕິບັດການສະແດງອອກປົກກະຕິດ້ວຍຕົວແກ້ໄຂ "/p".

ແມ່ນ​ຫຍັງ ດີ is "\G" in a ປົກກະຕິ ການສະແດງອອກ?
ທ່ານໃຊ້ສະມໍ "\G" ເພື່ອເລີ່ມຕົ້ນການແຂ່ງຂັນຕໍ່ໄປໃນສະຕຣິງດຽວກັນທີ່ກົງກັນສຸດທ້າຍ
ປະໄວ້. ເຄື່ອງຈັກການສະແດງອອກປົກກະຕິບໍ່ສາມາດຂ້າມຕົວອັກສອນໃດໆເພື່ອຊອກຫາຕໍ່ໄປ
ຈັບຄູ່ກັບສະມໍນີ້, ດັ່ງນັ້ນ "\G" ແມ່ນຄ້າຍຄືກັນກັບການເລີ່ມຕົ້ນຂອງສະມໍ, "^". ໄດ້
ໂດຍທົ່ວໄປແລ້ວສະມໍ "\G" ແມ່ນໃຊ້ກັບທຸງ "g". ມັນໃຊ້ຄ່າຂອງ "pos()" ເປັນ
ຕໍາແຫນ່ງເພື່ອເລີ່ມຕົ້ນການແຂ່ງຂັນຕໍ່ໄປ. ໃນຂະນະທີ່ຜູ້ປະຕິບັດການຈັບຄູ່ເຮັດໃຫ້ການແຂ່ງຂັນຢ່າງຕໍ່ເນື່ອງ, ມັນ
ປັບປຸງ "pos()" ກັບຕໍາແຫນ່ງຂອງລັກສະນະຕໍ່ໄປທີ່ຜ່ານມາທີ່ຜ່ານມາ (ຫຼືທໍາອິດ
ລັກສະນະຂອງການແຂ່ງຂັນຕໍ່ໄປ, ຂຶ້ນກັບວິທີທີ່ເຈົ້າມັກເບິ່ງມັນ). ແຕ່ລະສາຍມີຂອງມັນ
ຄ່າ "pos()" ຂອງຕົນເອງ.

ສົມມຸດວ່າທ່ານຕ້ອງການຈັບຄູ່ຕົວເລກຕິດຕໍ່ກັນທັງໝົດໃນສະຕຣິງເຊັ່ນ "1122a44"
ແລະຢຸດການຈັບຄູ່ເມື່ອທ່ານພົບກັບຕົວເລກທີ່ບໍ່ແມ່ນຕົວເລກ. ທ່ານຕ້ອງການຈັບຄູ່ 11 ແລະ 22 ແຕ່
ຕົວອັກສອນ ສະແດງໃຫ້ເຫັນເຖິງລະຫວ່າງ 22 ແລະ 44 ແລະທ່ານຕ້ອງການຢຸດຢູ່ທີ່ "a". ພຽງແຕ່ຈັບຄູ່ຄູ່
ຕົວເລກຂ້າມ "a" ແລະຍັງກົງກັບ 44.

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

ຖ້າທ່ານໃຊ້ສະມໍ "\G", ທ່ານບັງຄັບການຈັບຄູ່ຫຼັງຈາກ 22 ເພື່ອເລີ່ມຕົ້ນດ້ວຍ "a". ໄດ້
ການສະແດງອອກປົກກະຕິບໍ່ສາມາດຈັບຄູ່ຢູ່ທີ່ນັ້ນເນື່ອງຈາກມັນບໍ່ພົບຕົວເລກ, ດັ່ງນັ້ນການຈັບຄູ່ຕໍ່ໄປ
ລົ້ມເຫລວ ແລະຜູ້ປະຕິບັດການຈັບຄູ່ຈະສົ່ງຄືນຄູ່ທີ່ມັນພົບແລ້ວ.

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

ທ່ານຍັງສາມາດໃຊ້ສະມໍ "\G" ໃນບໍລິບົດສະເກັດເງິນໄດ້. ທ່ານຍັງຕ້ອງການທຸງ "g".

$_ = "1122a44";
ໃນຂະນະທີ່( m/\G(\d\d)/g ) {
ພິມ "ພົບ $1\n";
}

ຫຼັງ​ຈາກ​ການ​ແຂ່ງ​ຂັນ​ບໍ່​ສໍາ​ເລັດ​ຢູ່​ໃນ​ຕົວ​ອັກ​ສອນ "a​"​, perl reset "pos()​" ແລະ​ການ​ແຂ່ງ​ຂັນ​ຕໍ່​ໄປ​ໃນ​
ສາຍດຽວກັນເລີ່ມຕົ້ນໃນຕອນເລີ່ມຕົ້ນ.

$_ = "1122a44";
ໃນຂະນະທີ່( m/\G(\d\d)/g ) {
ພິມ "ພົບ $1\n";
}

ພິມ "Found $1 after while" ຖ້າ m/(\d\d)/g; # ພົບ "11"

ທ່ານ​ສາ​ມາດ​ປິດ​ການ​ທໍາ​ງານ "pos()​" ປັບ​ໃຫມ່​ໃນ​ການ​ລົ້ມ​ເຫຼວ​ດ້ວຍ​ທຸງ "c​"​, ເອ​ກະ​ສານ​ໃນ perlop ແລະ​
perlreref. ການແຂ່ງຂັນຕໍ່ມາເລີ່ມຕົ້ນບ່ອນທີ່ການແຂ່ງຂັນທີ່ສໍາເລັດຜົນສຸດທ້າຍສິ້ນສຸດລົງ (ມູນຄ່າຂອງ
"pos()") ເຖິງແມ່ນວ່າການຈັບຄູ່ຢູ່ໃນສະຕຣິງດຽວກັນຈະລົ້ມເຫລວໃນເວລານີ້. ໃນກໍລະນີດັ່ງກ່າວນີ້, ໄດ້
ການຈັບຄູ່ຫຼັງຈາກວົງ "while()" ເລີ່ມຕົ້ນທີ່ "a" (ບ່ອນທີ່ການແຂ່ງຂັນສຸດທ້າຍຢຸດ), ແລະນັບຕັ້ງແຕ່
ມັນບໍ່ໄດ້ໃຊ້ສະມໍໃດໆທີ່ມັນສາມາດຂ້າມຜ່ານ "a" ເພື່ອຊອກຫາ 44.

$_ = "1122a44";
ໃນຂະນະທີ່(m/\G(\d\d)/gc ) {
ພິມ "ພົບ $1\n";
}

ພິມ "Found $1 after while" ຖ້າ m/(\d\d)/g; # ພົບ "44"

ໂດຍປົກກະຕິທ່ານໃຊ້ສະມໍ "\G" ກັບທຸງ "c" ເມື່ອທ່ານຕ້ອງການລອງການຈັບຄູ່ອື່ນ
ຖ້າຫນຶ່ງລົ້ມເຫລວ, ເຊັ່ນໃນ tokenizer. Jeffrey Friedl ສະເຫນີຕົວຢ່າງນີ້ທີ່ເຮັດວຽກຢູ່ໃນ
5.004 ຫຼືຫຼັງຈາກນັ້ນ.

ໃນຂະນະທີ່ (<>) {
chomp;
ຕົວວິເຄາະ: {
m/ \G( \d+\b )/gcx && do {ພິມ "ຕົວເລກ: $1\n"; ເຮັດຄືນ; } ;
m/ \G( \w+ )/gcx && do {ພິມ "ຄຳສັບ: $1\n"; ເຮັດຄືນ; } ;
m/ \G(\s+ )/gcx && do {ພິມ "space: $1\n"; ເຮັດຄືນ; } ;
m/ \G( [^\w\d]+ )/gcx && do {ພິມ "other: $1\n"; ເຮັດຄືນ; } ;
}
}

ສໍາລັບແຕ່ລະແຖວ, "PARSER" loop ທໍາອິດພະຍາຍາມຈັບຄູ່ຊຸດຕົວເລກຕາມດ້ວຍ a
ຂອບ​ເຂດ​ຄໍາ​ສັບ​ຕ່າງໆ​. ການ​ແຂ່ງ​ຂັນ​ນີ້​ຕ້ອງ​ເລີ່ມ​ຕົ້ນ​ໃນ​ສະ​ຖານ​ທີ່​ການ​ແຂ່ງ​ຂັນ​ສຸດ​ທ້າຍ​ປະ​ໄວ້ (ຫຼື​
ການເລີ່ມຕົ້ນຂອງສະຕຣິງໃນການແຂ່ງຂັນຄັ້ງທໍາອິດ). ເນື່ອງຈາກ "m/ \G( \d+\b )/gcx" ໃຊ້ທຸງ "c",
ຖ້າສະຕຣິງບໍ່ກົງກັບການສະແດງຜົນປົກກະຕິນັ້ນ, perl ຈະບໍ່ຕັ້ງຄ່າໃໝ່ pos() ແລະ
ການແຂ່ງຂັນຕໍ່ໄປຈະເລີ່ມຈາກຕຳແໜ່ງດຽວກັນເພື່ອລອງໃຊ້ຮູບແບບອື່ນ.

ມີ Perl regexes DFAs or NFAs? ມີ ພວກເຂົາເຈົ້າ POSIX ສອດຄ່ອງ?
ໃນຂະນະທີ່ມັນເປັນຄວາມຈິງທີ່ວ່າການສະແດງອອກປົກກະຕິຂອງ Perl ຄ້າຍຄືກັບ DFAs (ກໍານົດຂອບເຂດຈໍາກັດ
automata) ຂອງ ຕົວຢ່າງ(1) ໂຄງການ, ພວກເຂົາເຈົ້າແມ່ນໃນຄວາມເປັນຈິງປະຕິບັດເປັນ NFAs (ບໍ່ກໍານົດ
automata finite) ເພື່ອອະນຸຍາດໃຫ້ backtracking ແລະ backreferencing. ແລະພວກມັນບໍ່ແມ່ນແບບ POSIX
ບໍ່ວ່າຈະເປັນ, ເນື່ອງຈາກວ່າການຮັບປະກັນການປະພຶດທີ່ຮ້າຍແຮງທີ່ສຸດສໍາລັບທຸກກໍລະນີ. (ເບິ່ງຄືວ່າບາງ
ປະຊາຊົນມັກການຮັບປະກັນຄວາມສອດຄ່ອງ, ເຖິງແມ່ນວ່າສິ່ງທີ່ຮັບປະກັນແມ່ນຄວາມຊ້າ.) ເບິ່ງ
ປື້ມ "Mastering Regular Expressions" (ຈາກ O'Reilly) ໂດຍ Jeffrey Friedl ສໍາລັບລາຍລະອຽດທັງຫມົດ
ເຈົ້າສາມາດຫວັງວ່າຈະຮູ້ກ່ຽວກັບເລື່ອງເຫຼົ່ານີ້ (ການອ້າງອີງເຕັມທີ່ປາກົດຢູ່ໃນ perlfaq2).

ແມ່ນຫຍັງ ຜິດພາດ ກັບ ການນໍາໃຊ້ grep in a void ສະພາບການ?
ບັນຫາແມ່ນວ່າ grep ກໍ່ສ້າງບັນຊີລາຍຊື່ກັບຄືນ, ໂດຍບໍ່ຄໍານຶງເຖິງສະພາບການ. ນີ້​ຫມາຍ​ຄວາມ​ວ່າ
ທ່ານກໍາລັງເຮັດໃຫ້ Perl ໄປຫາບັນຫາຂອງການສ້າງບັນຊີລາຍຊື່ທີ່ທ່ານພຽງແຕ່ຖິ້ມໄປ. ຖ້າ
ບັນຊີລາຍຊື່ແມ່ນຂະຫນາດໃຫຍ່, ທ່ານເສຍເວລາແລະພື້ນທີ່. ຖ້າ​ຫາກ​ວ່າ​ຄວາມ​ຕັ້ງ​ໃຈ​ຂອງ​ທ່ານ​ແມ່ນ​ເພື່ອ iterate ໃນ​ໄລ​ຍະ​
ບັນຊີລາຍຊື່, ຫຼັງຈາກນັ້ນໃຊ້ສໍາລັບ loop ສໍາລັບຈຸດປະສົງນີ້.

ໃນ perls ເກົ່າກວ່າ 5.8.1, ແຜນທີ່ທົນທຸກຈາກບັນຫານີ້ເຊັ່ນກັນ. ແຕ່ນັບຕັ້ງແຕ່ 5.8.1, ນີ້
ໄດ້ຖືກແກ້ໄຂແລ້ວ, ແລະແຜນທີ່ແມ່ນຮັບຮູ້ສະພາບການ - ໃນບໍລິບົດທີ່ເປັນໂມຄະ, ບໍ່ມີລາຍຊື່ໃດຖືກສ້າງຂື້ນ.

ວິທີການ ສາມາດເຮັດໄດ້ I ການແຂ່ງຂັນ strings ກັບ multibyte ຕົວລະຄອນ?
ເລີ່ມຕົ້ນຈາກ Perl 5.6 Perl ໄດ້ມີບາງລະດັບຂອງການສະຫນັບສະຫນູນລັກສະນະ multibyte. Perl 5.8 ຫຼື
ຕໍ່ມາແມ່ນແນະນໍາ. repertoires ລັກສະນະ multibyte ສະຫນັບສະຫນູນປະກອບມີ Unicode, ແລະ
ການເຂົ້າລະຫັດແບບເກົ່າຜ່ານໂມດູນການເຂົ້າລະຫັດ. ເບິ່ງ perluniintro, perlunicode, ແລະເຂົ້າລະຫັດ.

ຖ້າທ່ານຕິດຢູ່ກັບ Perls ເກົ່າ, ທ່ານສາມາດເຮັດ Unicode ດ້ວຍ Unicode:: String module, ແລະ
ການປ່ຽນຕົວອັກສອນໂດຍໃຊ້ Unicode::Map8 ແລະ Unicode::Map modules. ຖ້າທ່ານກໍາລັງໃຊ້
ການເຂົ້າລະຫັດພາສາຍີ່ປຸ່ນ, ທ່ານອາດຈະລອງໃຊ້ jperl 5.005_03.

ສຸດທ້າຍ, ວິທີການດັ່ງຕໍ່ໄປນີ້ໄດ້ຖືກສະເຫນີໂດຍ Jeffrey Friedl, ບົດຄວາມໃນ
ສະບັບ #5 ຂອງວາລະສານ Perl ເວົ້າກ່ຽວກັບເລື່ອງນີ້.

ໃຫ້ສົມມຸດວ່າເຈົ້າມີການເຂົ້າລະຫັດ Martian ແປກໆ ບ່ອນທີ່ມີຕົວອັກສອນຕົວພິມໃຫຍ່ ASCII ຄູ່.
encode ຕົວອັກສອນ Martian ດຽວ (ເຊັ່ນ: ສອງ bytes "CV" ສ້າງຈົດຫມາຍ Martian ດຽວ, ເຊັ່ນດຽວກັບ
ສອງ bytes "SG", "VS", "XX", ແລະອື່ນໆ). bytes ອື່ນໆເປັນຕົວແທນຂອງຕົວອັກສອນດຽວ, ຄືກັນກັບ
ASCII.

ດັ່ງນັ້ນ, ຊ່ອຍແນ່ຂອງ Martian "ຂ້ອຍແມ່ນ CVSGXX!" ໃຊ້ 12 bytes ເພື່ອເຂົ້າລະຫັດເກົ້າຕົວອັກສອນ 'I',
', 'a', 'm', ' ', 'CV', 'SG', 'XX', '!'.

ຕອນນີ້, ໃຫ້ເວົ້າວ່າທ່ານຕ້ອງການຄົ້ນຫາຕົວອັກສອນດຽວ "/GX/". Perl ບໍ່ຮູ້ກ່ຽວກັບ
Martian, ດັ່ງນັ້ນມັນຈະພົບເຫັນສອງ bytes "GX" ໃນ "ຂ້ອຍແມ່ນ CVSGXX!" string, ເຖິງແມ່ນວ່າ
ລັກສະນະບໍ່ໄດ້ຢູ່ທີ່ນັ້ນ: ມັນເບິ່ງຄືວ່າມັນເປັນຍ້ອນວ່າ "SG" ຢູ່ໃກ້ກັບ "XX", ແຕ່ວ່າມີ
ບໍ່ມີ "GX". ນີ້ແມ່ນບັນຫາໃຫຍ່.

ນີ້ແມ່ນບາງວິທີ, ເຈັບປວດທັງໝົດ, ເພື່ອຮັບມືກັບມັນ:

# ໃຫ້ແນ່ໃຈວ່າ "martian" bytes ທີ່ຢູ່ໃກ້ຄຽງແມ່ນບໍ່ຢູ່ຕິດກັນ.
$martian =~ s/([AZ][AZ])/ $1 /g;

ພິມ "ພົບ GX!\n" ຖ້າ $martian =~ /GX/;

ຫຼືແບບນີ້:

@chars ຂອງຂ້ອຍ = $martian =~ m/([AZ][AZ]|[^AZ])/g;
# ຂ້າງເທິງນີ້ແມ່ນແນວຄວາມຄິດຄ້າຍຄືກັນກັບ: my @chars = $text =~ m/(.)/g;
#
foreach my $char (@chars) {
ພິມ "ພົບ GX!\n", ສຸດທ້າຍຖ້າ $char eq 'GX';
}

ຫຼືແບບນີ້:

ໃນຂະນະທີ່ ($martian =~ m/\G([AZ][AZ]|.)/gs) {# \G ອາດຈະບໍ່ຈໍາເປັນ
ຖ້າ ($1 eq 'GX') {
ພິມ "ພົບ GX!\n";
ສຸດທ້າຍ;
}
}

ນີ້ແມ່ນວິທີອື່ນ, ເຈັບປວດຫນ້ອຍລົງ, ວິທີການເຮັດຈາກ Benjamin Goldberg, ຜູ້ທີ່ໃຊ້ a
ຢືນຢັນການເບິ່ງທາງລົບດ້ານລົບຄວາມກວ້າງສູນ.

ພິມ "ພົບ GX!\n" ຖ້າ $martian =~ m/
(?
(?:[AZ][AZ])*?
GX
/x;

ອັນນີ້ສຳເລັດຖ້າຕົວລະຄອນ "martian" GX ຢູ່ໃນສະຕຣິງ, ແລະບໍ່ດັ່ງນັ້ນ. ຖ້າ​ເຈົ້າ
ບໍ່ມັກໃຊ້ (?
(?

ມັນມີຂໍ້ບົກຜ່ອງໃນການວາງສິ່ງທີ່ຜິດພາດໃນ $-[0] ແລະ $+[0], ແຕ່ນີ້ປົກກະຕິແລ້ວ
ສາມາດເຮັດວຽກໄດ້ປະມານ.

ວິທີການ do I ການແຂ່ງຂັນ a ປົກກະຕິ ການສະແດງອອກ ນັ້ນແມ່ນ in a ຕົວແປ?
(ປະກອບສ່ວນໂດຍ brian d foy)

ພວກ​ເຮົາ​ບໍ່​ຈໍາ​ເປັນ​ຕ້ອງ​ໄດ້ hard-code ຮູບ​ແບບ​ເຂົ້າ​ໄປ​ໃນ​ຕົວ​ປະ​ຕິ​ບັດ​ການ​ຈັບ​ຄູ່ (ຫຼື​ສິ່ງ​ອື່ນໆ​ທີ່​ເຮັດ​ວຽກ​
ດ້ວຍການສະແດງອອກເປັນປົກກະຕິ). ພວກເຮົາສາມາດໃສ່ຮູບແບບໃນຕົວແປສໍາລັບການນໍາໃຊ້ຕໍ່ມາ.

ຕົວປະຕິບັດການຈັບຄູ່ແມ່ນບໍລິບົດອ້າງອີງຄູ່, ດັ່ງນັ້ນທ່ານສາມາດ interpolate ຕົວແປຂອງທ່ານໄດ້ພຽງແຕ່
ຄືກັບສະຕຣິງທີ່ອ້າງອີງສອງເທົ່າ. ໃນກໍລະນີນີ້, ທ່ານອ່ານການສະແດງອອກປົກກະຕິເປັນການປ້ອນຂໍ້ມູນຂອງຜູ້ໃຊ້
ແລະເກັບໄວ້ໃນ $regex. ເມື່ອທ່ານມີຮູບແບບໃນ $regex, ທ່ານໃຊ້ຕົວແປນັ້ນໃນ
ຈັບຄູ່ປະຕິບັດການ.

chomp( $regex ຂອງຂ້ອຍ = );

ຖ້າ ($string =~ m/$regex/ ) { ... }

ຕົວອັກສອນພິເສດທີ່ສະແດງອອກເປັນປົກກະຕິໃນ $regex ແມ່ນຍັງພິເສດ, ແລະຮູບແບບ
ຍັງຕ້ອງຖືກຕ້ອງຫຼື Perl ຈະຈົ່ມ. ສໍາລັບຕົວຢ່າງ, ໃນຮູບແບບນີ້ມີ
ວົງເລັບທີ່ບໍ່ໄດ້ຈັບຄູ່.

$regex ຂອງຂ້ອຍ = "ບໍ່ກົງກັນ (paren";

"ສອງ paren ທີ່ຈະຜູກມັດພວກເຂົາທັງຫມົດ" =~ m/$regex/;

ເມື່ອ Perl ລວບລວມການສະແດງອອກປົກກະຕິ, ມັນປະຕິບັດຕໍ່ວົງເລັບເປັນການເລີ່ມຕົ້ນຂອງ a
ຄວາມຈຳກົງກັນ. ເມື່ອມັນບໍ່ພົບວົງເລັບປິດ, ມັນຈົ່ມວ່າ:

ບໍ່ກົງກັນ (ໃນ regex; ໝາຍໂດຍ <-- ທີ່ນີ້ ໃນ m/Unmatched ( <-- ທີ່ນີ້ paren/ ຢູ່ແຖວສະຄຣິບ 3.

ທ່ານສາມາດໄດ້ຮັບປະມານນີ້ໃນຫຼາຍວິທີຂຶ້ນຢູ່ກັບສະຖານະການຂອງພວກເຮົາ. ທໍາອິດ, ຖ້າທ່ານບໍ່ເຮັດ
ຕ້ອງການຕົວລະຄອນໃດນຶ່ງໃນສະຕຣິງເປັນພິເສດ, ເຈົ້າສາມາດຫລົບໜີພວກມັນດ້ວຍ
"quotemeta" ກ່ອນທີ່ທ່ານຈະໃຊ້ສະຕຣິງ.

chomp( $regex ຂອງຂ້ອຍ = );
$regex = quotemeta($regex );

ຖ້າ ($string =~ m/$regex/ ) { ... }

ທ່ານຍັງສາມາດເຮັດສິ່ງນີ້ໂດຍກົງໃນຕົວປະຕິບັດການຈັບຄູ່ໂດຍໃຊ້ລໍາດັບ "\Q" ແລະ "\E". ໄດ້
"\Q" ບອກ Perl ບ່ອນທີ່ຈະເລີ່ມການຫລົບຫນີຕົວອັກຂະລະພິເສດ, ແລະ "\E" ບອກມັນວ່າຈະໄປໃສ.
ຢຸດ (ເບິ່ງ perlop ສໍາລັບລາຍລະອຽດເພີ່ມເຕີມ).

chomp( $regex ຂອງຂ້ອຍ = );

ຖ້າ($string =~ m/\Q$regex\E/ ) { ... }

ໃນທາງກົງກັນຂ້າມ, ທ່ານສາມາດນໍາໃຊ້ "qr//", ຕົວປະຕິບັດການ quote ປົກກະຕິ (ເບິ່ງ perlop ສໍາລັບ
ລາຍ​ລະ​ອຽດ​ເພີ່ມ​ເຕີມ). ມັນອ້າງອີງແລະບາງທີອາດລວບລວມຮູບແບບ, ແລະເຈົ້າສາມາດສະຫມັກໄດ້ເປັນປົກກະຕິ
ທຸງສະແດງອອກກັບຮູບແບບ.

chomp(ການປ້ອນຂໍ້ມູນ $ ຂອງຂ້ອຍ = );

$regex ຂອງຂ້ອຍ = qr/$input/is;

$string =~ m/$regex/ # ຄືກັນກັບ m/$input/is;

ທ່ານອາດຈະຕ້ອງການໃສ່ກັບດັກຄວາມຜິດພາດໃດໆໂດຍການຫໍ່ "eval" block ປະມານສິ່ງທັງຫມົດ.

chomp(ການປ້ອນຂໍ້ມູນ $ ຂອງຂ້ອຍ = );

ປະເມີນ {
ຖ້າ($string =~ m/\Q$input\E/ ) { ... }
};
ເຕືອນ $@ ຖ້າ $@;

ຫລື ...

$regex ຂອງຂ້ອຍ = eval { qr/$input/is };
ຖ້າ (ກໍານົດ $regex ) {
$string =~ m/$regex/;
}
ອື່ນ {
ເຕືອນ $@;
}

ຜູ້ຂຽນ ແລະ COPYRIGHT

ລິຂະສິດ (c) 1997-2010 Tom Christiansen, Nathan Torkington, ແລະຜູ້ຂຽນອື່ນໆຕາມທີ່ບັນທຶກໄວ້.
ສິດທິທັງຫມົດສະຫງວນ.

ເອກະສານນີ້ແມ່ນບໍ່ເສຍຄ່າ; ທ່ານສາມາດແຈກຢາຍມັນຄືນໃຫມ່ແລະ / ຫຼືດັດແປງມັນພາຍໃຕ້ເງື່ອນໄຂດຽວກັນ
ເປັນ Perl ຕົວຂອງມັນເອງ.

ໂດຍບໍ່ຄໍານຶງເຖິງການແຈກຢາຍຂອງມັນ, ຕົວຢ່າງລະຫັດທັງຫມົດໃນໄຟລ໌ນີ້ແມ່ນຖືກຈັດໃສ່ໃນນີ້
ໂດເມນສາທາລະນະ. ທ່ານໄດ້ຮັບອະນຸຍາດໃຫ້ແລະຊຸກຍູ້ໃຫ້ໃຊ້ລະຫັດນີ້ໃນໂຄງການຂອງທ່ານເອງ
ເພື່ອຄວາມມ່ວນຊື່ນ ຫຼືເພື່ອຜົນກຳໄລຕາມທີ່ເຈົ້າເຫັນ. ຄໍາເຫັນງ່າຍໆໃນລະຫັດໃຫ້ສິນເຊື່ອຈະເປັນ
ມາລະຍາດແຕ່ບໍ່ຈໍາເປັນຕ້ອງ.

ໃຊ້ perlfaq6 ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net