Come faccio a leggere il contenuto di una directory in Perl?

Question

Come faccio ad avere Perl per leggere il contenuto di una directory in un array?

Gli apici inversi può farlo, ma c'è un qualche metodo che utilizza 'scandir' o un termine simile?

Answer 1

opendir(D, "/path/to/directory") || die "Can't open directory: $!\n";
while (my $f = readdir(D)) {
    print "\$f = $f\n";
}
closedir(D);

EDIT:Oh, mi dispiace, perdere l' "in un array" parte:

my $d = shift;

opendir(D, "$d") || die "Can't open directory $d: $!\n";
my @list = readdir(D);
closedir(D);

foreach my $f (@list) {
    print "\$f = $f\n";
}

EDIT2:La maggior parte delle altre risposte sono valide, ma ho voluto commentare questa risposta in particolare, in cui questa soluzione è offerto:

opendir(DIR, $somedir) || die "Can't open directory $somedir: $!";
@dots = grep { (!/^\./) && -f "$somedir/$_" } readdir(DIR);
closedir DIR;

Primo, per documentare quello che sta facendo dato che la locandina non:è passando l'elenco restituito da readdir() attraverso un grep() che restituisce solo quei valori che sono i file (invece di directory, i dispositivi, le named pipe, etc.) e che non iniziano con un punto (il che rende il nome della lista @dots fuorviante, ma a causa del cambiamento ha fatto quando la copia sopra il readdir() documentazione).In quanto limita il contenuto della directory restituisce, non credo che è tecnicamente una risposta corretta a questa domanda, ma illustra un idioma comune utilizzato per filtrare i nomi di file Perl, e ho pensato che sarebbe utile per documento.Un altro esempio visto un sacco è:

@list = grep !/^\.\.?$/, readdir(D);

Questo frammento si legge tutto il contenuto della directory maniglia D salvo '.' e '..', in quanto questi sono molto raramente che si desidera utilizzare nell'elenco.

Answer 2

Una breve e veloce soluzione è quella di utilizzare glob

@files = glob ('/path/to/dir/*');

Answer 3

IO::Dir è bello e offre un legato di hash interfaccia.

Dal perldoc:

use IO::Dir;
$d = IO::Dir->new(".");
if (defined $d) {
    while (defined($_ = $d->read)) { something($_); }
    $d->rewind;
    while (defined($_ = $d->read)) { something_else($_); }
    undef $d;
}

tie %dir, 'IO::Dir', ".";
foreach (keys %dir) {
    print $_, " " , $dir{$_}->size,"\n";
}

Così si potrebbe fare qualcosa di simile:

tie %dir, 'IO::Dir', $directory_name;
my @dirs = keys %dir;

Answer 4

Questo farà, in una sola riga (notare il carattere jolly '*' alla fine)

@files = </path/to/directory/*>;
# To demonstrate:
print join(", ", @files);

Answer 5

Si potrebbe utilizzare DirHandle:

use DirHandle;
$d = new DirHandle ".";
if (defined $d)
{
    while (defined($_ = $d->read)) { something($_); }
    $d->rewind;
    while (defined($_ = $d->read)) { something_else($_); }
    undef $d;
}

DirHandle fornisce un'alternativa, pulita interfaccia per il opendir(), closedir(), readdir(), e rewinddir() funzioni.

Answer 6

Ecco un esempio di recursing attraverso una struttura di directory e la copia di file dal backup script che ho scritto.

sub copy_directory {
my ($source, $dest) = @_;
my $start = time;

# get the contents of the directory.
opendir(D, $source);
my @f = readdir(D);
closedir(D);

# recurse through the directory structure and copy files.
foreach my $file (@f) {
    # Setup the full path to the source and dest files.
    my $filename = $source . "\\" . $file;
    my $destfile = $dest . "\\" . $file;

    # get the file info for the 2 files.
    my $sourceInfo = stat( $filename );
    my $destInfo = stat( $destfile );

    # make sure the destinatin directory exists.
    mkdir( $dest, 0777 );

    if ($file eq '.' || $file eq '..') {
    } elsif (-d $filename) { # if it's a directory then recurse into it.
        #print "entering $filename\n";
        copy_directory($filename, $destfile); 
    } else { 
        # Only backup the file if it has been created/modified since the last backup 
        if( (not -e $destfile) || ($sourceInfo->mtime > $destInfo->mtime ) ) {
            #print $filename . " -> " . $destfile . "\n";
            copy( $filename, $destfile ) or print "Error copying $filename: $!\n";
        } 
    } 
}

print "$source copied in " . (time - $start) . " seconds.\n";       
}

Answer 7

Simile al precedente, ma credo che la versione migliore è (leggermente modificato) da "perldoc -f readdir ()":

opendir(DIR, $somedir) || die "can't opendir $somedir: $!";
@dots = grep { (!/^\./) && -f "$somedir/$_" } readdir(DIR);
closedir DIR;

Answer 8

da: http://perlmeme.org/faqs/file_io/directory_listing.html

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

my $directory = '/tmp';

opendir (DIR, $directory) or die $!;

while (my $file = readdir(DIR)) {
    next if ($file =~ m/^\./);
    print "$file\n";
}

Il seguente esempio (basato su un esempio di codice da perldoc -f readdir ()) riceve tutti i file (non le cartelle) che inizia con un periodo di open directory.I nomi dei file sono trovato nell'array @puntini.

#!/usr/bin/perl

use strict;
use warnings;

my $dir = '/tmp';

opendir(DIR, $dir) or die $!;

my @dots 
    = grep { 
        /^\./             # Begins with a period
    && -f "$dir/$_"   # and is a file
} readdir(DIR);

# Loop through the array printing out the filenames
foreach my $file (@dots) {
    print "$file\n";
}

closedir(DIR);
exit 0;


closedir(DIR);
exit 0;