Perl风格:各有所爱




*风格问题很容易变成信仰问题。
*我要告诉你们的绝大部分是个人意见。其中既有泛泛之论,也有指路明灯。
*警告:我不一定总是按自己说的做!:)
*我并不期望你们永远和我保持一致。选择一种风格,坚持下去。连贯性才是最重要的!
*K&P, K&R, S&W, Rob Pike, 和Larry Wall的基础性工作对本文有间接贡献。Jon Orwant, 
Mark-Jason Dominus, 和Nat Torkington则直接参与了本文草稿的审阅。
*Rob Pike说:“无论如何不要因为我说怎样编程你就怎样编程。如何编程取决于你对程序目的和
如何表现这一目的的认识。照这样坚持不懈、一丝不苟地做下去。”


Perl风格:写Perl程序,不是C/BASIC/Java/Pascal等等


*<<Perl编程>>中说:“仅仅因为你能用某种方式做事并不意味着你就应该用这种方式做事。”
*当你发现自己写的代码看上去象C,或BASIC,或JAVA,或PASCAL,你很可能正在欺骗自己。你
需要学习写符合习惯的Perl -- 这不是说写晦涩的Perl程序。这说的是写有Perl特色的Perl程序:
原汁Perl。
*有人说某些Perl习惯应该避免,否则负责维护代码的人如果不懂Perl就理解不了程序。这实属大
谬,可笑已极。如果不懂Perl就别维护Perl程序。你写英语的时候不会考虑法国人、德国人懂不懂,
写希腊语的时候也不会用拉丁文。


Perl风格:大方


*Dennis Ritchie说:“要做到既正确(紧凑、无误)又可用(统一、有吸引力),难。”
*写程序要努力做到有用,精练,灵活,易懂 -- 不一定是按这个顺序。
*某些情况下把程序写得短一些可以改善可维护性,另一些情况下就不行。


Perl风格:谨慎编程


*use strict
*#!/usr/bin/perl -w
*检查所有系统调用的返回值,打印$!
*用$?检查外部程序的失败。
*在eval或s///ee之后检查$@。
*参数声明。
*#!/usr/bin/perl -T
*在一串elsif后一定要加一个else
*在列表的最后放个逗号,这样别人在列表后面再加点东西的时候就不会出错。


Perl风格:注释艺术


*解释代码的作用,而不只是把代码翻成英语(汉语)。
*不要弄成花哨的招牌式的东西。
*用/x在正则表达式里加上注解。
*给整段代码加注,而不是给单句加注。
*Rob Pike说:“给数据加注比给算法加注通常要有用得多。”
*Rob Pike说:“基本避免注解。如果你的程序需要注解才能让人理解,最好重写,让它更好懂一些。”


Perl风格:命名原则(形式)


*Rob Pike说:“我不会在名字里放大写字母。对我看惯了散文的双眼来说它们看上去很不舒服,就象是
些拼写错误一样晃来晃去。”
*`IEschewEmbeddedCapitalLettersInNames ToMyProseOrientedEyes 
TheyAreTooAwkwardToReadComfortably TheyJangleLikeBadTypography.' (译注:这是重复上
句的原文,用原文所反对的风格写出的,看上去很难受吧!)
*虽然把两三个短词放在一起做名字比如$getit大概没事,最好还是用下划线把单词分隔开。一般说来
$var_names_like_this比$VarNamesLikeThis要好读,特别是对于不说英语的人。这条简单的规则和
VAR_NAMES_LIKE_THIS这样的变量名也能合作愉快。
*用变量名的大小写表示变量的范围和性质会很有帮助。例:


   $ALL_CAPS_HERE   只用于常量(小心和Perl的内在变量名冲突!)
   $Some_Caps_Here  全局变量、静态变量
   $no_caps_here    函数范围的 my() 或 local() 变量
*函数或方法名称最好全用小写,比如:$obj->as_string();


Perl风格:命名原则(内容)


*Rob Pike说:“过程的名称应该反映它做了什么,函数的名称应该反映它返回什么。”
*对象命名应使其阅读顺利。比如,谓语性质的函数通常用"is", "does", "can", "has"命名。所以,
$is_ready是比$ready更好的函数名。
*如上所述,&cannonize是过程名,&canonical_version表示一个返回值的函数,而&is_canonical
做一个布尔量检查。
*象&abc2xyz或&abc_to_xyz这样形式的名称为转换函数或哈希表对映函数所普遍采用。
*哈希表通常表示键的性质,代表“某物所拥有的”这样一个概念。所以为哈希表中的值来命名哈希,而不是
为键来命名。


   好例:
        %color = ('apple' => 'red', 'banana' => 'yellow');
        print $color{'apple'};          # Prints `red'


   坏例:
        %fruit = ('apple' => 'red', 'banana' => 'yellow');
        print $fruit{'apple'};          # Prints `red'


