2个半小时学会Perl [摘要]

shijiang1130

2个小时的时间我觉得是很不够的，至少也得要8个小时

xo1980

))))))

Perlvim

未翻译的部分还有很多，大家谁有兴趣，可以一起翻译：

Perlvim

楼主是用 Google 翻译的吧，还是看英文明白点。

Perlvim

还是另外开一个帖子放置最后翻译的结果吧。

Perlvim

此帖已被删除

shijiang1130

1. 
   
2. 数组函数
   
3. 我们将使用数组@stack来演示:
   
4. my @stack = ("Fred", "Eileen", "Denise", "Charlie");
   
5. print @stack; # "FredEileenDeniseCharlie"
   
6. pop提取和返回数组的最后一个元素。这可以被认为是堆栈的顶部:
   
7. print pop @stack; # "Charlie"
   
8. print @stack; # "FredEileenDenise"
   
9. push附加额外的元素到数组的末尾:
   
10. push @stack, "Bob", "Alice";
    
11. print @stack; # "FredEileenDeniseBobAlice"
    
12. 
    
13. shift提取并返回数组的第一个元素:
    
14. print shift @stack; # "Fred"
    
15. print @stack; # "EileenDeniseBobAlice"
    
16. 
    
17. unshift在数组的开始插入新元素:
    
18. unshift @stack, "Hank", "Grace";
    
19. print @stack; # "HankGraceEileenDeniseBobAlice"
    
20. pop,push,shift和unshift都特殊情况的拼接。splice移除并返回一个数组切片,取而代之的是一个不同的数组切片:
    
21. print splice(@stack, 1, 4, "<<<", ">>>"); # "GraceEileenDeniseBob"
    
22. print @stack; # "Hank<<<>>>Alice"
    
23. 
    
24. 从旧的数组创建新的数组
    
25. Perl提供了以下功能,作用于数组创建其他数组。
    
26. join连接函数连接许多字符串为一个:
    
27. my @elements = ("Antimony", "Arsenic", "Aluminum", "Selenium");
    
28. print @elements; # "AntimonyArsenicAluminumSelenium"
    
29. print "@elements"; # "Antimony Arsenic Aluminum Selenium"
    
30. print join(", ", @elements); # "Antimony, Arsenic, Aluminum, Selenium"
    
31. 
    
32. 在列表中上下文中,reverse函数以相反的顺序返回一个列表。在标量上下文,反向连接整个列表放在一起,然后反转它作为一个单独的词。
    
33. print reverse("Hello", "World"); # "WorldHello"
    
34. print reverse("HelloWorld"); # "HelloWorld"
    
35. print scalar reverse("HelloWorld"); # "dlroWolleH"
    
36. print scalar reverse("Hello", "World"); # "dlroWolleH"
    
37. 
    
38. map函数将一个数组作为输入,并在这个数组对每一个标量$ _实行操作。然后构造一个新的数组。在一个表达式括号内提供操作执行的形式:
    
39. my @capitals = ("Baton Rouge", "Indianapolis", "Columbus", "Montgomery", "Helena", "Denver", "Boise");
    
40. print join ", ", map { uc $_ } @capitals;
    
41. # "BATON ROUGE, INDIANAPOLIS, COLUMBUS, MONTGOMERY, HELENA, DENVER, BOISE"
    
42. grep函数将一个数组作为输入,并返回一个过滤数组作为输出。其语法类似于map。这一次,第二个参数是评估每个标量$ _在输入数组。如果一个布尔真值返回,标量放入输出数组。
    
43. print join ", ", grep { length $_ == 6 } @capitals;
    
44. # "Helena, Denver"
    
45. 
    
46. 显然,结果数组的长度是成功匹配的数量,这意味着您可以使用grep来快速检查是否包含一个元素的数组:
    
47. print scalar grep { $_ eq "Columbus" } @capitals; # "1"
    
48. 
    
49. grep and map may be combined to form list comprehensions, an exceptionally powerful feature conspicuously absent from many other programming languages.
    
50. grep和map可以组合成列表理解, 其他一些编程语言缺少一个这样的特性。
    
51. 
    
52. 默认情况下,sort函数返回按词法(字母)的顺序的输入数组,:
    
53. my @elevations = (19, 1, 2, 100, 3, 98, 100, 1056);
    
