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

shijiang1130

1. 学习Perl用约2小时30分钟
   
2. 
   
3. --- 考虑到自己的水平问题，写翻译实在是对不起大众，就改成摘要了，省略了面向对象那一章和其它自认为是翻不出来的内容，要是你有兴趣还是去看原版英文吧，http://qntm.org/files/perl/perl.html。 --
   
4. 
   
5. 在两个小时30分钟内了解 Perl
   
6. 
   
7. 作者 Sam Hughes
   
8. 
   
9. Perl语言是一门高级解释型动态语言，它的许多数据类型是运行时才决定的，并且经常和PHP和Python相提并论。Perl 从古老的Shell脚本语言中借鉴了许多语法特性，因为被过度使用的各种奇怪符号而声名狼藉，而且大部分代码借助Google的搜索功能都不能明白。Perl语言因其来自Shell的语言特性使之成为一门好用的胶水语言： 将其他语言和各种脚本连接在一起共同工作。  
   
10. 
    
11. Perl 语言非常适合处理文本，并生成更多的文本。Perl语言应用广泛，流行，可移植性极佳，而且有良好的社区支持。Perl 语言的设计哲学是："每个问题都有许多解决方式"（TMTOWTDI）( 与之相反，Python 的设计哲学是：每个问题应该只有一种，而且只有一种明确的，最好的解决方式)。
    
12. 
    
13. Perl 有令人沮丧的地方，但同时也有许多奇妙的特性。从这一点来看，它同其他任何一种曾经有过的编程语言一样。
    
14. 
    
15. 这篇文章只是提供一些知识，并不是什么宣传广告，目标读者只是针对像我这样的人: 厌恶 http://perl.org 上面学术性的文档，那些东西只会长篇累牍的讲述一些永远用不到的边缘问题。我只想通过一些通用规则和实例快速了解那些从Larry Wall的角度永远都不关心的基础编程问题，并学些能帮我找到一份工作的基础知识。
    
16. 
    
17. 这篇文档的目的是用短的不能再短的形式来讲：
    
18. 
    
19. 
    
20. 研究初探
    
21. 
    
22. 以下声明针对整个文档：“这并不是绝对的，实际情况要复杂的多”。你如果发现一个严重错误，请告诉我。但我保留对孩子们说错话的权利。
    
23. 
    
24. 在本文档中，我在实例中打印状态，输出数据，但没有明确的追加换行符。这样做是为了避免我发狂，让我能集中精力在实例中字符串的输出，我相信这是更重要的。在许多例子中，实际的输出可能是 "alotofwordsallsmusheduptogetherononeline". 请不要在意。
    
25. 
    
26. Hello world
    
27. 
    
28. 一个 Perl 脚本就是一个后缀为 .pl 的文本文件。
    
29. 
    
30. 这就是 helloworld.pl 的全文：
    
31. 
    
32.   use strict;
    
33.   use warnings;
    
34. 
    
35.   print "Hello world";
    
36. 
    
37. Perl 脚本被 Perl 的解释器来解释运行:
    
38. 
    
39.   perl helloworld.pl [arg0 [arg1 [arg2 ...]]]
    
40. 
    
41. 说实话，Perl 的语法非常宽容，他可以替你预测一些模糊的不知所云的代码的行为，我实在不想讲这些东西，因为你们应当竭力避免这么做。
    
42. 
    
43. 避免这么做的方法就是将 'use strict; use warnings' 放置在每一个脚本或模块的最前面。'use foo' 这样的语句是编译提示，编译提示是给 Perl.exe 的信号，在程序运行前，对解释器初始化语法验证规则施加影响。在代码运行的时候，解释器将忽略这些东西。
    
44. 
    
45. '#' 符号是一个注释的开始。注释的结束是到行的末尾。Perl 没有针对块的注释语法。
    
46. 
    
47. 变量
    
48. 
    
49. Perl 的变量有三种类型：标量，数组和散列。每种类型都有自己的前置符号：$, @ 和 % 分别代表这三种类型。变量使用 my 来声明，有效范围在闭合块范围内或到文件的末尾。
    
50. 
    
51. 标量变量
    
52. 
    
53. 一个标量变量可以包含：
    
54. 
    
55. undef (相当于 Python 中的 None, PHP 中的 null)
    
56. 
    
57. 一个数字( Perl 并不区分一个整型数字和浮点数字)
    
58. 
    
59. 一个字符串
    
60. 
    
61. 一个指向别的变量的引用
    
62. 
    
63.   my $undef = undef;
    
64.   print $undef; # prints the empty string "" and raises a warning
    
65. 
    
66.   # implicit undef:
    
67.   my $undef2;
    
68.   print $undef2; # prints "" and raises exactly the same warning
    
69.   my $num = 4040.5;
    
70.   print $num; # "4040.5"
    
71.   my $string = "world";
    
72.   print $string; # "world"
    
73. 
    
74. (稍后介绍引用)
    
75. 
    
76. 字符串使用 '.' 进行连接(和PHP一样)
    
77. 
    
78.   print "Hello ".$string; # "Hello world"
    
79. 
    
80. 布尔值
    
81. 
    
82. Perl 没有布尔数据类型。只有如下几种值才能在 if 判断语句中返回 'false' :
    
83. undef
    
84. 
    
85. 数字 0
    
86. 
    
87. 字符串 ""
    
88. 
    
89. 字符串 "0"
    
90. 
    
91. Perl 文档中经常提到函数在某些情况下会返回 'true' 或 'false'. 实际上，函数通常用 'return 1' 来返回真，用返回空字符串 '' 来表示返回假。
    
92. 
    
93. 弱类型
    
94. 
    
95. 它是不可能确定一个标量包含一个“数字”或“字符串”。更准确地说,它不应该有必要这样做。一个标量是否像一个数字或者字符串取决于操作者的使用它。当作为一个字符串、一个标量会表现得像一个字符串。当作为一个数字,一个标量会表现得像一个号码(增加一个警告如果这是不可能的):
    
96. 
    
97. my $str1 = "4G";
    
98. my $str2 = "4H";
    
99. print $str1 . $str2; # "4G4H"
    
100. print $str1 + $str2; # "8" with two warnings
     
101. print $str1 eq $str2; # "" (empty string, i.e. false)
     
102. print $str1 == $str2; # "1" with two warnings
     
103. # The classic error
     
104. 
     
105. #经典的错误
     
106. 
     
107. print "yes" == "no"; # "1" with two warnings; both values evaluate to 0 when used as numbers
     
108. 
     
109. 两个值用作数字评估为0
     
110. 
     
111. 这个教训是总是使用正确的操作符来比较标量数字和标量字符串比较:
     
112. #数值运算符:<、>、< =、> =、= =、!=、< = >,+,*
     
113. #字符串运算符: lt, gt, le, ge, eq, ne, cmp, . , x
     
114. 
     
115. 数组变量
     
116. 一个数组变量是一个标量的列表索引从0开始的整数。在Python中这被称为一个列表,在PHP这被称为数组。一个数组声明使用parenthesised标量的列表:
     
117. 
     
118. my @array = (
     
119. "print",
     
120. "these",
     
121. "strings",
     
122. "out",
     
123. "for",
     
124. "me", # trailing comma is okay
     
125. );
     
126. 
     
127. 你必须使用美元符号来访问一个值从一个数组,因为要取得的值不是一个数组但标量:
     
128. 
     
129. print $array[0]; # "print"
     
130. print $array[1]; # "these"
     
131. print $array[2]; # "strings"
     
132. print $array[3]; # "out"
     
133. print $array[4]; # "for"
     
134. print $array[5]; # "me"
     
135. print $array[6]; # returns undef, prints "" and raises a warning
     
136. 
     
137. 
     
138. 您可以使用负索引检索条目从结局开始和向后的工作:
     
139. 
     
140. print $array[-1]; # "me"
     
141. print $array[-2]; # "for"
     
142. print $array[-3]; # "out"
     
143. print $array[-4]; # "strings"
     
144. print $array[-5]; # "these"
     
145. print $array[-6]; # "print"
     
146. print $array[-7]; # returns undef, prints "" and raises a warning
     
147. 
     
148. 标量$ var和包含一个标量条目$ var[0] 的@var数组。有可能被读者困惑,所以避免这个。
     
149. 
     
150. 获取一个数组的长度:
     
151. print "This array has ". (scalar @array). "elements"; # "This array has 6 elements"
     
152. 
     
153. 最后的下标是5”
     
154. print "The last populated index is ". $#array; # "The last populated index is 5"
     
155. 
     
156. The arguments with which the original Perl script was invoked are stored in the built-in array variable @ARGV.
     
157. Perl脚本原来的参数调用存储在内置数组@ argv里面。
     
158. 变量可以插入到字符串:
     
159. print "Hello $string"; # "Hello world"
     
160. print "@array"; # "print these strings out for me"
     
161. 
     
162. 谨慎。有一天你会把某人的电子邮件地址在一个字符串,“[email]jeff@gmail.com[/email]”。这将导致Perl寻找一个数组变量称为@gmail来插入到字符串,并没有发现它,这会导致运行时错误。插值可以避免在两个方面:通过反斜杠转义特殊符号,或者用单引号代替双引号。
     
163. print "Hello \$string"; # "Hello $string"
     
164. print 'Hello $string'; # "Hello $string"
     
165. print "\@array"; # "@array"
     
166. print '@array'; # "@array"
     
167. 
     
168. 散列变量
     
169. 一个散列变量是一个字符串索引列表的标量。在Python中这被称为一个字典,在PHP中,这被称为一个数组。
     
170. my %scientists = (
     
171. "Newton" => "Isaac",
     
172. "Einstein" => "Albert",
     
173. "Darwin" => "Charles",
     
174. );
     
175. 
     
