精通Perl：现代Perl第四版

需积分: 9 108 浏览量更新于2024-07-19 收藏 803KB PDF 举报

"Modern Perl 4th Edition 2016" 是一本由 Perl 开发者 chromatic 编写的书籍，旨在教授读者如何使用现代 Perl 语言，特别针对 Perl 5.22 版本进行了更新。这本书不仅介绍了 Perl 的哲学基础，还详细解释了 Perl 的实际应用，帮助读者解决真实世界中的问题。chromatic 是 Perl 测试革命的推动者，对 Perl、Moose、Catalyst、Mojolicious 和 p5p 等项目的开发做出了贡献，并且参与制定了 Perl 的当前发布结构。在《Modern Perl 4th Edition》中，读者将学习到： 1. **Perl 哲学**：Perl 的设计理念强调简洁、强大和实用性。书中会探讨如何通过有效的代码解决问题，以及如何在保持代码简洁的同时增强其表达性。 2. **Perl 文档系统（Perldoc）**：Perl 提供了一套内建的文档系统，允许开发者轻松获取关于函数、模块和语言特性的文档。了解如何使用 perldoc 命令是每个 Perl 开发者的必备技能。 3. **上下文（Context）**：Perl 中的值会根据它们被使用的上下文（如列表或标量上下文）而改变。理解这一点对于编写正确且高效代码至关重要。 4. **空值、标量和列表上下文**：书中会详细讲解这些上下文的概念，包括如何在不同上下文中返回适当的数据类型。 5. **模块和 CPAN**：Perl 拥有一个庞大的模块生态系统，称为 Comprehensive Perl Archive Network (CPAN)。读者将学习如何利用 CPAN 寻找、安装和使用第三方模块。 6. **测试和调试**：chromatic 是 Perl 测试领域的专家，书中有大量关于编写测试用例和使用 Perl 测试框架的内容，帮助读者确保代码的质量和稳定性。 7. **现代 Perl 工具和技术**：包括 Moose（一个面向对象的扩展）、Catalyst（一个 web 应用框架）和 Mojolicious（一个轻量级的 web 开发框架）等工具的介绍和应用。 8. **Perl 社区和最佳实践**：书中会介绍全球 Perl 社区的资源，以及如何遵循社区的最佳实践来编写可维护和可扩展的代码。 9. **版本管理和持续集成**：书中可能涵盖了使用 Git 进行版本控制，以及如何设置自动化测试和构建流程，以实现持续集成。通过阅读《Modern Perl 4th Edition》，读者将能够全面了解 Perl 语言，掌握核心概念和最佳实践，从而成为一名高效的 Perl 开发者。此外，书中还包含了最新的语言特性，使得这本指南对新手和经验丰富的 Perl 程序员都极具价值。

Modern Perl

Perl has lots of documentation. Where do you start?

perldoc perltoc displays the table of contents of the core documentation, and perldoc perlfaq is the ta-

ble of contents for Frequently Asked Questions about Perl. perldoc perlop and perldoc perlsyn document

Perl's symbolic operators and syntactic constructs. perldoc perldiag explains the meanings of Perl's warning

messages. perldoc perlvar lists all of Perl's symbolic variables.

You don't have to memorize anything in these docs. Skim them for a great overview of the language and come back

to them when you have questions.

How to Read the Documentation

The perldoc utility can do much, much more (see perldoc perldoc). Use the -q option with a keyword to search the Perl

FAQ. For example, perldoc -q sort returns three questions: How do I sort an array by (anything)?, How do I sort a hash

(optionally by value instead of key)?, and How can I always keep my hash sorted?.

The -f option shows the documentation for a builtin Perl function, such as perldoc -f sort. If you don't know the name of

the function you want, browse the list of available builtins in perldoc perlfunc.

The -v option looks up a builtin variable. For example, perldoc -v $PID explains $PID, which is the variable containing the

current program's process id. Depending on your shell, you may have to quote the variable appropriately.

The -l option shows the path to the file containing the documentation. (A module may have a separate .pod file in addition to

its .pm file.)

The -m option displays the entire contents of the module, code and all, without any special formatting.

Perl uses a documentation format called POD, short for Plain Old Documentation. perldoc perlpod describes how POD

works. Other POD tools include podchecker, which validates the structure of POD documents, and the Pod::Webserver

CPAN module, which displays local POD as HTML through a minimal web server.

Expressivity

Before Larry Wall created Perl, he studied linguistics. Unlike other programming languages designed around a mathematical

notion, Perl's design emulates how people communicate with people. This gives you the freedom to write programs depending

on your current needs. You may write simple, straightforward code or combine many small pieces into larger programs. You

may select from multiple design paradigms, and you may eschew or embrace advanced features.

Learning Perl is like learning any spoken language. You'll learn a few words, then string together sentences, and then enjoy

simple conversations. Mastery comes from practice of both reading and writing code. You don't have to understand every detail

of Perl to be productive, but the principles in this chapter are essential to your growth as a programmer.

Other languages may claim that there should be only one best way to solve any problem. Perl allows you to decide what's most

readable, most useful, most appealing, or most fun.

Perl hackers call this TIMTOWTDI, pronounced “Tim Toady”, or “There's more than one way to do it!”

This expressivity allows master craftworkers to create amazing programs but also allows the unwary to make messes. You'll

develop your own sense of good taste with experience. Express yourself, but be mindful of readability and maintainability,

especially for those who come after you.

Perl novices often find certain syntactic constructs opaque. These idioms (Idioms, pp. 158) offer great (if subtle) power to

experienced programmers, but it's okay to avoid them until you're comfortable with them.

As another design goal, Perl tries to avoid surprising experienced (Perl) programmers. For example, adding two variables

($first_num + $second_num) is obviously a numeric operation (Numeric Operators, pp. 64). You've expressed your intent

to treat the values of those variables as numbers by using a numeric operator. Perl happily does so. No matter the contents of

$first_num and $second_num, Perl will coerce them to numeric values (Numeric Coercion, pp. 50).

Perl adepts often call this principle DWIM, or do what I mean. You could just as well call this the principle of least astonishment.

Given a cursory understanding of Perl (especially context; Context, pp. 3), it should be possible to understand the intent of an

unfamiliar Perl expression. You will develop this skill as you learn Perl.

Chapter 1. The Perl Philosophy

Perl's expressivity allows novices to write useful programs without having to understand the entire language. This is by design!

Experienced developers often call the results baby Perl as a term of endearment. Everyone begins as a novice. Through practice

and learning from more experienced programmers, you will understand and adopt more powerful idioms and techniques. It's

okay for you to write simple code that you understand. Keep practicing and you'll become a native speaker.

A novice Perl hacker might triple a list of numbers with:

my @tripled;

for (my $i = 0; $i < scalar @numbers; $i++) {

$tripled[$i] = $numbers[$i]

}

. . . and a Perl adept might write:

my @tripled;

for my $num (@numbers) {

push @tripled, $num

}

. . . while an experienced Perl hacker could write:

my @tripled = map { $_

3 } @numbers;

Every program gets the same result. Each uses Perl in a different way.

As you get more comfortable with Perl, you can let the language do more for you. With experience, you can focus on what you

want to do rather than how to do it. Perl doesn't care if you write baby or expert code. Design and refine your programs for

clarity, expressivity, reuse, and maintainability, in part or in whole. Take advantage of this flexibility and pragmatism: it's far

better to accomplish your task effectively now than to write a conceptually pure and beautiful program next year.

Context

In spoken languages, the meaning of a word or phrase depends on how you use it; the local context of other grammatical

constructs helps clarify the intent. For example, the inappropriate pluralization of “Please give me one hamburgers!” sounds

wrong (the pluralization of the noun differs from the amount), just as the incorrect gender of “la gato” (the article is feminine,

but the noun is masculine) makes native speakers chuckle. Some words do double duty; one sheep is a sheep just as two sheep

are also sheep and you program a program.

Perl uses context to express how to treat a piece of data. This governs the amount of data as well as the kind of data. For

example, several Perl operations produce different behaviors when you expect zero, one, or many results. A specific construct

in Perl may do something different if you write “Do this, but I don't care about any results” compared to “Do this and give me

multiple results.” Other operations allow you to specify whether you expect to work with numeric, textual, or true or false data.

You must keep context in mind when you read Perl code. Every expression is part of a larger context. You may find yourself

slapping your forehead after a long debugging session when you discover that your assumptions about context were incorrect.

If instead you're aware of context, your code will be more correct–and cleaner, flexible, and more concise.

Void, Scalar, and List Context

Amount context governs how many items you expect an operation to produce. Think of subject-verb number agreement in

English. Even without knowing the formal description of this principle, you probably understand the error in the sentence “Perl

are a fun language.” (In terms of amount context, you could say that the verb “are” expects a plural noun or noun phrase.) In

Perl, the number of items you request influences how many you receive.

Suppose the function (Declaring Functions, pp. 67) called find_chores() sorts your household todo list in order of priority.

The number of chores you expect to read from your list influences what the function produces. If you expect nothing, you're

Modern Perl

just pretending to be busy. If you expect one task, you have something to do for the next fifteen minutes. If you have a burst of

energy on a free weekend, you could get all of your chores.

Why does context matter? A context-aware function can examine its calling context and decide how much work it must do.

When you call a function and never use its return value, you've used void context:

find_chores();