54. print join ", ", sort @elevations;
    
55. # "1, 100, 100, 1056, 19, 2, 3, 98"
    
56. 然而,类似于grep和map,你可以提供你自己的一些代码。排序总是比较两个元素。你收到$a和$b作为输入, 如果$a是<$ b,应该返回-1,$a=$b应该返回0,$a>$b, 应该返回1。
    
57. 
    
58. 如果两个字符串比较就用cmp:
    
59. print join ", ", sort { $a cmp $b } @elevations;
    
60. # "1, 100, 100, 1056, 19, 2, 3, 98"
    
61. 对数字就用 < = >:
    
62. print join ", ", sort { $a <=> $b } @elevations;
    
63. # "1, 2, 3, 19, 98, 100, 100, 1056"
    
64. $a and $b are always scalars, but they can be references to quite complex objects which are difficult to compare. If you need more space for the comparison, you can create a separate subroutine and provide its name instead:
    
65. $ a和$b总是标量,他们可以采用引用, 但相当复杂,很难比较。如果你需要更多的空间来比较,您可以创建一个单独的子程序,并提供它的名字来代替:
    
66. sub comparator {
    
67. # return -1, 0 or 1
    
68. }
    
69. print join ", ", sort comparator @elevations;
    
70. 
    
71. 对于map和grep函数,你不能这样做,。
    
72. Notice how the subroutine and block are never explicitly provided with $a and $b. Like $_, $a and $b are, in fact, global variables which are populated with a pair of values to be compared each time.
    
73. 注意,子程序和块是从来没有明确地提供$a和$b。就像变量$ _, $ a和$b事实上是全局变量。
    

复制代码

shijiang1130

1. 内置函数
   
2. By now you have seen at least a dozen built-in functions: print, sort, map, grep, keys, scalar and so on. Built-in functions are one of Perl's greatest strengths. They
   
3. 现在你已经看到至少一打内置功能:print、sort、map、grep、keys、scalar等等。内置函数是Perl的最大优点。他们•众多•非常有用•广泛记录
   
4. •在语法差异很大,所以请核对文档
   
5. •有时接受正则表达式作为参数
   
6. •有时接受整个代码块作为参数
   
7. •有时不需要逗号分隔参数之间
   
8. •有时会使用任意数量的逗号分隔参数,有时不会
   
9. •如果太少的参数，有时会用缺省的
   
10. •一般不需要括号除了模棱两可的情况下
    
11. 
    
12. 关于内置函数最好的建议是知道他们的存在。将来好进行文档备查。如果你正在进行一项任务,感觉这是很基础和常见,而且以前做很多次,很可能是它。
    
13. 
    
14. 用户定义的子程序
    
15. 子例程使用sub关键字。相比之下,与内置函数,用户定义的子程序总是接受相同的输入:标量的列表。这个列表可能当然有一个单一的元素,或者是空的。一个标量是作为一个列表,一个元素。一个散列与N个元素作为一个列表2 N个元素。
    
16. 尽管括号是可选的,总是应该调用子程序使用方括号,即使称不带参数。这表明正在发生的子程序调用。
    
17. 一旦你在子程序内部,参数可以使用内置数组变量@ _。示例:
    
18. sub hyphenate {
    
19. # Extract the first argument from the array, ignore everything else
    
20. my $word = shift @_;
    
21. $word = join "-", map { substr $word, $_, 1 } (0 .. (length $word) - 1);
    
22. return $word;
    
23. }
    
24. 
    
25. print hyphenate("exterminate"); # "e-x-t-e-r-m-i-n-a-t-e"
    
26. 
    
27. 解开传入的参数
    
28. 有不止一种解压参数@ _的途径,但有些方法是优于其他方法的。
    
29. 通常调用如下:
    
30. print left_pad("hello", 10, "+"); # "+++++hello"
    
31. 
    
32. 1。有些人不解压的,这是不鼓励的:
    
33. sub left_pad {
    
34. my $newString = ($_[2] x ($_[1] - length $_[0])) . $_[0];
    
35. return $newString;
    
36. }
    
37. 第二种方式，仅解开参数
    