176. 注意这是一个类似声明数组声明。事实上,双箭头符号= >被称为“胖逗号“,因为它只是一个逗号分隔的同义词。一个散列声明使用列表与偶数个元素,偶数编号的元素(0、2、……)都作为字符串。
     
177. 你必须使用美元符号来访问一个值从一个散列,因为要取得的值不是一个散列但标量:
     
178. print $scientists{"Newton"}; # "Isaac"
     
179. print $scientists{"Einstein"}; # "Albert"
     
180. print $scientists{"Darwin"}; # "Charles"
     
181. print $scientists{"Dyson"}; # returns undef, prints "" and raises a warning
     
182. 注意：$ var和包含一个标量条目$ var {“foo”}的散列 % var与上面的数组包含标量。
     
183. 
     
184. 你可以直接转换一个散列与两倍条目的数组,交替键和值(和反向同样是容易的):
     
185. my @scientists = %scientists;
     
186. 然而,不像一个数组,将返回任意顺序。这个在编程的时候有注意！
     
187. 回顾一下,你必须使用方括号来检索一个值从一个数组,但是你必须使用括号来检索一个值从一个散列。方括号实际上是一个数值算子和括号都有效的字符串操作符。
     
188. 
     
189. my $data = "orange";
     
190. my @data = ("purple");
     
191. my %data = ( "0" => "blue");
     
192. print $data; # "orange"
     
193. print $data[0]; # "purple"
     
194. print $data["0"]; # "purple"
     
195. print $data{0}; # "blue"
     
196. print $data{"0"}; # "blue"
     
197. 
     

复制代码

7looki

学习Perl用约2小时30分钟

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

Perlvim

支持此计划，建议尝试用并行开发思路解决。

将此任务拆分成几个部分，允许别人认领，然后合并结果。

太多在名字上引人侧目的华而不实的文章，使类似速成，几天，几小时掌握什么的名字，让人厌烦。
同时也让许多精辟短小的好文章被人遗忘。

这篇是带领人入门的好文章，不能说掌握，只能是了解。建议中文名字起一个平实的名字。大家可以各抒已见。

shijiang1130

列表
一个列表在Perl是一种不同的东西再从要么数组或散列。你刚刚看到几个列表:

1. (
   
2. "print",
   
3. "these",
   
4. "strings",
   
5. "out",
   
6. "for",
   
7. "me",
   
8. )
   
9. (
   
10. "Newton" => "Isaac",
    
11. "Einstein" => "Albert",
    
12. "Darwin" => "Charles",
    
13. )
    

复制代码

一个列表不是一个变量。列表是一个短暂的价值,可分配给一个数组或散列变量。这就是为什么语法来声明数组和散列变量是相同的。在许多情况下,术语“列表”和“数组”可以互换使用,但有同样很多,列表和数组显示略有不同和极其混乱的行为。

好吧。记住,= >只是在伪装,然后看这个例子:

1. ("one", 1, "three", 3, "five", 5)
   
2. ("one" => 1, "three" => 3, "five" => 5)
   

复制代码

使用= >暗示这些列表是一个数组声明和其他是一个散列声明。但在他们自己的,他们两个都不是声明的任何东西。他们只是列表。相同的列表。
()
这里甚至没有暗示。这个列表可以用来声明一个空数组或一个空哈希和perl解释器显然没有告诉无论哪种方式。一旦你理解了这个奇怪的方面的Perl,你也会明白为什么以下事实必须真实:列表值不能嵌套。试一试:

1. my @array = (
   
2. "apples",
   
3. "bananas",
   
4. (
   
5. "inner",
   
6. "list",
   
7. "several",
   
8. "entries",
   
9. ),
   
10. "cherries",
    
11. );
    

复制代码

Perl无法知道是否("inner", "list", "several", "entries")被认为是一种内在的数组或一种内在的散列。因此,Perl假定它既不是和平滑的列表一个长长的名单:

1. print $array[0]; # "apples"
   
2. print $array[1]; # "bananas"
   
3. print $array[2]; # "inner"
   
4. print $array[3]; # "list"
   
5. print $array[4]; # "several"
   
6. print $array[5]; # "entries"
   
7. print $array[6]; # "cherries"
   
8. 
   
9. 相同的是真正的是否使用=>
   
10. my %hash = (
    
11. "beer" => "good",
    
12. "bananas" => (
    
13. "green" => "wait",
    
14. "yellow" => "eat",
    
15. ),
    
16. );
    
17. 
    
18. #以上提出了一个警告,因为散列被宣布使用7元素列表
    
19. print $hash{"beer"}; # "good"
    
20. print $hash{"bananas"}; # "green"
    
21. print $hash{"wait"}; # "yellow";
    
22. print $hash{"eat"}; # undef, so prints "" and raises a warning
    

复制代码

当然,这确实使它容易连接多个数组在一起:

1. my @bones = ("humerus", ("jaw", "skull"), "tibia");
   
2. my @fingers = ("thumb", "index", "middle", "ring", "little");
   