Perl风格:变量名长度


*Mark-Jason Dominus说:“合适的变量名长度与其作用范围的大小成反比。”
*变量名长不是优点,清楚才是。不要这样写:


    for ($index = 0; $index < @$array_pointer; $index++) {
         $array_pointer->[$index] += 2;
    }
应该这样写:


    for ($i = 0; $i < @$ap; $i++) {
         $ap->[$i] += 2;
    }
(虽然你可以说某个变量名会比$ap好,但也不见得....)


*全局变量名应该比局部变量名长一些,因为它们的语境比较难发现一些。比如%State_Table是一个程序
的全局变量,而$func只是一个局部指针。


    foreach $func (values %State_Table) { ... }


Perl风格:并列对齐


*一致性和并列对齐能使代码可读性大大增加。比较这段代码:


    my $filename =    $args{PATHNAME};
    my @names    = @{ $args{FIELDNAMES} };
    my $tab      =    $args{SEPARATOR};


和这段代码:


    my $filename = $args{PATHNAME};
    my @names = @{$args{FIELDNAMES}};
    my $tab = $args{SEPARATOR};


*把注释和所有的|| die语句对齐放在一列上,象这样:


    socket(SERVER, PF_UNIX, SOCK_STREAM, 0) || die "socket $sockname: $!";
    bind  (SERVER, $uaddr)                  || die "bind $sockname: $!";
    listen(SERVER,SOMAXCONN)                || die "listen $sockname: $!";


Perl风格:在控制和赋值里多用&&和||


*Perl里的&&和||操作符会象C里的一样短路,但返回值不一样:Perl返回的是第一个满足条件的值。
*以下情况经常用||来完成:


    ++$count{ $shell || "/bin/sh" };


    $a = $b || 'DEFAULT';


    $x ||= 'DEFAULT';


*时候也可以用&&来完成,通常返回的假值是空值而不是0。(在Perl里测试为假返回的是空值而
不是0!)


    $nulled_href = $href . ($add_nulls && "\0");


Perl风格:学习优先性
*可以象使用标点符号一样使用and和or的说法是胡说八道。它们的结合优先性不同。你^必须^学
会结合优先性。多用括号不会有坏处。


   print FH $data      || die "Can't write to FH: $!";  # 错
   print FH $data      or die "Can't write to FH: $!";  # 对


   $a = $b or $c;      # 错了,是个虫虫
   ($a = $b) or $c;    # 等于这样
   $a = $b || $c;      # 应该这么写


   @info = stat($file) || die;     # 嘿,stat()会返回一个单值
   @info = stat($file) or die;     # 这样才对


*这个怎么加括号?


   $a % 2 ? $a += 10 : $a += 2


是这个意思:


   (($a % 2) ? ($a += 10) : $a) += 2


而不是:


   ($a % 2) ? ($a += 10) : ($a += 2)


Perl风格:别把?:用过了头


*在控制结构中用?:会带来麻烦。最好还是用if/else。千万别在控制结构中嵌套使用?:


    # 坏:
    ($pid = fork) ? waitpid($pid, 0) : exec @ARGS;


    # 好:
    if ($pid = fork) {
        waitpid($pid, 0);
    } else {
        die "can't fork: $!"    unless defined $pid;
        exec @ARGS;
        die "can't exec @ARGS: $!";
    }


*最好当表达式用:


    $State = (param() != 0) ? "Review" : "Initial";


    printf "%-25s %s\n", $Date{$url}
            ? (scalar localtime $Date{$url})
            : "",


