PERLFAQ7 7

中文man手册

PERLFAQ7

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

NAME

perlfaq7 - ç»¼åçé®é¢ (2003/07/24 02:17:21)

DESCRIPTION æè¿°

æè½æ¿å° Perlç BNF/yacc/REåï¼

ç¨ Chaim Frenkelçè¯ï¼"Perlçè¯æ³æ æ³è¢«ç®åå°å¯ä»¥ç¨ BNF è¡¨ç¤ºãè§£æPerlçå·¥ä½æ¯åæ£äº yaccãlexerãçé¾åéåä¹é´ã"

å®ä»¬é½æ¯ç±»åéå®ç¬¦å·ï¼å¨ perldata ä¸è¯¦è¿°ï¼

æäºå¶ä»çç¬¦å·ä½ å¯è½ä¼ç¢°å°ä½å´ä¸æ¯æå®å½¢æç¨çæï¼

æ³¨æ < FILE > ä¸æ¯ç¨æ¥æå®æä»¶ç±»åï¼äº¦éæ¤å¥æçååãå®åªæ¯ å°<>è¿ä¸ªè¿ç®ç¬¦ä½ç¨å¨ FILEè¿ä¸ªå¥æä¸ãå¨æ éä¸ä¸æ (scalar context) ä¸- ï¼å®èª FILE ææä¸æ¬¡è¯»å¥ä¸è¡ (å¯ï¼è¯¥è¯´ä¸ç¬è®°å½ï¼åç $/)ï¼å¨åºåæå¢ (list context)ä¸ï¼åä¸æ¬¡å° å¨é¨çåå®¹è¯» å¥ãå½å¯¹æ¡£æ¡ä½¿ç¨å¼ãå³æå¶å® <>ä¹å¤çå¨ä½ãæçè³åªæ¯æå°æ ææ¶ï¼åè®°ä¸è¦ä½¿ç¨ <>ãä¸é¢çç¨æ³æ¯æ- £ç¡®çï¼"eof(FH)", "seek(FH, 0, 2)" ä»¥å "copying from STDIN to FILE ".

è¿äº åè¿äºä¸æ ·
------------ ---------------
$foo{line} $foo{"line"}
bar => stuff "bar" => stuff

if ($whoops) { exit 1 }
@nums = (1, 2, 3);

if ($whoops) {
exit 1;
}
@lines = (
"There Beren came from mountains cold",
"And lost he wandered under leaves",
);

æå¦ä½è·³è¿ä¸äºä¼ åå¼ï¼

$dir = (getpwnam($user))[7];

å¦ä¸ç§æ¹æ³å°±æ¯å¨çå·å·¦ç«¯ç¨ undef ä½åç´ ï¼

($dev, $ino, undef, undef, $uid, $gid) = stat($file);

ä¹å¯ä»¥ç¨ä¸ä¸ªåè¡¨çæ®µæ¥ä»éæ©ä½ éè¦çåç´ ï¼

($dev, $ino, $uid, $gid) = ( stat($file) )[0,1,4,5];

æå¦ä½ææ¶æ»¤æè¦åè®¯æ¯ï¼

å¦ææ£å¨è¿è¡ Perl 5.6.0 ææ´é«çæ¬ï¼ "use warnings" ç¼ç¨å¯ä»¥å¯¹è- ¦åå¦ä½äº§çè¿è¡å¾å¥½çæ§å¶ãåè§ perllexwarn ä¸çç»è

{
no warnings; # ææ¶å³æè¦åè®¯æ¯
$a = $b + $c; # æç¥éè¿äºåæ°å¯è½æªå®ä¹
}

{
local $ˆW = 0; # ææ¶å³æè¦åè®¯æ¯
$a = $b + $c; # æç¥éè¿äºåæ°å¯è½æªå®ä¹
}

ä»ä¹æ¯ä¸ä¸ªæ©å?

ä¸ºä½ Perlè¿ç®åçä¼åé¡ºåºå Cçä¸ä¸æ ·ï¼

ä¸ä¸ªå¸¸ç¯çéè¯¯åæ¯ï¼

unlink $file ⎪⎪ die "snafu";

è¿ä¼è¢«è§£è¯å¨çææ¯ï¼

unlink ($file ⎪⎪ die "snafu");

(unlink $file) ⎪⎪ die "snafu";
unlink $file or die "snafu";

