PERLFAQ8 7

中文man手册

PERLFAQ8

NAME
DESCRIPTION æè¿°
AUTHOR AND COPYRIGHT
è¯è

NAME

perlfaq8 - ç³»ç»äº¤äº (2003/01/26 17:44:04 )

DESCRIPTION æè¿°

éè¯»ä½ ç³»ç»ä¸ç perl èªå¸¦ç FAQ åææ¡£ (ä¾å¦ï¼perlvms,perlplan9...)ãå®ä»¬ä¼åå«æå³ä½ ç perl çæ¬çæ´è¯¦ç»çä¿¡æ¯ã

å¦ä½æ¾åºæ£å¨è¿è¡çæä½ç³»ç»ï¼

ä¸ºä»ä¹ exec() ä¸è¿å?

å¦ä½å¯¹é®çï¼è¤å¹ï¼æ»é¼ åäºè±æ ·ï¼

Term::Cap æ ååå»ºæ¨¡ç»
Term::ReadKey CPAN
Term::ReadLine::Gnu CPAN
Term::ReadLine::Perl CPAN
Term::Screen CPAN

Screen

Term::Cap æ ååå»ºæ¨¡ç»
Curses CPAN
Term::ANSIColor CPAN

Mouse

Tk CPAN

Some of these specific cases are shown below.

How do I print something out in color?

In general, you don’t, because you don’t know whether the recipient has a color-aware display device. If you know that they have an ANSI terminal that understands color, you can use the Term::ANSIColor module from CPAN:

use Term::ANSIColor;
print color("red"), "Stop!\n", color("reset");
print color("green"), "Go!\n", color("reset");

Or like this:

use Term::ANSIColor qw(:constants);
print RED, "Stop!\n", RESET;
print GREEN, "Go!\n", RESET;

How do I read just one key without waiting for a return key?

Controlling input buffering is a remarkably system-dependent matter. On many systems, you can just use the stty command as shown in "getc" in perlfunc, but as you see, that’s already getting you into portability snags.

open(TTY, "+</dev/tty") or die "no tty: $!";
system "stty cbreak </dev/tty >/dev/tty 2>&1";
$key = getc(TTY); # perhaps this works
# OR ELSE
sysread(TTY, $key, 1); # probably this does
system "stty -cbreak </dev/tty >/dev/tty 2>&1";

The Term::ReadKey module from CPAN offers an easy-to-use interface that should be more efficient than shelling out to stty for each key. It even includes limited support for Windows.

use Term::ReadKey;
ReadMode(’cbreak’);
$key = ReadKey(0);
ReadMode(’normal’);

However, using the code requires that you have a working C compiler and can use it to build and install a CPAN module. Here’s a solution using the standard POSIX module, which is already on your systems (assuming your system supports POSIX ).

use HotKey;
$key = readkey();

And here’s the HotKey module, which hides the somewhat mystifying calls to manipulate the POSIX termios structures.

# HotKey.pm
package HotKey;

@ISA = qw(Exporter);
@EXPORT = qw(cbreak cooked readkey);

use strict;
use POSIX qw(:termios_h);
my ($term, $oterm, $echo, $noecho, $fd_stdin);

$fd_stdin = fileno(STDIN);
$term = POSIX::Termios->new();
$term->getattr($fd_stdin);
$oterm = $term->getlflag();

$echo = ECHO ⎪ ECHOK ⎪ ICANON;
$noecho = $oterm & ˜$echo;

sub cbreak {
$term->setlflag($noecho); # ok, so i don’t want echo either
$term->setcc(VTIME, 1);
$term->setattr($fd_stdin, TCSANOW);
}

sub cooked {
$term->setlflag($oterm);
$term->setcc(VTIME, 0);
$term->setattr($fd_stdin, TCSANOW);
}

sub readkey {
my $key = ’’;
cbreak();
sysread(STDIN, $key, 1);
cooked();
return $key;
}

END { cooked() }

How do I check whether input is ready on the keyboard?

The easiest way to do this is to read a key in nonblocking mode with the Term::ReadKey module from CPAN , passing it an argument of -1 to indicate not to block:

use Term::ReadKey;

ReadMode(’cbreak’);

if (defined ($char = ReadKey(-1)) ) {
# input was waiting and it was $char
} else {
# no input was waiting
}

ReadMode(’normal’); # restore normal tty settings

