perlrun - Online sa Cloud

PROGRAMA:

NAME

perlrun - kung paano isagawa ang Perl interpreter

SINOPSIS

perlas [ -sTtuUWX ] [ -hv ] [ -V[:configvar] ]
[ -cw ] [ -d[t][:debugger] ] [ -D[numero/listahan] ]
[ -pna ] [ -Fhuwaran ] [ -l[octal] ] [ -0[octal/hexadecimal] ]
[ -Idir ] [ -m[-]module ] [ -M[-]'module...' ] [ -f ] [ -C [numero/listahan] ]
[ -S ] [ -x[dir] ] [ -i[karugtong] ]
[[-e|-E] 'utos' ] [ -- ] [ programfile ] [ argumento ] ...

DESCRIPTION

Ang normal na paraan upang magpatakbo ng isang Perl program ay sa pamamagitan ng paggawa nitong direktang maipapatupad, o kung hindi man ay sa pamamagitan ng
pagpasa sa pangalan ng source file bilang argumento sa command line. (Isang interactive
Posible rin ang Perl environment--tingnan ang perldebug para sa mga detalye kung paano gawin iyon.) Pagkatapos
startup, hinahanap ng Perl ang iyong programa sa isa sa mga sumusunod na lugar:

1. Tinukoy na linya sa pamamagitan ng linya -e or -E lumilipat sa command line.