38. sub left_pad {
    
39. my $oldString = $_[0];
    
40. my $width = $_[1];
    
41. my $padChar = $_[2];
    
42. my $newString = ($padChar x ($width - length $oldString)) . $oldString;
    
43. return $newString;
    
44. }
    
45. 3。通过删除数据取出@ _,推荐使用转变为最多4个参数:
    
46. sub left_pad {
    
47. my $oldString = shift @_;
    
48. my $width = shift @_;
    
49. my $padChar = shift @_;
    
50. my $newString = ($padChar x ($width - length $oldString)) . $oldString;
    
51. return $newString;
    
52. }
    
53. 
    
54. If no array is provided to the shift function, then it operates on @_ implicitly. This approach is seen very commonly:
    
55. 如果没有数组提供给shift函数,那么@_作为隐式的提供。这种方法被认为非常普遍:
    
56. sub left_pad {
    
57. my $oldString = shift;
    
58. my $width = shift;
    
59. my $padChar = shift;
    
60. my $newString = ($padChar x ($width - length $oldString)) . $oldString;
    
61. return $newString;
    
62. }
    

复制代码

shijiang1130

1. 超出4个参数难以追踪哪些正被分配的地方。
   
2. 你可以解压的@ _去使用多个同时标量赋值。这是允许最多4个参数:
   
3. sub left_pad {
   
4. my ($oldString, $width, $padChar) = @_;
   
5. my $newString = ($padChar x ($width - length $oldString)) . $oldString;
   
6. return $newString;
   
7. }
   
8. 
   
9. 5. For subroutines with large numbers of arguments or where some arguments are optional or cannot be used in combination with others, best practice is to require the user to provide a hash of arguments when calling the subroutine, and then unpack @_ back into that hash of arguments. For this approach, our subroutine call would look a little different:
   
10. 5。大量的参数或一些参数是可选的或不能用在与其它相结合的子程序,最佳实践是要求用户提供一个散列的参数调用子程序时,然后解压@ _回到散列的参数。对于这种方法,我们的子程序调用会看起来有点不同:
    
11. print left_pad("oldString" => "pod", "width" => 10, "padChar" => "+");
    
12. 子程序本身看起来像这样:
    
13. sub left_pad {
    
14. my %args = @_;
    
15. my $newString = ($args{"padChar"} x ($args{"width"} - length $args{"oldString"})) . $args{"oldString"};
    
16. return $newString;
    
17. }
    
18. 
    
19. 返回值
    
20. 像其他Perl表达式、子程序调用与上下文的行为相关。您可以使用wantarray函数(这应该叫做wantlist但是没关系)来检测什么上下文子程序,并返回一个合适结果:
    
21. sub contextualSubroutine {
    
22. # Caller wants a list. Return a list
    
23. return ("Everest", "K2", "Etna") if wantarray;
    
24. # Caller wants a scalar. Return a scalar
    
25. return 3;
    
26. }
    
27. 
    
28. my @array = contextualSubroutine();
    
29. print @array; # "EverestK2Etna"
    
30. my $scalar = contextualSubroutine();
    
31. print $scalar; # "3"
    
32. 
    
33. 
    
34. 系统调用
    
35. 我重复你已经知道的以下非perl相关事实。每次一个过程完成后在Windows或Linux系统(我认为,在大多数其他系统),它包括了一个16位的状态字。最高的8位构成一个返回代码0和255之间的包容性,0代表不合格的成功,而其他值代表不同程度的失败。其他8位不经常检查——他们“反映模式的失败,如信号死亡和核心转储信息”。
    
36. 你可以带返回码(从0到255)退出一个Perl脚本。
    
37. Perl提供超过一个办法——在一个call - spawn子进程,暂停当前的脚本,直到子进程结束,然后恢复解释当前的脚本。使用哪种方法,你会发现,紧接着,内置的标量变量$ ?已填充状态字,回来子过程的终止。你可以返回代码以最高的8的16位:$ ?> > 8。
    
38. The system function can be used to invoke another program with the arguments listed. The value returned by system is the same value with which $? is populated:
    
39. 系统功能可用于调用另一个程序的参数列。系统通过$ ?返回的:
    
40. my $rc = system "perl", "anotherscript. pl", "foo", "bar", "baz";
    
41. $rc >>= 8;
    
42. print $rc; # "37"
    
43. 
    