Perl风格:不要定义TRUE和FALSE


*Perl理解布尔量,不要试图自行定义。以下的代码十分糟糕:


     $TRUE  = (1 == 1);
     $FALSE = (0 == 1);


     if ( ($var =~ /pattern/ == $TRUE  ) { .... }
     if ( ($var =~ /pattern/ == $FALSE ) { .... }
     if ( ($var =~ /pattern/ eq $TRUE  ) { .... }
     if ( ($var =~ /pattern/ eq $FALSE ) { .... }


     sub getone { return "This string is true" }


     if ( getone() == $TRUE  ) { .... }
     if ( getone() == $FALSE ) { .... }
     if ( getone() eq $TRUE  ) { .... }
     if ( getone() eq $FALSE ) { .... }


*想象一下如下的引申是多么愚蠢,还是在第一个语句后就停下吧。


     if (    getone() )                  { .... }                   
     if (    getone() == $TRUE  )      { .... }
     if (   (getone() == $TRUE) == $TRUE  )      { .... }
     if ( ( (getone() == $TRUE) == $TRUE) == $TRUE  ) { .... }


Perl风格:多用正则表达式


*正则表达式是你的朋友。不仅如此,它还是一种全新的思考方式。
*就象象棋选手会在棋盘上的子力分布上看出模式,Perl对分析数据中的模式很拿手。虽然大多数现代
编程语言都提供一些模式匹配的基本工具,通常是用外带的库,但Perl的模式匹配可是直接整合在语言核
心里的。象/..../, $1什么的。
*Perl的模式匹配提供许多别的语言没有的强大功能,这些功能会鼓励你用一套全新的眼光看待数据。


Perl风格:边走边换


*拷贝和替换可以一次完成。例:


    chomp($answer = );


    ($a += $b) *= 2;


    # 把路径名去掉
    ($progname = $0)        =~ s!^.*/!!;


    # 所有单词第一字母大写
    ($capword  = $word)     =~ s/(\w+)/\u\L$1/g;


    # /usr/man/man3/foo.1 换成 /usr/man/cat3/foo.1
    ($catpage  = $manpage)  =~ s/man(?=\d)/cat/;


    @bindirs = qw( /usr/bin /bin /usr/local/bin );
    for (@libdirs = @bindirs) { s/bin/lib/ }
    print "@libdirs\n";
  | /usr/lib /lib /usr/local/lib


Perl风格:用负数作数列下标


*要得到数列的最后一个元素,用$array[-1]而不要用$array[$#array]。前者对列表和数列都有效,
而后者不是。
*请记住substr,index,rindex和splice都接受负数下标,从列表尾部开始计数。


  split(@array, -2);   # 两次pop


*请记住substr可以被赋值。例:


    substr($s, -10) =~ s/ /./g;


Perl风格:多用哈希


*当你用哈希方式思考的时候才开始理解Perl。哈希常常可以代替冗长的循环和复杂的算法。
*当你想表达一个集,或关系,或表,或结构,或记录的时候,请用哈希。
*“在。。。中”,“唯一”,“第一”,“重复”这样的字眼应该引起你条件反射式的大喊:“哈希!”如果你把
这些字眼和“列表”放在一个句子里,恐怕有些东西不太对头。


Perl风格:用哈希处理集


*下面这段代码找出两个列表@a和@b的并集和交集:


    foreach $e (@a) { $union{$e} = 1 }
    foreach $e (@b) {
        if ( $union{$e} ) { $isect{$e} = 1 }
        $union{$e} = 1;
    }
    @union = keys %union;
    @isect = keys %isect;


下面的代码做的是同样的事情,而利用了Perl的特色:


    foreach $e (@a, @b) { $union{$e}++ && $isect{$e}++ }
    @union = keys %union;
    @isect = keys %isect;


Perl风格:用哈希记录做过什么


*哈希是追踪你有没有做过什么事的好办法。
*多用 ... unless $seen{$item}++ 这样的办法,例:


    %seen = ();
    foreach $item (genlist()) {
        func($item) unless $seen{$item}++;
    }


Perl风格:用哈希储存记录,不要用并行列表


*学习使用哈希结构储存记录,再把这些记录保存在列表或哈希里,不要用并行列表,象这样:


    $age{"Jason"} = 23;
    $dad{"Jason"} = "Herbert";


应该这样:


    $people{"Jason"}{AGE} = 23;
    $people{"Jason"}{DAD} = "Herbert";


或者这样(注意这里for的用法):


    for $his ($people{"Jason"}) {
        $his->{AGE} = 23;
        $his->{DAD} = "Herbert";
    }


不过在象下面这样做之前,最好^三思^:


    @{ $people{"Jason"} }{"AGE","DAD"} = (23, "Herbert");


Perl风格:在代码不长时使用$_


*和新手的想法恰恰相反,使用$_可以改善代码的可读性。比较下面这段代码:


    while ($line = <>) {
        next if $line =~ /^#/;
        $line =~ s/left/right/g;
        $line =~ tr/A-Z/a-z/;
        print "$ARGV:";
        print $line;
    }


和这段:


    while ( <> ) {
        next if /^#/;
        s/left/right/g;
        tr/A-Z/a-z/;
        print "$ARGV:";
        print;
    }


Perl风格:使用foreach()循环


*foreach循环的隐含重命名和局部化可是强力工具。例:


    foreach $e (@a, @b) { $e *= 3.14159 }


    for (@lines) {
        chomp;
        s/fred/barney/g;
        tr[a-z][A-Z];
    }


*记住你可以把拷贝和修改一次完成:


    foreach $n (@square = @single) { $n **= 2 }


*你还可以用哈希片段来改变哈希值。例:


    # 把单量、列表里的氖有值、哈希里的所有值中的
    # 空白字符都去掉。
    foreach ($scalar, @array, @hash{keys %hash}) {
        s/^\s+//;
        s/\s+$//;
    }


Perl风格:避免字节处理


*C程序员常常在处理字符串时一次处理一个字节。别这么做!Perl在处理大串字符时很轻松!
*不要用getc,一次抓一整行,对一整行进行处理。
*即使是传统上在C语言里一次处理一个字符的操作,比如语义分析,也应采用不同的方法。例:


    @chars = split //, $input;
    while (@chars) {
      $c = shift @chars;
      # State machine;
    }
这样的办法太底层了。试试这样:


    sub parse_expr {
local $_ = shift;
my @tokens = ();
my $paren = 0;
my $want_term = 1;


while (length) {
   s/^\s*//;


   if (s/^\(//) {
return unless $want_term;
push @tokens, '(';
$paren++;
$want_term = 1;
next;
   } 


   if (s/^\)//) {
return if $want_term;
push @tokens, ')';
if ($paren < 1) {
   return;

--$paren;
$want_term = 0;
next;
   } 


   if (s/^and\b//i || s/^&&?//) {
return if $want_term;
push @tokens, '&';
$want_term = 1;
next;
   } 


   if (s/^or\b//i || s/^\|\|?//) {
return if $want_term;
push @tokens, '|';
$want_term = 1;
next;
   } 


   if (s/^not\b//i || s/^~// || s/^!//) {
return unless $want_term;
push @tokens, '~';
$want_term = 1;
next;
   } 


   if (s/^(\w+)//) {
push @tokens, '&' unless $want_term;
push @tokens, $1 . '()';
$want_term = 0;
next;
   } 


   return;


}
return "@tokens";
    }


Perl风格:避免使用符号引用


*新手常常想用一个变量包含另一个变量的名字:


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


*有时候这也奏效,不过这归根结底是个馊点子。^符号引用只对全局变量有效^,而全局变量是要大力避免
的,太容易引起重名冲突了。
*当你用了use strict的时候,它就失效了。
*它们不是真正的引用,不计入引用计数,也不被Perl的垃圾回收站回收。
*应该使用哈希或真正的引用。


Perl风格:想用$$name的时候,用哈希


*用变量包含另一个变量的名字总是意味着此人对哈希掌握不够。虽然可以这样写:


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


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


最好还是这样写:


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


Perl风格:不要对eof作测试


*不要这样写(死锁):


    while (!eof(STDIN)) {
        statements;
    }


*应当这样写:


    while () {
        statements;
    }


*在eof不成立的时候给用户提示是很烦人的。试试这个:


   $on_a_tty = -t STDIN && -t STDOUT;
   sub prompt { print "yes? " if $on_a_tty }
   for ( prompt(); ; prompt() ) {
        statements;
   }


Perl风格:不要滥用反斜杠


*Perl允许你选用自定的分隔符来分隔模式和引文,这样可避免“牙签成堆综合症”(指许多反斜杠连续出现)。
请多用自定分隔符。例:


    m#^/usr/spool/m(ail|queue)#


    qq(Moms said, "That's all, $kid.")


    tr[a-z]
      [A-Z];


    s { /          }{::}gx;
    s { \.p(m|od)$ }{}x;


Perl风格:减少复杂性


*但当可能的时候请把next和redo放在循环的最前面。
*使用unless和until。
*但不要使用 unless ... else ... 
*从Pascal的暴政下逃脱。不要在经历无谓的弯弯绕之后最后才退出循环或函数。不要这样写:


    while (C1) {
        if (C2) {
            statement;
            if (C3) {
                statements;
            }
        } else {
            statements;
        }
    }


Perl风格:减少复杂性(解决方案)


*应该这样写:




    while (C1) {
        unless (C2) {
            statement;
            next;
        }
        statements;
        next unless C3;
        statements;
    }


*或者这样写:


    while (C1) {
        statement, next unless C2;
        statements;
        next unless C3;
        statements;
    }


Perl风格:减少重复


*把重复代码放到段落之外。例:修改前:


    if (...) {
        X;  Y;
    } else {
        X;  Z;
    }


修改后:


    X;
    if (...) {
        Y;
    } else {
        Z;
    }


Perl风格:化整为零


*把子函数分成便于管理的单位。
*不要试图用一个正则表达式匹配所有的东西。
*在ARGV上下点工夫。例:


    # 程序期待环境变量
    @ARGV = keys %ENV       unless @ARGV;


    # 程序期待源程序
    @ARGV = glob("*.[chyC]") unless @ARGV;


    # 对gzip文件也能行
    # from Perl Cook Book 16.6
    @ARGV = map { /^\.(gz|Z)$/ ? "gzip -dc $_ |" : $_  } @ARGV;


Perl风格:把程序分为不同的进程


*学习使用特殊形式的open:


    # from Perl Cookbook 16.5
    head(100);
    sub head {
        my $lines = shift || 20;
        return if $pid = open(STDOUT, "|-");
        die "cannot fork: $!" unless defined $pid;
        while () {
            print;
            last if --$lines < 0;
        }
        exit;
    }


(译者按:读者最好阅读一下Perl Cookbook的相关章节,本节内容较深。)


Perl风格:面向数据的编程


*数据结构比代码更重要。
*Rob Pike说:“数据至高无上。只要你选择了正确的数据结构并进行了合理的组织,算法总是不言自明的。
数据结构,而不是算法,是编程的核心。(参阅Brooks, 第102页)”
*用数据概括普遍,用代码处理异常。(Kernighan)
*如果在两个地方看到类似的功能,把它们统一起来。这叫做“子函数”。
*考虑做一个函数指针的哈希结构来代表状态表或switch语句。


Perl风格:配置文件


*如果需要配置文件,用do语句来加载。
*你于是得以使用Perl的全部威力:


    # 摘自 Perl Cookbook 8.16
    $APPDFLT = "/usr/local/share/myprog";
    do "$APPDFLT/sysconfig.pl";
    do "$ENV{HOME}/.myprogrc";


    # 在配置文件中这样写
    $NETMASK = '255.255.255.0';
    $MTU     = 0x128;
    $DEVICE  = 'cua1';
    $RATE    = 115_200;


*请在此处(http://www.perl.com/CPAN/authors/id/TOMC/scripts/)参阅本文作者的clip和cliprc
文件。


Perl风格:函数作为数据


*将函数指针用在数据结构或用作函数参数。例:


    # from MxScreen in TSA (see also PCB 19.12)
    %State_Table = (
        Initial  => \&show_top,
        Execute  => \&run_query,
        Format   => \&get_format,
        Login    => \&resister_login,
        Review   => \&review_selections,
        Sorting  => \&get_sorting,
        Wizard   => \&wizards_only,
    );


    foreach my $state (sort keys %State_Table) {
        my $function = $State_Table{$state};
        my $how      = ($action == $function)
                        ? SCREEN_DISPLAY
                        : SCREEN_HIDDEN;
        $function->($how);
    }


Perl风格:闭包(closure)


*用闭包克隆相似的函数。例:


    # from MxScreen in TSA
    no strict 'refs';
    for my $color (qw[red yellow orange green blue purple violet]) {
        *$color = sub { qq<@_> };
    }
    undef &yellow;      # lint happiness
    *yellow = \&purple; # function aliasing


*或类似地:


    # from psgrep (in TSA, or PCB 1.18)
    my %fields;
    my @fieldnames = qw(FLAGS UID PID PPID PRI NICE SIZE
                        RSS WCHAN STAT TTY TIME COMMAND);


    for my $name (@fieldnames) {
        no strict 'refs';
        *$name = *{lc $name} = sub () { $fields{$name} };
    }


Perl风格:学习用for作开关语句


*虽然Perl没有switch语句,这实际上是个机会而不是困难。
*做一个开关控制很容易。for这个词有时念作“switch”


   SWITCH: for ($where) {
               /In Card Names/     && do { push @flags, '-e'; last; };
               /Anywhere/          && do { push @flags, '-h'; last; };
               /In Rulings/        && do {                    last; };
               die "unknown value for form variable where: `$where'";
           }


*就像一系列的elsif,开关语句一定要有一个缺省设置。即使这种缺省情况“永远也不可能发生”。


Perl风格:创造性地用do{}语句来作开关语句


*另一种有趣的办法是用do{}语句返回的值来做成开关语句。例:


   $amode = do {
       if     ($flag & O_RDONLY) { "r" }       # XXX: isn't this 0?
       elsif  ($flag & O_WRONLY) { ($flag & O_APPEND) ? "a" : "w" }
       elsif  ($flag & O_RDWR)   {
           if ($flag & O_CREAT)  { "w+" }
           else                  { ($flag & O_APPEND) ? "a+" : "r+" }
       }
   };


Perl风格:用&&和||来作开关语句


*要小心,&&的右边总为真。


   $dir = 'http://www.wins.uva.nl/~mes/jargon';
   for ($ENV{HTTP_USER_AGENT}) {
       $page  =    /Mac/            && 'm/Macintrash.html'
                || /Win(dows )?NT/  && 'e/evilandrude.html'
                || /Win|MSIE|WebTV/ && 'm/MicroslothWindows.html'
                || /Linux/          && 'l/Linux.html'
                || /HP-UX/          && 'h/HP-SUX.html'
                || /SunOS/          && 's/ScumOS.html'
                ||                     'a/AppendixB.html';
   }


Perl风格:更创造性地使用for和do来构造开关语句


*有时审美也很重要。:)


    for ($^O) {
        *struct_flock =                do                           {


                                /bsd/  &&  \&bsd_flock
                                       ||
                            /linux/    &&    \&linux_flock
                                       ||
                          /sunos/      &&      \&sunos_flock
                                       ||
                  die "unknown operating system $^O, bailing out";
        };
    }


Perl风格:管好模块


*使用Pod为你的模块写文档,用pod2man和pod2html作检查。
*使用Carp模块里的carp,croak,confess,不要用warn和die。
*写得好的模块很少需要用到::。用户应该可以用import和类函数得到模块内容。
*传统的模块也不错。不要因为用对象编程看着很酷就急急忙忙跳上去。明显需要的时候再用不迟。
*使用对象应该通过调用对象函数。
*对象函数本身也应该通过对象指针使用类数据。


Perl风格:补丁


*当你和别人写的代码打交道的时候,遵循他们的范例。
*不要因为会产生巨大的diff文件就重新样式化代码。
*有时候为了对付某些自定义tab键的空格数的坏蛋,把tab转换成空格似乎是必要的。但^别这么做^!

你可能感兴趣的:(编程经验,perl)