3. my @parts = (@bones, @fingers, ("foot", "toes"), "eyeball", "knuckle");
   
4. print @parts;
   

复制代码

shijiang1130

1. 上下文
   
2. Perl最鲜明的特征是,它的代码是上下文敏感的。每个表达式在Perl是评估无论是在标量上下文语境或列表,根据是否将产生一个标量或列表。许多Perl表达式和内置函数显示截然不同的行为取决于上下文的评估。
   
3. 一个标量作业如$scalar =评估它的表达式在标量上下文。在这种情况下,该表达式是"Mendeleev"和返回的值是相同的标量值"Mendeleev":
   
4. my $scalar = "Mendeleev";
   
5. 一个数组或散列赋值如@array =或%hash =评估其表达上下文列表。一个列表值列表上下文中计算得到的返回列表
   
6. my @array = ("Alpha", "Beta", "Gamma", "Pie");
   
7. my %hash = ("Alpha" => "Beta", "Gamma" => "Pie");
   
8. 
   
9. 到目前为止没有惊喜。
   
10. 一个标量表达式列表上下文中计算得到的变成一个单元素列表:
    
11. my @array = "Mendeleev"; # same as 'my @array = ("Mendeleev");'
    
12. 
    
13. 表达式列表评估在标量上下文返回最终的标量在列表中:
    
14. my $scalar = ("Alpha", "Beta", "Gamma", "Pie"); # Value of $scalar is now "Pie"
    
15. 一个数组表达式(数组是不同的从一个列表,还记得吗?)评估在标量上下文返回数组的长度:
    
16. my @array = ("Alpha", "Beta", "Gamma", "Pie");
    
17. my $scalar = @array; # Value of $scalar is now 4
    
18. 打印内置函数评估它的所有参数在上下文列表。事实上,打印接受无限的参数列表,并打印每个一个接一个,这意味着它可以用来直接打印数组:
    
19. my @array = ("Alpha", "Beta", "Goo");
    
20. my $scalar = "-X-";
    
21. print @array; # "AlphaBetaGoo";
    
22. print $scalar, @array, 98; # "-X-AlphaBetaGoo98";
    
23. 你可以迫使任何表达式计算在标量上下文使用标量内置函数。事实上,这就是为什么我们使用标量来检索一个数组的长度。
    
24. 你没有语法来返回标量值在标量上下文,也没有返回值在列表上下文。如上所述,Perl是完全有能力为你捏造结果。
    

复制代码

shijiang1130

1. 引用和嵌套的数据结构
   
2. 以同样的方式列出不能包含列表元素,数组和散列不能包含其他元素数组和散列。他们只能包含标量。看看会发生什么:
   
3. my @outer = ("Sun", "Mercury", "Venus", undef, "Mars");
   
4. my @inner = ("Earth", "Moon");
   
5. $outer[3] = @inner;
   
6. print $outer[3]; # "2"
   
7. $@outer是一个标量,所以它需要一个标量值。当你试图分配一个数组值像@inner,@inner评估在标量上下文。这是一样的标量@inner分配,这是@inner数组的长度,这是2。
   
8. 然而,一个标量变量可能包含一个引用到任何变量,包括一个数组变量或一个散列变量。这是在PERL中创建更复杂的数据结构。
   
9. 创建一个引用是使用一个反斜杠。
   
10. my $colour = "Indigo";
    
11. my $scalarRef = \$colour;
    
12. 任何时间你将使用一个变量的名字,您可以只放一些括号,括号内,将一个引用变量来代替。
    
13. print $colour; # "Indigo"
    
14. print $scalarRef; # e.g. "SCALAR(0x182c180)"
    
15. print ${ $scalarRef }; # "Indigo"
    
16. 
    
17. 只要结果是不模糊,你可以省略括号:
    
18. print $$scalarRef; # "Indigo"
    
19. If your reference is a reference to an array or hash variable, you can get data out of it using braces or using the more popular arrow operator, ->:
    
20. 如果你的引用是引用一个数组或散列变量,您可以用括号或使用更受欢迎的箭头操作符 - >得到数据
    
21. my @colours = ("Red", "Orange", "Yellow", "Green", "Blue");
    
22. my $arrayRef = \@colours;
    
23. print $colours[0]; # direct array access
    
24. print ${ $arrayRef }[0]; # use the reference to get to the array
    
25. print $arrayRef->[0]; # exactly the same thing
    
26. my %atomicWeights = ("Hydrogen" => 1.008, "Helium" => 4.003, "Manganese" => 54.94);
    
27. my $hashRef = \%atomicWeights;
    
28. print $atomicWeights{"Helium"}; # direct hash access
    
29. print ${ $hashRef }{"Helium"}; # use a reference to get to the hash
    
30. print $hashRef->{"Helium"}; # exactly the same thing - this is very common
    
31. 
    
32. 声明一个数据结构
    
33. 这里有四个例子,但在实践中最后一个是最有益的。
    
