perlopentut - Online sa Cloud

PROGRAMA:

NAME

perlopentut - mga simpleng recipe para sa pagbubukas ng mga file at pipe sa Perl

DESCRIPTION

Sa tuwing gagawin mo ang I/O sa isang file sa Perl, ginagawa mo ito sa pamamagitan ng tinatawag sa Perl na a
filehandle. Ang filehandle ay isang panloob na pangalan para sa isang panlabas na file. Ito ay trabaho ng
"bukas" na function upang gawin ang kaugnayan sa pagitan ng panloob na pangalan at panlabas na pangalan,
at trabaho ng "close" na function na sirain ang asosasyong iyon.

Para sa iyong kaginhawahan, si Perl ay nagse-set up ng ilang espesyal na filehandle na bukas na kung kailan
Tumakbo ka. Kabilang dito ang "STDIN", "STDOUT", "STDERR", at "ARGV". Dahil ang mga iyon ay pre-
binuksan, maaari mong gamitin ang mga ito kaagad nang hindi nahihirapang buksan ang mga ito
iyong sarili:

print STDERR "Ito ay isang mensahe sa pag-debug.\n";

print STDOUT "Mangyaring magpasok ng isang bagay: ";
$tugon = // mamatay "bakit walang input?";
print STDOUT "Salamat!\n";

habang ( ) { ... }

Tulad ng nakikita mo mula sa mga halimbawang iyon, ang "STDOUT" at "STDERR" ay mga output handle, at "STDIN" at
Ang "ARGV" ay mga input handle. Ang mga ito ay nasa lahat ng malalaking titik dahil sila ay nakalaan sa
Perl, katulad ng @ARGV array at ang %ENV hash ay. Ang kanilang mga panlabas na asosasyon ay
itinakda ng iyong shell.

Kakailanganin mong buksan ang bawat iba pang filehandle nang mag-isa. Bagama't marami
mga variant, ang pinakakaraniwang paraan ng pagtawag sa Perl's bukas() ang function ay may tatlong argumento at
isang return value:

" OK = bukas(HANDLE, MODE, PATHNAME)"

Saan:

OK ay magiging ilang tinukoy na halaga kung magtagumpay ang bukas, ngunit "undef" kung nabigo ito;

HAWAKAN
dapat ay isang hindi natukoy na scalar variable na pupunan ng "bukas" na function kung ito
nagtagumpay;

MODE
ay ang access mode at ang encoding format para buksan ang file gamit ang;

PATHNAME
ay ang panlabas na pangalan ng file na gusto mong buksan.

Karamihan sa pagiging kumplikado ng "bukas" na function ay nakasalalay sa maraming posibleng mga halaga na ang
MODE maaaring tumagal ang parameter.

Isang huling bagay bago namin ipakita sa iyo kung paano magbukas ng mga file: ang pagbubukas ng mga file ay hindi (karaniwan)
awtomatikong i-lock ang mga ito sa Perl. Tingnan ang perlfaq5 para sa kung paano i-lock.

Pagbubukas teksto File

Pagbubukas teksto File para Pagbabasa
Kung gusto mong magbasa mula sa isang text file, buksan muna ito sa read-only mode tulad nito:

ang aking $filename = "/some/path/to/a/textfile/goes/here";
my $encoding = ":encoding(UTF-8)";
aking $handle = undef; # ito ay mapupunan sa tagumpay

bukas($handle, "< $encoding", $filename)
|| mamatay "$0: hindi mabuksan ang $filename para sa pagbabasa: $!";

Tulad ng sa shell, sa Perl ang "<" ay ginagamit upang buksan ang file sa read-only na mode. Kung ito
nagtagumpay, naglalaan si Perl ng bagong filehandle para sa iyo at pinupunan ang iyong dati
hindi natukoy na $handle argument na may reference sa handle na iyon.

Ngayon ay maaari kang gumamit ng mga function tulad ng "readline", "read", "getc", at "sysread" sa handle na iyon.
Marahil ang pinakakaraniwang input function ay ang mukhang isang operator:

$line = readline($handle);
$line = <$handle>; # parehas na bagay