Although it has the same precedence as in C, Perl’s "?:" operator produces an lvalue. This assigns $x to either $a or $b, depending on the trueness of $maybe:

($maybe ? $a : $b) = $x;

æå¦ä½å£°æ/åå»ºä¸ä¸ªæ°æ®ç»æï¼

ä¸è¬æ¥è¯´ï¼æä»¬ä¸ ‘‘å£°æ’’ ä¸ä¸ªç»æãç¨ä¸ä¸ª (éå¸¸æ¯å¿åç) æ£åçå¼ç¨ (hash reference)å³å¯ãåç perlref ä»¥å perldscï¼éé¢ææ´å¤èµæãä»¥ä¸æ¯ä¸ä¸ªèä¾ï¼

$person = {}; # new anonymous hash
$person->{AGE} = 24; # set field AGE to 24
$person->{NAME} = "Nat"; # set field NAME to "Nat"

å¦æä½ è¦çæ¯æ´ä¸¥è°¨çåæ³ï¼çç perltoot ã

å¦ä½åå»ºä¸ä¸ªæ¨¡åï¼

ä¸ä¸ªæ¨¡ç»å°±æ¯ä¸ä¸ªæ¾å¨ååæ¡£æ¡éçåè£¹(package)ãä¾å¦ï¼Hello::Thereæ¨¡ç»ä¼æ¾å¨Hello/There.pmãperlmod éæè¯¦å°½è¯´æãExporter ä¹ä¼å¾æå¸®å©ãå¦æä½ æ£å¨åä¸ä¸ª C ææ¯æ··åäº Cå Perl çæ¨¡ç»ï¼é£ä¹ä½ å°±è¯¥è¯» perlxstut ã

The "h2xs" program will create stubs for all the important stuff for you:

% h2xs -XA -n My::Module

The "-X" switch tells "h2xs" that you are not using "XS" extension code. The "-A" switch tells "h2xs" that you are not using the AutoLoader, and the "-n" switch specifies the name of the module. See h2xs for more details.

å¦ä½åå»ºä¸ä¸ªç±»ï¼

perltoot éé¢æå¯¹äºç±»åå¯¹è±¡çä»ç»ï¼ perlobj å perlbot ä¹æã

å¦ä½ç¥éä¸ä¸ªåéæ¯å¦æ¯æ±¡æçï¼

å¯ä»¥ä½¿ç¨ Scalar::Util æ¨¡åä¸ç tainted() å½æ° (å¯ä» CPAN è·åï¼ä¹åå«å¨ Perl 5.8.0 ä¸)ãåè§ perlsec ä¸ç "Laundering and Detecting Tainted Data" ã

ä»ä¹æ¯éåï¼

å³äºéåçè¯´æï¼è¯·ç perlref ã

ä»¥ä¸æ¯ä¸ªå¸åçäº§çå½æ°çå½æ°ï¼

sub add_function_generator {
return sub { shift + shift };
}

$add_sub = add_function_generator();
$sum = $add_sub->(4,5); # $sum is 9 now.

sub make_adder {
my $addpiece = shift;
return sub { shift + $addpiece };
}

$f1 = make_adder(20);
$f2 = make_adder(555);

è¿æ ·ä¸æ¥ "&$f1($n)" æ°¸è¿ä¼æ¯ 20å ä¸ä½ ä¼ è¿å»çå¼ $n ï¼è "&$f2($n)" å° æ°¸è¿ä¼æ¯ 555å ä¸ä½ ä¼ è¿å»çå¼ $nã$addpiece çå¼ä¼å¨éåä¸ä¿çä¸æ¥ã

my $line;
timeout( 30, sub { $line = <STDIN> } );

ä»ä¹æ¯åéèªæï¼æåºè¯¥ææ ·é²æ¢å®ï¼

my $f = "foo";
sub T {
while ($i++ < 3) { my $f = $f; $f .= "bar"; print $f, "\n" }
}
T;
print "Finally $f\n";

æåä¸ª "bar" å è¿å»ç $f åæ°åºè¯¥æ¯ä¸ä¸ªæ°ç $f (å ä¸º "my $f" å¨æ¯ä¸ªå¾ªç¯é½åºè¯¥åé ä¸ä¸ªæ°çåºååæ°)ãç¶èï¼å®éä¸å¹¶éå¦æ¤ãè¿ä¸ªèè«ææ°ç Perl çæ¬ä¸å·²è¢«ä¿®æ£ (å¨ 5.004_05, 5.005_03 å 5.005_56 ä¸æµè¯è¿)ã