How do I clear the screen?

If you only have do so infrequently, use "system":

system("clear");

If you have to do this a lot, save the clear string so you can print it 100 times without calling a program 100 times:

$clear_string = ‘clear‘;
print $clear_string;

If you’re planning on doing other screen manipulations, like cursor positions, etc, you might wish to use Term::Cap module:

use Term::Cap;
$terminal = Term::Cap->Tgetent( {OSPEED => 9600} );
$clear_string = $terminal->Tputs(’cl’);

How do I get the screen size?

If you have Term::ReadKey module installed from CPAN , you can use it to fetch the width and height in characters and in pixels:

use Term::ReadKey;
($wchar, $hchar, $wpixels, $hpixels) = GetTerminalSize();

This is more portable than the raw "ioctl", but not as illustrative:

require ’sys/ioctl.ph’;
die "no TIOCGWINSZ " unless defined &TIOCGWINSZ;
open(TTY, "+</dev/tty") or die "No tty: $!";
unless (ioctl(TTY, &TIOCGWINSZ, $winsize=’’)) {
die sprintf "$0: ioctl TIOCGWINSZ (%08x: $!)\n", &TIOCGWINSZ;
}
($row, $col, $xpixel, $ypixel) = unpack(’S4’, $winsize);
print "(row,col) = ($row,$col)";
print " (xpixel,ypixel) = ($xpixel,$ypixel)" if $xpixel ⎪⎪ $ypixel;
print "\n";

å¦ä½åä½¿ç¨èè¯¢é®å¯ç ï¼

use Term::ReadKey;

ReadMode(’noecho’);
$password = ReadLine(0);

å¦ä½è¯»åä¸²å£ï¼

open mode

end of line

æäºè£ç½®ä¼ççå¨æ¯è¡ç»å°¾å¤çå°ä¸ä¸ª "\r"ï¼èé "\n"ãå¨æäºå¹³å°ä¸ç perlï¼ "\r"å "\n" ä¸å®ä»¬å¹³å¸¸ï¼å¨ Unix ä¸ï¼ææç ASCII å¼ "\015" å "\012" æ æä¸åãä½ ä¹è®¸å¾ç´æ¥ç»å®æ°å¼ï¼ä¾å¦ç¨å«è¿ä½ ("\015")ãååè¿ä½ ("0x0D")ï¼ ææå®æ§å¶åå ("\cM")ã

print DEV "atv1\012"; # wrong, for some devices
print DEV "atv1\015"; # right, for some devices

flushing output

å¦æä½ å¸æ print() çæ¶åæ¯ä¸ªå- åé½è¦éå°ä½ æå®çè£ç½®å»ï¼é£ä½ åºèªå¨å·æ°æä»¶å¥æãå¯ä»¥ä½¿ç¨ select() å $⎪ åéæ§å¶èªå¨å·æ°ï¼åè§ perlvar ä¸ç "$⎪" å perlfunc ä¸ç "select"ï¼æ perlfaq5, ‘‘How do I flush/unbuffer an output filehandle? Why must I do this?’’):

$oldh = select(DEV);
$⎪ = 1;
select($oldh);

ä½ ä¹å¯è½çå°ä¸ä½¿ç¨é¢å¤çæååæ°çåæ³ï¼ä¾å¦ï¼

select((select(DEV), $⎪ = 1)[0]);

Or if you don’t mind pulling in a few thousand lines of code just because you’re afraid of a little $⎪ variable:

use IO::Handle;
DEV->autoflush(1);

As mentioned in the previous item, this still doesn’t work when using socket I/O between Unix and Macintosh. You’ll need to hard code your line terminators, in that case.

non-blocking input

While trying to read from his caller-id box, the notorious Jamie Zawinski <jwz@netscape.com>, after much gnashing of teeth and fighting with sysread, sysopen, POSIX ’s tcgetattr business, and various other functions that go bump in the night, finally came up with this:

sub open_modem {
use IPC::Open2;
my $stty = ‘/bin/stty -g‘;
open2( \*MODEM_IN, \*MODEM_OUT, "cu -l$modem_device -s2400 2>&1");
# starting cu hoses /dev/tty’s stty settings, even when it has
# been opened on a pipe...
system("/bin/stty $stty");
$_ = <MODEM_IN>;
chomp;
if ( !m/ˆConnected/ ) {
print STDERR "$0: cu printed ‘$_’ instead of ‘Connected’\n";
}
}