2. Nakapaloob sa file na tinukoy ng unang filename sa command line. (Tandaan na
mga system na sumusuporta sa "#!" ang notasyon ay humihimok ng mga interpreter sa ganitong paraan. Tingnan ang "Lokasyon ng
Perl".)

3. Ipinasa nang tahasan sa pamamagitan ng karaniwang input. Gumagana lamang ito kung walang filename
mga argumento--upang ipasa ang mga argumento sa isang STDIN-read program dapat mong tahasang tukuyin ang isang "-"
para sa pangalan ng programa.

Sa mga pamamaraan 2 at 3, sinisimulan ni Perl ang pag-parse ng input file mula sa simula, maliban kung nagawa mo na
tinukoy a -x switch, kung saan ini-scan nito ang unang linya na nagsisimula sa "#!" at
naglalaman ng salitang "perl", at sa halip ay nagsisimula doon. Ito ay kapaki-pakinabang para sa pagpapatakbo ng a
program na naka-embed sa isang mas malaking mensahe. (Sa kasong ito, ipahiwatig mo ang pagtatapos ng
program gamit ang "__END__" na token.)

Ang "#!" Ang linya ay palaging sinusuri para sa mga switch habang ang linya ay na-parse. Kaya, kung
ikaw ay nasa isang makina na nagbibigay-daan lamang sa isang argumento na may "#!" linya, o mas masahol pa, ay hindi
kahit na kilalanin ang "#!" linya, maaari ka pa ring makakuha ng pare-parehong pag-uugali ng paglipat anuman ang
kung paano tinawag si Perl, kahit na -x ay ginamit upang mahanap ang simula ng programa.

Dahil sa kasaysayan ang ilang mga operating system ay tahimik na tinadtad ang interpretasyon ng kernel
ang "#!" linya pagkatapos ng 32 character, ang ilang mga switch ay maaaring maipasa sa command line, at
ang ilan ay maaaring hindi; maaari ka ring makakuha ng "-" nang walang sulat nito, kung hindi ka mag-iingat. Ikaw
malamang na gustong tiyakin na ang lahat ng iyong switch ay mahuhulog bago o pagkatapos nito
32-character na hangganan. Karamihan sa mga switch ay walang pakialam kung naproseso ang mga ito
kalabisan, ngunit ang pagkuha ng "-" sa halip na isang kumpletong switch ay maaaring maging sanhi ng Perl na subukan
isagawa ang karaniwang input sa halip na ang iyong programa. At isang bahagyang -I switch ay maaari ding maging sanhi
kakaibang resulta.

Ang ilang mga switch ay nagmamalasakit kung ang mga ito ay naproseso nang dalawang beses, halimbawa mga kumbinasyon ng -l at -0.
Ilagay ang lahat ng switch pagkatapos ng 32-character na hangganan (kung naaangkop), o palitan
ang paggamit ng mga -0numero sa pamamagitan ng "BEGIN{ $/ = "\0digit"; }".

Pag-parse ng "#!" nagsisimula ang mga switch saanman nabanggit ang "perl" sa linya. Ang
ang mga pagkakasunud-sunod na "-*" at "- " ay partikular na binabalewala upang magawa mo, kung ikaw ay gayon
hilig, sabihin

#!/ Bin / SH
#! -*-perl-*-
eval 'exec perl -x -wS $0 ${1+"$@"}'
kung 0;

para makita ni Perl ang -p Lumipat.

Ang isang katulad na lansihin ay nagsasangkot ng env programa, kung mayroon ka nito.

#!/usr/bin/env perlas

Ang mga halimbawa sa itaas ay gumagamit ng kaugnay na landas patungo sa perl interpreter, na nakakakuha ng anumang bersyon
ay una sa landas ng gumagamit. Kung gusto mo ng partikular na bersyon ng Perl, sabihin, perl5.14.1, ikaw
dapat ilagay iyon nang direkta sa "#!" landas ng linya.

Kung ang "#!" Ang linya ay hindi naglalaman ng salitang "perl" o ang salitang "indir" na pinangalanan ng programa
pagkatapos ng "#!" ay isinasagawa sa halip na ang Perl interpreter. Ito ay bahagyang kakaiba, ngunit
nakakatulong ito sa mga tao sa mga makina na hindi gumagawa ng "#!", dahil masasabi nila sa isang programa na ang kanilang
SHELL ay /usr/bin/perl, at pagkatapos ay ipapadala ni Perl ang programa sa tamang interpreter
para sa kanila.

Pagkatapos mahanap ang iyong programa, kino-compile ng Perl ang buong programa sa isang panloob na form. Kung
mayroong anumang mga error sa compilation, ang pagpapatupad ng programa ay hindi sinubukan. (Ito ay
hindi tulad ng tipikal na script ng shell, na maaaring tumakbo nang part-way bago makahanap ng syntax
pagkakamali.)

Kung ang program ay syntactically tama, ito ay executed. Kung ang programa ay tumatakbo sa dulo
nang hindi tinatamaan ang isang exit () or mamatay () operator, isang implicit lumabas(0) ay ibinigay upang ipahiwatig
matagumpay na pagtatapos.

#! at pag-quote on hindi Unix system
Ang "#!" ng Unix Ang pamamaraan ay maaaring gayahin sa iba pang mga sistema:

OS / 2
ilagay

extproc perl -S -your_switches

bilang unang linya sa "*.cmd" na file (-S dahil sa isang bug sa paghawak ng `extproc' ng cmd.exe).

Ms-dos
Gumawa ng batch file para patakbuhin ang iyong program, at i-codify ito sa "ALTERNATE_SHEBANG" (tingnan ang
dosish.h file sa source distribution para sa karagdagang impormasyon).

Win95/NT
Ang pag-install ng Win95/NT, kapag ginagamit ang ActiveState installer para sa Perl, ay magbabago
ang Rehistro upang iugnay ang .pl extension sa perl interpreter. Kung nag-install ka
Perl sa iba pang paraan (kabilang ang pagbuo mula sa mga pinagmulan), maaaring kailanganin mong baguhin ang
Irehistro ang iyong sarili. Tandaan na nangangahulugan ito na hindi mo na masasabi ang pagkakaiba sa pagitan
isang executable Perl program at isang Perl library file.

VMS Put

$ perl -mysw 'f$env("procedure")' 'p1' 'p2' 'p3' 'p4' 'p5' 'p6' 'p7' 'p8' !
$ exit++ + ++$status != 0 at $exit = $status = undef;

sa tuktok ng iyong programa, kung saan -mysw anumang command line switch na gusto mong ipasa
kay Perl. Maaari mo na ngayong i-invoke ang program nang direkta, sa pamamagitan ng pagsasabi ng "perl program", o bilang a
DCL procedure, sa pamamagitan ng pagsasabi ng @program (o implicitly via DCL$PATH sa pamamagitan lamang ng paggamit ng pangalan
ng programa).

Ang incantation na ito ay medyo dapat tandaan, ngunit ipapakita ito ng Perl para sa iyo kung ikaw
sabihin ang "perl "-V:startperl"".

Ang mga command-interpreter sa mga non-Unix system ay may iba't ibang ideya sa pag-quote kaysa sa Unix
mga shell. Kakailanganin mong matutunan ang mga espesyal na character sa iyong command-interpreter ("*", "\"
at """ ay karaniwan) at kung paano protektahan ang whitespace at ang mga character na ito upang magpatakbo ng mga one-liner
(tingnan ang -e sa ibaba).

Sa ilang mga system, maaaring kailanganin mong baguhin ang mga single-quote sa mga doble, na kailangan mo hindi
gawin sa Unix o Plan 9 system. Maaaring kailanganin mo ring baguhin ang isang % sa isang %%.

Halimbawa:

# Unix
perl -e 'print "Hello world\n"'

# MS-DOS, atbp.
perl -e "print \"Hello world\n\""

# VMS
perl -e "print ""Hello world\n"""

Ang problema ay wala sa mga ito ang maaasahan: depende ito sa utos at ito ay ganap
posibleng hindi gumagana. Kung 4DOS ay ang command shell, ito ay malamang na gagana nang mas mahusay:

perl -e "print "Kumusta mundo\n ""

CMD.EXE sa Windows NT nadulas ng maraming karaniwang pag-andar ng Unix noong walang tao
naghahanap, ngunit subukan lamang na maghanap ng dokumentasyon para sa mga panuntunan sa pag-quote nito.

Walang pangkalahatang solusyon sa lahat ng ito. Ang gulo lang.

lugar of Perl
Maaaring mukhang halatang sabihin, ngunit ang Perl ay kapaki-pakinabang lamang kapag madaling mahanap ito ng mga user. Kailan
posible, ito ay mabuti para sa dalawa /usr/bin/perl at /usr/local/bin/perl upang maging mga symlink sa
aktwal na binary. Kung hindi iyon magagawa, mahigpit na hinihikayat ang mga administrator ng system na gawin iyon
ilagay (symlinks to) perl at ang mga kasamang utility nito sa isang direktoryo na karaniwang matatagpuan
kasama ang PATH ng gumagamit, o sa ilang iba pang halata at maginhawang lugar.

Sa dokumentasyong ito, "#!/usr/bin/perl" sa unang linya ng programa ay tatayo
para sa anumang paraan na gumagana sa iyong system. Ikaw ay pinapayuhan na gumamit ng isang tiyak na landas kung ikaw
nagmamalasakit sa isang partikular na bersyon.

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

o kung gusto mo lang magpatakbo ng kahit man lang bersyon, maglagay ng pahayag na ganito sa itaas
ng iyong programa:

gumamit ng 5.014;

Utos Lilipat
Tulad ng lahat ng karaniwang mga utos, ang isang solong-character na switch ay maaaring i-cluster sa
sumusunod na switch, kung mayroon man.

#!/usr/bin/perl -spi.orig # katulad ng -s -p -i.orig

Ang "--" ay nagpapahiwatig ng pagtatapos ng mga opsyon at hindi pinapagana ang karagdagang pagpoproseso ng opsyon. Anumang argumento
pagkatapos ituturing ang "--" bilang mga filename at argumento.

Kasama sa mga switch ang:

-0[octal/hexadecimal]
tumutukoy sa input record separator ($/) bilang isang octal o hexadecimal na numero. Kung
walang mga digit, ang null character ay ang separator. Maaaring mauna ang ibang switch
o sundin ang mga digit. Halimbawa, kung mayroon kang bersyon ng mahanap na maaaring mag-print
mga filename na winakasan ng null character, maaari mong sabihin ito:

hanapin ang . -pangalan '*.orig' -print0 | perl -n0e i-unlink

Ang espesyal na halaga 00 ay magiging sanhi ng Perl sa pag-slurp ng mga file sa paragraph mode. Anumang halaga
Ang 0400 o mas mataas ay magiging sanhi ng Perl sa pag-slurp ng mga file nang buo, ngunit ayon sa convention ang value na 0777
ay ang karaniwang ginagamit para sa layuning ito.

Maaari mo ring tukuyin ang separator character gamit ang hexadecimal notation: -0xHHH...,
saan ang"H" ay mga wastong hexadecimal digit. Hindi tulad ng octal form, ito ay maaaring
ginamit upang tukuyin ang anumang Unicode character, kahit na ang mga lampas sa 0xFF. Kaya kung ikaw Talaga gusto
isang record separator ng 0777, tukuyin ito bilang -0x1FF. (Ibig sabihin hindi mo magagamit
ang -x opsyon na may pangalan ng direktoryo na binubuo ng mga hexadecimal digit, o kung hindi, Perl
iisipin na tinukoy mo ang isang hex na numero sa -0.)

-a Ino-on ang autosplit mode kapag ginamit sa a -n or -p. Isang implicit split command sa
Ang @F array ay ginagawa bilang unang bagay sa loob ng implicit while loop na ginawa ng -n
or -p.

perl -ane 'print pop(@F), "\n";'

ay katumbas ng

habang (<>) {
@F = split(' ');
print pop(@F), "\n";
}

Maaaring tukuyin ang isang kahaliling delimiter gamit -F.

-a implicitly sets -n.

-C [numero/listahan]
Ang -C kinokontrol ng flag ang ilan sa mga feature ng Perl Unicode.

Bilang ng 5.8.1, ang -C maaaring sundan ng alinman sa isang numero o isang listahan ng mga titik ng opsyon.
Ang mga titik, ang kanilang mga numerong halaga, at mga epekto ay ang mga sumusunod; paglilista ng mga titik ay
katumbas ng pagsusuma ng mga numero.

Ang I 1 STDIN ay ipinapalagay na nasa UTF-8
Ang O 2 STDOUT ay nasa UTF-8
Ang E 4 STDERR ay nasa UTF-8
S 7 I + O + E
i 8 Ang UTF-8 ay ang default na layer ng PerlIO para sa mga input stream
o 16 UTF-8 ay ang default na PerlIO layer para sa mga output stream
D 24 i + o
A 32 ang mga elemento ng @ARGV ay inaasahang mga string na naka-encode
sa UTF-8
L 64 karaniwang ang "IOEioA" ay walang kondisyon, ginagawa ng L
ang mga ito ay may kondisyon sa lokal na mga variable ng kapaligiran
(ang LC_ALL, LC_CTYPE, at LANG, sa pagkakasunud-sunod ng
nagpapababa ng precedence) -- kung ang mga variable ay nagpapahiwatig
UTF-8, pagkatapos ay ang napiling "IOEioA" ay may bisa
isang 256 Itakda ang ${^UTF8CACHE} sa -1, upang patakbuhin ang UTF-8 caching
code sa debugging mode.

Halimbawa, -COE at -C6 ay parehong i-on ang UTF-8-ness sa parehong STDOUT at STDERR.
Ang pag-uulit ng mga titik ay paulit-ulit lamang, hindi pinagsama-sama o nagpapalipat-lipat.

Ang mga opsyon na "io" ay nangangahulugan na ang anumang kasunod bukas() (o katulad na I/O operations) sa
ang kasalukuyang saklaw ng file ay magkakaroon ng ":utf8" PerlIO layer na tahasang inilapat sa kanila, sa
sa madaling salita, ang UTF-8 ay inaasahan mula sa anumang input stream, at ang UTF-8 ay ginawa sa alinman
stream ng output. Ito lang ang default, na may tahasang mga layer bukas() at may
binmode() ang isa ay maaaring manipulahin ang mga stream gaya ng dati.

-C sa sarili nitong (hindi sinusundan ng anumang numero o listahan ng opsyon), o ang walang laman na string na "" para sa
ang "PERL_UNICODE" na environment variable, ay may parehong epekto sa -CSDL. Sa iba
salita, ang karaniwang I/O handle at ang default na "open()" na layer ay UTF-8-fied pero
lamang kung ang mga variable ng kapaligiran ng lokal ay nagpapahiwatig ng isang lokal na UTF-8. Ang ugali na ito
sumusunod sa pahiwatig (at may problema) UTF-8 na pag-uugali ng Perl 5.8.0. (Tingnan ang "UTF-8 no
mas mahabang default sa ilalim ng mga lokal na UTF-8" sa perl581delta.)

Maaari mong gamitin ang -C0 (o "0" para sa "PERL_UNICODE") upang tahasang i-disable ang lahat ng nasa itaas
Mga tampok ng Unicode.

Ang read-only na magic variable na "${^UNICODE}" ay sumasalamin sa numeric na halaga nito
setting. Ang variable na ito ay itinakda sa panahon ng Perl startup at pagkatapos ay read-only. Kung
gusto mo ng runtime effect, gamitin ang three-arg bukas() (tingnan ang "bukas" sa perlfunc), ang dalawang-
arg binmode() (tingnan ang "binmode" sa perlfunc), at ang "bukas" na pragma (tingnan ang bukas).

(Sa Perls mas maaga kaysa sa 5.8.1 ang -C switch ay isang Win32-only switch na pinagana ang
paggamit ng Unicode-aware na "wide system call" na mga Win32 API. Ang tampok na ito ay praktikal
hindi nagamit, gayunpaman, at ang command line switch ay samakatuwid ay "recycled".)

tandaan: Dahil perl 5.10.1, kung ang -C ang opsyon ay ginagamit sa "#!" linya, dapat na
tinukoy din sa command line, dahil naka-set up na ang mga karaniwang stream
sa puntong ito sa pagpapatupad ng perl interpreter. Maaari mo ring gamitin binmode()
upang itakda ang pag-encode ng isang I/O stream.

-c nagiging sanhi ng Perl na suriin ang syntax ng programa at pagkatapos ay lumabas nang hindi ito isinasagawa.
Sa totoo lang, ito habilin execute at "BEGIN", "UNITCHECK", o "CHECK" blocks at anumang "use"
mga pahayag: ang mga ito ay itinuturing na nagaganap sa labas ng pagpapatupad ng iyong programa.
Ang "INIT" at "END" na mga bloke, gayunpaman, ay lalaktawan.

-d
-dt nagpapatakbo ng programa sa ilalim ng Perl debugger. Tingnan ang perldebug. Kung t ay tinukoy, ito
ay nagpapahiwatig sa debugger na ang mga thread ay gagamitin sa code na ina-debug.

-d:MOD[=bar,baz]
-dt:MOD[=bar,baz]
nagpapatakbo ng program sa ilalim ng kontrol ng isang pag-debug, pag-profile, o pagsubaybay sa module
naka-install bilang "Devel::MOD". Hal, -d:DPof nagsasagawa ng programa gamit ang
"Devel::DPof" profiler. Tulad ng sa -M flag, maaaring ipasa ang mga opsyon sa
"Devel::MOD" package kung saan matatanggap at mabibigyang-kahulugan ang mga ito ng
"Devel::MOD::import" nakagawian. Muli, tulad ng -M, gamitin --d:-MOD tawagan
"Devel::MOD::unimport" sa halip na import. Ang listahan ng mga opsyon na pinaghihiwalay ng kuwit ay dapat
sundin ang isang "=" character. Kung t ay tinukoy, ito ay nagpapahiwatig sa debugger na ang mga thread
ay gagamitin sa code na na-debug. Tingnan ang perldebug.

-Dtitik
-Dnumero
nagtatakda ng mga flag sa pag-debug. Upang panoorin kung paano nito isinasagawa ang iyong programa, gamitin -Dtls. (Gumagana ito
lamang kung ang pag-debug ay pinagsama-sama sa iyong Perl.) Isa pang magandang halaga ay -Dx, Na
naglilista ng iyong pinagsama-samang syntax tree. At -Dr nagpapakita ng pinagsama-samang mga regular na expression; ang
Ang format ng output ay ipinaliwanag sa perldebguts.

Bilang kahalili, tumukoy ng numero sa halip na listahan ng mga titik (hal., -D14 is
katumbas ng -Dtls):

1 p Tokenizing at pag-parse (na may v, nagpapakita ng parse stack)
2 s Stack snapshot (na may v, ipinapakita ang lahat ng stack)
4 l Context (loop) stack processing
8 t Trace execution
16 o Paraan at overloading na resolusyon
32 c String/numeric na mga conversion
64 P Mag-print ng impormasyon sa profile, estado ng pag-input ng source file
128 m Memory at paglalaan ng SV
256 f Pagproseso ng format
512 r Regular na expression na pag-parse at pagpapatupad
1024 x Syntax tree dump
2048 u Mga tseke sa pagdumi
4096 U Hindi Opisyal, Pag-hack ng user (nakareserba para sa pribado,
hindi inilabas na paggamit)
8192 H Hash dump -- umaagaw ng mga halaga()
16384 X Paglalaan ng Scratchpad
32768 D Paglilinis
65536 S Op slab allocation
131072 T Tokenizing
262144 R Isama ang mga bilang ng sanggunian ng mga na-dump na variable (hal. kapag
gamit ang -Ds)
524288 J show s,t,P-debug (huwag Tumalon) sa mga opcode sa loob
pakete DB
1048576 v Verbose: gamitin kasabay ng iba pang mga flag
2097152 C Kopyahin Sa Isulat
4194304 A Pagsusuri ng pagkakapare-pareho sa mga panloob na istruktura
8388608 q tahimik - sa kasalukuyan ay pinipigilan lamang ang "EXECUTING"
mensahe
16777216 M trace smart match resolution
33554432 B dump subBroutine na mga kahulugan, kabilang ang mga espesyal na Block
tulad ng BEGIN
67108864 L trace Impormasyong nauugnay sa lokal; kung ano ang nakakakuha ng output ay napaka
napapailalim sa pagbabago

Ang lahat ng mga flag na ito ay nangangailangan -DDEBUGGING kapag pinagsama-sama mo ang Perl na maipapatupad (ngunit tingnan
":opd" sa Devel::Peek o "'debug' mode" sa re na maaaring magbago nito). Tingnan ang
INSTALL file sa pamamahagi ng pinagmumulan ng Perl para sa kung paano ito gawin. Ang watawat na ito ay
awtomatikong itatakda kung isasama mo -g opsyon kapag tinanong ka ng "I-configure" tungkol sa
mga flag ng optimizer/debugger.

Kung sinusubukan mo lang na makakuha ng print out sa bawat linya ng Perl code habang isinasagawa ito,
ang paraan na nagbibigay ng "sh -x" para sa mga script ng shell, hindi mo magagamit ang Perl's -D Lumipat.
Sa halip gawin ito

# Kung mayroon kang "env" na utility
env PERLDB_OPTS="NonStop=1 AutoTrace=1 frame=2" perl -dS program

# Bourne shell syntax
$ PERLDB_OPTS="NonStop=1 AutoTrace=1 frame=2" perl -dS program

# csh syntax
% (setenv PERLDB_OPTS "NonStop=1 AutoTrace=1 frame=2"; perl -dS program)

Tingnan ang perldebug para sa mga detalye at pagkakaiba-iba.

-e commandline
ay maaaring gamitin upang magpasok ng isang linya ng programa. Kung -e ay ibinigay, hindi maghahanap si Perl ng a
filename sa listahan ng argumento. Maramihan -e maaaring magbigay ng mga utos upang bumuo ng a
multi-line na script. Tiyaking gumamit ng mga semicolon kung saan mo gagawin sa isang normal na programa.

-E commandline
behaves tulad ng -e, maliban sa tahasang pinapagana nito ang lahat ng opsyonal na feature (sa
pangunahing yunit ng compilation). Tingnan ang tampok.

-f Huwag paganahin ang pagsasagawa $Config{sitelib}/sitecustomize.pl sa startup.

Maaaring itayo ang Perl upang ito sa pamamagitan ng default ay susubukang isagawa
$Config{sitelib}/sitecustomize.pl sa startup (sa isang BEGIN block). Ito ay isang kawit na
nagbibigay-daan sa sysadmin na i-customize kung paano kumikilos si Perl. Maaari itong halimbawa ay ginagamit upang
magdagdag ng mga entry sa hanay ng @INC upang mahanap ang Perl ng mga module sa hindi karaniwang mga lokasyon.

Ang Perl ay aktwal na naglalagay ng sumusunod na code:

MAGSIMULA {
gawin { local $!; -f "$Config{sitelib}/sitecustomize.pl"; }
&& gawin ang "$Config{sitelib}/sitecustomize.pl";
}

Dahil ito ay isang aktwal na "gawin" (hindi isang "kailangan"), sitecustomize.pl hindi na kailangang bumalik
isang tunay na halaga. Ang code ay pinapatakbo sa package na "pangunahing", sa sarili nitong lexical na saklaw. gayunpaman,
kung mamatay ang script, hindi itatakda ang $@.

Ang halaga ng $Config{sitelib} ay tinutukoy din sa C code at hindi nababasa mula sa
"Config.pm", na hindi na-load.

Ang code ay naisakatuparan napaka maaga. Halimbawa, lalabas ang anumang pagbabagong ginawa sa @INC
sa output ng `perl -V`. Siyempre, ang mga bloke ng "END" ay isasagawa din nang napakahusay
huli na

Upang matukoy sa runtime kung ang kakayahang ito ay naipon sa iyong perl, magagawa mo
suriin ang halaga ng $Config{usesitecustomize}.

-Fhuwaran
tumutukoy sa pattern na hahatiin para sa -a. Ang pattern ay maaaring napapalibutan ng "//", "",
o '', kung hindi ay ilalagay ito sa mga solong panipi. Hindi ka maaaring gumamit ng literal na whitespace sa
ang pattern.

-F implicitly sets pareho -a at -n.

-h nagpi-print ng buod ng mga opsyon.

-i[karugtong]
tumutukoy na ang mga file na naproseso ng "<>" construct ay dapat i-edit sa lugar. Ito
ginagawa ito sa pamamagitan ng pagpapalit ng pangalan ng input file, pagbubukas ng output file sa pamamagitan ng orihinal na pangalan,
at pagpili sa output file na iyon bilang default para sa i-print () mga pahayag. Ang extension,
kung ibinibigay, ay ginagamit upang baguhin ang pangalan ng lumang file upang makagawa ng backup na kopya,
sumusunod sa mga tuntuning ito:

Kung walang extension na ibinigay, at sinusuportahan ito ng iyong system, ang orihinal file ay itinabi
bukas nang walang pangalan habang ang output ay na-redirect sa isang bagong file na may orihinal
filename. Kapag lumabas ang perl, malinis man o hindi, ang orihinal file ay na-unlink.

Kung ang extension ay hindi naglalaman ng isang "*", pagkatapos ito ay idinagdag sa dulo ng kasalukuyang
filename bilang isang suffix. Kung ang extension ay naglalaman ng isa o higit pang "*" na mga character, kung gayon
bawat "*" ay pinapalitan ng kasalukuyang filename. Sa mga termino ng Perl, maaari mong isipin
ito bilang:

($backup = $extension) =~ s/\*/$file_name/g;

Nagbibigay-daan ito sa iyo na magdagdag ng prefix sa backup file, sa halip na (o bilang karagdagan sa) a
panlapi:

$ perl -pi'orig_*' -e 's/bar/baz/' fileA # backup to
# 'orig_fileA'

O kahit na maglagay ng mga backup na kopya ng orihinal na mga file sa isa pang direktoryo (ibinigay
umiiral na ang direktoryo):

$ perl -pi'old/*.orig' -e 's/bar/baz/' fileA # backup sa
# 'old/fileA.orig'

Ang mga set na ito ng mga one-liner ay katumbas:

$ perl -pi -e 's/bar/baz/' fileA # i-overwrite ang kasalukuyang file
$ perl -pi'*' -e 's/bar/baz/' fileA # i-overwrite ang kasalukuyang file

$ perl -pi'.orig' -e 's/bar/baz/' fileA # backup sa 'fileA.orig'
$ perl -pi'*.orig' -e 's/bar/baz/' fileA # backup sa 'fileA.orig'

Mula sa shell, sinasabi

$ perl -p -i.orig -e "s/foo/bar/; ... "

ay pareho sa paggamit ng programa:

#!/usr/bin/perl -pi.orig
s/foo/bar/;

na katumbas ng

#!/usr/bin/perl
$extension = '.orig';
LINE: habang (<>) {
kung ($ARGV ne $oldargv) {
kung ($extension !~ /\*/) {
$backup = $ARGV . $extension;
}
tao {
($backup = $extension) =~ s/\*/$ARGV/g;
}
palitan ang pangalan($ARGV, $backup);
open(ARGVOUT, ">$ARGV");
piliin(ARGVOUT);
$oldargv = $ARGV;
}
s/foo/bar/;
}
magpatuloy {
print; # ito ay nagpi-print sa orihinal na filename
}
piliin(STDOUT);

maliban na ang -i hindi kailangang ihambing ng form ang $ARGV sa $oldargv upang malaman kung kailan ang
nabago ang filename. Gayunpaman, ginagamit nito ang ARGVOUT para sa napiling filehandle.
Tandaan na ang STDOUT ay naibalik bilang default na output filehandle pagkatapos ng loop.

Gaya ng ipinapakita sa itaas, nililikha ni Perl ang backup na file kung ang anumang output ay aktwal o hindi
nagbago. Kaya ito ay isang magarbong paraan upang kopyahin ang mga file:

$ perl -p -i'/some/file/path/*' -e 1 file1 file2 file3...
or
$ perl -p -i'.orig' -e 1 file1 file2 file3...

Maaari mong gamitin ang "eof" nang walang panaklong upang mahanap ang dulo ng bawat input file, kung sakali
gusto mong idagdag sa bawat file, o i-reset ang line numbering (tingnan ang halimbawa sa "eof" sa
perlfunc).

Kung, para sa isang naibigay na file, hindi magawa ni Perl ang backup na file tulad ng tinukoy sa
extension pagkatapos ay laktawan nito ang file na iyon at magpapatuloy sa susunod (kung ito
umiiral).

Para sa isang talakayan ng mga isyu sa paligid ng mga pahintulot ng file at -i, tingnan ang "Bakit ang Perl
hayaan mo akong tanggalin ang mga read-only na file? Bakit pinoprotektahan ng -i ang mga file? Hindi ba ito a
bug sa Perl?" sa perlfaq5.

Hindi mo magagamit -i upang lumikha ng mga direktoryo o mag-alis ng mga extension mula sa mga file.

Hindi pinalawak ng Perl ang "~" sa mga filename, na mabuti, dahil ginagamit ito ng ilang tao para sa
kanilang mga backup na file:

$ perl -pi~ -e 's/foo/bar/' file1 file2 file3...

Tandaan na dahil -i pinapalitan o tinatanggal ang orihinal na file bago gumawa ng bagong file
ng parehong pangalan, ang Unix-style na malambot at matigas na mga link ay hindi papanatilihin.

Panghuli, ang mga -i switch ay hindi humahadlang sa pagpapatupad kapag walang mga file na ibinigay sa
command line. Sa kasong ito, walang backup na ginawa (ang orihinal na file ay hindi maaaring, siyempre,
matukoy) at ang pagproseso ng mga nalikom mula sa STDIN hanggang STDOUT gaya ng maaaring inaasahan.

-Idirektoryo
Mga direktoryo na tinukoy ni -I ay prepended sa path ng paghahanap para sa mga module (@INC).

-l[octnum]
nagbibigay-daan sa awtomatikong pagpoproseso ng pagtatapos ng linya. Ito ay may dalawang magkahiwalay na epekto. Una, ito
awtomatikong chomps $/ (ang input record separator) kapag ginamit sa -n or -p.
Pangalawa, itinatalaga nito ang "$\" (ang output record separator) upang magkaroon ng halaga ng octnum so
na ang anumang naka-print na pahayag ay idaragdag muli ang separator na iyon. Kung octnum is
tinanggal, itinatakda ang "$\" sa kasalukuyang halaga ng $/. Halimbawa, upang i-trim ang mga linya sa 80
mga hanay:

perl -lpe 'substr($_, 80) = ""'

Tandaan na ang pagtatalaga na "$\ = $/" ay tapos na kapag ang switch ay naproseso, kaya ang input
record separator ay maaaring iba kaysa sa output record separator kung ang -l lumipat
ay sinusundan ng a -0 lumipat:

gnufind / -print0 | perl -ln0e 'print "nahanap $_" kung -p'

Itinatakda nito ang "$\" sa newline at pagkatapos ay itinatakda ang $/ sa null na character.

-m[-]module
-M[-]module
-M[-]'modyul ... '
-[mM][-]module=arg[,arg]...
-mmodule nagsasagawa ng "gamitin" module "();" bago isagawa ang iyong programa.

-Mmodule nagsasagawa ng "gamitin" module ";" bago isagawa ang iyong programa. Maaari kang gumamit ng mga panipi
upang magdagdag ng karagdagang code pagkatapos ng pangalan ng module, hal, '-MMODYUL qw(foo bar)'.

Kung ang unang karakter pagkatapos ng -M or -m ay isang gitling (-) pagkatapos ay papalitan ang 'paggamit'
na may 'hindi'.

Ang isang maliit na builtin na syntactic na asukal ay nangangahulugan na maaari mo ring sabihin -mMODYUL=foo,bar or
-MMODYUL=foo,bar bilang isang shortcut para sa '-MMODYUL qw(foo bar)'. Iniiwasan nito ang pangangailangan
gumamit ng mga panipi kapag nag-i-import ng mga simbolo. Ang aktwal na code na nabuo ng -MMODYUL=foo,bar is
"gumamit ng module split(/,/,q{foo,bar})". Tandaan na ang "=" form ay nag-aalis ng pagkakaiba
sa pagitan ng -m at -M; yan ay, -mMODYUL=foo,bar ay pareho -MMODYUL=foo,bar.

Ang kahihinatnan nito ay iyon -MMODYUL= numero hindi kailanman nagsusuri ng bersyon, maliban kung
"MODULE::import()" mismo ay naka-set up na gumawa ng pagsusuri sa bersyon, na maaaring mangyari para sa
halimbawa kung MODYUL nagmana mula sa Exporter.

-n nagiging sanhi ng Perl na ipagpalagay ang sumusunod na loop sa paligid ng iyong programa, na ginagawa itong umulit
sa mga argumento ng filename medyo gusto uhaw -n or ang awkward:

Linya:
habang (<>) {
... # napupunta dito ang iyong programa
}

Tandaan na ang mga linya ay hindi naka-print bilang default. Tingnan ang "-p" upang magkaroon ng mga linyang naka-print. Kung
ang isang file na pinangalanan ng isang argument ay hindi mabubuksan para sa ilang kadahilanan, binabalaan ka ni Perl tungkol dito
at lumipat sa susunod na file.

Tandaan din na ang "<>" ay nagpapasa ng mga argumento ng command line sa "open" sa perlfunc, na
ay hindi kinakailangang bigyang-kahulugan ang mga ito bilang mga pangalan ng file. Tingnan ang perlop para sa posibleng seguridad
implikasyon.

Narito ang isang mahusay na paraan upang tanggalin ang lahat ng mga file na hindi pa nabago nang hindi bababa sa
isang linggo:

hanapin ang . -mtime +7 -print | perl -nle i-unlink

Ito ay mas mabilis kaysa sa paggamit ng -exec Lumipat ng mahanap dahil hindi mo kailangang magsimula a
proseso sa bawat filename na natagpuan. Nagdurusa ito sa bug ng maling paghawak ng mga bagong linya
sa mga pathname, na maaari mong ayusin kung susundin mo ang halimbawa sa ilalim -0.

Maaaring gamitin ang mga block na "BEGIN" at "END" para makuha ang kontrol bago o pagkatapos ng implicit
loop ng programa, tulad ng sa ang awkward.

-p nagiging sanhi ng Perl na ipagpalagay ang sumusunod na loop sa paligid ng iyong programa, na ginagawa itong umulit
sa mga argumento ng filename medyo gusto uhaw:

Linya:
habang (<>) {
... # napupunta dito ang iyong programa
} magpatuloy {
i-print o mamatay ang "-p destinasyon: $!\n";
}

Kung ang isang file na pinangalanan ng isang argument ay hindi mabubuksan para sa ilang kadahilanan, binabalaan ka ni Perl
ito, at lumipat sa susunod na file. Tandaan na ang mga linya ay awtomatikong naka-print.
Ang isang error na nagaganap sa panahon ng pag-print ay itinuturing na nakamamatay. Upang sugpuin ang pag-print gamitin ang
-n lumipat A -p pinapalampas a -n Lumipat.

Maaaring gamitin ang mga block na "BEGIN" at "END" para makuha ang kontrol bago o pagkatapos ng implicit
loop, tulad ng sa ang awkward.

-s nagbibigay-daan sa panimulang switch parsing para sa mga switch sa command line pagkatapos ng programa
pangalan ngunit bago ang anumang mga argumento ng filename (o bago ang isang argumento ng --). Kahit anong switch
natagpuan doon ay inalis mula sa @ARGV at itinatakda ang kaukulang variable sa Perl
programa. Ang sumusunod na programa ay nagpi-print ng "1" kung ang programa ay hinihimok ng a -xyz
switch, at "abc" kung ito ay ginagamit sa -xyz=abc.

#!/usr/bin/perl -s
if ($xyz) { print "$xyz\n" }

Tandaan na ang isang switch tulad ng - Tumulong lumilikha ng variable na "${-help}", na hindi
sumusunod sa "gumamit ng mahigpit na "refs"". Gayundin, kapag ginagamit ang opsyong ito sa isang script na may
pinagana ang mga babala maaari kang makakuha ng maraming huwad na "isang beses lang nagamit" na mga babala.

-S ginagawang Perl gamitin ang PATH environment variable upang hanapin ang program maliban kung ang
Ang pangalan ng programa ay naglalaman ng mga path separator.

Sa ilang mga platform, ginagawa rin nito ang Perl na magdagdag ng mga suffix sa filename habang
hinahanap ito. Halimbawa, sa mga platform ng Win32, ang ".bat" at ".cmd" ay mga suffix
ay idinaragdag kung ang paghahanap para sa orihinal na pangalan ay nabigo, at kung ang pangalan ay hindi
nagtatapos na sa isa sa mga suffix na iyon. Kung ang iyong Perl ay pinagsama-sama sa "DEBUGGING"
naka-on, gamit ang -Dp ang paglipat sa Perl ay nagpapakita kung paano umuusad ang paghahanap.

Kadalasan ito ay ginagamit upang tularan ang "#!" startup sa mga platform na hindi sumusuporta sa "#!".
Maginhawa rin ito kapag nagde-debug ng script na gumagamit ng "#!", at sa gayon ay normal
natagpuan ng mekanismo ng paghahanap ng $PATH ng shell.

Gumagana ang halimbawang ito sa maraming platform na may shell na tugma sa Bourne shell:

#!/usr/bin/perl
eval 'exec /usr/bin/perl -wS $0 ${1+"$@"}'
kung $running_under_some_shell;

Binabalewala ng system ang unang linya at pinapakain ang programa sa / Bin / SH, na nagpapatuloy sa
subukang isagawa ang Perl program bilang shell script. Isinasagawa ng shell ang pangalawa
linya bilang isang normal na utos ng shell, at sa gayon ay sinisimulan ang Perl interpreter. Sa ilan
system $0 ay hindi palaging naglalaman ng buong pathname, kaya ang -S sabi ni Perl na maghanap
para sa programa kung kinakailangan. Matapos mahanap ni Perl ang programa, pina-parse nito ang mga linya
at binabalewala ang mga ito dahil ang variable na $running_under_some_shell ay hindi kailanman totoo. Kung
ang programa ay bibigyang-kahulugan ng csh, kakailanganin mong palitan ang "${1+"$@"}" ng $*,
kahit na hindi nito naiintindihan ang mga naka-embed na puwang (at tulad nito) sa listahan ng argumento.
Upang magsimula sh sa halip na csh, maaaring kailangang palitan ng ilang system ang "#!" linyang may a
linyang naglalaman lamang ng colon, na magalang na hindi papansinin ni Perl. Iba pang mga sistema
hindi makokontrol iyon, at kailangan ng isang ganap na palihis na konstruksyon na gagana sa ilalim ng alinman sa
csh, sh, o Perl, tulad ng sumusunod:

eval '(exit $?0)' && eval 'exec perl -wS $0 ${1+"$@"}'
& eval 'exec /usr/bin/perl -wS $0 $argv:q'
kung $running_under_some_shell;

Kung ang ibinigay na filename ay naglalaman ng mga separator ng direktoryo (at sa gayon ay isang ganap na o
relative pathname), at kung hindi mahanap ang file na iyon, ang mga platform na nagdaragdag ng file
gagawin ito ng mga extension at subukang hanapin ang file na may idinagdag na mga extension, isa
ng isa.

Sa mga platform na tulad ng DOS, kung ang programa ay hindi naglalaman ng mga separator ng direktoryo, ito ay
hahanapin muna sa kasalukuyang direktoryo bago hanapin sa PATH.
Sa mga platform ng Unix, mahigpit na hahanapin ang programa sa PATH.

-t katulad -T, ngunit ang mga taint check ay maglalabas ng mga babala sa halip na mga malalang error. Ang mga ito
ang mga babala ay maaari na ngayong kontrolin nang normal na may "walang babala qw(taint)".

tandaan: ito is hindi a kapalit para "-T"! Ito ay sinadya upang gamitin lamang bilang isang pansamantala
tulong sa pagpapaunlad habang sini-secure ang legacy code: para sa totoong production code at para sa bago
secure na code na nakasulat mula sa simula, palaging gamitin ang tunay -T.

-T Ino-on ang "taint" para masubukan mo ang mga ito. Karaniwan ang mga pagsusuring ito ay ginagawa lamang kapag
tumatakbo setuid o setgid. Magandang ideya na tahasang i-on ang mga ito para sa mga programa
na tumatakbo sa ngalan ng ibang tao na maaaring hindi mo pinagkakatiwalaan, gaya ng CGI
mga programa o anumang mga internet server na maaari mong isulat sa Perl. Tingnan ang perlsec para sa mga detalye.
Para sa mga kadahilanang pangseguridad, ang opsyong ito ay dapat makita ng Perl nang maaga; kadalasan ito
nangangahulugan na dapat itong lumitaw nang maaga sa command line o sa "#!" linya para sa mga sistema na
suportahan ang konstruksyon na iyon.

-u Ang switch na ito ay nagiging sanhi ng Perl na i-dump ang core pagkatapos i-compile ang iyong program. Maaari ka nang pumasok
kunin ng teorya ang core dump na ito at gawing executable file sa pamamagitan ng paggamit ng alisin sa basurahan
programa (hindi ibinigay). Pinapabilis nito ang pagsisimula sa gastos ng ilang espasyo sa disk (na
maaari mong i-minimize sa pamamagitan ng pagtanggal ng executable). (Gayunpaman, isang "hello world" na maipapatupad
lumalabas sa humigit-kumulang 200K sa aking makina.) Kung gusto mong i-execute ang isang bahagi ng iyong
programa bago dumping, gamitin ang dump() operator sa halip. Tandaan: pagkakaroon ng
alisin sa basurahan ay partikular sa platform at maaaring hindi available para sa isang partikular na port ng Perl.

-U nagbibigay-daan sa Perl na gumawa ng mga hindi ligtas na operasyon. Sa kasalukuyan ang tanging "hindi ligtas" na mga operasyon ay
sinusubukang i-unlink ang mga direktoryo habang tumatakbo bilang superuser at tumatakbo sa setuid
naging mga babala ang mga programang may nakamamatay na pagsusuri ng bahid. Tandaan na ang mga babala ay dapat
pinagana kasama ng pagpipiliang ito sa aktwal na lumikha ang mga babala ng taint-check.

-v nagpi-print ng bersyon at patchlevel ng iyong perl na maipapatupad.

-V nagpi-print ng buod ng mga pangunahing halaga ng pagsasaayos ng perl at ang kasalukuyang mga halaga ng @INC.

-SA:configvar
Ini-print sa STDOUT ang halaga ng pinangalanang configuration variable (s), na may multiple
kapag ang iyong "configvar" ang argumento ay mukhang isang regex (may mga hindi titik). Halimbawa:

$ perl -V:libc
libc='/lib/libc-2.2.4.so';
$ perl -V:lib.
libs='-lnsl -lgdbm -ldb -ldl -lm -lcrypt -lutil -lc';
libc='/lib/libc-2.2.4.so';
$ perl -V:lib.*
libpth='/ usr / local / lib / lib / Usr / lib';
libs='-lnsl -lgdbm -ldb -ldl -lm -lcrypt -lutil -lc';
lib_ext='.a';
libc='/lib/libc-2.2.4.so';
libperl='libperl.a';
....

Bukod pa rito, maaaring gamitin ang mga karagdagang colon para makontrol ang pag-format. Isang trailing colon
pinipigilan ang linefeed at terminator na ";", na nagpapahintulot sa iyo na mag-embed ng mga query sa shell
mga utos. (mnemonic: PATH separator ":".)

$ echo "compression-vars: " `perl -V:z.*: ` " ay narito !"
compression-vars: zcat='' zip='zip' ay narito!

Ang isang nangungunang colon ay nag-aalis ng "pangalan=" na bahagi ng tugon, ito ay nagbibigay-daan sa iyo upang mapa sa
ang pangalan na kailangan mo. (mnemonic: walang laman na label)

$ echo "goodvfork="`./perl -Ilib -V::usevfork`
goodvfork=false;

Maaaring gamitin nang magkasama ang leading at trailing colons kung kailangan mo ng positional parameter
mga halaga nang walang mga pangalan. Tandaan na sa kaso sa ibaba, ang "PERL_API" na mga param ay
ibinalik sa alpabetikong ayos.

$ echo building_on `perl -V::osname: -V::PERL_API_.*:` ngayon
building_on 'linux' '5' '1' '9' ngayon

-w nagpi-print ng mga babala tungkol sa mga kahina-hinalang construct, gaya ng mga variable na pangalan na binanggit nang isang beses lang
at mga scalar variable na ginamit bago itakda; muling tinukoy na mga subroutine; mga sanggunian sa
hindi natukoy na mga filehandle; Binuksan ng filehandles ang read-only na sinusubukan mong isulat
sa; mga value na ginamit bilang isang numero na hindi tumingin tulad ng mga numero; gamit ang isang array na parang ito
ay isang scalar; kung ang iyong mga subroutine ay umuulit ng higit sa 100 malalim; at hindi mabilang na iba pa
bagay na ito.

Ang switch na ito ay talagang nagbibigay-daan sa pandaigdigang $^W variable; karaniwan, ang leksikal
scoped "use warnings" pragma is preferred. Maaari mong i-disable o i-promote sa fatal
mga error na partikular na babala gamit ang "__WARN__" na mga kawit, gaya ng inilarawan sa perlvar at "babalaan"
sa perlfunc. Tingnan din ang perldiag at perltrap. Ang isang fine-grained na pasilidad ng babala ay
magagamit din kung gusto mong manipulahin ang buong klase ng mga babala; tingnan ang mga babala.

-W Pinapagana ang lahat ng babala anuman ang "walang babala" o $^W. Tingnan ang mga babala.

-X Hindi pinapagana ang lahat ng babala anuman ang "mga babala sa paggamit" o $^W. Tingnan ang mga babala.

-x
-xdirektoryo
ay nagsasabi kay Perl na ang programa ay naka-embed sa isang mas malaking tipak ng hindi nauugnay na teksto, tulad ng
sa isang mensaheng mail. Ang mga nangungunang basura ay itatapon hanggang sa unang linya na
nagsisimula sa "#!" at naglalaman ng string na "perl". Anumang makabuluhang switch sa iyon
linya ay ilalapat.

Ang lahat ng mga sanggunian sa mga numero ng linya ng programa (mga babala, mga error, ...) ay ituturing ang
"#!" linya bilang unang linya. Kaya isang babala sa ika-2 linya ng programa, na
sa ika-100 na linya sa file ay iuulat bilang linya 2, hindi bilang linya 100. Maaari itong
ma-override sa pamamagitan ng paggamit ng "#line" na direktiba. (Tingnan ang "Plain Old Comments (Hindi!)" sa
perlsyn)

Kung may tinukoy na pangalan ng direktoryo, lilipat si Perl sa direktoryo na iyon bago tumakbo
ang programa. Ang -x kontrolado lamang ng switch ang pagtatapon ng mga nangungunang basura. Ang
ang programa ay dapat wakasan ng "__END__" kung may mga sumusunod na basura na hindi papansinin;
ang programa ay maaaring magproseso ng anuman o lahat ng sumusunod na basura sa pamamagitan ng "DATA" filehandle
kung gusto.

Ang direktoryo, kung tinukoy, ay dapat lumitaw kaagad kasunod ng -x na walang
intervening whitespace.

Kapaligiran

HOME Ginagamit kung ang "chdir" ay walang argumento.

LOGDIR Ginagamit kung ang "chdir" ay walang argumento at HOME ay hindi nakatakda.

PATH Ginagamit sa pagsasagawa ng mga subprocess, at sa paghahanap ng program kung -S Ginagamit.

PERL5LIB Isang listahan ng mga direktoryo kung saan hahanapin ang mga file ng Perl library bago maghanap
sa karaniwang aklatan at sa kasalukuyang direktoryo. Anumang arkitektura-spesipiko
at mga direktoryo na tukoy sa bersyon, gaya ng bersyon/archname/, bersyon /, O
archname/ sa ilalim ng tinukoy na mga lokasyon ay awtomatikong kasama kung sila
umiiral, kasama ang paghahanap na ito sa oras ng pagsisimula ng interpreter. Bilang karagdagan, anuman
idinaragdag ang mga direktoryo na tumutugma sa mga entry sa $Config{inc_version_list}.
(Ang mga ito ay karaniwang para sa mga mas lumang compatible na bersyon ng perl na naka-install sa
parehong puno ng direktoryo.)

Kung ang PERL5LIB ay hindi tinukoy, PERLLIB ang ginagamit. Ang mga direktoryo ay pinaghihiwalay (tulad ng
sa PATH) sa pamamagitan ng isang colon sa Unixish platform at sa pamamagitan ng isang semicolon sa Windows (ang
wastong path separator na ibinibigay ng command na "perl -V:path_sep").

Kapag nagpapatakbo ng mga taint check, alinman dahil ang program ay tumatakbo sa setuid o
setgid, o ang -T or -t switch ay tinukoy, hindi PERL5LIB o PERLLIB ay
kinonsulta. Sa halip, dapat sabihin ng programa:

gumamit ng lib "/my/directory";

PERL5OPT Mga opsyon sa command-line (mga switch). Ang mga switch sa variable na ito ay itinuturing na parang
sila ay nasa bawat command line ng Perl. Tanging ang -[CDIMUdmtwW] ang mga switch ay
pinapayagan. Kapag nagpapatakbo ng mga taint check (alinman dahil tumatakbo ang program
setuid o setgid, o dahil ang -T or -t ginamit ang switch), ang variable na ito ay
hindi pinansin. Kung magsisimula ang PERL5OPT sa -T, paganahin at kasunod ang pagdumi
binalewala ang mga opsyon. Kung magsisimula ang PERL5OPT sa -t, paganahin ang pagdumi, a
inalis ang nasusulat na tuldok mula sa @INC, at pinarangalan ang mga kasunod na opsyon.

PERLIO Isang puwang (o colon) na pinaghiwalay na listahan ng mga layer ng PerlIO. Kung ang perl ay binuo para gamitin
PerlIO system para sa IO (ang default) ang mga layer na ito ay nakakaapekto sa Perl's IO.

Karaniwang simulan ang mga pangalan ng layer na may colon (halimbawa, ":perlio")
upang bigyang-diin ang kanilang pagkakatulad sa variable na "mga katangian". Ngunit ang code na
nag-parse ng mga string ng detalye ng layer, na ginagamit din para i-decode ang PERLIO
environment variable, tinatrato ang colon bilang isang separator.

Ang hindi nakatakda o walang laman na PERLIO ay katumbas ng default na hanay ng mga layer para sa iyong
platform; halimbawa, ":unix:perlio" sa mga sistemang katulad ng Unix at ":unix:crlf" sa
Windows at iba pang mga sistemang tulad ng DOS.

Ang listahan ay nagiging default para sa lahat IO ni Perl. Dahil dito ay built-in lamang
maaaring lumitaw ang mga layer sa listahang ito, bilang mga panlabas na layer (tulad ng ":encoding()")
kailangan ng IO para ma-load ang mga ito! Tingnan ang "open pragma" para sa kung paano magdagdag ng external
pag-encode bilang mga default.

Ang mga layer na makatuwirang isama sa variable na kapaligiran ng PERLIO ay
maikling buod sa ibaba. Para sa higit pang mga detalye tingnan ang PerlIO.

:bytes Isang pseudolayer na pinipihit ang flag na ":utf8". off para sa layer sa ibaba;
malabong maging kapaki-pakinabang sa sarili nitong kapaligiran ng PERLIO
variable. Marahil ay iniisip mo ang ":crlf:bytes" o
":perlio:bytes".

:crlf Isang layer na nagsasalin ng CRLF sa "\n" na nagpapakilala sa "teksto" at
"binary" na mga file sa paraan ng MS-DOS at mga katulad na operating system.
(Kasalukuyan itong ginagawa hindi gayahin ang MS-DOS hanggang sa paggamot sa Control-Z bilang
pagiging isang end-of-file marker.)

:mmap Isang layer na nagpapatupad ng "pagbabasa" ng mga file sa pamamagitan ng paggamit mmap(2) gumawa ng isang
lalabas ang buong file sa address space ng proseso, at pagkatapos ay ginagamit iyon
bilang "buffer" ni PerlIO.

:perlio Ito ay isang muling pagpapatupad ng mala-stdio na buffering na isinulat bilang a
PerlIO layer. Dahil dito tatawagin nito ang anumang layer na nasa ibaba nito para dito
mga operasyon, karaniwang ":unix".

:pop Isang pang-eksperimentong pseudolayer na nag-aalis sa pinakamataas na layer. Gamitin kasama ang
ang parehong pangangalaga na nakalaan para sa nitroglycerine.

:raw Isang pseudolayer na nagmamanipula ng iba pang mga layer. Paglalapat ng ":raw"
ang layer ay katumbas ng pagtawag sa "binmode ($fh)". Ginagawa nito ang stream
ipasa ang bawat byte nang walang pagsasalin. Sa partikular, parehong CRLF
Ang pagsasalin at intuiting ":utf8" mula sa lokal ay hindi pinagana.

Hindi tulad sa mga naunang bersyon ng Perl, ang ":raw" ay hindi kabaligtaran lang ng
":crlf": ibang mga layer na makakaapekto sa binary na katangian ng
ang stream ay tinanggal din o hindi pinagana.

:stdio Nagbibigay ang layer na ito ng interface ng PerlIO sa pamamagitan ng pagbabalot ng ANSI C ng system
"stdio" na mga tawag sa library. Ang layer ay nagbibigay ng parehong buffering at IO. Tandaan
na ginagawa ng ":stdio" na layer hindi gawin ang pagsasalin ng CRLF kahit na iyon
normal na pag-uugali ng platform. Kakailanganin mo ng ":crlf" na layer sa itaas
para gawin iyon.

:unix Low-level layer na tinatawag na "read", "write", "lseek", atbp.

:utf8 Isang pseudolayer na nagbibigay-daan sa isang flag sa layer sa ibaba upang sabihin iyon kay Perl
ang output ay dapat nasa utf8 at ang input na iyon ay dapat ituring na na
sa wastong utf8 form. BABALA: It ang hindi tsek para bisa at as
tulad dapat be paghawak sa sukdulan mag-ingat para input, dahil sa
katiwasayan paglabag maaari mangyari sa hindi pinakamaikling UTF-8 pag-encode, at iba pa
Karaniwang ":encoding(utf8)" ang pinakamagandang opsyon kapag nagbabasa ng UTF-8
naka-encode na data.

:win32 Sa mga platform ng Win32 na ito pagsubok Ang layer ay gumagamit ng katutubong "hawakan" na IO
sa halip na isang Unix-like numeric file descriptor layer. Kilala na
buggy sa release na ito (5.14).

Ang default na hanay ng mga layer ay dapat magbigay ng mga katanggap-tanggap na resulta sa lahat ng platform

Para sa mga platform ng Unix na magiging katumbas ng "unix perlio" o "stdio".
Naka-set up ang pag-configure upang mas gusto ang pagpapatupad ng "stdio" kung ang system ay
ang library ay nagbibigay ng mabilis na pag-access sa buffer; kung hindi, ginagamit nito ang "unix
perlio" na pagpapatupad.

Sa Win32 ang default sa release na ito (5.14) ay "unix crlf". "stdio" ng Win32
ay may ilang mga bug/mis-feature para sa Perl IO na medyo nakadepende sa
ang bersyon at vendor ng C compiler. Gamit ang aming sariling "crlf" layer bilang ang
iniiwasan ng buffer ang mga isyung iyon at ginagawang mas pare-pareho ang mga bagay. Ang layer na "crlf".
nagbibigay ng CRLF conversion pati na rin ang buffering.

Ang release na ito (5.14) ay gumagamit ng "unix" bilang ang ilalim na layer sa Win32, at gayon pa man
gumagamit ng numeric file descriptor routine ng C compiler. May isang
pang-eksperimentong katutubong "win32" na layer, na inaasahang mapapahusay at dapat
kalaunan ay naging default sa ilalim ng Win32.

Ang variable na kapaligiran ng PERLIO ay ganap na binabalewala kapag ang Perl ay pinapatakbo
mantsa mode.

PERLIO_DEBUG
Kung nakatakda sa pangalan ng isang file o device, ang ilang partikular na operasyon ng PerlIO subsystem
ay mai-log sa file na iyon, na binuksan sa append mode. Ang mga karaniwang gamit ay
sa Unix:

% env PERLIO_DEBUG=/dev/tty perl script ...

at sa ilalim ng Win32, ang tinatayang katumbas:

> itakda ang PERLIO_DEBUG=CON
perl script...

Ang functionality na ito ay hindi pinagana para sa mga setuid na script at para sa mga script na ginagamit nito -T.

PERLLIB Isang listahan ng mga direktoryo kung saan hahanapin ang mga file ng Perl library bago maghanap
sa karaniwang aklatan at sa kasalukuyang direktoryo. Kung ang PERL5LIB ay tinukoy,
Hindi ginagamit ang PERLLIB.

Ang variable na kapaligiran ng PERLLIB ay ganap na binabalewala kapag ang Perl ay pinapatakbo
mantsa mode.

PERL5DB Ang utos na ginamit upang i-load ang debugger code. Ang default ay:

MAGSIMULA { nangangailangan ng "perl5db.pl" }

Ang PERL5DB environment variable ay ginagamit lamang kapag ang Perl ay sinimulan nang walang laman
-d Lumipat.

PERL5DB_THREADED
Kung nakatakda sa isang tunay na halaga, ipinapahiwatig sa debugger na ang code ay na-debug
gumagamit ng mga thread.

PERL5SHELL (tiyak sa Win32 port)
Sa mga Win32 port lang, maaaring itakda sa isang alternatibong shell na dapat gamitin ni Perl
panloob para sa pagpapatupad ng "backtick" na mga utos o sistema(). Default ay "cmd.exe
/x/d/c" sa WindowsNT at "command.com /c" sa Windows95. Ang halaga ay
itinuturing na space-separated. Nauna sa anumang karakter na kailangang protektahan,
tulad ng isang puwang o backslash, na may isa pang backslash.

Tandaan na hindi ginagamit ng Perl ang COMSPEC para sa layuning ito dahil mataas ang COMSPEC
antas ng pagkakaiba-iba sa mga user, na humahantong sa mga alalahanin sa portability. Bukod sa,
Maaaring gumamit ang Perl ng shell na maaaring hindi akma para sa interactive na paggamit, at setting
Ang COMSPEC sa naturang shell ay maaaring makagambala sa wastong paggana ng iba
mga programa (na karaniwang tumitingin sa COMSPEC upang makahanap ng shell na akma para sa interactive
gamitin).

Bago ang Perl 5.10.0 at 5.8.8, hindi nasuri ang PERL5SHELL kapag tumatakbo
panlabas na utos. Inirerekomenda na tahasan mong itakda (o tanggalin)
$ENV{PERL5SHELL} kapag tumatakbo sa taint mode sa ilalim ng Windows.

PERL_ALLOW_NON_IFS_LSP (partikular sa Win32 port)
Itakda sa 1 upang payagan ang paggamit ng mga LSP na hindi katugma sa IFS (Layered Service
Mga tagapagkaloob). Ang Perl ay karaniwang naghahanap ng isang LSP na katugma sa IFS dahil ito ay
kinakailangan para sa pagtulad nito sa mga Windows socket bilang tunay na filehandles. gayunpaman,
maaari itong magdulot ng mga problema kung mayroon kang firewall gaya ng McAfee Tagapag-alaga, Na
nangangailangan na gamitin ng lahat ng application ang LSP nito ngunit hindi katugma sa IFS,
dahil malinaw na karaniwang iiwasan ni Perl ang paggamit ng naturang LSP.

Ang pagtatakda sa variable ng kapaligiran na ito sa 1 ay nangangahulugan na gagamitin lang ni Perl ang
unang angkop na LSP na binanggit sa catalog, na nagpapanatili McAfee Tagapag-alaga
masaya--at sa partikular na kaso, gumagana pa rin si Perl dahil McAfee
Tagapag-alagaAng LSP ay aktwal na naglalaro ng iba pang mga laro na nagpapahintulot sa mga application na nangangailangan
IFS compatibility sa trabaho.

PERL_DEBUG_MSTATS
May kaugnayan lamang kung ang Perl ay pinagsama-sama sa "malloc" na kasama sa Perl
pamamahagi; ibig sabihin, kung ang "perl -V:d_mymalloc" ay "define".

Kung itatakda, itatapon nito ang mga istatistika ng memorya pagkatapos ng pagpapatupad. Kung nakatakda sa isang
integer na mas malaki kaysa sa isa, ay nagtatapon din ng mga istatistika ng memorya pagkatapos ng compilation.

PERL_DESTRUCT_LEVEL
May kaugnayan lamang kung ang iyong Perl executable ay binuo gamit ang -DDEBUGGING, Ito
kinokontrol ang pag-uugali ng pandaigdigang pagkasira ng mga bagay at iba pang mga sanggunian.
Tingnan ang "PERL_DESTRUCT_LEVEL" sa perlhacktips para sa higit pang impormasyon.

PERL_DL_NONLAZY
Itakda sa "1" upang malutas ang Perl lahat hindi natukoy na mga simbolo kapag nag-load ito ng isang dynamic
aklatan. Ang default na gawi ay upang malutas ang mga simbolo kapag ginamit ang mga ito.
Ang pagtatakda ng variable na ito ay kapaki-pakinabang sa panahon ng pagsubok ng mga extension, dahil sinisiguro nito
na nakakakuha ka ng error sa maling spelling ng mga pangalan ng function kahit na ang test suite
ay hindi tumatawag sa kanila.

PERL_ENCODING
Kung gumagamit ng pragma na "gamitin ang pag-encode" nang walang tahasang pangalan ng pag-encode, ang
Kinunsulta ang PERL_ENCODING environment variable para sa pangalan ng encoding.

PERL_HASH_SEED
(Mula noong Perl 5.8.1, mga bagong semantika sa Perl 5.18.0) Ginamit upang i-override ang
randomization ng internal hash function ng Perl. Ang halaga ay ipinahayag sa
hexadecimal, at maaaring may kasamang nangungunang 0x. Ang mga pinutol na pattern ay itinuturing bilang
kahit na ang mga ito ay nilagyan ng sapat na 0 kung kinakailangan.

Kung ang opsyon ay ibinigay, at ang "PERL_PERTURB_KEYS" ay HINDI nakatakda, pagkatapos ay isang halaga ng
Ang '0' ay nagpapahiwatig ng "PERL_PERTURB_KEYS=0" at ang anumang iba pang halaga ay nagpapahiwatig
"PERL_PERTURB_KEYS=2".

MANGYARING TANDAAN: Ang sumira magbigay ng binhi is maramdamin impormasyon. Ang mga hash ay randomized sa
protektahan laban sa lokal at malayuang pag-atake laban sa Perl code. Sa pamamagitan ng mano-mano
pagtatakda ng binhi, ang proteksyong ito ay maaaring bahagyang o ganap na mawala.

Tingnan ang "Algorithmic Complexity Attacks" sa perlsec, "PERL_PERTURB_KEYS", at
"PERL_HASH_SEED_DEBUG" para sa higit pang impormasyon.

PERL_PERTURB_KEYS
(Since Perl 5.18.0) Itakda sa "0" o "NO" at ang mga traversing key ay magiging
nauulit mula run hanggang run para sa parehong PERL_HASH_SEED. Pagpasok sa isang hash
ay hindi babaguhin ang pagkakasunud-sunod, maliban na magbigay ng mas maraming espasyo sa hash. Kailan
kasama ng pagtatakda ng PERL_HASH_SEED ang mode na ito ay kasing lapit sa pre 5.18
pag-uugali hangga't maaari mong makuha.

Kapag itinakda sa "1" o "RANDOM" pagkatapos ay magiging randomized ang mga traversing key. Bawat
ang oras na ang isang hash ay ipinasok sa key order ay magbabago sa random na paraan.
Ang pagkakasunud-sunod ay maaaring hindi maulit sa isang sumusunod na programa na tumatakbo kahit na ang
Ang PERL_HASH_SEED ay tinukoy. Ito ang default na mode para sa perl.

Kapag itinakda sa "2" o "DETERMINISTIC" ang pagpasok ng mga key sa isang hash ay magdudulot
ang pangunahing pagkakasunud-sunod upang baguhin, ngunit sa paraang nauulit mula sa pagtakbo ng programa hanggang
pagpapatakbo ng programa.

TANDAAN: Ang paggamit ng opsyong ito ay itinuturing na hindi secure, at nilayon lamang para sa
pag-debug ng hindi tiyak na pag-uugali sa hash function ng Perl. Huwag gamitin ito sa
produksyon.

Tingnan ang "Algorithmic Complexity Attacks" sa perlsec at "PERL_HASH_SEED" at
"PERL_HASH_SEED_DEBUG" para sa higit pang impormasyon. Maaari mong makuha at itakda ang susi
traversal mask para sa isang partikular na hash sa pamamagitan ng paggamit ng "hash_traversal_mask()"
function mula sa Hash::Util.

PERL_HASH_SEED_DEBUG
(Mula noong Perl 5.8.1.) Itakda sa "1" upang ipakita (sa STDERR) ang impormasyon tungkol sa
hash function, seed, at kung anong uri ng key traversal randomization ang may bisa
sa simula ng pagpapatupad. Ito, na sinamahan ng "PERL_HASH_SEED" at
Ang "PERL_PERTURB_KEYS" ay nilayon na tumulong sa pag-debug ng hindi tiyak na gawi
sanhi ng hash randomization.

nota na ang anumang impormasyon tungkol sa hash function, lalo na ang hash seed ay
maramdamin impormasyon: sa pamamagitan ng pag-alam nito, ang isa ay makakagawa ng denial-of-service attack
laban sa Perl code, kahit sa malayo; tingnan ang "Algorithmic Complexity Attacks" sa
perlsec para sa karagdagang impormasyon. Do hindi ipaalam ang sumira magbigay ng binhi sa mga taong
hindi na kailangang malaman ito. Tingnan din ang "hash_seed()" at "key_traversal_mask()" sa
Hash::Util.

Ang isang halimbawang output ay maaaring:

HASH_FUNCTION = ONE_AT_A_TIME_HARD HASH_SEED = 0x652e9b9349a7a032 PERTURB_KEYS = 1 (RANDOM)

PERL_MEM_LOG
Kung ang iyong Perl ay na-configure sa -Accflags=-DPERL_MEM_LOG, pagtatakda ng
Ang environment variable na "PERL_MEM_LOG" ay nagbibigay-daan sa pag-log ng mga mensahe ng debug. Ang halaga
may porma"numero>[m][s][t]", saan"numero" ay ang file descriptor number
gusto mong sulatan (2 ay default), at ang kumbinasyon ng mga titik ay tumutukoy
na gusto mo ng impormasyon tungkol sa (m)emory at/o (s)v, opsyonal na kasama
(t) mga imestamp. Halimbawa, nila-log ng "PERL_MEM_LOG=1mst" ang lahat ng impormasyon sa stdout.
Maaari kang sumulat sa iba pang nakabukas na mga deskriptor ng file sa iba't ibang paraan:

$ 3>foo3 PERL_MEM_LOG=3m perl ...

PERL_ROOT (partikular sa VMS port)
Isang translation-concealed rooted logical name na naglalaman ng Perl at ang logical
device para sa @INC path sa VMS lang. Iba pang mga lohikal na pangalan na nakakaapekto sa Perl sa
Kasama sa VMS ang PERLSHR, PERL_ENV_TABLES, at SYS$TIMEZONE_DIFFERENTIAL, ngunit
opsyonal at tinalakay pa sa perlvms at sa README.vms sa pinagmulan ng Perl
pamamahagi.

PERL_SIGNALS
Available sa Perls 5.8.1 at mas bago. Kung nakatakda sa "hindi ligtas", ang pre-Perl-5.8.0
Ang pag-uugali ng signal (na kaagad ngunit hindi ligtas) ay naibalik. Kung nakatakda sa
"ligtas", pagkatapos ay ligtas (ngunit ipinagpaliban) ang mga signal na ginagamit. Tingnan ang "Mga Deferred Signal
(Safe Signals)" sa perlipc.

PERL_UNICODE
Katumbas ng -C switch ng command-line. Tandaan na hindi ito boolean
variable. Ang pagtatakda nito sa "1" ay hindi ang tamang paraan para "paganahin ang Unicode"
(anuman ang ibig sabihin nito). Maaari mong gamitin ang "0" para "i-disable ang Unicode", bagaman (o
Bilang kahalili, i-unset ang PERL_UNICODE sa iyong shell bago simulan ang Perl). Tingnan ang
paglalarawan ng mga -C lumipat para sa karagdagang impormasyon.

SYS$LOGIN (tiyak sa VMS port)
Ginagamit kung ang chdir ay walang argumento at HOME at LOGDIR ay hindi nakatakda.

Ang Perl ay mayroon ding mga variable sa kapaligiran na kumokontrol kung paano pinangangasiwaan ng Perl ang data na partikular sa
partikular na natural na mga wika; tingnan ang perllocale.

Maaaring minsan ang Perl at ang iba't ibang module at bahagi nito, kasama ang mga test framework nito
gumamit ng ilang iba pang mga variable sa kapaligiran. Ang ilan sa mga ito ay tiyak sa a
partikular na plataporma. Mangyaring kumonsulta sa naaangkop na dokumentasyon ng module at anuman
dokumentasyon para sa iyong platform (tulad ng perlsolaris, perllinux, perlmacosx, perlwin32, atbp)
para sa mga variable na kakaiba sa mga partikular na sitwasyon.

Ginagawang magagamit ng Perl ang lahat ng mga variable ng kapaligiran sa programang isinasagawa, at ipinapasa
ang mga ito kasama sa anumang proseso ng bata na sinisimulan nito. Gayunpaman, magagawa ng mga programang tumatakbo ang setuid
mahusay na isagawa ang mga sumusunod na linya bago gumawa ng anupaman, para lamang mapanatili ang mga tao
matapat:

$ENV{PATH} = "/ bin:/ usr / bin"; # o anumang kailangan mo
$ENV{SHELL} = "/ Bin / SH" kung mayroong $ENV{SHELL};
tanggalin ang @ENV{qw(IFS CDPATH ENV BASH_ENV)};

Gumamit ng perlrun online gamit ang mga serbisyo ng onworks.net