å¦ä½ä¼ é/è¿åä¸ä¸ª{å½æ° Function, æä»¶å¥æ FileHandle, æ°ç» Array,æ£å Hash, æ¹æ³ Method, æ£åè¡¨è¾¾å¼ Regex}?

åè§ä¸é¢ç ‘‘Passing Regexes’’ï¼å¦ä¹ å¦ä½ä¼ éæ£åè¡¨è¾¾å¼ã
ä¼ éåéåå½æ°

func( \$some_scalar );

func( \@some_array );
func( [ 1 .. 10 ] );

func( \%some_hash );
func( { this => 10, that => 20 } );

func( \&some_func );
func( sub { $_[0] ** $_[1] } );

ä¼ éæä»¶å¥æ

open my $fh, $filename or die "Cannot open $filename! $!";
func( $fh );

sub func {
my $passed_fh = shift;

my $line = <$fh>;
}

å¨ Perl5.6 ä¹åï¼å¿é¡»ç¨ *FH æ "\*FH" è¯æ³ãè¿å«å "typeglobs"--åè§ perldata ä¸ç "Typeglobs and Filehandles" å perlsub ä¸ç "Pass by Reference"ã

ä¼ éæ£åè¡¨è¾¾å¼

sub compare($$) {
my ($val1, $regex) = @_;
my $retval = $val1 =˜ /$regex/;
return $retval;
}
$match = compare("old McDonald", qr/d.*D/i);

sub compare($$) {
my ($val1, $regex) = @_;
my $retval = eval { $val1 =˜ /$regex/ };
die if $@;
return $retval;
}

$match = compare("old McDonald", q/($?i)d.*D/);

ç¡®ä¿ä½ æ²¡æä»»ä½è¿æ ·çä¸è¥¿ï¼

return eval "\$val =˜ /$regex/"; # WRONG

$pattern_of_evil = ’danger ${ system("rm -rf * &") } danger’;

eval "\$string =˜ /$pattern_of_evil/";

æ³å¦éå¸¸éå¸¸èªæçæ¹æ³çè¯»èå¯ä»¥åè O’Reilly åºç Mastering Regular Expressionsè¿æ¬ä¹¦ï¼ä½èæ¯ Jeffrey Friedlãå¶ä¸ç¬¬ 273é¡µç Build_MatchMany_Function()ç¹å«çæè¶£ãå¨ perlfaq2ä¸å¯ä»¥æ¾å°æå³æ¬ä¹¦ çèµæã

ä¼ éæ¹æ³

è¦ä¼ éä¸ä¸ªå¯¹è±¡æ¹æ³ç»ä¸ä¸ªå½æ°ï¼å¯ä»¥è¿æ ·åï¼

call_a_lot(10, $some_obj, "methname")
sub call_a_lot {
my ($count, $widget, $trick) = @_;
for (my $i = 0; $i < $count; $i++) {
$widget->$trick();
}
}

my $whatnot = sub { $some_obj->obfuscate(@args) };
func($whatnot);
sub func {
my $code = shift;
&$code();
}

ä¹å¯ä»¥ç ç©¶ UNIVERSAL ç±»å«ä¸ç can()æ¹æ³ (éäºæ å Perl çæ¬ä¸)ã

How do I create a static variable?

ä»¥ä¸å°±æ¯å®ä½å½æ°ç§æåæ°çç¨å¼ï¼

BEGIN {
my $counter = 42;
sub prev_counter { return --$counter }
sub next_counter { return $counter++ }
}

prev_counter() å next_counter() å°ä¼å±ç¨ä¸ä¸ªäºç¼è¯æ¶åå§åçç§æåæ° $counterã

package Pax;
my $started = scalar(localtime(time()));

sub begun { return $started }

åè§ perlsub ä¸ç "Persistent Private Variables" çç»è.

What’s the difference between dynamic and lexical (static) scoping? Between local() and my()?

ä¾å¦ï¼

sub visible {
print "var has value $var\n";
}

