在反引号中使用date命令的perl

Question

There are a bunch of scripts - actually all the Perl scripts in this shop that use a date - use this kind of structure. It uses the date command in backticks. Is this really bad? Does it open up a subshell or something, or is just not 'perlish'. Is it worth me going though all the scripts in the SVN and changing this to localtime?

#!/usr/bin/perl
chomp($date=`date '+%Y%m%d'`);
if (@ARGV) {
   $date = $ARGV[0] ;
}

Answer 1

Why not using perl's :

$ perl -MPOSIX -e 'print POSIX::strftime("%Y%m%d", localtime());'
20150106

? Your solution is all but perlish and it needs to fork() at low level

This is a benchmark of the 3 solutions given : the code :

#!/usr/bin/env perl
use strict; use warnings;

use Benchmark qw(:all) ; 
use autodie;

open my $daveNull, ">", "/dev/null";

my $results = timethese(my $count, {
    'POSIX'         => sub {
        use POSIX;
        print $daveNull POSIX::strftime("%Y%m%d", localtime());
    },
    'Time::Piece'   => sub {
        use Time::Piece;
        print $daveNull localtime()->strftime('%Y%m%d');
    },
    'sysdate'       => sub {
        chomp(my $date=`date '+%Y%m%d'`);
        print $daveNull $date;
    },
});
print "-----8<-------------\n";
cmpthese( $results ) ;

OUTPUT :

Benchmark: running POSIX, Time::Piece, sysdate for at least 3 CPU seconds...
POSIX:  3 wallclock secs ( 2.14 usr +  1.06 sys =  3.20 CPU) @ 234115.94/s (n=749171)
Time::Piece:  3 wallclock secs ( 2.72 usr +  0.47 sys =  3.19 CPU) @ 68128.84/s (n=217331)
sysdate: 37 wallclock secs ( 0.36 usr  2.67 sys + 20.62 cusr  8.00 csys = 31.65 CPU) @ 285.91/s (n=9049)
-----8<-------------
                Rate     sysdate Time::Piece       POSIX
sysdate        286/s          --       -100%       -100%
Time::Piece  68129/s      23729%          --        -71%
POSIX       234116/s      81785%        244%          --

CONCLUSION

POSIX is the winner.

Answer 2

Or you could just use Time::Piece, which has been in Core since 5.009005.

use Time::Piece;

then you can just

my $t = localtime;
print $t->strftime('%Y%m%d');

or

use Time::Piece;
print localtime()->strftime('%Y%m%d');

This uses the strftime format, but has much less overhead than loading the entire POSIX extension.

Plus is has a bunch of preset formats, one of which is 'ymd' where you can specify the delimter... in this case, none

print localtime()->ymd("")

Check the perldoc for more examples.

Answer 3

At minimum, only invoke the shell if you need to:

if (@ARGV) {
   $date = $ARGV[0] ;
}
else {
    chomp($date=`date '+%Y%m%d'`);
}

It's considerably less efficient to invoke the shell only to throw the result away.

But you can generate the output with pure Perl — in multiple ways. The Time::Piece module is a Perl core module, which means it is always there, or you could use strftime from one of the modules that provides it.

$ perl -MTime::Piece -le '$t = new Time::Piece; print $t->ymd("");'
20150106
$ perl -MTime::Piece -le '$t = localtime; print $t->ymd("");'
20150106
$ perl -MTime::Piece -le '$t = localtime; print $t->strftime("%Y%m%d")'
20150106
$ perl -MPOSIX -le 'print strftime("%Y%m%d", localtime(time))'
20150106
$

So, in context, and assuming you add use Time::Piece; at the top of your file, you might write:

use Time::Piece;

…

if (@ARGV) {
   $date = $ARGV[0] ;
}
else {
    my $t = localtime;
    $date = $t->ymd("");
}

This doesn't calculate a default date unless it is needed.

Answer 4

Calling date like that will open a new shell environment, which is painfully inefficient. Try it with Benchmark and see just how bad it gets.

#!/usr/bin/perl

use strict;
use warnings;
use 5.010;
use Time::Piece;
use POSIX 'strftime';

use Benchmark;

my $fmt = '%Y%m%d';

timethese(100_000, {
  backticks => sub {
    my $date = `date +$fmt`;
  },
  strftime => sub {
    my $date = POSIX::strftime($fmt, localtime);
  },
  timepiece => sub {
    my $date = localtime->strftime($fmt);
  },
});

And here's the output:

Benchmark: timing 100000 iterations of backticks, strftime, timepiece...
 backticks: 108 wallclock secs ( 4.26 usr 25.05 sys +  4.82 cusr 85.59 csys = 119.72 CPU) @ 835.28/s (n=100000)
  strftime:  1 wallclock secs ( 1.03 usr +  0.00 sys =  1.03 CPU) @ 97087.38/s (n=100000)
 timepiece:  1 wallclock secs ( 1.33 usr +  0.00 sys =  1.33 CPU) @ 75187.97/s (n=100000)

The backticks solution is about a hundred times slower than the other two options.

But, of course, it works. And if you're not worried about the performance of the program then don't bother to change it.