34. my %owner1 = (
    
35. "name" => "Santa Claus",
    
36. "DOB" => "1882-12-25",
    
37. );
    
38. my $owner1Ref = \%owner1;
    
39. my %owner2 = (
    
40. "name" => "Mickey Mouse",
    
41. "DOB" => "1928-11-18",
    
42. );
    
43. my $owner2Ref = \%owner2;
    
44. my @owners = ( $owner1Ref, $owner2Ref );
    
45. my $ownersRef = \@owners;
    
46. my %account = (
    
47. "number" => "12345678",
    
48. "opened" => "2000-01-01",
    
49. "owners" => $ownersRef,
    
50. );
    
51. 
    
52. 这显然是不必要的辛苦,因为你可以简化成:
    
53. my %owner1 = (
    
54. "name" => "Santa Claus",
    
55. "DOB" => "1882-12-25",
    
56. );
    
57. my %owner2 = (
    
58. "name" => "Mickey Mouse",
    
59. "DOB" => "1928-11-18",
    
60. );
    
61. my @owners = ( \%owner1, \%owner2 );
    
62. my %account = (
    
63. "number" => "12345678",
    
64. "opened" => "2000-01-01",
    
65. "owners" => \@owners,
    
66. );
    
67. 也可以使用不同的符号声明匿名数组和散列。使用方括号为一个匿名数组和括号为匿名散列。返回的值在每个案例是一个参考的匿名数据结构问题。仔细看:
    
68. #括号表示一个匿名散列
    
69. my $owner1Ref = {
    
70. "name" => "Santa Claus",
    
71. "DOB" => "1882-12-25",
    
72. };
    
73. my $owner2Ref = {
    
74. "name" => "Mickey Mouse",
    
75. "DOB" => "1928-11-18",
    
76. };
    
77. 
    
78. #方括号表示一个匿名数组
    
79. my $ownersRef = [ $owner1Ref, $owner2Ref ];
    
80. my %account = (
    
81. "number" => "12345678",
    
82. "opened" => "2000-01-01",
    
83. "owners" => $ownersRef,
    
84. );
    
85. 
    
86. 或者, (你应该实际使用复杂数据结构时声明内联):
    
87. my %account = (
    
88. "number" => "31415926",
    
89. "opened" => "3000-01-01",
    
90. "owners" => [
    
91. {
    
92. "name" => "Philip Fry",
    
93. "DOB" => "1974-08-06",
    
94. },
    
95. {
    
96. "name" => "Hubert Farnsworth",
    
97. "DOB" => "2841-04-09",
    
98. },
    
99. ],
    
100. );
     

复制代码

Perlvim

大家看看有什么地方翻译的有问题，请随时提出，我会继续翻译直到翻译完成：

=encoding utf8

en: =head1 Learn Perl in about 2 hours 30 minutes
cn: =head1 在两个小时30分钟内了解 Perl

en: =head2 By Sam Hughes
cn: =head2 作者 Sam Hughes

en: Perl is a dynamic, dynamically-typed, high-level, scripting (interpreted) language most comparable with PHP and Python. Perl's syntax owes a lot to ancient shell scripting tools, and it is famed for its overuse of confusing symbols, the majority of which are impossible to Google for. Perl's shell scripting heritage makes it great for writing glue code: scripts which link together other scripts and programs.
cn: Perl语言是一门高级解释型动态语言，它的许多数据类型是运行时才决定的，并且经常和PHP和Python相提并论。Perl 从古老的Shell脚本语言中借鉴了许多语法特性，因为被过度使用的各种奇怪符号而声名狼藉，而且大部分代码借助Google的搜索功能都不能明白。Perl语言因其来自Shell的语言特性使之成为一门好用的胶水语言： 将其他语言和各种脚本连接在一起共同工作。  

en: Perl is ideally suited for processing text data and producing more text data. Perl is widespread, popular, highly portable and well-supported. Perl was designed with the philosophy "There's More Than One Way To Do It" (TMTOWTDI) (contrast with Python, where "there should be one - and preferably only one - obvious way to do it").
cn: Perl 语言非常适合处理文本，并生成更多的文本。Perl语言应用广泛，流行，可移植性极佳，而且有良好的社区支持。Perl 语言的设计哲学是："每个问题都有许多解决方式"（TMTOWTDI）( 与之相反，Python 的设计哲学是：每个问题应该只有一种，而且只有一种明确的，最好的解决方式)。

en: Perl has horrors, but it also has some great redeeming features. In this respect it is like every other programming language ever created.
cn: Perl 有令人沮丧的地方，但同时也有许多奇妙的特性。从这一点来看，它同其他任何一种曾经有过的编程语言一样。

