perlintro.pdf

(81 KB) Pobierz
Perl version 5.22.0 documentation - perlintro
NAME
perlintro -- a brief introduction and overview of Perl
DESCRIPTION
This document is intended to give you a quick overview of the Perl programming language, along with
pointers to further documentation. It is intended as a "bootstrap" guide for those who are new to the
language, and provides just enough information for you to be able to read other peoples' Perl and
understand roughly what it's doing, or write your own simple scripts.
This introductory document does not aim to be complete. It does not even aim to be entirely accurate.
In some cases perfection has been sacrificed in the goal of getting the general idea across. You are
strongly
advised to follow this introduction with more information from the full Perl manual, the table of
contents to which can be found in
perltoc.
Throughout this document you'll see references to other parts of the Perl documentation. You can
read that documentation using the
perldoc
command or whatever method you're using to read this
document.
Throughout Perl's documentation, you'll find numerous examples intended to help explain the
discussed features. Please keep in mind that many of them are code fragments rather than complete
programs.
These examples often reflect the style and preference of the author of that piece of the
documentation, and may be briefer than a corresponding line of code in a real program. Except where
otherwise noted, you should assume that
use strict
and
use warnings
statements appear
earlier in the "program", and that any variables used have already been declared, even if those
declarations have been omitted to make the example easier to read.
Do note that the examples have been written by many different authors over a period of several
decades. Styles and techniques will therefore differ, although some effort has been made to not vary
styles too widely in the same sections. Do not consider one style to be better than others - "There's
More Than One Way To Do It" is one of Perl's mottos. After all, in your journey as a programmer, you
are likely to encounter different styles.
What is Perl?
Perl is a general-purpose programming language originally developed for text manipulation and now
used for a wide range of tasks including system administration, web development, network
programming, GUI development, and more.
The language is intended to be practical (easy to use, efficient, complete) rather than beautiful (tiny,
elegant, minimal). Its major features are that it's easy to use, supports both procedural and
object-oriented (OO) programming, has powerful built-in support for text processing, and has one of
the world's most impressive collections of third-party modules.
Different definitions of Perl are given in
perl, perlfaq1
and no doubt other places. From this we can
determine that Perl is different things to different people, but that lots of people think it's at least worth
writing about.
Running Perl programs
To run a Perl program from the Unix command line:
perl progname.pl
Alternatively, put this as the first line of your script:
#!/usr/bin/env perl
... and run the script as
/path/to/script.pl.
Of course, it'll need to be executable first, so
chmod 755
http://perldoc.perl.org
Page 1
Perl version 5.22.0 documentation - perlintro
script.pl
(under Unix).
(This start line assumes you have the
env
program. You can also put directly the path to your perl
executable, like in
#!/usr/bin/perl).
For more information, including instructions for other platforms such as Windows and Mac OS, read
perlrun.
Safety net
Perl by default is very forgiving. In order to make it more robust it is recommended to start every
program with the following lines:
#!/usr/bin/perl
use strict;
use warnings;
The two additional lines request from perl to catch various common problems in your code. They
check different things so you need both. A potential problem caught by
use strict;
will cause your
code to stop immediately when it is encountered, while
use warnings;
will merely give a warning
(like the command-line switch
-w)
and let your code run. To read more about them check their
respective manual pages at
strict
and
warnings.
Basic syntax overview
A Perl script or program consists of one or more statements. These statements are simply written in
the script in a straightforward fashion. There is no need to have a
main()
function or anything of that
kind.
Perl statements end in a semi-colon:
print "Hello, world";
Comments start with a hash symbol and run to the end of the line
# This is a comment
Whitespace is irrelevant:
print
"Hello, world"
;
... except inside quoted strings:
# this would print with a linebreak in the middle
print "Hello
world";
Double quotes or single quotes may be used around literal strings:
print "Hello, world";
print 'Hello, world';
However, only double quotes "interpolate" variables and special characters such as newlines (\n):
print "Hello, $name\n";
print 'Hello, $name\n';
# works fine
# prints $name\n literally
http://perldoc.perl.org
Page 2
Perl version 5.22.0 documentation - perlintro
Numbers don't need quotes around them:
print 42;
You can use parentheses for functions' arguments or omit them according to your personal taste.
They are only required occasionally to clarify issues of precedence.
print("Hello, world\n");
print "Hello, world\n";
More detailed information about Perl syntax can be found in
perlsyn.
Perl variable types
Perl has three main variable types: scalars, arrays, and hashes.
Scalars
A scalar represents a single value:
my $animal = "camel";
my $answer = 42;
Scalar values can be strings, integers or floating point numbers, and Perl will automatically
convert between them as required. There is no need to pre-declare your variable types, but
you have to declare them using the
my
keyword the first time you use them. (This is one of the
requirements of
use strict;.)
Scalar values can be used in various ways:
print $animal;
print "The animal is $animal\n";
print "The square of $answer is ", $answer * $answer, "\n";
There are a number of "magic" scalars with names that look like punctuation or line noise.
These special variables are used for all kinds of purposes, and are documented in
perlvar.
The only one you need to know about for now is
$_
which is the "default variable". It's used as
the default argument to a number of functions in Perl, and it's set implicitly by certain looping
constructs.
print;
Arrays
An array represents a list of values:
my @animals = ("camel", "llama", "owl");
my @numbers = (23, 42, 69);
my @mixed
= ("camel", 42, 1.23);
Arrays are zero-indexed. Here's how you get at elements in an array:
print $animals[0];
print $animals[1];
# prints "camel"
# prints "llama"
# prints contents of $_ by default
The special variable
$#array
tells you the index of the last element of an array:
print $mixed[$#mixed];
# last element, prints 1.23
You might be tempted to use
$#array + 1
to tell you how many items there are in an array.
Don't bother. As it happens, using
@array
where Perl expects to find a scalar value ("in
scalar context") will give you the number of elements in the array:
if (@animals < 5) { ... }
http://perldoc.perl.org
Page 3
Perl version 5.22.0 documentation - perlintro
The elements we're getting from the array start with a
$
because we're getting just a single
value out of the array; you ask for a scalar, you get a scalar.
To get multiple values from an array:
@animals[0,1];
@animals[0..2];
@animals[1..$#animals];
This is called an "array slice".
You can do various useful things to lists:
my @sorted
= sort @animals;
my @backwards = reverse @numbers;
There are a couple of special arrays too, such as
@ARGV
(the command line arguments to your
script) and
@_
(the arguments passed to a subroutine). These are documented in
perlvar.
Hashes
A hash represents a set of key/value pairs:
my %fruit_color = ("apple", "red", "banana", "yellow");
You can use whitespace and the
=>
operator to lay them out more nicely:
my %fruit_color = (
apple => "red",
banana => "yellow",
);
To get at hash elements:
$fruit_color{"apple"};
# gives "red"
# gives ("camel", "llama");
# gives ("camel", "llama", "owl");
# gives all except the first element
You can get at lists of keys and values with
keys()
and
values().
my @fruits = keys %fruit_colors;
my @colors = values %fruit_colors;
Hashes have no particular internal order, though you can sort the keys and loop through them.
Just like special scalars and arrays, there are also special hashes. The most well known of
these is
%ENV
which contains environment variables. Read all about it (and other special
variables) in
perlvar.
Scalars, arrays and hashes are documented more fully in
perldata.
More complex data types can be constructed using references, which allow you to build lists and
hashes within lists and hashes.
A reference is a scalar value and can refer to any other Perl data type. So by storing a reference as
the value of an array or hash element, you can easily create lists and hashes within lists and hashes.
The following example shows a 2 level hash of hash structure using anonymous hash references.
my $variables = {
scalar => {
description => "single item",
sigil => '$',
},
{
description => "ordered list of items",
sigil => '@',
Page 4
array
=>
http://perldoc.perl.org
Perl version 5.22.0 documentation - perlintro
hash
=>
},
{
description => "key/value pairs",
sigil => '%',
},
};
print "Scalars begin with a $variables->{'scalar'}->{'sigil'}\n";
Exhaustive information on the topic of references can be found in
perlreftut, perllol, perlref
and
perldsc
.
Variable scoping
Throughout the previous section all the examples have used the syntax:
my $var = "value";
The
my
is actually not required; you could just use:
$var = "value";
However, the above usage will create global variables throughout your program, which is bad
programming practice.
my
creates lexically scoped variables instead. The variables are scoped to the
block (i.e. a bunch of statements surrounded by curly-braces) in which they are defined.
my $x = "foo";
my $some_condition = 1;
if ($some_condition) {
my $y = "bar";
print $x;
# prints "foo"
print $y;
# prints "bar"
}
print $x;
# prints "foo"
print $y;
# prints nothing; $y has fallen out of scope
Using
my
in combination with a
use strict;
at the top of your Perl scripts means that the
interpreter will pick up certain common programming errors. For instance, in the example above, the
final
print $y
would cause a compile-time error and prevent you from running the program. Using
strict
is highly recommended.
Conditional and looping constructs
Perl has most of the usual conditional and looping constructs. As of Perl 5.10, it even has a
case/switch statement (spelled
given/when).
See
"Switch Statements" in perlsyn
for more details.
The conditions can be any Perl expression. See the list of operators in the next section for information
on comparison and boolean logic operators, which are commonly used in conditional statements.
if
if ( condition ) {
...
} elsif ( other condition ) {
...
} else {
...
}
http://perldoc.perl.org
Page 5

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin