BlogJava-Java天空任我翱翔-随笔分类-perl

Perl学习六（练习题）

persister — Tue, 15 Sep 2009 06:16:00 GMT

下面的习题解答：

1 # !/usr/bin/perl -w
      2
      3 @list = <STDIN>;
      4 @list = sort(@list);
      5 @list = reverse @list;
      6
      7 print "\n";
      8
      9 print @list;
     10
     11 print "\n";
     12 print "input the number:\n";
     13 $num = <STDIN>;
     14 print $list[$num];
     15 srand;
     16 print $list[rand(@list)];

发现第四行 @list[$num]的结果也是一样的，不必是$list[$num]，难道是版本问题？
书上说srand是进行随机数初始化的，但是发现如果删除这行也可以

persister 2009-09-15 14:16 发表评论

Perl学习笔记五

persister — Mon, 14 Sep 2009 14:10:00 GMT

1.The -x File Tests

1 print "where? ";
2 $filename = <STDIN>;
3 chomp $filename; # toss pesky newline
4 if (-r $filename && -w $filename) {
5 # file exists, and I can read and write it
6
7 }

Table 10.1: File Tests and Their Meanings
File Test Meaning
-r File or directory is readable
-w File or directory is writable
-x File or directory is executable
-o File or directory is owned by user
-R File or directory is readable by real user, not effective user (differs from -r for setuid
programs)
-W File or directory is writable by real user, not effective user (differs from -w for setuid
programs)
-X File or directory is executable by real user, not effective user (differs from -x for setuid
programs)
-O File or directory is owned by real user, not effective user (differs from -o for setuid
programs)
-e File or directory exists
-z File exists and has zero size (directories are never empty)
-s File or directory exists and has nonzero size (the value is the size in bytes)
-f Entry is a plain file
-d Entry is a directory
-l Entry is a symlink
-S Entry is a socket
-p Entry is a named pipe (a "fifo")
-b Entry is a block-special file (like a mountable disk)
-c Entry is a character-special file (like an I/O device)
-u File or directory is setuid
-g File or directory is setgid
-k File or directory has the sticky bit set
-t isatty() on the filehandle is true
-T File is "text"
-B File is "binary"
-M Modification age in days
-A Access age in days
-C Inode-modification age in days

1 foreach (@some_list_of_filenames) {
2 print "$_ is readable\n" if -r; # same as -r $_
3 }

2.The stat and lstat Functions

1 ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,
2 $size,$atime,$mtime,$ctime,$blksize,$blocks) = stat()

persister 2009-09-14 22:10 发表评论

Perl学习笔记四

persister — Fri, 11 Sep 2009 07:23:00 GMT

1. subroutine

1 sub say {
2        print "$_[0], $_[1]!"n";
3    }
4    say("hello","world"); # hello world, once again
5    say("goodbye","cruel world"); # silent movie lament
6

2.Private Variables in Functions

1 sub bigger_than {
2     my($n,@values); # create some local variables
3     ($n,@values) = @_; # split args into limit and values
4     my(@result); # temporary for holding the return value
5     foreach $_ (@values) { # step through the arg list
6       if ($_ > $n) { # is it eligible?
7        push(@result,$_); # add it
8       }
9     }
10     return @result; # return the final list
11   }

# some invocations:
@this = bigger_than(5,1,5,15,30); # @this gets (15,30)

3.File-Level my( ) Variables
The my() operator can also be used at the outermost level of your program, outside of
any subroutines or blocks. While this isn't really a "local" variable in the sense
defined above, it's actually rather useful,especially when used in conjunction with a
Perl pragma:
use strict;
A pragma is a compiler directive. Other directives include those to set up integer
arithmetic, overload numeric operators, or request more verbose warnings and error
messages.
If you place this pragma at the beginning of your file, you will no longer be able
to use variables (scalars,arrays, and hashes) until you have first "declared" them.
And you declare them with my(), like so:

1 use strict;
2   my $a; # starts as undef
3   my @b = qw(fred barney betty); # give initial value
4
5   push @b, qw(wilma); # cannot leave her out
6   @c = sort @b; # WILL NOT COMPILE

That last statement will be flagged at compile time as an error, because it referred
to a variable that had not previously been declared with my (that is, @c). In other
words,your program won't even start running unless every single variable being used
has been declared. The advantages of forcing variable declarations are twofold:
1. Your programs will run slightly faster (variables created with my are accessed
slightly faster than ordinary variables).

Variables created with my() are not found in any package.
2. You'll catch mistakes in typing much faster, because you'll no longer be able
to accidentally reference a nonexisting variable named $freed when you wanted $fred.

4.The last Statement

1 while (something) {
2       something;
3       something;
4       something;
5       if (somecondition) {
6          somethingorother;
7          somethingorother;
8          last; # break out of the while loop
9       }
10       morethings;
11       morethings;
12    }
13    # last comes here

5.The next Statement

1   while (something) {
2    firstpart;
3    firstpart;
4    firstpart;
5    if (somecondition) {
6      somepart;
7      somepart;
8      next;
9    }
10    otherpart;
11    otherpart;
12    # next comes here
13   }

6.The redo Statement

1 while (somecondition) {
2      # redo comes here
3     something;
4     something;
5     something;
6     if (somecondition) {
7          somestuff;
8          somestuff;
9         redo;
10 }
11 morething;
12 morething;
13 morething;
14 }

7.Expression Modifiers

1 exp2 unless exp1; # like: unless (exp1) { exp2; }
2 exp2 while exp1; # like: while (exp1) { exp2; }
3 exp2 until exp1; # like: until (exp1) { exp2; }
4 some_expression if control_expression; # like if (control_expression) { some_expression;}

8.&& and || as Control Structures

1 if (this) { that; } # one way
2 that if this; # another way
3
4 #Here's a third (and believe it or not, there are still others):
5 this && that;
6 #Likewise, the logical-or works like the unless statement (or unless modifier). So you can replace:
7 unless (this) { that; }
8 #with:
9 this || that;

9.Opening and Closing a Filehandle

1 open(FILEHANDLE,"somename"); #opens the filehandle for reading
2
3 open(OUT, ">outfile"); #open a file for writing
4
5 open(LOGFILE, ">>mylogfile"); #you can open a file for appending
6 close(LOGFILE);

10.A Slight Diversion: die

1 open(DATAPLACE,">/tmp/dataplace") ||
2 die "Sorry, I couldn't create /tmp/dataplace\n";
3
4 die "you gravy-sucking pigs"; #prints the file and line number
5
6 die "you gravy-sucking pigs\n"; #print either
7
8 open(LOG, ">>logfile") || die "cannot append: $!"; # $!: most recent operating system error

11.Using Filehandles

1 open (EP,"/etc/passwd");
2 while (<EP>) {
3 chomp;
4 print "I saw $_ in the password file!\n";
5 }
6 close(EP);

1 open(OUT, ">outfile"); #open a file for writing
2 print OUT "What's going on in this file";
3 close(OUT);

persister 2009-09-11 15:23 发表评论

perl学习笔记三

persister — Wed, 18 Mar 2009 14:00:00 GMT

1、Anchoring Patterns
    \b意味着字符边界。代码：
    print "what's your name?";
    $name=;
    chomp($name);
    if($name=~ /^randl\b/i){
        print "matched\n";
    }else{
        print "not matched\n";
    }
    如果输入randl*, *是字符、数字和下划线，那么都会打印not matched
   而输入"randl%"、"randl fa"等则matched。

    /fred\b/; # matches fred, but not frederick
    /\bmo/; # matches moe and mole, but not Elmo
    /\bFred\b/; # matches Fred but not Frederick or alFred
    /\b\+\b/; # matches "x+y" but not "++" or " + "
    /abc\bdef/; # never matches (impossible for a boundary there)
   word boundary按字面来看是一种边界，一个位置。在这个位置两边的字符一个与\w匹配，一个与
   \W匹配，这是一种情况；还有一种情况就是，一个字符与\w匹配，而另一个字符嘛，要么是
   字符串的打头，要么是结尾。而\b这个anchor恰恰需要在它出现的位置是一个word boundary。
   再看来/abc\bdef/，\b两边一个是c，一个是d，都与\w匹配，这已不满足上述的第一种情况，
   至于第二种情况，更加不会是字符串的打头或末尾了。所以\b出现的地方不可能是word boundary。

附Learning Perl中的片段说明：

if ($name =~ /^Randal/) {
## yes, it matches
} else {
## no, it doesn't
}
Note that the regular expression is delimited by slashes. Within the slashes, spaces and other whitespace
are significant, just as they are within strings.
This almost does it, but it doesn't handle selecting randal or rejecting Randall. To accept randal,
we add the ignore-case option, a small i appended after the closing slash. To reject Randall, we add a
word boundary special marker (similar to vi and some versions of grep) in the form of "b in the regular
expression. This ensures that the character following the first l in the regular expression is not another
letter. This changes the regular expression to be /^randal"b/i, which means "randal at the
beginning of the string, no letter or digit following, and OK to be in either case."

persister 2009-03-18 22:00 发表评论

perl连接mysql数据库

persister — Mon, 16 Mar 2009 13:46:00 GMT

1、查看系统上是否已经安装好了DBI，perl -e "use DBI"，如果没有出现错误且没有退出，表明已经安装
    此模块。
2、如果未安装，到www.cpan.org进行下载两个模块，DBI-1.607.tar.gz和DBD-mysql-4.010进行安装。
    tar -xzvf DBI-1.607.tar.gz
    cd DBI-1.607
    perl Makefile.PL
    make
    make test
    make install
    DBD-myql-4.010也同样的方式进行安装。
3、通过下面的perl脚本连接数据库：
    my $dbh = DBI->connect("DBI:mysql:database=test;host=localhost","root","123456");
    my $sth = $dbh->("select * from clients");
    $sth->execute();
    while(my $ref = $sth->fetchrow_hashref())
    {
        print "cid=$ref->{'cid'} and cname=$ref->{'cname'}\n";
    }
    $sth->finish();
    $dbh->disconnect();

persister 2009-03-16 21:46 发表评论

apache的安装和perl测试

persister — Mon, 16 Mar 2009 02:54:00 GMT

1.到官方网站下载最新apache
2. 下载后的文件形式是httpd-2.2.11.tar.gz.
    1)利用命令tar xvfz *.tar.gz将apache解压.
    2)cd httpd-2.2.11    3)利用./configure --help查看帮助信息,看看需要配置哪些选项.由于我要装mysql和php,所以选择了以下
        几个选项:./configure --prefix=/usr/local/apache2 --enable-rewrite   --with-mpm=worker --enable-so
        最后一个很重要,如果要装php,一定要写,前面两个不是必需的.<如果不明白选项的含义,去google.>
    4)make
    5)make install
3. 启动Apache：
    #cd /usr/local/apache2/bin
    #./apachectl start

   停掉apache是
    #cd /usr/local/apache2/bin
    #./apachectl stop
4.测试安装是否成功，浏览器输入http://localhost, 页面显示it works，表明apache安装成功.
5.测试perl.文件为cgitest.pl,放在/usr/local/apache2/cgi-bin目录中，并且chmod a+x cgitest.pl使其可执行
：

    #!/usr/bin/perl -w

    use CGI;
    {
        my $q = new CGI;
        print $q->header(),
        $q->start_html("hello,perl"),
        $q->h1('hello perl'),
        $q->end_html();
    }
6.在浏览器中输入：http://localhost/cgi-bin/cgitest.pl 即可看到hello perl。

7.自定义文件存放位置：
    # ScriptAlias /cgi-bin/ "/usr/local/apache2/cgi-bin/"
    # ScriptAlias /cgi/ "/usr/local/www/"
      ScriptAlias / "/usr/local/www/"

#

这样就可以将网页文件存放在/usr/local/www目录
访问的时候：http://localhost/cgitest.pl 即可。

persister 2009-03-16 10:54 发表评论

Perl学习笔记二

persister — Sat, 14 Mar 2009 15:33:00 GMT

1.the string abc as a regular expression by enclosing the string in slashes:
    while (<>) {
        if (/abc/) {
            print $_;
        }
    }
2.dot "." pattern
   This matches any single character except newline (\n). For example, the pattern /a./ matches any two-letter sequence
   that starts with a and is not "a\n".
3.A pattern-matching character class
     open and close square brackets and a list of characters between the brackets. One and only one of these characters
     must be present at the corresponding part of the string for the pattern to match. For example,
     /[abcde]/
    [0123456789] # match any single digit
    [0-9] # same thing
    [0-9\-] # match 0-9, or minus
    [a-z0-9] # match any single lowercase letter or digit
    [a-zA-Z0-9_] # match any single letter, digit, or underscore
    There's also a negated character class, which is the same as a character class, but has a leading up-arrow
    (or caret: ^) immediately after the left bracket. （if caret ^ is not right after the left bracket,then it means starting with）This character class matches any single character that is
    not in the list. For example:
    [^0-9] # match any single non-digit
    [^aeiouAEIOU] # match any single non-vowel
    [^\^] # match single character except an up-arrow

    Predefined Character Class Abbreviations
    Construct             Equivalent Class     Negated Construct     Equivalent Negated Class
    \d (a digit)             [0-9]                     \D (digits, not!)           [^0-9]
    \w (word char)     [a-zA-Z0-9_]         \W (words, not!)        [^a-zA-Z0-9_]
    \s (space char)     [ \r\t\n\f]                 \S (space, not!)         [^ \r\t\n\f]
4. Multipliers
    asterisk (*) as a grouping pattern. The asterisk indicates zero or more of the
        immediately previous character (or character class).
    Two other grouping patterns that work like this are the plus sign (+), meaning one or more of the
    immediately previous character, and the question mark (?), meaning zero or one of the immediately
    previous character. For example, the regular expression /fo+ba?r/ matches an f followed by one or
    more o's followed by a b, followed by an optional a, followed by an r.

    the general multiplier. The general multiplier consists of a pair of matching curly braces with one or two numbers
        inside, as in /x{5,10}/

    We could dispense with *, +, and ? entirely, since they are completely equivalent to {0,}, {1,}, and
    {0,1}. But it's easier to type the equivalent single punctuation character, and more familiar as well.

    If two multipliers occur in a single expression, the greedy rule is augmented with "leftmost is greediest."
    For example:
    $_ = "a xxx c xxxxxxxx c xxx d";
    /a.*c.*d/;
    In this case, the first ".*" in the regular expression matches all characters up to the second c, even
    though matching only the characters up to the first c would still allow the entire regular expression to
    match. Right now, this doesn't make any difference (the pattern would match either way), but later when
    we can look at parts of the regular expression that matched, it'll matter quite a bit.
    We can force any multiplier to be nongreedy (or lazy) by following it with a question mark:
    $_ = "a xxx c xxxxxxxx c xxx d";
    /a.*?c.*d/;
    Here, the a.*?c now matches the fewest characters between the a and c, not the most characters. This
    means the leftmost c is matched, not the rightmost. You can put such a question-mark modifier after any
    of the multipliers (?,+,*, and {m,n}).
    What if the string and regular expression were slightly altered, say, to:
    $_ = "a xxx ce xxxxxxxx ci xxx d";
    /a.*ce.*d/;
    In this case, if the .* matches the most characters possible before the next c, the next regular expression
    character (e) doesn't match the next character of the string (i). In this case, we get automatic
    backtracking: the multiplier is unwound and retried, stopping at someplace earlier (in this case, at the
    earlier c, next to the e).[2] A complex regular expression may involve many such levels of backtracking,
    leading to long execution times. In this case, making that match lazy (with a trailing "?") will actually
    simplify the work that Perl has to perform, so you may want to consider that.
    [2] Well, technically there was a lot of backtracking of the * operator to find the c's in the
    first place. But that's a little trickier to describe, and it works on the same principle.