en: This document is intended to be informative, not evangelical. It is aimed at people who, like me: dislike the official Perl documentation at http://perl.org/ for being intensely technical and giving far too much space to very unusual edge cases learn new programming languages most quickly by "axiom and example" wish Larry Wall would get to the point already know how to program in general terms don't care about Perl beyond what's necessary to get the job done.
cn: 这篇文章只是提供一些知识，并不是什么宣传广告，目标读者只是针对像我这样的人: 厌恶 http://perl.org 上面学术性的文档，那些东西只会长篇累牍的讲述一些永远用不到的边缘问题。我只想通过一些通用规则和实例快速了解那些从Larry Wall的角度永远都不关心的基础编程问题，并学些能帮我找到一份工作的基础知识。

en: This document is intended to be as short as possible, but no shorter.
cn: 这篇文档的目的是用短的不能再短的形式来讲：

en: =head2 Preliminary notes
cn: =head2 研究初探

en: The following can be said of almost every declarative statement in this document: "that's not, strictly speaking, true; the situation is actually a lot more complicated". If you see a serious lie, point it out, but I reserve the right to preserve certain critical lies-to-children.
cn: 以下声明针对整个文档：“这并不是绝对的，实际情况要复杂的多”。你如果发现一个严重错误，请告诉我。但我保留对孩子们说错话的权利。

en: Throughout this document I'm using example print statements to output data but not explicitly appending line breaks. This is done to prevent me from going crazy and to give greater attention to the actual string being printed in each case, which is invariably more important. In many examples, this results in alotofwordsallsmusheduptogetherononeline if the code is run in reality. Try to ignore this.
cn: 在本文档中，我在实例中打印状态，输出数据，但没有明确的追加换行符。这样做是为了避免我发狂，让我能集中精力在实例中字符串的输出，我相信这是更重要的。在许多例子中，实际的输出可能是 "alotofwordsallsmusheduptogetherononeline". 请不要在意。

en: =head2 Hello world
cn: =head2 Hello world

en: A Perl script is a text file with the extension .pl.
cn: 一个 Perl 脚本就是一个后缀为 .pl 的文本文件。

en: Here's the full text of helloworld.pl:
cn: 这就是 helloworld.pl 的全文：

  use strict;
  use warnings;

  print "Hello world";

en: Perl scripts are interpreted by the Perl interpreter, perl or perl.exe:
cn: Perl 脚本被 Perl 的解释器来解释运行:

  perl helloworld.pl [arg0 [arg1 [arg2 ...]]]

en: A few immediate notes. Perl's syntax is highly permissive and it will allow you to do things which result in ambiguous-looking statements with unpredictable behaviour. There's no point in me explaining what these behaviours are, because you want to avoid them.
cn: 说实话，Perl 的语法非常宽容，他可以替你预测一些模糊的不知所云的代码的行为，我实在不想讲这些东西，因为你们应当竭力避免这么做。

en: The way to avoid them is to put use strict; use warnings; at the very top of every Perl script or module that you create. Statements of the form use foo; are pragmas. A pragma is a signal to perl.exe, which takes effect when initial syntactic validation is being performed, before the program starts running. These lines have no effect when the interpreter encounters them at run time.
cn: 避免这么做的方法就是将 'use strict; use warnings' 放置在每一个脚本或模块的最前面。'use foo' 这样的语句是编译提示，编译提示是给 Perl.exe 的信号，在程序运行前，对解释器初始化语法验证规则施加影响。在代码运行的时候，解释器将忽略这些东西。

en: The symbol # begins a comment. A comment lasts until the end of the line. Perl has no block comment syntax.
cn: '#' 符号是一个注释的开始。注释的结束是到行的末尾。Perl 没有针对块的注释语法。

en: =head2 Variables
cn: =head2 变量

en: Perl variables come in three types: scalars, arrays and hashes. Each type has its own sigil: $, @ and % respectively. Variables are declared using my, and remain in scope until the end of the enclosing block or file.
cn: Perl 的变量有三种类型：标量，数组和散列。每种类型都有自己的前置符号：$, @ 和 % 分别代表这三种类型。变量使用 my 来声明，有效范围在闭合块范围内或到文件的末尾。

en: =head3 Scalar variables
cn: 标量变量

en: A scalar variable can contain:
cn: 一个标量变量可以包含：

=over 4

en: =item * undef (corresponds to None in Python, null in PHP)
cn: =item * undef (相当于 Python 中的 None, PHP 中的 null)

en: =item * a number (Perl does not distinguish between an integer and a float)
cn: =item * 一个数字( Perl 并不区分一个整型数字和浮点数字)

en: =item * a string
cn: =item * 一个字符串

en: =item * a reference to any other variable.
cn: =item * 一个指向别的变量的引用

=back

  my $undef = undef;
  print $undef; # prints the empty string "" and raises a warning

  # implicit undef:
  my $undef2;
  print $undef2; # prints "" and raises exactly the same warning
  my $num = 4040.5;
  print $num; # "4040.5"
  my $string = "world";
  print $string; # "world"

en: (References are coming up shortly.)
cn: (稍后介绍引用)

en: String concatenation using the . operator (same as PHP):
cn: 字符串使用 '.' 进行连接(和PHP一样)

  print "Hello ".$string; # "Hello world"