å¦ä½è§£ç å å¯çå£ä»¤æä»¶ï¼

å¦ä½å¨åå°å¼å¯è¿ç¨ï¼

Several modules can start other processes that do not block your Perl program. You can use IPC::Open3, Parallel::Jobs, IPC::Run, and some of the POE modules. See CPAN for more details.

ä½ å¯ä»¥ä½¿ç¨ï¼

system("cmd &")

ææ¯ç¨ forkï¼å perlfunc ä¸ç fork éåçï¼å¨ perlipc éææ´è¿ä¸æ¥ç èä¾ï¼ãå¦æä½ å¨ Unix ç±»çç³»ç»ä¸çè¯ï¼è¯·æ³¨æä»¥ä¸å ä»¶äºæï¼
STDIN , STDOUT , and STDERR are shared

ä¿¡å·

åµå°¸è¿ç¨

ä½ å¾ååå¤ï¼å¨åç¨åºç»ææ¶ãæ¶æãå®ï¼

$SIG{CHLD} = sub { wait };

$SIG{CHLD} = ’IGNORE’;

You can also use a double fork. You immediately wait() for your first child, and the init daemon will wait() for your grandchild once it exits.

unless ($pid = fork) {
unless (fork) {
exec "what you really wanna do";
die "exec failed!";
}
exit 0;
}
waitpid($pid,0);

å¨ Signals æèä¾ç¨å¼æä½ æä¹åãç¨ system("prog &") ç è¯ä¸ä¼æåµ ç¨åºçé®é¢ã

å¦ä½æªè·æ§å¶åç¬¦/ä¿¡å·ï¼

ä¾å¦ï¼

$Interrupted = 0; # ç¡®å®å®æä¸ªå¼
$SIG{INT} = sub {
$Interrupted++;
syswrite(STDERR, "ouch\n", 5);
}

å¨ Unix ç³»ç»ä¸å¦ä½ä¿®æ¹ shadow æä»¶ï¼

å¦ä½è®¾ç½®æ¶é´åæ¥æï¼

$ENV{TZ} = "MST7MDT"; # unixish
$ENV{’SYS$TIMEZONE_DIFFERENTIAL’}="-5" # vms
system "trn comp.lang.perl.misc";

å¦ä½ sleep() æ alarm() å°äºä¸ç§çæ¶é´?

å¦æä½ è¦æ¯ sleep() ææä¾çæå°åä½ä¸ç§æ´ç²¾ç»çè¯ï¼æç®åçæ¹æ³å°±æ¯ç¨ select éé¢åç select() å½æ°ãè¯ä¸è¯ Time::HiRes å BSD::Itimer æ¨¡å (å¯ä»¥ä» CPAN ä¸è½½ï¼ä» Perl 5.8 å¼å§ Time::HiRes æä¸ºæ ååè¡çä¸é¨å).

å¦ä½æµåº¦å°äºä¸ç§çæ¶é´ï¼

require ’sys/syscall.ph’;

$TIMEVAL_T = "LL";

$done = $start = pack($TIMEVAL_T, ());

syscall(&SYS_gettimeofday, $start, 0) != -1
or die "gettimeofday: $!";

##########################
# DO YOUR OPERATION HERE #
##########################

syscall( &SYS_gettimeofday, $done, 0) != -1
or die "gettimeofday: $!";

@start = unpack($TIMEVAL_T, $start);
@done = unpack($TIMEVAL_T, $done);

# fix microseconds
for ($done[1], $start[1]) { $_ /= 1_000_000 }

$delta_time = sprintf "%.4f", ($done[0] + $done[1] )
-
($start[0] + $start[1] );

å¦ä½å atexit()æ setjmp()/longjmp()çå¨ä½ï¼ï¼å¼å¸¸å¤çï¼

ç¬¬äºçç Perl å¢å äº END åºåï¼å¯ä»¥ç¨æ¥æ¨¡æ atexit()çææãå½ç¨å¼ææ§è¡ ç»ª(thread) ç»äºæ¶å°±ä¼å»å¼å«è¯¥åè£ç END åºåï¼åè perlmod æä»¶ï¼ã

For example, you can use this to make sure your filter program managed to finish its output without filling up the disk:

END {
close(STDOUT) ⎪⎪ die "stdout close failed: $!";
}

use sigtrap qw(die normal-signals);

Perl çä¾å¤å¤çæºå¶å°±æ¯å®ç eval() è¿ç®åãä½ å¯ä»¥æ eval() å½å setjmp èdie()å½å longjmp æ¥ä½¿ç¨ãæ´è¯¦ç»çè¯´æè¯·åè Signals å Camelä¹¦ç¬¬å- ç« éå³äºè®¯å·çé£æ®µï¼å°¤å¶æ¯æè¿°æå³ flock() çé¾æ¶å¤çå¨é£æ®µã

å¦æä½ è¦çæ¯ atexit() è¯æ³ï¼ä»¥å rmexit()ï¼ï¼è¯è¯ CPAN éç AtExit æ¨¡ç»ã

å¦ä½ä» Perléå¼å«ç³»ç»ä¸ç¬ç¹ç Cå½æ°ï¼

åè®°åæ¥æ¥çä½ ç perl çæ¬ä¸æéçæ¨¡ç»ä»¥å CPAN éçæ¨¡ç»ï¼å ä¸ºä¹è®¸æäººå·² ç»åäºä¸ªè¿æ ·çæ¨¡ç»ã On Windows, try Win32::API. On Macs, try Mac::Carbon. If no module has an interface to the C function, you can inline a bit of C in your Perl source with Inline::C.

å¨åªéå¯ä»¥æ¾å¼å¥æ¡£æ¥å ioctl()æ syscall()ï¼