sub dynamic {
local $var = ’local’; # ä¸ºå¨å±åéææ¶èµå¼
visible(); # è°ç¨ $var åé
}

sub lexical {
my $var = ’private’; # æ°çç§æåé $var
visible(); # (å¨ sub ä½ç¨åä¹å¤ä¸å¯è§)
}

$var = ’global’;

visible(); # prints global
dynamic(); # prints local
lexical(); # prints global

åè§ perlsub ä¸ç "Private Variables via my()" ä»¥å "Temporary Values via local()" æ¥è·åè¯¦æ

å¨åå¨åååé¨åéçä½ç¨åä¸ï¼å¦ä½ååä¸ä¸ªå¨æåéï¼

å¦æä½ ç¥éä½ æå¨çæ¯åªä¸ä¸ªåè£¹(package)çè¯ï¼ä½ å¯ä»¥ç´æ¥æåï¼å°±åå $Some_Pack::var è¿æ ·ãæ³¨æ $::var è¿ä¸ªåæ³ å¹¶éè¡¨ç¤ºç®åæ¤åè£¹ (package) åçå¨æåæ° $varï¼èæ¯æå¨ mainåè£¹(package) éçé£ä¸ªï¼å°±çä»·äº $main::var ã

use vars ’$var’;
local $var = "global";
my $var = "lexical";

print "lexical is $var\n";
print "global is $main::var\n";

require 5.006; # our() did not exist before 5.6
use vars ’$var’;

local $var = "global";
my $var = "lexical";

print "lexical is $var\n";

{
our $var;
print "global is $var\n";
}

æ·±è¿æ¥åæµè¿æ¥æä»ä¹ä¸åï¼

ä¸ºä»ä¹

local($foo) = <FILE>; # WRONG
local($foo) = scalar(<FILE>); # ok
local $foo = <FILE>; # right

my($foo) = <FILE>; # WRONG
my $foo = <FILE>; # right

å¦ä½éå®ä¹ä¸ä¸ªåå»ºå½æ°ï¼æä½ç¬¦ æèæ¹æ³ï¼

ä¸ºä»ä¹è¦è¿ä¹åï¼ :-)

å¦æä½ è¦è¦çææä¸ªåå»ºå½æ°ï¼ä¾å¦è¯´ open()ï¼é£ä½ å¾å°å¶å®ä¹ä»å¦ä¸ä¸ªæ¨¡ç»è½½ å¥ãåè perlsub ä¸ç Overriding Builtin Functionsãå¨ "Class::Template" éé¢ä¹æä¸ªèä¾ã

å¦æä½ è¦è¦çæä¸ä¸ª Perlè¿ç®åï¼åæ¯ "+" æ "**", é£ä½ è¯¥ä½¿ç¨ "use overload" è¿ä¸ªç¼ç¨ï¼å¨ overload ä¸æè®°è½½ã

å¦æä½ è¦è¦çç¶ç±»å« (parent class)éçæ¹æ³å¼å« (method calls)ï¼è¯·ç perltoot ä¸ç Overridden Methods ã

è°ç¨å½æ°æ¶ &foo å foo() çå½¢å¼æä»ä¹ä¸å?

å¦ä½åå»ºä¸ä¸ªåæ¯è¯å¥ï¼

ä» Perl 5.8 å¼å§ï¼è¦ä½¿ç¨ swtich å caseï¼å¯ä»¥ä½¿ç¨ Switch æ©å±ï¼å°±æ¯è¿æ ·ï¼

use Switch;

æ¤åå°±å¯ä»¥ç¨ switch å case äº. It is not as fast as it could be because it’s not really part of the language (it’s done using source filters) but it is available, and it’s very flexible.

But if one wants to use pure Perl, the general answer is to write a construct like this:

for ($variable_to_test) {
if (/pat1/) { } # do something
elsif (/pat2/) { } # do something else
elsif (/pat3/) { } # do something else
else { } # default
}

ä¸é¢è¿ä¸ªç®åç switchèä¾ä»¥æ¨¡å¼å¯¹åºä¸ºåºç¡ãæä»¬å°è¦åçæ¯å¯¹å¨åå¨ $whatchamacallitéé¢çåèå¼ (reference)çç±»åè¿è¡å¤éæ¡ä»¶çå¤æ- ããè¯æ³¨ï¼$whatchamacallit å½æä¸º $what_you_might_call_itã