en: =head3 Booleans
cn: =head3 布尔值

en: Perl has no boolean data type. A scalar in an if statement evaluates to boolean "false" if and only if it is one of the following:
cn: Perl 没有布尔数据类型。只有如下几种值才能在 if 判断语句中返回 'false' :

=over 4

en: =item * undef
cn: =item * undef

en: =item * number 0
cn: =item * 数字 0

en: =item * string ""
cn: =item * 字符串 ""

en: =item * string "0"
cn: =item * 字符串 "0"

=back

en: The Perl documentation repeatedly claims that functions return "true" or "false" values in certain situations. In practice, when a function is claimed to return "true" it usually returns 1, and when it is claimed to return false it usually returns the empty string, "".
cn: Perl 文档中经常提到函数在某些情况下会返回 'true' 或 'false'. 实际上，函数通常用 'return 1' 来返回真，用返回空字符串 '' 来表示返回假。

en: =head3 Weak typing
cn: =head3 弱类型

shijiang1130

Perlvim 发表于 2013-03-05 17:04

翻得准确多了。我继续往下啊。

shijiang1130

1. 获取信息的数据结构
   
2. 这里有四个例子,其中最后一个是最有用的:
   
3. 1．
   
4. my $ownersRef = $account{"owners"};
   
5. my @owners = @{ $ownersRef };
   
6. my $owner1Ref = $owners[0];
   
7. my %owner1 = %{ $owner1Ref };
   
8. my $owner2Ref = $owners[1];
   
9. my %owner2 = %{ $owner2Ref };
   
10. print "Account #", $account{"number"}, "\n";
    
11. print "Opened on ", $account{"opened"}, "\n";
    
12. print "Joint owners:\n";
    
13. print "\t", $owner1{"name"}, " (born ", $owner1{"DOB"}, ")\n";
    
14. print "\t", $owner2{"name"}, " (born ", $owner2{"DOB"}, ")\n";
    
15. 
    
16. 2．
    
17. my @owners = @{ $account{"owners"} };
    
18. my %owner1 = %{ $owners[0] };
    
19. my %owner2 = %{ $owners[1] };
    
20. print "Account #", $account{"number"}, "\n";
    
21. print "Opened on ", $account{"opened"}, "\n";
    
22. print "Joint owners:\n";
    
23. print "\t", $owner1{"name"}, " (born ", $owner1{"DOB"}, ")\n";
    
24. print "\t", $owner2{"name"}, " (born ", $owner2{"DOB"}, ")\n";
    
25. 
    
26. 3．
    
27. my $ownersRef = $account{"owners"};
    
28. my $owner1Ref = $ownersRef->[0];
    
29. my $owner2Ref = $ownersRef->[1];
    
30. print "Account #", $account{"number"}, "\n";
    
31. print "Opened on ", $account{"opened"}, "\n";
    
32. print "Joint owners:\n";
    
33. print "\t", $owner1Ref->{"name"}, " (born ", $owner1Ref->{"DOB"}, ")\n";
    
34. print "\t", $owner2Ref->{"name"}, " (born ", $owner2Ref->{"DOB"}, ")\n";
    
35. 
    
36. 4．
    
37. print "Account #", $account{"number"}, "\n";
    
38. print "Opened on ", $account{"opened"}, "\n";
    
39. print "Joint owners:\n";
    
40. print "\t", $account{"owners"}->[0]->{"name"}, " (born ", $account{"owners"}->[0]->{"DOB"}, ")\n";
    
41. print "\t", $account{"owners"}->[1]->{"name"}, " (born ", $account{"owners"}->[1]->{"DOB"}, ")\n";
    
42. 
    
43. 数组与数组引用
    
44. 这个数组有五个要素:
    
45. my @array1 = (1, 2, 3, 4, 5);
    
46. print @array1; # "12345"
    
47. 
    
48. 这个数组,有一个元素(是一个匿名引):
    
49. my @array2 = [1, 2, 3, 4, 5];
    
50. print @array2; # e.g. "ARRAY(0x182c180)"
    
51. 
    
52. 这个标量是一个匿名引用:
    
53. my $array3Ref = [1, 2, 3, 4, 5];
    
54. print $array3Ref; # e.g. "ARRAY(0x22710c0)"
    
55. print @{ $array3Ref }; # "12345"
    
56. print @$array3Ref; # "12345"
    

复制代码

shijiang1130

1. 条件
   
2. if ... elsif ... else ...
   
3. 在这里没有惊喜,除了拼写elsif:
   
4. my $word = "antidisestablishmentarianism";
   
5. my $strlen = length $word;
   
6. if($strlen >= 15) {
   
7. print "'", $word, "' is a very long word";
   
8. } elsif(10 <= $strlen && $strlen < 15) {
   
9. print "'", $word, "' is a medium-length word";
   
10. } else {
    
11. print "'", $word, "' is a a short word";
    
12. }
    