1. æä¸ºè¶çº§ç¨æ·
2. cd /usr/include
3. h2ph *.h */*.h

å¦æä½ çç³»ç»ä¸æ¯æ´å¨æè½½å¥ï¼ä½ å¯è½ä»åºä½¿ç¨ h2xsãåç perlxstut å MakeMaker ï¼ç®åæ¥è¯´ï¼å°±æ¯ç¨ make perl ãèé make æ¥é å»ºä¸ä»½ä½¿ç¨æ°çéæè¿ç»ç perlï¼ã

å¦ä½æå¼å¯¹æç¨å¼æ¢è¾å¥åè¾åºçç®¡é (pipe)ï¼

IPC::Open2 æ¨¡ç»ï¼perl çæ åéä»¶ï¼æ¯ä¸ªå¥½ç¨çæ¹æ³ï¼å®å¨åé¨æ¯åçpipe()ã fork() å exec() æ¥å®ææ¤å·¥ä½ãä¸è¿åè®°è¦è¯»å®æä»¶éå³äºéæ»çè¦å ( åè§ IPC::Open2 )ãåè§ perlipc ä¸ç "Bidirectional Communication with Another Process" å "Bidirectional Communication with Yourself"

You may also use the IPC::Open3 module (part of the standard perl distribution), but be warned that it has a different order of arguments from IPC::Open2 (see IPC::Open3).

ä¸ºä½ç¨ system()å´å¾ä¸å°ä¸ä¸ªæä»¤çè¾åºå¢ï¼

$exit_status = system("mail-users");
$output_string = ‘ls‘;

å¦ä½ææå¤é¨æä»¤ç STDERRï¼

æåç§åºæ¬æ¹å¼æ§è¡å¤é¨æä»¤ï¼

system $cmd; # ä½¿ç¨ system()
$output = ‘$cmd‘; # ä½¿ç¨ backticks (‘‘)
open (PIPE, "cmd ⎪"); # ä½¿ç¨ open()

å¨ system() ä¸ï¼STDOUT å STDERR é½ä¼è¾åºå°å script æ¬èº«ç STDOUT, STDERRç¸åçåºå¤ï¼é¤éæä»¤æ¬èº«å°å®ä»¬å¯¼åå®å¤ãååå¼å·å open() å åª è¯»åæä»¤ç STDOUT é¨ä»½ã

ä½ ä¹å¯ä»¥ä½¿ç¨ IPC::Open3 æ¨¡ç». Benjamin Goldberg provides some sample code:

To capture a program’s STDOUT , but discard its STDERR:

use IPC::Open3;
use File::Spec;
use Symbol qw(gensym);
open(NULL, ">", File::Spec->devnull);
my $pid = open3(gensym, \*PH, ">&NULL", "cmd");
while( <PH> ) { }
waitpid($pid, 0);

To capture a program’s STDERR , but discard its STDOUT:

use IPC::Open3;
use File::Spec;
use Symbol qw(gensym);
open(NULL, ">", File::Spec->devnull);
my $pid = open3(gensym, ">&NULL", \*PH, "cmd");
while( <PH> ) { }
waitpid($pid, 0);

To capture a program’s STDERR , and let its STDOUT go to our own STDERR:

use IPC::Open3;
use Symbol qw(gensym);
my $pid = open3(gensym, ">&STDERR", \*PH, "cmd");
while( <PH> ) { }
waitpid($pid, 0);

To read both a command’s STDOUT and its STDERR separately, you can redirect them to temp files, let the command run, then read the temp files:

use IPC::Open3;
use Symbol qw(gensym);
use IO::File;
local *CATCHOUT = IO::File->new_tempfile;
local *CATCHERR = IO::File->new_tempfile;
my $pid = open3(gensym, ">&CATCHOUT", ">&CATCHERR", "cmd");
waitpid($pid, 0);
seek $_, 0, 0 for \*CATCHOUT, \*CATCHERR;
while( <CATCHOUT> ) {}
while( <CATCHERR> ) {}

But there’s no real need for *both* to be tempfiles... the following should work just as well, without deadlocking:

use IPC::Open3;
use Symbol qw(gensym);
use IO::File;
local *CATCHERR = IO::File->new_tempfile;
my $pid = open3(gensym, \*CATCHOUT, ">&CATCHERR", "cmd");
while( <CATCHOUT> ) {}
waitpid($pid, 0);
seek CATCHERR, 0, 0;
while( <CATCHERR> ) {}

And it’ll be faster, too, since we can begin processing the program’s stdout immediately, rather than waiting for the program to finish.

open(STDOUT, ">logfile");
system("ls");

æèä½¿ç¨ Bourne shell çæä»¶æè¿°ç¬¦éå¯¼åè½ï¼

$output = ‘$cmd 2>some_file‘;
open (PIPE, "cmd 2>some_file ⎪");

$output = ‘$cmd 2>&1‘;
open (PIPE, "cmd 2>&1 ⎪");

open(STDERR, ">&STDOUT");
$alloutput = ‘cmd args‘; # stderr still escapes

å¤±è´¥çåå æ¯ï¼open() è®© STDERR å¨å¼å« open() æ¶å¾ STDOUTçæ¹åèµ°ãç¶åå åå¼å·è®© STDOUTçåå®¹è·å°ä¸ä¸ªåä¸²åæ°éï¼ä½æ¯æ²¡ææ¹å STDERR çå»åï¼å® ä»ç¶å¾æ§ç STDOUTé£éè·ï¼ã

æ³¨æï¼å¨ååå¼å·éä½ å¿é¡» ä½¿ç¨ Bourne shell (sh(1)) éå¯¼çè¯æ³èé csh(1)çï¼è³äºä¸ºä½ Perl ç system()ãååå¼å·åå¼ç®¡éé½ç¨ Bourne shellè¯- æ³çåå ï¼å¯å¨ä¸åæ¾å°ï¼"Far More Than You Ever Wanted To Know"ï¼ http://www.cpan.org/misc/olddoc/FMTEYEWTK.tgz . è¦åæ¶ææä¸ä¸ªå½ä»¤ç STDERR å STDOUT :

$output = ‘cmd 2>&1‘; # either with backticks
$pid = open(PH, "cmd 2>&1 ⎪"); # or with an open pipe
while (<PH>) { } # plus a read

To capture a command’s STDOUT but discard its STDERR:

$output = ‘cmd 2>/dev/null‘; # either with backticks
$pid = open(PH, "cmd 2>/dev/null ⎪"); # or with an open pipe
while (<PH>) { } # plus a read

To capture a command’s STDERR but discard its STDOUT:

$output = ‘cmd 2>&1 1>/dev/null‘; # either with backticks
$pid = open(PH, "cmd 2>&1 1>/dev/null ⎪"); # or with an open pipe
while (<PH>) { } # plus a read

To exchange a command’s STDOUT and STDERR in order to capture the STDERR but leave its STDOUT to come out our old STDERR:

$output = ‘cmd 3>&1 1>&2 2>&3 3>&-‘; # either with backticks
$pid = open(PH, "cmd 3>&1 1>&2 2>&3 3>&-⎪");# or with an open pipe
while (<PH>) { } # plus a read

To read both a command’s STDOUT and its STDERR separately, it’s easiest and safest to redirect them separately to files, and then read from those files when the program is done:

system("program args 1>/tmp/program.stdout 2>/tmp/program.stderr");

Ordering is important in all these examples. That’s because the shell processes file descriptor redirections in strictly left to right order.

system("prog args 1>tmpfile 2>&1");
system("prog args 2>&1 1>tmpfile");

The first command sends both standard out and standard error to the temporary file. The second command sends only the old standard output there, and the old standard error shows up on the old standard out.

If the second argument to a piped open() contains shell metacharacters, perl fork()s, then exec()s a shell to decode the metacharacters and eventually run the desired program. If the program couldn’t be run, it’s the shell that gets the message, not Perl. All your Perl program can find out is whether the shell itself could be successfully started. You can still capture the shell’s STDERR and check it for error messages. See "How can I capture STDERR from an external command?" elsewhere in this document, or use the IPC::Open3 module.

If there are no shell metacharacters in the argument of open(), Perl runs the command directly, without using the shell, and can correctly report whether the command started.

å¨å¿½ç¥è¿åå¼çä¸ä¸æéä½¿ç¨ååå¼å·æä½ä¸å¯¹ï¼

Writing backticks in your program sends a clear message to the readers of your code that you wanted to collect the output of the command. Why send a clear message that isn’t true?

åççä¸åè¿ä¸è¡ï¼

‘cat /etc/termcap‘;

print ‘cat /etc/termcap‘;

ä½å¨å¤§é¨ä»½æåµä¸ï¼è¿æ¬æ¥å¯ä»¥ãèä¸ä¹åºè¯¥åæ

system("cat /etc/termcap") == 0
or die "cat program failed!";

system() åæ¶å·æç´æ¥å³å®æ¯å¦åå shell ä¸ç¨åå (wildcard)å¤ççåè½ï¼ ååå¼å·å°±ä¸è¡ã

å¦ä½ä¸ç»è¿ shellå¤çæ¥å¼å«ååå¼å·ï¼

è¿éè¦äºæå·§ãä¸è½åæè¿æ ·ï¼

@ok = ‘grep @opts ’$search_string’ @filenames‘;

å¨ Perl 5.8.0 ä¸ï¼ä½ å¯ä»¥ä½¿ç¨æå¤ä¸ªåæ°ç open()ãç±»ä¼¼ system() å exec() çåè¡¨å½¢å¼ï¼ä¸ä¼è¿è¡ shell è½¬ä¹ã

open( GREP, "-⎪", ’grep’, @opts, $search_string, @filenames );
chomp(@ok = <GREP>);
close GREP;

ä¹å¯ä»¥è¿æ ·ï¼

my @ok = ();
if (open(GREP, "-⎪")) {
while (<GREP>) {
chomp;
push(@ok, $_);
}
close GREP;
} else {
exec ’grep’, @opts, $search_string, @filenames;
}

ä¸å¦ system()ï¼å½ä½ exec() ä¸ä¸ªåºåæ¶ä¸ä¼æ shell è§£è¯çæåµåçãæ´å¤ç¤ºä¾å¯ä»¥ä» perlipc ç "Safe Pipe Opens" ä¸æ¾å°ã

Note that if you’re use Microsoft, no solution to this vexing issue is even possible. Even if Perl were to emulate fork(), you’d still be stuck, because Microsoft does not have a argc/argv-style API .

è¯çä¿åæå¯»ææ ç¶åå»æ¾å®ï¼ä¾å¦ï¼

$where = tell(LOG);
seek(LOG, $where, 0);

	2		å¦æé£æ ·è¡ä¸éï¼è¯çå» seek() æ¡£æ¡çå¦ä¸é¨ä»½ç¶ååæ¾åæ¥ã
	3		å¦æè¿æ¯è¡ä¸éï¼è¯ç seek() æ¡£æ¡å¦ä¸ä¸ªç¸å¼ççé¨ä»½ï¼è¯»ç¹ä¸è¥¿ï¼ååå»æ¾ã
	4		å¦æä¾ç¶ä¸è¡ï¼æ¾å¼ä½¿ç¨ stdio æ¹ç¨ sysreadã

å¦ä½æ shellç¨å¼è½¬æ perlï¼

perlè½å¤ç telnetæ ftp ä¼è¯åï¼

è¯è¯ Net::FTPãTCP::Client å NET::Telnet æ¨¡ç»ï¼CPAN æï¼ã http://www.perl.com/CPAN/scripts/netstuff/telnet.emul.shar ä¹æå©äºæ¨¡æ telnet åå®ï¼ä½æ¯ Net::Telnet å¯è½è¾å®¹æä½¿ç¨ã

use IO::Socket; # new in 5.004
$handle = IO::Socket::INET->new(’www.perl.com:80’)
⎪⎪ die "can’t connect to port 80 on www.perl.com: $!";
$handle->autoflush(1);
if (fork()) { # XXX: undef means failure
select($handle);
print while <STDIN>; # everything from stdin to socket
} else {
print while <$handle>; # everything from socket to stdout
}
close $handle;
exit;

å¦ä½å¨ Perléè¾¾å° Expectçåè½ï¼

ææ²¡æå¯è½å° perlçæä»¤åéèèµ·æ¥ï¼ä»¥èº²é¿å

$0 = "orcus [accepting connections]";

å¦ä½å³éä¸ä¸ªç¨åºçæä»¶å¥æèä¸ç¨çå®å®æå¢ï¼

å¦ä½ fork ä¸ä¸ªå®æ¤è¿ç¨ï¼

	•		æå¼ /dev/tty ç¶åå¯¹å®ç¨ TIOCNOTTY ioctlãè¯·åè tty(4) ãæ´å¥½çåæ³ï¼ä½ å¯ä»¥åªç¨ POSIX::setsid() å½æ°ï¼ä»èä¸å¿æå¿è¿ç¨ç»ã
	•		æç®å½æ¢å° /
	•		éå¼ STDINãSTDOUT å STDERR ä½¿å®ä»¬ä¸ä¼ä¸æ§ç tty è¿æ¥ã
	•		ç¨ä¸åæ¹æ³æç¨å¼ä¸¢å°åå°ï¼

fork && exit;

The Proc::Daemon module, available from CPAN , provides a function to perform these actions for you.

å¦ä½ç¥éèªå·±æ¯å¦å¨äº¤äºå°è¿è¡ï¼

é®å¾å¥½ãæçæ¶å "-t STDIN"N å "-t STDOUT" å¯ä»¥æä¾çº¿ç´¢ï¼ææ¶ä¸è¡ã

if (-t STDIN && -t STDOUT) {
print "Now what? ";
}

use POSIX qw/getpgrp tcgetpgrp/;
open(TTY, "/dev/tty") or die $!;
$tpgrp = tcgetpgrp(fileno(*TTY));
$pgrp = getpgrp();
if ($tpgrp == $pgrp) {
print "foreground\n";
} else {
print "background\n";
}

å¦ä½ä¸ºç¼æ¢çäºä»¶è®¾ç½®è¶æ¶ï¼

å¦å Signals å Camel ä¹¦ç¬¬åç« éææè¿°çï¼ç¨ alarm() å½æ°ï¼ æè®¸åéåä¸ä¸ä¸ªè®¯å·å¤çå¨ãä½ ä¹å¯ä»¥æ¹ç¨ CPAN éæ´å·å¼¹æ§ç Sys::AlarmCall æ¨¡ç»æ¥åã

The alarm() function is not implemented on all versions of Windows. Check the documentation for your specific version of Perl.

å¦ä½è®¾ç½® CPU éé¢?

ä½¿ç¨ CPAN éç BSD::Resource æ¨¡ç»ã

å¦ä½é¿åå¨ Unix ç³»ç»ä¸äº§çåµå°¸è¿ç¨ï¼

ä½¿ç¨ Signals éé¢å« reaper çç¨å¼ç ï¼å¨æ¥å° SIGCHLD æ¶ä¼å¼ å«wait()ï¼ææ¯ç¨ perlfaq8 ä¸ç "How do I start a process in the background?" éé¢åçå fork æå·§ã

å¦ä½ä½¿ç¨ SQL æ°æ®åº?

The DBI module provides an abstract interface to most database servers and types, including Oracle, DB2 , Sybase, mysql, Postgresql, ODBC , and flat files. The DBI module accesses each database type through a database driver, or DBD . You can see a complete list of available drivers on CPAN: http://www.cpan.org/modules/by-module/DBD/ . You can read more about DBI on http://dbi.perl.org .

Other modules provide more specific access: Win32::ODBC, Alzabo, iodbc, and others found on CPAN Search: http://search.cpan.org .

å¦ä½ä½¿ system() å¨æ¶å° control-C æ¶éåº?

$rc = system($cmd);
if ($rc & 127) { die "signal death" }

å¦ä½æ é»å¡å°æå¼ä¸ä¸ªæä»¶ï¼

å¦æä½ æå¹¸ä½¿ç¨å°æ¯æ´æ é»å¡è¯»çç³»ç»ï¼å¤§é¨ä»½ Unix è¬çç³»ç»é½ææ¯æ´ï¼ï¼ ä½ åªéè¦ç¨ Fcntl æ¨¡ç»éç O_NDELAY æ O_NONBLOCK ææ ï¼éå sysopen()ï¼

use Fcntl;
sysopen(FH, "/tmp/somefile", O_WRONLY⎪O_NDELAY⎪O_CREAT, 0644)
or die "can’t open /tmp/somefile: $!":

How do I install a module from CPAN ?

$ perl -MCPAN -e shell

cpan shell -- CPAN exploration and modules installation (v1.59_54)
ReadLine support enabled

cpan> install Some::Module

	1		ææºä»£ç è§£åå°ä¸´æ¶ç®å½
	2

perl Makefile.PL

make

make test

make install

require å use çåºå«æ¯ä»ä¹ï¼

Perl offers several different ways to include code from one file into another. Here are the deltas between the various inclusion constructs:

1) do $file is like eval ‘cat $file‘, except the former
1.1: searches @INC and updates %INC.
1.2: bequeaths an *unrelated* lexical scope on the eval’ed code.

2) require $file is like do $file, except the former
2.1: checks for redundant loading, skipping already loaded files.
2.2: raises an exception on failure to find, compile, or execute $file.

3) require Module is like require "Module.pm", except the former
3.1: translates each "::" into your system’s directory separator.
3.2: primes the parser to disambiguate class Module as an indirect object.

4) use Module is like require Module, except the former
4.1: loads the module at compile time, not run-time.
4.2: imports symbols and semantics from that package to the current one.

In general, you usually want "use" and a proper Perl module.

å¦ä½è®¾ç½®æèªå·±çæ¨¡å/åºè·¯å¾ï¼

perl Makefile.PL PREFIX=/mydir/perl LIB=/mydir/perl/lib

use lib ’/mydir/perl/lib’;

è¿æ ·ä¸ä¸é¢å ä¹ç¸å

BEGIN {
unshift(@INC, ’/mydir/perl/lib’);
}

use FindBin;
use lib "$FindBin::Bin";
use your_own_modules;

ä»¥ä¸æ¯æä»¬å»ºè®®æ´å¨å¼å¥è·¯å¾çæ¹æ³ï¼

ç¯å¢åé PERLLIB
ç¯å¢åé PERL5LIB
perl -Idir å½ä»¤è¡æ å¿
use lib ç¼ç¨ï¼ç±»ä¼¼
use lib "$ENV{HOME}/myown_perllib";

ä»ä¹æ¯ socket.phï¼ä»åªå¿å¯ä»¥å¾å°å®ï¼

It’s a perl4-style file defining values for system networking constants. Sometimes it is built using h2ph when Perl is installed, but other times it is not. Modern programs "use Socket;" instead.

AUTHOR AND COPYRIGHT

This documentation is free; you can redistribute it and/or modify it under the same terms as Perl itself.

Irrespective of its distribution, all code examples in this file are hereby placed into the public domain. You are permitted and encouraged to use this code in your own programs for fun or for profit as you see fit. A simple comment in the code giving credit would be courteous but is not required.

è¯è

éå½¦éï¼è§ç¾é¾ï¼ä¸¤åªèèå·¥ä½å®¤

è·

æ¬é¡µé¢ä¸æçç±ä¸æ man æåé¡µè®¡åæä¾ã
ä¸æ man æåé¡µè®¡åï¼https://github.com/man-pages-zh/manpages-zh

手册导航

man1

man2

man3

man4

man5

man6

man7

man8

PERLFAQ8 7

目录

PERLFAQ8

NAME

DESCRIPTION æè¿°

AUTHOR AND COPYRIGHT

è¯è