Assigning the function's return value to a single item (Scalars, pp. 37) enforces scalar context:

my $single_result = find_chores();

Assigning the results of calling the function to an array (Arrays, pp. 39) or a list, or using it in a list, evaluates the function in

list context:

my @all_results = find_chores();

my ($single_element, @rest) = find_chores();

# list of results passed to a function

process_list_of_results( find_chores() );

The parentheses in the second line of the previous example group the two variable declarations (Lexical Scope, pp. 77) into a

single unit so that assignment assigns to both of the variables. A single-item list is still a list, though. You could also correctly

write:

my ($single_element) = find_chores();

. . . . in which case the parentheses tell Perl parser that you intend list context for the single variable $single_element. This is

subtle, but now that you know about it, the difference of amount context between these two statements should be obvious:

my $scalar_context = find_chores();

my ($list_context) = find_chores();

Lists propagate list context to the expressions they contain. This often confuses novices until they understand it. Both of these

calls to find_chores() occur in list context:

process_list_of_results( find_chores() );

my %results = (

cheap_operation => $cheap_results,

expensive_operation => find_chores(), # OOPS!

);

Yes, initializing a hash (Hashes, pp. 43) with a list of values imposes list context on find_chores. Use the scalar operator

to impose scalar context:

my %results = (

cheap_operation => $cheap_results,

expensive_operation => scalar find_chores(),

);

Again, context can help you determine how much work a function should do. In void context, find_chores() may legitimately

do nothing. In scalar context, it can find only the most important task. In list context, it must sort and return the entire list.

Chapter 1. The Perl Philosophy

Numeric, String, and Boolean Context

Perl's other context–value context–influences how Perl interprets a piece of data. Perl can figure out if you have a number or

a string and convert data between the two types. In exchange for not having to declare explicitly what type of data a variable

contains or a function produces, Perl's value contexts provide hints about how to treat that data.

Perl will coerce values to specific proper types (Coercion, pp. 49) depending on the operators you use. For example, the eq

operator tests that two values contain equivalent string values:

say "Catastrophic crypto fail!" if $alice eq $bob;

You may have had a bafﬂing experience where you know that the strings are different, but they still compare the same:

my $alice = 'alice';

say "Catastrophic crypto fail!" if $alice == 'Bob';

The eq operator treats its operands as strings by enforcing string context on them, but the == operator imposes numeric context.

In numeric context, both strings evaluate to 0 (Numeric Coercion, pp. 50). Be sure to use the proper operator for your desired

value context.

Boolean context occurs when you use a value in a conditional statement. In the previous examples, if evaluated the results of

the eq and == operators in boolean context.

In rare circumstances, you may not be able to use the appropriate operator to enforce value context. To force a numeric context,

add zero to a variable. To force a string context, concatenate a variable with the empty string. To force a boolean context, double

up the negation operator:

my $numeric_x = 0 + $x; # forces numeric context

my $stringy_x = '' . $x; # forces string context

my $boolean_x = !!$x; # forces boolean context

Value contexts are easier to identify than amount contexts. Once you know which operators provide which contexts (Operator

Types, pp. 64), you'll rarely make mistakes.

Implicit Ideas

Perl code can seem dense at first, but it's full of linguistic shortcuts. These allow experienced programmers to glance at code

and understand its important implications. Context is one shortcut. Another is default variables–the programming equivalent of

pronouns.

The Default Scalar Variable

The default scalar variable (or topic variable), $_, is most notable in its absence: many of Perl's builtin operations work on the

contents of $_ in the absence of an explicit variable. You can still type $_ if it makes your code clearer to you, but it's often

unnecessary.

Many of Perl's scalar operators (including chr, ord, lc, length, reverse, and uc) work on the default scalar variable if you

do not provide an alternative. For example, the chomp builtin removes any trailing newline sequence (technically the contents

of $/; see perldoc -f chomp) from its operand:

my $uncle = "Bob\n";

chomp $uncle;

say "'$uncle'";

$_ behaves the same way in Perl as the pronoun it does in English. Without an explicit variable, chomp removes the trailing

newline sequence from $_. When you write “chomp;“, Perl will always chomp it. These two lines of code are equivalent:

剩余204页未读，继续阅读

__春雪__

粉丝: 9
资源: 20

精通Perl：现代Perl第四版

Modern.Perl.4th.Ed

modern_perl_a4.pdf

Pro jsp 4th editon

LPIC-1 Linux Professional Institute-4th editon

Digital and Analog Communication Systems 5th Editon part3

Computer science 9th editon ppt 第一章

Computer science 9th editon ppt 第三章

C++ Primer (5th Editon) Source for GCC_4_7_0.zip

Computer Networking A Top-Down Approach 6th Editon

Computer Networking: A Top-Down Approach (5th Editon)

最新资源