SWITCH: for (ref $whatchamacallit) {

/ˆ$/ && die "not a reference";

/SCALAR/ && do {
print_scalar($$ref);
last SWITCH;
};

/ARRAY/ && do {
print_array(@$ref);
last SWITCH;
};

/HASH/ && do {
print_hash(%$ref);
last SWITCH;
};

/CODE/ && do {
warn "can’t print function ref";
last SWITCH;
};

# DEFAULT

warn "User defined type skipped";

}

See "perlsyn/"Basic BLOCKs and Switch Statements"" for many other examples in this style.

Sometimes you should change the positions of the constant and the variable. For example, let’s say you wanted to test which of many answers you were given, but in a case-insensitive way that also allows abbreviations. You can use the following technique if the strings all start with different characters or if you want to arrange the matches so that one takes precedence over another, as "SEND" has precedence over "STOP" here:

chomp($answer = <>);
if ("SEND" =˜ /ˆ\Q$answer/i) { print "Action is send\n" }
elsif ("STOP" =˜ /ˆ\Q$answer/i) { print "Action is stop\n" }
elsif ("ABORT" =˜ /ˆ\Q$answer/i) { print "Action is abort\n" }
elsif ("LIST" =˜ /ˆ\Q$answer/i) { print "Action is list\n" }
elsif ("EDIT" =˜ /ˆ\Q$answer/i) { print "Action is edit\n" }

A totally different approach is to create a hash of function references.

my %commands = (
"happy" => \&joy,
"sad", => \&sullen,
"done" => sub { die "See ya!" },
"mad" => \&angry,
);

print "How are you? ";
chomp($string = <STDIN>);
if ($commands{$string}) {
$commands{$string}->();
} else {
print "No such command: $string\n";
}

å¦ä½æè·å¯¹æªå®ä¹åéï¼å½æ°ææ¹æ³çè®¿é®ï¼

å¨ perlsub ä¸ç "Autoloading" å perltoot ä¸ç " AUTOLOAD: Proxy Methods" é æå°ç AUTOLOAD æ¹æ³è®©ä½ è½ææå¯¹äºæªå®ä¹å½æ°ä¸æ¹æ³çå¼å«ã

When it comes to undefined variables that would trigger a warning under "use warnings", you can promote the warning to an error.

use warnings FATAL => qw(uninitialized);

ä¸ºä»ä¹æ¾ä¸å°åå«å¨åä¸ä¸ªæä»¶ä¸çæ¹æ³ï¼

Make sure to read about creating modules in perlmod and the perils of indirect objects in "Method Invocation" in perlobj.

å¦ä½æ¾å°å½åçåï¼

my $packname = __PACKAGE__;

sub amethod {
my $self = shift;
my $class = ref($self) ⎪⎪ $self;
warn "called me from a $class object";
}

å¦ä½æ³¨éæå¤§åç perl ä»£ç ï¼

ç¨ååµ PODæ ¼å¼çæ¹æ³æç¨å¼ç åæ³¨è§£ãå°è¦æ³¨éæçååå«å¨ POD æ è®°å, ä¾å¦ "=for nobody" å "=cut" (æ å¿ç POD åçç»æ).

# è¿æ¯ç¨å¼

=for nobody

all of this stuff

æ¥ä¸æ¥æ¤å¤ææçæåé½ä¼è¢«å¿½ç¥

=cut

# program continues

The pod directives cannot go just anywhere. You must put a pod directive where the parser is expecting a new statement, not just in the middle of an expression or some other arbitrary grammar production.

See perlpod for more details.

How do I clear a package?

Use this code, provided by Mark-Jason Dominus:

sub scrub_package {
no strict ’refs’;
my $pack = shift;
die "Shouldn’t delete main package"
if $pack eq "" ⎪⎪ $pack eq "main";
my $stash = *{$pack . ’::’}{HASH};
my $name;
foreach $name (keys %$stash) {
my $fullname = $pack . ’::’ . $name;
# Get rid of everything with that name.
undef $$fullname;
undef @$fullname;
undef %$fullname;
undef &$fullname;
undef *$fullname;
}
}

Or, if you’re using a recent release of Perl, you can just use the Symbol::delete_package() function instead.

How can I use a variable as a variable name?

Beginners often think they want to have a variable contain the name of a variable.

