diff options
Diffstat (limited to 'Master/tlpkg/tlperl/lib/pods/perlintro.pod')
-rw-r--r-- | Master/tlpkg/tlperl/lib/pods/perlintro.pod | 700 |
1 files changed, 0 insertions, 700 deletions
diff --git a/Master/tlpkg/tlperl/lib/pods/perlintro.pod b/Master/tlpkg/tlperl/lib/pods/perlintro.pod deleted file mode 100644 index afce360a2ac..00000000000 --- a/Master/tlpkg/tlperl/lib/pods/perlintro.pod +++ /dev/null @@ -1,700 +0,0 @@ -=head1 NAME - -perlintro -- a brief introduction and overview of Perl - -=head1 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 -I<strongly> advised to follow this introduction with more information -from the full Perl manual, the table of contents to which can be found -in L<perltoc>. - -Throughout this document you'll see references to other parts of the -Perl documentation. You can read that documentation using the C<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 C<use strict> and C<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. - -=head2 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 L<perl>, L<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. - -=head2 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 C</path/to/script.pl>. Of course, it'll need -to be executable first, so C<chmod 755 script.pl> (under Unix). - -(This start line assumes you have the B<env> program. You can also put -directly the path to your perl executable, like in C<#!/usr/bin/perl>). - -For more information, including instructions for other platforms such as -Windows and Mac OS, read L<perlrun>. - -=head2 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 C<use strict;> will cause your code to stop -immediately when it is encountered, while C<use warnings;> will merely -give a warning (like the command-line switch B<-w>) and let your code run. -To read more about them check their respective manual pages at L<strict> -and L<warnings>. - -=head2 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 C<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 (C<\n>): - - print "Hello, $name\n"; # works fine - print 'Hello, $name\n'; # prints $name\n literally - -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 L<perlsyn>. - -=head2 Perl variable types - -Perl has three main variable types: scalars, arrays, and hashes. - -=over 4 - -=item 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 C<my> keyword the first time you use them. (This is one of the -requirements of C<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 L<perlvar>. The only one you -need to know about for now is C<$_> 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; # prints contents of $_ by default - -=item 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]; # prints "camel" - print $animals[1]; # prints "llama" - -The special variable C<$#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 C<$#array + 1> to tell you how many items there -are in an array. Don't bother. As it happens, using C<@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) { ... } - -The elements we're getting from the array start with a C<$> 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]; # gives ("camel", "llama"); - @animals[0..2]; # gives ("camel", "llama", "owl"); - @animals[1..$#animals]; # gives all except the first element - -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 C<@ARGV> (the command -line arguments to your script) and C<@_> (the arguments passed to a -subroutine). These are documented in L<perlvar>. - -=item Hashes - -A hash represents a set of key/value pairs: - - my %fruit_color = ("apple", "red", "banana", "yellow"); - -You can use whitespace and the C<< => >> operator to lay them out more -nicely: - - my %fruit_color = ( - apple => "red", - banana => "yellow", - ); - -To get at hash elements: - - $fruit_color{"apple"}; # gives "red" - -You can get at lists of keys and values with C<keys()> and -C<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 C<%ENV> which contains environment -variables. Read all about it (and other special variables) in -L<perlvar>. - -=back - -Scalars, arrays and hashes are documented more fully in L<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 => '$', - }, - array => { - description => "ordered list of items", - sigil => '@', - }, - 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 -L<perlreftut>, L<perllol>, L<perlref> and L<perldsc>. - -=head2 Variable scoping - -Throughout the previous section all the examples have used the syntax: - - my $var = "value"; - -The C<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. C<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 C<my> in combination with a C<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 -C<print $y> would cause a compile-time error and prevent you from -running the program. Using C<strict> is highly recommended. - -=head2 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 C<given>/C<when>). See -L<perlsyn/"Switch Statements"> 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. - -=over 4 - -=item if - - if ( condition ) { - ... - } elsif ( other condition ) { - ... - } else { - ... - } - -There's also a negated version of it: - - unless ( condition ) { - ... - } - -This is provided as a more readable version of C<if (!I<condition>)>. - -Note that the braces are required in Perl, even if you've only got one -line in the block. However, there is a clever way of making your one-line -conditional blocks more English like: - - # the traditional way - if ($zippy) { - print "Yow!"; - } - - # the Perlish post-condition way - print "Yow!" if $zippy; - print "We have no bananas" unless $bananas; - -=item while - - while ( condition ) { - ... - } - -There's also a negated version, for the same reason we have C<unless>: - - until ( condition ) { - ... - } - -You can also use C<while> in a post-condition: - - print "LA LA LA\n" while 1; # loops forever - -=item for - -Exactly like C: - - for ($i = 0; $i <= $max; $i++) { - ... - } - -The C style for loop is rarely needed in Perl since Perl provides -the more friendly list scanning C<foreach> loop. - -=item foreach - - foreach (@array) { - print "This element is $_\n"; - } - - print $list[$_] foreach 0 .. $max; - - # you don't have to use the default $_ either... - foreach my $key (keys %hash) { - print "The value of $key is $hash{$key}\n"; - } - -The C<foreach> keyword is actually a synonym for the C<for> -keyword. See C<L<perlsyn/"Foreach Loops">>. - -=back - -For more detail on looping constructs (and some that weren't mentioned in -this overview) see L<perlsyn>. - -=head2 Builtin operators and functions - -Perl comes with a wide selection of builtin functions. Some of the ones -we've already seen include C<print>, C<sort> and C<reverse>. A list of -them is given at the start of L<perlfunc> and you can easily read -about any given function by using C<perldoc -f I<functionname>>. - -Perl operators are documented in full in L<perlop>, but here are a few -of the most common ones: - -=over 4 - -=item Arithmetic - - + addition - - subtraction - * multiplication - / division - -=item Numeric comparison - - == equality - != inequality - < less than - > greater than - <= less than or equal - >= greater than or equal - -=item String comparison - - eq equality - ne inequality - lt less than - gt greater than - le less than or equal - ge greater than or equal - -(Why do we have separate numeric and string comparisons? Because we don't -have special variable types, and Perl needs to know whether to sort -numerically (where 99 is less than 100) or alphabetically (where 100 comes -before 99). - -=item Boolean logic - - && and - || or - ! not - -(C<and>, C<or> and C<not> aren't just in the above table as descriptions -of the operators. They're also supported as operators in their own -right. They're more readable than the C-style operators, but have -different precedence to C<&&> and friends. Check L<perlop> for more -detail.) - -=item Miscellaneous - - = assignment - . string concatenation - x string multiplication - .. range operator (creates a list of numbers) - -=back - -Many operators can be combined with a C<=> as follows: - - $a += 1; # same as $a = $a + 1 - $a -= 1; # same as $a = $a - 1 - $a .= "\n"; # same as $a = $a . "\n"; - -=head2 Files and I/O - -You can open a file for input or output using the C<open()> function. -It's documented in extravagant detail in L<perlfunc> and L<perlopentut>, -but in short: - - open(my $in, "<", "input.txt") or die "Can't open input.txt: $!"; - open(my $out, ">", "output.txt") or die "Can't open output.txt: $!"; - open(my $log, ">>", "my.log") or die "Can't open my.log: $!"; - -You can read from an open filehandle using the C<< <> >> operator. In -scalar context it reads a single line from the filehandle, and in list -context it reads the whole file in, assigning each line to an element of -the list: - - my $line = <$in>; - my @lines = <$in>; - -Reading in the whole file at one time is called slurping. It can -be useful but it may be a memory hog. Most text file processing -can be done a line at a time with Perl's looping constructs. - -The C<< <> >> operator is most often seen in a C<while> loop: - - while (<$in>) { # assigns each line in turn to $_ - print "Just read in this line: $_"; - } - -We've already seen how to print to standard output using C<print()>. -However, C<print()> can also take an optional first argument specifying -which filehandle to print to: - - print STDERR "This is your final warning.\n"; - print $out $record; - print $log $logmessage; - -When you're done with your filehandles, you should C<close()> them -(though to be honest, Perl will clean up after you if you forget): - - close $in or die "$in: $!"; - -=head2 Regular expressions - -Perl's regular expression support is both broad and deep, and is the -subject of lengthy documentation in L<perlrequick>, L<perlretut>, and -elsewhere. However, in short: - -=over 4 - -=item Simple matching - - if (/foo/) { ... } # true if $_ contains "foo" - if ($a =~ /foo/) { ... } # true if $a contains "foo" - -The C<//> matching operator is documented in L<perlop>. It operates on -C<$_> by default, or can be bound to another variable using the C<=~> -binding operator (also documented in L<perlop>). - -=item Simple substitution - - s/foo/bar/; # replaces foo with bar in $_ - $a =~ s/foo/bar/; # replaces foo with bar in $a - $a =~ s/foo/bar/g; # replaces ALL INSTANCES of foo with bar in $a - -The C<s///> substitution operator is documented in L<perlop>. - -=item More complex regular expressions - -You don't just have to match on fixed strings. In fact, you can match -on just about anything you could dream of by using more complex regular -expressions. These are documented at great length in L<perlre>, but for -the meantime, here's a quick cheat sheet: - - . a single character - \s a whitespace character (space, tab, newline, ...) - \S non-whitespace character - \d a digit (0-9) - \D a non-digit - \w a word character (a-z, A-Z, 0-9, _) - \W a non-word character - [aeiou] matches a single character in the given set - [^aeiou] matches a single character outside the given set - (foo|bar|baz) matches any of the alternatives specified - - ^ start of string - $ end of string - -Quantifiers can be used to specify how many of the previous thing you -want to match on, where "thing" means either a literal character, one -of the metacharacters listed above, or a group of characters or -metacharacters in parentheses. - - * zero or more of the previous thing - + one or more of the previous thing - ? zero or one of the previous thing - {3} matches exactly 3 of the previous thing - {3,6} matches between 3 and 6 of the previous thing - {3,} matches 3 or more of the previous thing - -Some brief examples: - - /^\d+/ string starts with one or more digits - /^$/ nothing in the string (start and end are adjacent) - /(\d\s){3}/ a three digits, each followed by a whitespace - character (eg "3 4 5 ") - /(a.)+/ matches a string in which every odd-numbered letter - is a (eg "abacadaf") - - # This loop reads from STDIN, and prints non-blank lines: - while (<>) { - next if /^$/; - print; - } - -=item Parentheses for capturing - -As well as grouping, parentheses serve a second purpose. They can be -used to capture the results of parts of the regexp match for later use. -The results end up in C<$1>, C<$2> and so on. - - # a cheap and nasty way to break an email address up into parts - - if ($email =~ /([^@]+)@(.+)/) { - print "Username is $1\n"; - print "Hostname is $2\n"; - } - -=item Other regexp features - -Perl regexps also support backreferences, lookaheads, and all kinds of -other complex details. Read all about them in L<perlrequick>, -L<perlretut>, and L<perlre>. - -=back - -=head2 Writing subroutines - -Writing subroutines is easy: - - sub logger { - my $logmessage = shift; - open my $logfile, ">>", "my.log" or die "Could not open my.log: $!"; - print $logfile $logmessage; - } - -Now we can use the subroutine just as any other built-in function: - - logger("We have a logger subroutine!"); - -What's that C<shift>? Well, the arguments to a subroutine are available -to us as a special array called C<@_> (see L<perlvar> for more on that). -The default argument to the C<shift> function just happens to be C<@_>. -So C<my $logmessage = shift;> shifts the first item off the list of -arguments and assigns it to C<$logmessage>. - -We can manipulate C<@_> in other ways too: - - my ($logmessage, $priority) = @_; # common - my $logmessage = $_[0]; # uncommon, and ugly - -Subroutines can also return values: - - sub square { - my $num = shift; - my $result = $num * $num; - return $result; - } - -Then use it like: - - $sq = square(8); - -For more information on writing subroutines, see L<perlsub>. - -=head2 OO Perl - -OO Perl is relatively simple and is implemented using references which -know what sort of object they are based on Perl's concept of packages. -However, OO Perl is largely beyond the scope of this document. -Read L<perlootut> and L<perlobj>. - -As a beginning Perl programmer, your most common use of OO Perl will be -in using third-party modules, which are documented below. - -=head2 Using Perl modules - -Perl modules provide a range of features to help you avoid reinventing -the wheel, and can be downloaded from CPAN ( http://www.cpan.org/ ). A -number of popular modules are included with the Perl distribution -itself. - -Categories of modules range from text manipulation to network protocols -to database integration to graphics. A categorized list of modules is -also available from CPAN. - -To learn how to install modules you download from CPAN, read -L<perlmodinstall>. - -To learn how to use a particular module, use C<perldoc I<Module::Name>>. -Typically you will want to C<use I<Module::Name>>, which will then give -you access to exported functions or an OO interface to the module. - -L<perlfaq> contains questions and answers related to many common -tasks, and often provides suggestions for good CPAN modules to use. - -L<perlmod> describes Perl modules in general. L<perlmodlib> lists the -modules which came with your Perl installation. - -If you feel the urge to write Perl modules, L<perlnewmod> will give you -good advice. - -=head1 AUTHOR - -Kirrily "Skud" Robert <skud@cpan.org> |