[6323] in Perl-Users-Digest
Perl-Users Digest, Issue: 945 Volume: 7
daemon@ATHENA.MIT.EDU (Perl-Users Digest)
Thu Feb 13 23:07:17 1997
Date: Thu, 13 Feb 97 20:01:29 -0800
From: Perl-Users Digest <Perl-Users-Request@ruby.OCE.ORST.EDU>
To: Perl-Users@ruby.OCE.ORST.EDU (Perl-Users Digest)
Perl-Users Digest Thu, 13 Feb 1997 Volume: 7 Number: 945
Today's topics:
Re: Q: how best to share a hash between packages (Mark Daku)
Re: Randal trashed yet again--*sigh* <philip@remove.crl.com>
Re: Reading files in a directory and printing to one tx (Nathan V. Patwardhan)
regex in context <mstearns@darkwing.uoregon.edu>
Re: search engines like infoseek <rootbeer@teleport.com>
Solaris 2.5 with perl ver.5 <robert@tnet.es>
Re: Stumped on INPUT_RECORD_SEPARATER problem - please <rootbeer@teleport.com>
upper to lowercase replace (Michael Paul Stearns)
Re: Using Perl to get LAst Modified Dates (brian d foy)
Digest Administrivia (Last modified: 8 Jan 97) (Perl-Users-Digest Admin)
----------------------------------------------------------------------
Date: 13 Feb 1997 20:27:42 -0500
From: daku@nortel.ca (Mark Daku)
Subject: Re: Q: how best to share a hash between packages
Message-Id: <esqbu9ofa7l.fsf@nortel.ca>
greg@iweb.net (Greg Haygood) writes:
> hi, all
>
> i'm rewriting a CGI/perl application i wrote a while back . the
> basics of the app are that it's composed of a number of scripts, which
> share a bunch of code. previously, this shared code was partly
> bundled in a 'util.pl' script, and the rest was, sadly, duplicated
> among the different pieces of the app. this "structure" just
> followed the code writing, with no real pre-planning involved.
> anyway, i'm going back over the code to modularize and condense the
> pieces.
>
> so now i have a decent module which each main script calls for
> subroutines and variables. the problem is that i really want to add a
> hash to the variables which are exported. this is because each script
> does a lot of work with one or two hashes currently, but would benefit
> from this package'd hash(es), since both the scripts and the modules
> subroutines access this hash.
>
So let me get this straight. You are try to share a hash from a module.
Well that's staright forward you are on the right track. But what it
appears to you want to do is actually share the data in the hash between to
completely seperate processes. Even worse I suspect you want to share the
data in real time. I hope I'm wrong in the way I read you post.
OPTIONS: If you want to share realtime dat between 2 distinct processes.
ipc
socket
flatfile with mdate polling.
database polling.
Some strange event notification system like XAtoms event watching.
etc.
=================================
AGAIN the quick and dirty way to pass around a hash.
sub func1 {
my (*localhash) = @_;
.code.
}
my (%globalhash);
$globalhash{one} = 1;
$globalhash{two} = 2;
func1(*globalhash);
=================================
The best place to look is in the man pages that come with your perl dist.
The 2 pages that pop up are:
perlref - Perl references and nested data structures
perldsc - Perl Data Structures Cookbook
I'm about to do a big NONO. Here is that man page for perlref.
==================================
NAME
perlref - Perl references and nested data structures
DESCRIPTION
Before release 5 of Perl it was difficult to represent complex
data structures, because all references had to be symbolic,
and even that was difficult to do when you wanted to refer to
a variable rather than a symbol table entry. Perl not only
makes it easier to use symbolic references to variables, but
lets you have ``hard'' references to any piece of data. Any
scalar may hold a hard reference. Because arrays and hashes
contain scalars, you can now easily build arrays of arrays,
arrays of hashes, hashes of arrays, arrays of hashes of
functions, and so on.
Hard references are smart--they keep track of reference
counts for you, automatically freeing the thing referred to
when its reference count goes to zero. (Note: The reference
counts for values in self-referential or cyclic data structures
may not go to zero without a little help; see ``Two-Phased
Garbage Collection'' for a detailed explanation. If that thing
happens to be an object, the object is destructed. See the
perlobj manpage for more about objects. (In a sense,
everything in Perl is an object, but we usually reserve the
word for references to objects that have been officially
``blessed'' into a class package.)
A symbolic reference contains the name of a variable, just as
a symbolic link in the filesystem contains merely the name of a
file. The *glob notation is a kind of symbolic reference. Hard
references are more like hard links in the file system: merely
another way at getting at the same underlying object,
irrespective of its name.
``Hard'' references are easy to use in Perl. There is just one
overriding principle: Perl does no implicit referencing or
dereferencing. When a scalar is holding a reference, it always
behaves as a scalar. It doesn't magically start being an array
or a hash unless you tell it so explicitly by dereferencing it.
References can be constructed several ways.
1.By using the backslash operator on a variable,
subroutine, or value. (This works much like the &
(address-of) operator works in C.) Note that this
typically creates ANOTHER reference to a variable,
because there's already a reference to the variable in
the symbol table. But the symbol table reference might
go away, and you'll still have the reference that the
backslash returned. Here are some examples:
$scalarref = \$foo;
$arrayref = \@ARGV;
$hashref = \%ENV;
$coderef = \&handler;
$globref = \*foo;
It isn't possible to create a true reference to an IO
handle (filehandle or dirhandle) using the backslash
operator. See the explanation of the *foo{THING}
syntax below. (However, you're apt to find Perl code
out there using globrefs as though they were IO
handles, which is grandfathered into continued
functioning.)
2.A reference to an anonymous array can be
constructed using square brackets:
$arrayref = [1, 2, ['a', 'b', 'c']];
Here we've constructed a reference to an anonymous
array of three elements whose final element is itself
reference to another anonymous array of three
elements. (The multidimensional syntax described later
can be used to access this. For example, after the
above, $arrayref->[2][1] would have the value
``b''.)
Note that taking a reference to an enumerated list is
not the same as using square brackets--instead it's
the same as creating a list of references!
@list = (\$a, \@b, \%c);
@list = \($a, @b, %c); # same thing!
As a special case, \(@foo) returns a list of references
to the contents of @foo, not a reference to @foo itself.
Likewise for %foo.
3.A reference to an anonymous hash can be constructed
using curly brackets:
$hashref = {
'Adam' => 'Eve',
'Clyde' => 'Bonnie',
};
Anonymous hash and array constructors can be
intermixed freely to produce as complicated a structure
as you want. The multidimensional syntax described
below works for these too. The values above are
literals, but variables and expressions would work just
as well, because assignment operators in Perl (even
within local() or my() ) are executable statements, not
compile-time declarations.
Because curly brackets (braces) are used for several
other things including BLOCKs, you may occasionally
have to disambiguate braces at the beginning of a
statement by putting a + or a return in front so that Perl
realizes the opening brace isn't starting a BLOCK. The
economy and mnemonic value of using curlies is
deemed worth this occasional extra hassle.
For example, if you wanted a function to make a new
hash and return a reference to it, you have these
options:
sub hashem { { @_ } } # silently wrong
sub hashem { +{ @_ } } # ok
sub hashem { return { @_ } } # ok
4.A reference to an anonymous subroutine can be
constructed by using sub without a subname:
$coderef = sub { print "Boink!\n" };
Note the presence of the semicolon. Except for the fact
that the code inside isn't executed immediately, a sub
{} is not so much a declaration as it is an operator, like
do{} or eval{} . (However, no matter how many times
you execute that line (unless you're in an eval(``...'') ),
$coderef will still have a reference to the SAME
anonymous subroutine.)
Anonymous subroutines act as closures with respect to
my() variables, that is, variables visible lexically within
the current scope. Closure is a notion out of the Lisp
world that says if you define an anonymous function in
a particular lexical context, it pretends to run in that
context even when it's called outside of the context.
In human terms, it's a funny way of passing arguments
to a subroutine when you define it as well as when you
call it. It's useful for setting up little bits of code to run
later, such as callbacks. You can even do
object-oriented stuff with it, though Perl provides a
different mechanism to do that already--see the
perlobj manpage .
You can also think of closure as a way to write a
subroutine template without using eval. (In fact, in
version 5.000, eval was the only way to get closures.
You may wish to use ``require 5.001'' if you use
closures.)
Here's a small example of how closures works:
sub newprint {
my $x = shift;
return sub { my $y = shift; print "$x, $y!\n"; };
}
$h = newprint("Howdy");
$g = newprint("Greetings");
# Time passes...
&$h("world");
&$g("earthlings");
This prints
Howdy, world!
Greetings, earthlings!
Note particularly that $x continues to refer to the value
passed into newprint() despite the fact that the ``my $x''
has seemingly gone out of scope by the time the
anonymous subroutine runs. That's what closure is all
about.
This applies to only lexical variables, by the way.
Dynamic variables continue to work as they have
always worked. Closure is not something that most Perl
programmers need trouble themselves about to begin
with.
5.References are often returned by special subroutines
called constructors. Perl objects are just references to
a special kind of object that happens to know which
package it's associated with. Constructors are just
special subroutines that know how to create that
association. They do so by starting with an ordinary
reference, and it remains an ordinary reference even
while it's also being an object. Constructors are
customarily named new(), but don't have to be:
$objref = new Doggie (Tail => 'short', Ears => 'long');
6.References of the appropriate type can spring into
existence if you dereference them in a context that
assumes they exist. Because we haven't talked about
dereferencing yet, we can't show you any examples
yet.
7.A reference can be created by using a special syntax,
lovingly known as the *foo{THING} syntax. *foo{THING}
returns a reference to the THING slot in *foo (which is
the symbol table entry which holds everything known
as foo).
$scalarref = *foo{SCALAR};
$arrayref = *ARGV{ARRAY};
$hashref = *ENV{HASH};
$coderef = *handler{CODE};
$ioref = *STDIN{IO};
$globref = *foo{GLOB};
All of these are self-explanatory except for *foo{IO}. It
returns the IO handle, used for file handles ( open ),
sockets ( socket and socketpair ), and directory
handles ( opendir ). For compatibility with previous
versions of Perl, *foo{FILEHANDLE} is a synonym for
*foo{IO}.
*foo{THING} returns undef if that particular THING
hasn't been used yet, except in the case of scalars.
*foo{SCALAR} returns a reference to an anonymous
scalar if $foo hasn't been used yet. This might change
in a future release.
The use of *foo{IO} is the best way to pass bareword
filehandles into or out of subroutines, or to store them
in larger data structures.
splutter(*STDOUT{IO});
sub splutter {
my $fh = shift;
print $fh "her um well a hmmm\n";
}
$rec = get_rec(*STDIN{IO});
sub get_rec {
my $fh = shift;
return scalar <$fh>;
}
Beware, though, that you can't do this with a routine
which is going to open the filehandle for you, because
*HANDLE{IO} will be undef if HANDLE hasn't been
used yet. Use \*HANDLE for that sort of thing instead.
Using \*HANDLE (or *HANDLE) is another way to use
and store non-bareword filehandles (before perl
version 5.002 it was the only way). The two methods
are largely interchangeable, you can do
splutter(\*STDOUT);
$rec = get_rec(\*STDIN);
with the above subroutine definitions.
That's it for creating references. By now you're probably dying
toknow how to use references to get back to your long-lost
data. There are several basic methods.
1.Anywhere you'd put an identifier (or chain of
identifiers) as part of a variable or subroutine name,
you can replace the identifier with a simple scalar
variable containing a reference of the correct type:
$bar = $$scalarref;
push(@$arrayref, $filename);
$$arrayref[0] = "January";
$$hashref{"KEY"} = "VALUE";
&$coderef(1,2,3);
print $globref "output\n";
It's important to understand that we are specifically
NOT dereferencing $arrayref[0] or
$hashref{``KEY''} there. The dereference of the
scalar variable happens BEFORE it does any key
lookups. Anything more complicated than a simple
scalar variable must use methods 2 or 3 below.
However, a ``simple scalar'' includes an identifier that
itself uses method 1 recursively. Therefore, the
following prints ``howdy''.
$refrefref = \\\"howdy";
print $$$$refrefref;
2.Anywhere you'd put an identifier (or chain of
identifiers) as part of a variable or subroutine name,
you can replace the identifier with a BLOCK returning
a reference of the correct type. In other words, the
previous examples could be written like this:
$bar = ${$scalarref};
push(@{$arrayref}, $filename);
${$arrayref}[0] = "January";
${$hashref}{"KEY"} = "VALUE";
&{$coderef}(1,2,3);
$globref->print("output\n"); # iff IO::Handle is loaded
Admittedly, it's a little silly to use the curlies in this
case, but the BLOCK can contain any arbitrary
expression, in particular, subscripted expressions:
&{ $dispatch{$index} }(1,2,3); # call correct routine
Because of being able to omit the curlies for the simple
case of $$ x, people often make the mistake of viewing
the dereferencing symbols as proper operators, and
wonder about their precedence. If they were, though,
you could use parentheses instead of braces. That's
not the case. Consider the difference below; case 0 is
a short-hand version of case 1, NOT case 2:
$$hashref{"KEY"} = "VALUE"; # CASE 0
${$hashref}{"KEY"} = "VALUE"; # CASE 1
${$hashref{"KEY"}} = "VALUE"; # CASE 2
${$hashref->{"KEY"}} = "VALUE"; # CASE 3
Case 2 is also deceptive in that you're accessing a
variable called %hashref, not dereferencing through
$hashref to the hash it's presumably referencing. That
would be case 3.
3.The case of individual array elements arises often
enough that it gets cumbersome to use method 2. As a
form of syntactic sugar, the two lines like that above
can be written:
$arrayref->[0] = "January";
$hashref->{"KEY"} = "VALUE";
The left side of the array can be any expression
returning a reference, including a previous
dereference. Note that $array[$x] is NOT the same
thing as $array->[$x] here:
$array[$x]->{"foo"}->[0] = "January";
This is one of the cases we mentioned earlier in which
references could spring into existence when in an
lvalue context. Before this statement, $array[$x] may
have been undefined. If so, it's automatically defined
with a hash reference so that we can look up
{``foo''} in it. Likewise $array[$x]->{``foo''}
will automatically get defined with an array reference
so that we can look up [0] in it.
One more thing here. The arrow is optional BETWEEN
brackets subscripts, so you can shrink the above down
to
$array[$x]{"foo"}[0] = "January";
Which, in the degenerate case of using only ordinary
arrays, gives you multidimensional arrays just like C's:
$score[$x][$y][$z] += 42;
Well, okay, not entirely like C's arrays, actually. C
doesn't know how to grow its arrays on demand. Perl
does.
4.If a reference happens to be a reference to an object,
then there are probably methods to access the things
referred to, and you should probably stick to those
methods unless you're in the class package that
defines the object's methods. In other words, be nice,
and don't violate the object's encapsulation without a
very good reason. Perl does not enforce encapsulation.
We are not totalitarians here. We do expect some basic
civility though.
The ref() operator may be used to determine what type of
thing thereference is pointing to. See the perlfunc manpage .
The bless() operator may be used to associate a reference
with a package functioning as an object class. See the perlobj
manpage .
A typeglob may be dereferenced the same way a reference
can, because the dereference syntax always indicates the
kind of reference desired. So ${*foo} and ${\$foo} both
indicate the same scalar variable.
Here's a trick for interpolating a subroutine call into a string:
print "My sub returned @{[mysub(1,2,3)]} that time.\n";
The way it works is that when the @{...} is seen in the
double-quoted string, it's evaluated as a block. The block
creates a reference to an anonymous array containing the
results of the call to mysub(1,2,3). So the whole block
returns a reference to an array, which is then dereferenced by
@{...} and stuck into the double-quoted string. This
chicanery is also useful for arbitrary expressions:
print "That yields @{[$n + 5]} widgets\n";
Symbolic references
We said that references spring into existence as necessary if
they are undefined, but we didn't say what happens if a value
used as a reference is already defined, but ISN'T a hard
reference. If you use it as a reference in this case, it'll be
treated as a symbolic reference. That is, the value of the
scalar is taken to be the NAME of a variable, rather than a
direct link to a (possibly) anonymous value.
People frequently expect it to work like this. So it does.
$name = "foo";
$$name = 1; # Sets $foo
${$name} = 2; # Sets $foo
${$name x 2} = 3; # Sets $foofoo
$name->[0] = 4; # Sets $foo[0]
@$name = (); # Clears @foo
&$name(); # Calls &foo() (as in Perl 4)
$pack = "THAT";
${"${pack}::$name"} = 5; # Sets $THAT::foo without eval
This is very powerful, and slightly dangerous, in that it's
possible to intend (with the utmost sincerity) to use a hard
reference, and accidentally use a symbolic reference instead.
To protect against that, you can say
use strict 'refs';
and then only hard references will be allowed for the rest of
the enclosing block. An inner block may countermand that
with
no strict 'refs';
Only package variables are visible to symbolic references.
Lexical variables (declared with my() ) aren't in a symbol
table, and thus are invisible to this mechanism. For example:
local($value) = 10;
$ref = \$value;
{
my $value = 20;
print $$ref;
}
This will still print 10, not 20. Remember that local() affects
package variables, which are all ``global'' to the package.
Not-so-symbolic references
A new feature contributing to readability in perl version 5.001
is that the brackets around a symbolic reference behave more
like quotes, just as they always have within a string. That is,
$push = "pop on ";
print "${push}over";
has always meant to print ``pop on over'', despite the fact that
push is a reserved word. This has been generalized to work
the same outside of quotes, so that
print ${push} . "over";
and even
print ${ push } . "over";
will have the same effect. (This would have been a syntax
error in Perl 5.000, though Perl 4 allowed it in the spaceless
form.) Note that this construct is not considered to be a
symbolic reference when you're using strict refs:
use strict 'refs';
${ bareword }; # Okay, means $bareword.
${ "bareword" }; # Error, symbolic reference.
Similarly, because of all the subscripting that is done using
single words, we've applied the same rule to any bareword
that is used for subscripting a hash. So now, instead of writing
$array{ "aaa" }{ "bbb" }{ "ccc" }
you can write just
$array{ aaa }{ bbb }{ ccc }
and not worry about whether the subscripts are reserved
words. In the rare event that you do wish to do something like
$array{ shift }
you can force interpretation as a reserved word by adding
anything that makes it more than a bareword:
$array{ shift() }
$array{ +shift }
$array{ shift @_ }
The -w switch will warn you if it interprets a reserved word as
a string. But it will no longer warn you about using lowercase
words, because the string is effectively quoted.
WARNING
You may not (usefully) use a reference as the key to a hash. It
will be converted into a string:
$x{ \$a } = $a;
If you try to dereference the key, it won't do a hard
dereference, and you won't accomplish what you're
attempting. You might want to do something more like
$r = \@a;
$x{ $r } = $r;
And then at least you can use the values() , which will be real
refs, instead of the keys() , which won't.
SEE ALSO
Besides the obvious documents, source code can be
instructive. Some rather pathological examples of the use of
references can be found in the t/op/ref.t regression test in the
Perl source directory.
See also the perldsc manpage and the perllol manpage for
how to use references to create complex data structures, and
the perlobj manpage for how to use them to create objects.
------------------------------
Date: 14 Feb 1997 01:08:34 GMT
From: Phil Stripling <philip@remove.crl.com>
Subject: Re: Randal trashed yet again--*sigh*
Message-Id: <5e0dui$3hu@nexp.crl.com>
Clinton Pierce <cpierce1@cp501.fsic.ford.com> wrote:
: *sigh* The suits have trashed him yet again. Catch the Feb 3 issue
: of Fortune Magazine. For God's sake don't buy it! Just catch it
: online at:
Just out of idle curiousity, is the mention of Randal Schwartz's
conviction _always_ worth bringing up and publishing world-wide on Usenet
and rubbing his nose in it for those that didn't read it in the magazine?
Or is it just something you do for fun?
--
Phil Stripling |Sorry to make it difficult to reply
The Civilized Explorer |but you know what needs to be removed
http://www.cieux.com/~philip/
------------------------------
Date: 14 Feb 1997 01:48:39 GMT
From: nvp@shore.net (Nathan V. Patwardhan)
Subject: Re: Reading files in a directory and printing to one txt file
Message-Id: <5e0g9n$6ok@fridge-nf0.shore.net>
mohawk@swceweb.com wrote:
: I'm completely new at this and am trying to create a script to read a
: bunch of files in a directory and output them to one txt file.
You might peruse some Perl documentation dealing with opendir(),
closedir(), and readdir().
: Can I get some advice as to how to proceed with this?
: thank you
http://www.perl.com/perl ->follow the links to the Perl documentation.
--
Nathan V. Patwardhan
nvp@shore.net
"What is your quest?"
------------------------------
Date: Thu, 13 Feb 1997 16:34:31 -0800
From: Michael Stearns <mstearns@darkwing.uoregon.edu>
Subject: regex in context
Message-Id: <3303B317.615BDCA6@darkwing.uoregon.edu>
I have many .html pages with "same-page" links that look like:
<a href = "#Setting Up procmail">Setting Up procmail</a>
I want all these to look like:
<a href = "#Setting_Up_procmail">Setting Up procmail</a>
In other words, I want to add underscores (I will change the
corresponding "a name" links.)
I am unsure how to replace only those spaces that fall between
<a href = \"#\w+ and \"> without altering other spaces on the page.
Can anyone tell me how to replace the spaces, but only in the context of
the "a href = #....." lines?
Thanks,
Michael Stearns
University of Oregon
------------------------------
Date: Thu, 13 Feb 1997 15:10:47 -0800
From: Tom Phoenix <rootbeer@teleport.com>
To: David Waters <przec@westminster.ac.uk>
Subject: Re: search engines like infoseek
Message-Id: <Pine.GSO.3.95q.970213150746.15428N-100000@julie.teleport.com>
On 13 Feb 1997, David Waters wrote:
> I was wondering if anyone could tell me how the search engines
> on the web work with regard to only displaying 10 search matches
> at a time.
I think you could use the methods in Randal's second Web Techniques
column, which shows how to do that sort of thing. Hope this helps!
http://www.stonehenge.com/merlyn/WebTechniques/
-- Tom Phoenix http://www.teleport.com/~rootbeer/
rootbeer@teleport.com PGP Skribu al mi per Esperanto!
Randal Schwartz Case: http://www.lightlink.com/fors/
------------------------------
Date: 12 Feb 1997 23:53:16 GMT
From: "robert@tnet.es" <robert@tnet.es>
Subject: Solaris 2.5 with perl ver.5
Message-Id: <5dtl5c$86s$1@diana.ibernet.es>
I am a newbie to the world of Perl and would like to try the "hack".I however
am getting off to a bad start in that I can't seem to get past first base.
I would appreciate it if someone could let me know what I should be answering
to all the questions.My intended use is to learn a lttle and try some basic
"hacks" from Matt and Selena Sol's sites.Could someone let me know if they are
willing to guide me through the experience of getting to where I can type 'make
install'
and it works.
Any help would be appreciated,
Regards,
Robert:-)
------------------------------
Date: Thu, 13 Feb 1997 15:06:55 -0800
From: Tom Phoenix <rootbeer@teleport.com>
To: Mark Hickey <cc42735@hrp6.FMR.com>
Subject: Re: Stumped on INPUT_RECORD_SEPARATER problem - please help
Message-Id: <Pine.GSO.3.95q.970213150104.15428M-100000@julie.teleport.com>
On Wed, 12 Feb 1997, Mark Hickey wrote:
> I tried using various other patterns as the $/, like "\n[ \t\f\r]*\n",
> with and w/o various amounts of quoting, but as soon as I put the "[]"
> in, things fall apart.
That's because $/ is not a pattern. Never has been. If you want to split
input on a pattern, you'll have to split it yourself. It's not hard to do.
I'd make a sub which uses sysread to read blocks until it either reaches
eof or finds your split pattern, then returns what's appropriate and
buffers the rest.
Hope this helps!
-- Tom Phoenix http://www.teleport.com/~rootbeer/
rootbeer@teleport.com PGP Skribu al mi per Esperanto!
Randal Schwartz Case: http://www.lightlink.com/fors/
------------------------------
Date: 14 Feb 1997 03:07:13 GMT
From: mstearns@darkwing.uoregon.edu (Michael Paul Stearns)
Subject: upper to lowercase replace
Message-Id: <5e0kt1$egd@pith.uoregon.edu>
I am trying to do a search and replace that involves changing an uppercase character to a lowercase.
Right now I have :
$text=~ tr^(<a href = \"\#)A-Z(\w+.*?\")^\1a-z\2^s;
But this doesn't work.
Any idea what I am doing wrong?
Thanks,
Michael Stearns
University of Oregon
------------------------------
Date: Wed, 12 Feb 1997 21:31:36 -0500
From: comdog@computerdog.com (brian d foy)
Subject: Re: Using Perl to get LAst Modified Dates
Message-Id: <comdog-1202972131360001@nntp.netcruiser>
In article <01bc1986$b1cdd520$e67409a2@BenoitB.deco.com>, "Brian R.
Benoit" <benoitb@detroitedison.com> wrote:
> I need to know if there is a way to get the date last modified of files in
> a directory and compare those dates to a date stored in a cookie.
have you looked at stat()?
> I am new to perl and don't even know where to start looking.
the perlfunc man page is great reading for beginners. shows you
what toys you have to play with :) Chapter 3 of the Blue Camel[1] has
the same info...
[1]
Blue Camel = Programming Perl, Larry Wall, Tom Christensen,
& Randal L. Schwartz, ISBN 1-56592-149-6.
--
brian d foy <URL:http://computerdog.com>
unsolicited commercial email is not appreciated
------------------------------
Date: 8 Jan 97 21:33:47 GMT (Last modified)
From: Perl-Request@ruby.oce.orst.edu (Perl-Users-Digest Admin)
Subject: Digest Administrivia (Last modified: 8 Jan 97)
Message-Id: <null>
Administrivia:
The Perl-Users Digest is a retransmission of the USENET newsgroup
comp.lang.perl.misc. For subscription or unsubscription requests, send
the single line:
subscribe perl-users
or:
unsubscribe perl-users
to almanac@ruby.oce.orst.edu.
To submit articles to comp.lang.perl.misc (and this Digest), send your
article to perl-users@ruby.oce.orst.edu.
To submit articles to comp.lang.perl.announce, send your article to
clpa@perl.com.
To request back copies (available for a week or so), send your request
to almanac@ruby.oce.orst.edu with the command "send perl-users x.y",
where x is the volume number and y is the issue number.
The Meta-FAQ, an article containing information about the FAQ, is
available by requesting "send perl-users meta-faq". The real FAQ, as it
appeared last in the newsgroup, can be retrieved with the request "send
perl-users FAQ". Due to their sizes, neither the Meta-FAQ nor the FAQ
are included in the digest.
For other requests pertaining to the digest, send mail to
perl-users-request@ruby.oce.orst.edu. Do not waste your time or mine
sending perl questions to the -request address, I don't have time to
answer them even if I did know the answer.
------------------------------
End of Perl-Users Digest V7 Issue 945
*************************************