$fred = 23;
$varname = "fred";
++$$varname; # $fred now 24

This works sometimes, but it is a very bad idea for two reasons.

The first reason is that this technique only works on global variables. That means that if $fred is a lexical variable created with my() in the above example, the code wouldn’t work at all: you’d accidentally access the global and skip right over the private lexical altogether. Global variables are bad because they can easily collide accidentally and in general make for non-scalable and confusing code.

Symbolic references are forbidden under the "use strict" pragma. They are not true references and consequently are not reference counted or garbage collected.

The other reason why using a variable to hold the name of another variable is a bad idea is that the question often stems from a lack of understanding of Perl data structures, particularly hashes. By using symbolic references, you are just using the package’s symbol-table hash (like %main::) instead of a user-defined hash. The solution is to use your own hash or a real reference instead.

$USER_VARS{"fred"} = 23;
$varname = "fred";
$USER_VARS{$varname}++; # not $$varname++

There we’re using the %USER_VARS hash instead of symbolic references. Sometimes this comes up in reading strings from the user with variable references and wanting to expand them to the values of your perl program’s variables. This is also a bad idea because it conflates the program-addressable namespace and the user-addressable one. Instead of reading a string and expanding it to the actual contents of your program’s own variables:

$str = ’this has a $fred and $barney in it’;
$str =˜ s/(\$\w+)/$1/eeg; # need double eval

it would be better to keep a hash around like %USER_VARS and have variable references actually refer to entries in that hash:

$str =˜ s/\$(\w+)/$USER_VARS{$1}/g; # no /e here at all

That’s faster, cleaner, and safer than the previous approach. Of course, you don’t need to use a dollar sign. You could use your own scheme to make it less confusing, like bracketed percent symbols, etc.

$str = ’this has a %fred% and %barney% in it’;
$str =˜ s/%(\w+)%/$USER_VARS{$1}/g; # no /e here at all

Another reason that folks sometimes think they want a variable to contain the name of a variable is because they don’t know how to build proper data structures using hashes. For example, let’s say they wanted two hashes in their program: %fred and %barney, and that they wanted to use another scalar variable to refer to those by name.

$name = "fred";
$$name{WIFE} = "wilma"; # set %fred

$name = "barney";
$$name{WIFE} = "betty"; # set %barney

This is still a symbolic reference, and is still saddled with the problems enumerated above. It would be far better to write:

$folks{"fred"}{WIFE} = "wilma";
$folks{"barney"}{WIFE} = "betty";

And just use a multilevel hash to start with.

The only times that you absolutely must use symbolic references are when you really must refer to the symbol table. This may be because it’s something that can’t take a real reference to, such as a format name. Doing so may also be important for method calls, since these always go through the symbol table for resolution.

In those cases, you would turn off "strict ’refs’" temporarily so you can play around with the symbol table. For example:

@colors = qw(red blue green yellow orange purple violet);
for my $name (@colors) {
no strict ’refs’; # renege for the block
*$name = sub { "<FONT COLOR=’$name’>@_</FONT>" };
}

All those functions (red(), blue(), green(), etc.) appear to be separate, but the real code in the closure actually was compiled only once.

So, sometimes you might want to use symbolic references to directly manipulate the symbol table. This doesn’t matter for formats, handles, and subroutines, because they are always global--you can’t use my() on them. For scalars, arrays, and hashes, though--and usually for subroutines-- you probably only want to use hard references.

What does "bad interpreter" mean?

The "bad interpreter" message comes from the shell, not perl. The actual message may vary depending on your platform, shell, and locale settings.

If you see "bad interpreter - no such file or directory", the first line in your perl script (the "shebang" line) does not contain the right path to perl (or any other program capable of running scripts). Sometimes this happens when you move the script from one machine to another and each machine has a different path to perl---/usr/bin/perl versus /usr/local/bin/perl for instance.

If you see "bad interpreter: Permission denied", you need to make your script executable.

In either case, you should still be able to run the scripts with perl explicitly:

% perl script.pl

If you get a message like "perl: command not found", perl is not in your PATH , which might also mean that the location of perl is not where you expect it so you need to adjust your shebang line.

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

PERLFAQ7 7

目录

PERLFAQ7

NAME

DESCRIPTION æè¿°

AUTHOR AND COPYRIGHT

è¯è