Dahil ang function na "readline" ay nagbabalik ng "undef" sa dulo ng file o kapag nagkamali, gagawin mo
minsan makita itong ginamit sa ganitong paraan:

$line = <$handle>;
kung (tinukoy $line) {
# gumawa ng isang bagay gamit ang $line
}
tao {
# $line ay hindi wasto, kaya laktawan ito
}

Maaari mo ring mabilis na "mamatay" sa isang hindi natukoy na halaga sa ganitong paraan:

$line = <$handle> // die "no input found";

Gayunpaman, kung ang pagpindot sa EOF ay isang inaasahan at normal na kaganapan, hindi mo nais na lumabas nang simple
dahil naubusan ka na ng input. Sa halip, malamang na gusto mo lang lumabas sa isang input loop.
Pagkatapos ay maaari mong subukan upang makita kung ang isang aktwal na error ay naging sanhi ng loop upang wakasan, at kumilos
naaayon:

habang (<$handle>) {
# gumawa ng isang bagay gamit ang data sa $_
}
kung ($!) {
mamatay "hindi inaasahang error habang nagbabasa mula sa $filename: $!";
}

A nota on Mga encoding: Ang pagkakaroon upang tukuyin ang text encoding sa bawat oras ay maaaring mukhang isang bit ng isang
abala. Upang mag-set up ng default na pag-encode para sa "bukas" para hindi mo na kailangang ibigay ito sa bawat isa
oras, maaari mong gamitin ang "bukas" na pragma:

gumamit ng open qw< :encoding(UTF-8) >;

Kapag nagawa mo na iyon, maaari mong ligtas na alisin ang bahagi ng pag-encode ng open mode:

bukas($handle, "<", $filename)
|| mamatay "$0: hindi mabuksan ang $filename para sa pagbabasa: $!";

Ngunit huwag gamitin ang hubad na "<" nang hindi muna nagse-set up ng default na pag-encode. kung hindi,
Hindi malalaman ni Perl kung alin sa marami, marami, maraming posibleng lasa ng text file na mayroon ka, at
Walang ideya si Perl kung paano imapa nang tama ang data sa iyong file sa mga aktwal na character
maaari itong gumana sa. Iba pang karaniwang mga format ng pag-encode kabilang ang "ASCII", "ISO-8859-1",
"ISO-8859-15", "Windows-1252", "MacRoman", at maging ang "UTF-16LE". Tingnan ang kailangan para sa higit pa
tungkol sa pag-encode.

Pagbubukas teksto File para Pagsulat
Kapag gusto mong magsulat sa isang file, kailangan mo munang magpasya kung ano ang gagawin tungkol sa anumang umiiral na
nilalaman ng file na iyon. Mayroon kang dalawang pangunahing pagpipilian dito: upang mapanatili o mag-clobber.

Kung gusto mong panatilihin ang anumang mga umiiral na nilalaman, pagkatapos ay gusto mong buksan ang file sa append
mode. Tulad ng sa shell, sa Perl ginagamit mo ang ">>" upang buksan ang isang umiiral na file sa append mode.
Ginagawa ng ">>" ang file kung wala pa ito.

aking $handle = undef;
ang aking $filename = "/some/path/to/a/textfile/goes/here";
my $encoding = ":encoding(UTF-8)";

bukas($handle, ">> $encoding", $filename)
|| mamatay "$0: hindi mabuksan ang $filename para sa pagdaragdag: $!";

Ngayon ay maaari kang sumulat sa filehandle na iyon gamit ang alinman sa "print", "printf", "say", "write", o
"syswrite".

Gaya ng nabanggit sa itaas, kung wala pa ang file, lilikha ang append-mode open
para sa iyo ito. Ngunit kung ang file ay mayroon na, ang mga nilalaman nito ay ligtas mula sa pinsala dahil
idaragdag mo ang iyong bagong teksto sa dulo ng lumang teksto.

Sa kabilang banda, kung minsan gusto mong i-clobber kung ano ang maaaring naroroon. Upang
alisan ng laman ang isang file bago ka magsimulang sumulat dito, maaari mo itong buksan sa write-only mode:

aking $handle = undef;
ang aking $filename = "/some/path/to/a/textfile/goes/here";
my $encoding = ":encoding(UTF-8)";