13. 
    
14. Perl提供了一个较短的语法,这是高度推荐的:
    
15. print "'", $word, "' is actually enormous" if $strlen >= 20;
    
16. 
    
17. unless ... else ...
    
18. my $temperature = 20;
    
19. unless($temperature > 30) {
    
20. print $temperature, " degrees Celsius is not very hot";
    
21. } else {
    
22. print $temperature, " degrees Celsius is actually pretty hot";
    
23. }
    
24. 
    
25. unless通常最好避免使用,因为它们使程序难读懂。“unless[…else]“块可以重构到一个“if[…else]”块。幸运的是,没有elsunless关键字。
    
26. 
    
27. 这个,相比之下,强烈推荐,因为它是如此容易阅读:
    
28. print "Oh no it's too cold" unless $temperature > 15;
    
29. 
    
30. 三元操作符
    
31. The ternary operator ? : allows simple if statements to be embedded in a statement. The canonical use for this is singular/plural forms:
    
32. 三目操作符?:允许简单的if语句嵌入在一个声明中。
    
33. my $gain = 48;
    
34. print "You gained ", $gain, " ", ($gain == 1 ? "experience point" : "experience points"), "!";
    
35. 
    
36. 三元操作符可以嵌套:
    
37. my $eggs = 5;
    
38. print "You have ", $eggs == 0 ? "no eggs" :
    
39. $eggs == 1 ? "an egg" :
    
40. "some eggs";
    
41. 
    
42. 
    
43. 循环
    
44. 不止有一种方法来做。
    
45. Perl有传统的while循环:
    
46. my $i = 0;
    
47. while($i < scalar @array) {
    
48. print $i, ": ", $array[$i];
    
49. $i++;
    
50. }
    
51. Perl还提供了until关键字:
    
52. my $i = 0;
    
53. until($i >= scalar @array) {
    
54. print $i, ": ", $array[$i];
    
55. $i++;
    
56. }
    
57. 
    
58. These do loops are almost equivalent to the above (a warning would be raised if @array were empty):
    
59. do循环几乎相当于上述的例子(如果@array是空的将会有一个警告):
    
60. my $i = 0;
    
61. do {
    
62. print $i, ": ", $array[$i];
    
63. $i++;
    
64. } while ($i < scalar @array);
    
65. 
    
66. 和
    
67. my $i = 0;
    
68. do {
    
69. print $i, ": ", $array[$i];
    
70. $i++;
    
71. } until ($i >= scalar @array);
    
72. 基本的c风格的for循环也是可以的。
    
73. for(my $i = 0; $i < scalar @array; $i++) {
    
74. print $i, ": ", $array[$i];
    
75. }
    
76. 
    
77. 这种循环被认为是老式的,应该尽量避免这样使用。迭代列表是好得多。
    
78. foreach my $string ( @array ) {
    
79. print $string;
    
80. }
    
81. 
    
82. 操作符. .创建一个匿名的整数列表:
    
83. foreach my $i ( 0 .. $#array ) {
    
84. print $i, ": ", $array[$i];
    
85. }
    
86. 
    
87. 你不能遍历一个散列。然而,你可以遍历它的键值。使用键内置函数来检索一个数组包含所有键的一个散列。然后使用foreach方法,我们用于数组:
    
88. foreach my $key (keys %scientists) {
    
89. print $key, ": ", $scientists{$key};
    
90. }
    
91. 
    
92. Since a hash has no underlying order, the keys may be returned in any order. Use the sort built-in function to sort the array of keys alphabetically beforehand:
    
93. 因为一个散列并没有顺序,键值可能在按任何顺序返回。使用排序内置函数事先按字母顺序排序数组的键:
    
94. foreach my $key (sort keys %scientists) {
    
95. print $key, ": ", $scientists{$key};
    
96. }
    
97. 
    
98. 如果你不提供显式迭代器,Perl使用一个默认的迭代器,$ _。$ _内置变量:
    
99. foreach ( @array ) {
    
100. print $_;
     
101. }
     
102. 
     
103. 如果使用默认的迭代器,你只希望把单个语句内部循环,您可以使用超短循环语法:
     
104. print $_ foreach @array;
     
105. 
     
106. 循环控制
     
107. next and last can be used to control the progress of a loop. In most programming languages these are known as continue and break respectively. We can also optionally provide a label for any loop. By convention, labels are written in ALLCAPITALS. Having labelled the loop, next and last may target that label. This example finds primes below 100:
     
108. next和last可用于控制循环的进展。在大多数编程语言这些被称为continue和break。我们还可以为任何循环提供一个label。按照惯例,lable所有字母都大写:
     
109. CANDIDATE: for my $candidate ( 2 .. 100 ) {
     
110. for my $divisor ( 2 .. sqrt $candidate ) {
     
111. next CANDIDATE if $candidate % $divisor == 0;
     
112. }
     
113. 
     
114. print $candidate. " is prime\n";
     
115. }
     

复制代码