Perl Programming

Because y is a kind of quoting operator.

The y/// operator is the sed-savvy synonym for tr///. That means y(3) would be like tr(), which would be looking for a second string, as in tr/a-z/A-Z/, tr(a-z)(A-Z), or tr[a-z][A-Z].

False so long as f() returns false, after which it returns true until g() returns true, and then starts the cycle again.

This is scalar not list context, so we have the bistable flip-flop range operator famous in parsing of mail messages, as in `$in_body = /^$/ .. eof()'. Except for the first time f() returns true, g() is entirely ignored, and f() will be ignored while g() later when g() is evaluated. Double dot is the inclusive range operator, f() and g() will both be evaluated on the same record. If you don't want that to happen, the exclusive range operator, triple dots, can be used instead. For extra credit, describe this:

$bingo = ( a() .. b() ) ... ( c() .. d() );

0

A defined (but false) 0 value is the proper indication of the end of file for read() and sysread().

Because you can inspect the argument count, return context, and object types all by yourself.

In Perl, the number of arguments is trivially available to a function via the scalar sense of @_, the return context via wantarray(), and the types of the arguments via ref() if they're references and simple pattern matching like /^d+$/ otherwise. In languages like C++ where you can't do this, you simply must resort to overloading of functions.

$cur->new()->{LINK}

The indirect object syntax only has a single token lookahead. That means if new() is a method, it only grabs the very next token, not the entire following expression.

This is why `new $obj[23] arg' does't work, as well as why `print $fh[23] "stuffn"' does't work. Mixing notations between the OO and IO notations is perilous. If you always use arrow syntax for method calls, and nothing else, you'll not be surprised.

open(IN, "<name_file")

or die "Couldn't open file for processing: $!";

while (<IN>) {

chomp;

$hash_table{$_} = 0;

}

close IN;

print "$_ = $hash_table{$_}n" foreach keys %hash_table;

The second would match Foo other than at the start of the record if $* were set.

The deprecated $* flag does double duty, filling the roles of both /s and /m. By using /s, you suppress any settings of that spooky variable, and force your carets and dollars to match only at the ends of the string and not at ends of line as well -- just as they would if $* weren't set at all.

The undefined value in scalar context, and the empty list value () in list context.

This way functions that wish to return failure can just use a simple return without worrying about the context in which they were called.

$@array

Yes. Perl can make a scalar or hash type reference by using backslash operator.

For example

$str = "here we go"; # a scalar variable

$strref = $str; # a reference to a scalar

@array = (1..10); # an array

$arrayref = @array; # a reference to an array

Note that the reference itself is a scalar.

5

length() is a built-in prototyped as sub length($), and a scalar prototype silently changes aggregates into radically different forms. The scalar sense of a hash is false (0) if it's empty, otherwise it's a string representing the fullness of the buckets, like "18/32" or "39/64". The length of that string is likely to be 5. Likewise, `length(@a)' would be 2 if there were 37 elements in @a.

There are a number of ways to dereference a reference.

Using two dollar signs to dereference a scalar.

$original = $$strref;

Using @ sign to dereference an array.

@list = @$arrayref;

Similar for hashes.

The second is disallowed under `use strict "refs"'.

Dereferencing a string with *{"STR"} is disallowed under the refs stricture, although *{STR} would not be. This is similar in spirit to the way ${"STR"} is always the symbol table variable, while ${STR} may be the lexical variable. If it's not a bareword, you're playing with the symbol table in a particular dynamic fashion.

Once you have the libwww-perl library, LWP.pm installed, the code is this:

#!/usr/bin/perl

use LWP::Simple;

$url = get 'http://www.websitename.com/';

perl -pi.bak -e 's/t/,/g' myfile.txt

#!/usr/bin/perl -w

@homeRunHitters = ('McGwire', 'Sosa', 'Maris', 'Ruth');

foreach (@homeRunHitters) {

print "$_ hit a lot of home runs in one yearn";

}

Method #1 - using Perl's dot operator:

$name = 'checkbook';

$filename = "/tmp/" . $name . ".tmp";

Method #2 - using Perl's join function

$name = "checkbook";

$filename = join "", "/tmp/", $name, ".tmp";

Method #3 - usual way of concatenating strings

$filename = "/tmp/${name}.tmp";

When your caller was in the middle for a while(m//g) loop

The /g state on a global variable is not protected by running local on it. That'll teach you to stop using locals. Too bad $_ can't be the target of a my() -- yet.

With Perl, command-line arguments are stored in the array named @ARGV.

$ARGV[0] contains the first argument, $ARGV[1] contains the second argument, etc.

$#ARGV is the subscript of the last element of the @ARGV array, so the number of arguments on the command line is $#ARGV + 1.

Here's a simple program:

#!/usr/bin/perl

$numArgs = $#ARGV + 1;

print "thanks, you gave me $numArgs command-line arguments.n";

foreach $argnum (0 .. $#ARGV) {

print "$ARGV[$argnum]n";

}