5.Parentheses as memory

    To recall a memorized part of a string, you must include a backslash followed by an integer. This pattern
    construct represents the same sequence of characters matched earlier in the same-numbered pair of
    parentheses (counting from one). For example,
        /fred(.)barney\1/;
    matches a string consisting of fred, followed by any single non-newline character, followed by
    barney, followed by that same single character. So, it matches fredxbarneyx, but not
    fredxbarneyy. Compare that with
        /fred.barney./;

    /a(.)b(.)c\2d\1/;   # it matches axbycydx, for example
    /a(.*)b\1c/; matches an a, followed by any number of characters (even zero) followed by b, followed by that same
    sequence of characters followed by c. So, it would match aFREDbFREDc, or even abc, but not aXXbXXXc.

persister 2009-03-14 23:33 发表评论

Perl学习笔记一

persister — Tue, 06 Jan 2009 07:42:00 GMT

1、Perl的Hello World版，vi编辑文件hello，在此文件中输入以下内容：

1 #!/usr/bin/perl
2 print ("Hello, world!\n");

即打印Hello World！
2、变量定义：

1 #!/usr/bin/perl -w
2    print "What is your name? ";
3    $name = <STDIN>;  #定义一个变量采用符号$
4    chomp ($name);  #删除本字符串最后的"\n"，即回车符
5    print "Hello, $name!\n";

3、在perl中，只区分字符串和数字这两种数据类型，而且两者之间还可以互换。字符串分单引号字符串和
   双引号字符串，数字分整型和浮点型。
4、string repetition operator：
   "fred" x 3 # is "fredfredfred"
5、"." operator
   "hello" . "world" # same as "helloworld"
6、chop and chomp Functions

1 $x = "hello world";
2    chop($x); # $x is now "hello worl"
3
4    $a = "hello world\n";
5    chomp ($a); # $a is now "hello world"
6    chomp ($a); # aha! no change in $a

7、variable interpolation：

1 $a = "fred";
2    $b = "some text $a"; # $b is now "some text fred"
3
4    $fred = 'hi';
5    $barney = "a test of " . '$fred'; # literally: 'a test of $fred'
6    $barney2= "a test of \$fred"; # same thing

8、list literal
   1,2,3) # array of three values 1, 2, and 3
   ("fred",4.5) # two values, "fred" and 4.5
9、list constructor operator
   (1 .. 5) # same as (1, 2, 3, 4, 5)
   (1.2 .. 5.2) # same as (1.2, 2.2, 3.2, 4.2, 5.2)
   (1.3 .. 6.1) # same as (1.3,2.3,3.3,4.3,5.3)
10、"quote word" function
   @a = ("fred","barney","betty","wilma"); # ugh!
   @a = qw(fred barney betty wilma); # better!
11、Array Element Access
   @fred = (7,8,9);
   $b = $fred[0]; # give 7 to $b (first element of @fred)
   $fred[0] = 5; # now @fred = (5,8,9)
   @fred[0,1]; # same as ($fred[0],$fred[1])
12、push and pop Functions
   @mylist = (1,2,3);
   push(@mylist,4,5,6); # @mylist = (1,2,3,4,5,6)
   pop(@mylist); # @mylist = (1,2,3,4,5);
13、shift and unshift Functions
   @fred = (5,6,7);
   unshift(@fred,2,3,4); # @fred is now (2,3,4,5,6,7)
   $x = shift(@fred); # $x gets 2, @fred is now (3,4,5,6,7)
14、reverse Function
   @a = (7,8,9);
   @b = reverse(@a); # gives @b the value of (9,8,7)
   @b = reverse(7,8,9); # same thing

14.1 as an Array:
@a = ; # read standard input in a list context

15、The if/unless Statement，unless其实就是if not

1 print "how old are you? ";
2    $a = <STDIN>;
3    chomp($a);
4    unless ($a < 18) {
5      print "Old enough! Cool! So go vote!\n";
6      $voter++;
7    }

16、true or false：
   In Perl, the rules are slightly weird, but they give you the expected
   results. The control expression is evaluated for a string value in scalar
   context (if it's already a string, no change, but if it's a number, it is converted
   to a string).If this string is either the empty string (with a length of zero), or a
   string consisting of the single character "0" (the digit zero), then the value of
   the expression is false. Anything else is true automatically.Some examples below：

   0        # converts to "0", so false
   1-1      # computes to 0, then converts to "0", so false
   1        # converts to "1", so true
   ""       # empty string, so false
   "1"      # not "" or "0", so true
   "00"     # not "" or "0", so true (this is weird, watch out)
   "0.000" # also true for the same reason and warning
   undef # evaluates to "", so false
17、elsif（not elseif or elif）

1 if (some_expression_one) {
2        one_true_statement_1;
3    } elsif (some_expression_two) {
4       two_true_statement_1;
5    } else {
6       all_false_statement_1;
7    }

18、while/until Statement

1 $stops = 0;
2    do {
3       $stops++;
4       print "Next stop? ";
5       chomp($location = <STDIN>);
6    } until $stops > 5 || $location eq 'home';

19、for Statement
   for ( initial_exp; test_exp; re-init_exp ) {
      statement_1;
   }
20、foreach Statement
   @a = (1,2,3,4,5);
   foreach $b (reverse @a) {
     print $b;
   }
   or
   foreach (reverse @a) {
      print; # $_ variable is used as a default for many of Perl's operations
   }
21、Hash
   %smooth = ("aaa","bbb","234.5",456.7);
22、keys Function
   $fred{"aaa"} = "bbb";
   $fred{234.5} = 456.7;
   @list = keys(%fred); # @list gets ("aaa",234.5) or (234.5,"aaa")
23、values function
   %lastname = (); # force %lastname empty
   $lastname{"fred"} = "flintstone";
   $lastname{"barney"} = "rubble";
   @lastnames = values(%lastname); # grab the values
24、each Function
   while (($first,$last) = each(%lastname)) {
     print "The last name of $first is $last\n";
   }
25、delete Function
   %fred = ("aaa","bbb",234.5,34.56); # give %fred two elements
   delete $fred{"aaa"}; //# %fred is now just one key-value pair
26、Hash Slices
   @score{"fred","barney","dino"} = (205,195,30);
   Hash slices can also be used to merge a smaller hash into a larger one. In this example,
   the smaller hash takes precedence in the sense that if there are duplicate keys,
   the value    from the smaller hash is used:
       %league{keys %score} = values %score;
    Here, the values of %score are merged into the %league hash. This is equivalent to
    the much slower operation:
            %league = (%league, %score); # merge %score into %league

27、Input from STDIN
   $a = ; # read the next line
   @a = ;

   Typically, one thing you want to do is read all lines one at a time and do something
   with each line. One common way to do this is:
      while (defined($line = )) {
               # process $line here
      }
28、Diamond Operator
   If you don't specify any filenames on the command line, the diamond operator reads
   from standard input automatically.
   #!/usr/bin/perl
   while (<>) {
        print $_;
   }

   or
   @ARGV = ("aaa","bbb","ccc");
   while (<>) { # process files aaa, bbb, and ccc
          print "this line is: $_"; //print every line in these files aaa,bbb and ccc
   }
29、printf for Formatted Output
   printf "%15s %5d %10.2f\n", $s, $n, $r;

30、if (($words{$somename} || "groucho") eq $someguess) {
       return 1; # return value is true
    注意上面的||不是或运算符，而是说如果左边的值为空的话，那么就是用右边的值。

persister 2009-01-06 15:42 发表评论

BlogJava-Java天空 任我翱翔-随笔分类-perl