bukas($handle, "> $encoding", $filename)
|| mamatay "$0: hindi mabuksan ang $filename sa write-open mode: $!";

Narito muli ang Perl ay gumagana tulad ng shell sa na ang ">" clobbers isang umiiral na file.

Tulad ng append mode, kapag nagbukas ka ng file sa write-only mode, maaari ka na ngayong sumulat
na filehandle gamit ang alinman sa "print", "printf", "say", "write", o "syswrite".

Paano ang read-write mode? Dapat mo sigurong magpanggap na wala ito, dahil pagbubukas
Ang mga text file sa read-write mode ay malabong gawin ang gusto mo. Tingnan ang perlfaq5 para sa
mga detalye.

Pagbubukas binary File

Kung ang file na bubuksan ay naglalaman ng binary data sa halip na mga text character, ang "MODE"
Ang argumento sa "bukas" ay medyo naiiba. Sa halip na tukuyin ang pag-encode, sasabihin mo
Perl na ang iyong data ay nasa raw bytes.

ang aking $filename = "/some/path/to/a/binary/file/goes/here";
aking $encoding = ":raw :bytes"
aking $handle = undef; # ito ay mapupunan sa tagumpay

At pagkatapos ay buksan tulad ng dati, piliin ang "<", ">>", o ">" kung kinakailangan:

bukas($handle, "< $encoding", $filename)
|| mamatay "$0: hindi mabuksan ang $filename para sa pagbabasa: $!";

bukas($handle, ">> $encoding", $filename)
|| mamatay "$0: hindi mabuksan ang $filename para sa pagdaragdag: $!";

bukas($handle, "> $encoding", $filename)
|| mamatay "$0: hindi mabuksan ang $filename sa write-open mode: $!";

Bilang kahalili, maaari kang lumipat sa binary mode sa isang umiiral nang handle sa ganitong paraan:

binmode($handle) || mamatay "hindi mahawakan ang binmode";

Ito ay lalong madaling gamitin para sa mga handle na binuksan na ni Perl para sa iyo.

binmode(STDIN) || mamatay "hindi maaaring binmode STDIN";
binmode(STDOUT) || mamatay "hindi maaaring binmode STDOUT";

Maaari mo ring ipasa ang "binmode" ng isang tahasang pag-encode upang baguhin ito sa mabilisang. Ito ay hindi
eksaktong "binary" mode, ngunit ginagamit pa rin namin ang "binmode" upang gawin ito:

binmode(STDIN, ":encoding(MacRoman)") || mamatay "hindi maaaring binmode STDIN";
binmode(STDOUT, ":encoding(UTF-8)") || mamatay "hindi maaaring binmode STDOUT";

Kapag nabuksan mo nang maayos ang iyong binary file sa tamang mode, maaari mong gamitin ang lahat ng pareho
Ang Perl I/O ay gumagana tulad ng ginamit mo sa mga text file. Gayunpaman, maaaring naisin mong gamitin ang nakapirming laki
"read" sa halip na ang variable-sized na "readline" para sa iyong input.

Narito ang isang halimbawa kung paano kumopya ng binary file:

aking $BUFSIZ = 64 * (2 ** 10);
my $name_in = "/some/input/file";
my $name_out = "/some/output/flie";

my($in_fh, $out_fh, $buffer);

bukas($in_fh, "<", $name_in)
|| mamatay "$0: hindi mabuksan ang $name_in para sa pagbabasa: $!";
bukas($out_fh, ">", $name_out)
|| mamatay "$0: hindi mabuksan ang $name_out para sa pagsulat: $!";

para sa aking $fh ($in_fh, $out_fh) {
binmode($fh) || mamatay "binmode failed";
}

habang (read($in_fh, $buffer, $BUFSIZ)) {
maliban kung (i-print ang $out_fh $buffer) {
mamatay "hindi magsulat sa $name_out: $!";
}
}

malapit($in_fh) || mamatay "hindi maisara ang $name_in: $!";
malapit($out_fh) || mamatay "hindi maisara ang $name_out: $!";

Pagbubukas Pipa

Ipapahayag.

Mababang antas talaksan Binubuksan sa pamamagitan ng sysopen

Upang ipahayag. O tinanggal.

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