44. 或者,您可以使用反引号``来运行一个实际的命令,在命令行和捕获标准输出命令。在标量上下文返回整个输出作为一个单一的字符串。在列表背景下,整个输出返回一个字符串数组,每一个代表一行输出。
    
45. my $text = `perl anotherscript. pl foo bar baz`;
    
46. print $text; # "foobarbaz"
    
47. 
    
48. This is the behaviour which would be seen if anotherscript. pl contained, for example:
    
49. 这是行为将可见的如果包含anotherscript.pl,例如:
    
50. use strict;
    
51. use warnings;
    
52. print @ARGV;
    
53. exit 37;
    
54. 
    
55. 
    
56. 文件和文件句柄
    
57. 一个标量变量可能包含一个文件句柄,而不是一个数字/字符串/参考或undef。一个文件处理本质上是一个引用一个特定的位置在一个特定的文件。
    
58. 
    
59. 使用open将标量变量变成一个文件句柄。必须提供一个open模式。这个模式<表明我们希望打开文件阅读它:
    
60. my $f = "text.txt";
    
61. my $result = open my $fh, "<", $f;
    
62. if(!$result) {
    
63. die "Couldn't open '".$f. "' for reading because: ".$!;
    
64. }
    
65. 
    
66. 如果成功,返回真值。否则,它将返回false和错误消息在变量$ !里面。如上所述,你应该总是检查打开操作成功完成。这个检查是很乏味的,一个常见的是:
    
67. open(my $fh, "<", $f) || die "Couldn't open '".$f. "' for reading because: ".$!;
    
68. 
    
69. 注意在调用的参数需要括号。
    
70. 从一个文件句柄读一行文本,使用readline内置函数。返回一个完整的文本, 它的末端包括一个换行符(除了可能对文件的最后一行),或者如果你到了undef文件的末尾。
    
71. while(1) {
    
72. my $line = readline $fh;
    
73. last unless defined $line;
    
74. # process the line...
    
75. }
    
76. 
    
77. 截断后面的换行符,使用chomp:
    
78. chomp $line;
    
79. 
    
80. Note that chomp acts on $line in place. $line = chomp $line is probably not what you want.
    
81. 注意,chomp的用法。$line= chomp $line不是你想要的结果。
    
82. 您还可以使用eof检测是否已经达到文件的末尾:
    
83. while(! eof $fh) {
    
84. my $line = readline $fh;
    
85. # process $line...
    
86. }
    
87. 
    
88. 
    
89. But beware of just using while(my $line = readline $fh), because if $line turns out to be "0", the loop will terminate early. If you want to write something like that, Perl provides the <> operator which wraps up readline in a fractionally safer way. This is very commonly-seen and perfectly safe:
    
90. 但要注意使用 while(my $line= readline $fh),因为如果$line 变成了“0”,循环将提前终止合同。如果你想写这样的东西,Perl提供< >操作符, 在一个安全的方式结束。这是很常见的,而且非常安全:
    
91. while(my $line = <$fh>) {
    
92. # process $line...
    
93. }
    
94. 甚至:
    
95. while(<$fh>) {
    
96. # process $_...
    
97. }
    
98. 
    
99. 写入文件涉及不同的模式。这个模式>表明我们希望打开文件写它。(>如果它已经存在并有内容,将覆盖已经存在。使用模式> >只是附加到现有文件)。然后,只需提供文件句柄作为一个输出参数。
    
100. open(my $fh2, ">", $f) || die "Couldn't open '".$f. "' for writing because: ".$!;
     
101. print $fh2 "The eagles have left the nest";
     
102. 
     
103. 注意中间没有一个逗号第一和第二个参数
     
104. 文件句柄实际上关闭时自动退出范围:
     
105. close $fh2;
     
106. close $fh;
     
107. 
     
108. 三个文件句柄作为全局常量:STDIN、STDOUT和STDERR存在。这些都是自动打开脚本时开始。读取一行用户输入:
     
109. my $line = <STDIN>;
     
110. 只是等待用户回车:
     
111. <STDIN>;
     

复制代码

方兆国儿

7looki 发表于 2013-03-04 02:41
学习Perl用约2小时30分钟

光这几个字, 唉, 我就不想看翻译的了(虽然我的英语很差很差, 差到看不懂).

嘿嘿   友情支持