use File::Path qw( mkpath );
mkpath( $path, 0, 0777 );
[download]

And, no, I can't see this as a good case for using recursion. Sure, you could code it recursively, but the value of recursion is when it makes coding it easier. I think it would almost be a stretch to do this one recursively so you'd just be working hard to make your code slower. (:

FYI, see (tye)Re: Recursion for my thoughts on recursion.

This node has been updated.

Thanks for the suggestion. I hadnt come across that module. Ill have to check it out, Im interested how the module does it.

I used recursion, because it was the only obvious way I could think of doing it. One question. How much slower could the code be when dealing with creating subdirectories? Since realisticly you are not going to create directories of say 100 deep. The script Im using it in seems to work quickly.

THANKS!
zzSPECTREz

Yeah, sorry, I was just noticing that you had coded it recursively. I didn't notice the recursion and had interpretted your posting as, in part, asking how you would go about rewriting it recursively (to learn about recursion). :-}

No, doing this recursively isn't going to make this unacceptably slow. I think the reason that you ended up with a recursive solution is that your first idea at how to loop through the list of directories went in the "wrong" order (or you chose this order because you wanted to be optimistic and assume that most of the time you don't need to create many directories so start from that end).

Recursion is one way to reverse a loop, but there is usually a "better" way. In fact, in Perl you can use the built-in "stacks" to reverse even the most hard to reverse loop via:

my @stack;
while( <> ) {
    push @stack, $_;
}
while(  @stack  ) {
    local( $_ )= pop @stack;
    # your code here
}
[download]

And it is hard to argue that the above is worse than recursion in any way. ;)
        - tye (but my friends call me "Tye")

If you're running on a Unix-like system, then you could always use

system("mkdir -p $dir");
[download]

which will create all intermediate directories.

"Perl makes the fun jobs fun
and the boring jobs bearable" - me

on many systems the command "mkdirhier" will create subdirectories as well.

of course, the recursive perl solution *is* much cooler. ;)

-Nakano

sub my_mkdir {
    my $path = shift;
    my $perms = shift;
    
    my @parts = split /\//, $path;
    for my $num (1..$#parts) {
        my $check = join('/', @parts[0..$num]);
        unless (-d $check) {
            mkdir( $check, $perms );
        }
    }
}
[download]

Neat. You can get rid of the join by using a .=.

sub my_mkdir {
    my ($path, $perms) = @_;

    my $dir = '.';
    for ( split /\//, $path ) {
        mkdir $dir .= "/$_", $perms;        
    }
}
[download]

That's a nice iterative solution. One small correction: the for loop should start at 0, rather than 1, because it may need to create the very first directory in the path.

(I tested it with my_mkdir('dir1/dir2/dir3', '0777'); it worked only if dir1 already existed.)

my ($parent) = $path =~ /([^\/]*)\//;
[download]

Yoiks! I'm completely backwards here - You want to be greedy. Dang recursion!Forget I mentioned it,... look, out that window, why it's Supermunk! (slinks quietly away to chop onions).

a

Heh. The .* is correct here. The first call to my_mkdir matches all the parent directories, and each subsequent recursive call matches one fewer parent directory.

I believe Im dealing with the return's properly. I want my routine to respond just like mkdir. Return 1 if succesfful and 0 if error and the error from mkdir still in $!.

Correct me if I got it wrong. Seems to test out right

zzspectrez

sub dir_ensure {
    for (@_) { # handles multiple DIRs
        my $path = ($_ // die("Dir must be specified")) =~ s!/$!!sr;
        next if -d $path; # DIR is already there
        die("Path '$path' already exists and it's not a DIR") if -e _;
        my $parent = $path =~ m"^(/[^/].*?)/(?!\.{1,2}$)[^/]+$"s
            ? $1 : die("Invalid path '$path'");
        dir_ensure($parent); # ensure parent DIR exists
        mkdir($path) or die("Failed to create DIR $path $!");
    }
}
[download]

sub dir_ensure {
    for (@_) { # handles multiple DIRs
        my $path = ($_ // die("Dir must be specified")) =~ s!/$!!sr;
        next if -d $path; # DIR is already there
        die("Path '$path' already exists and it's not a DIR") if -e _;
        my $parent = $path =~ m"^(/[^/].*?)/(?!\.{1,2}$)[^/]+$"s
            ? $1 : die("Invalid path '$path'");
        dir_ensure($parent); # ensure parent DIR exists
        mkdir($path) or die("Failed to create DIR $path $!");
    }
}
[download]

Problems with that code:

• Recursion is not needed to split a path into a series of directories, as explained in other posts in this thread.
• The code assumes a single root directory. There are several operating systems that have more than one root directory. (DOS, Windows, OS/2, ...)
• There is a race condition: You stat() a part of the path way before you mkdir that part (see TOCTTOU). To avoid that problem, just call mkdir() and check its result. Expect EEXISTS for already existing directories.
• There is at least one module that already takes care of all those issues, plus OS-specific surprises: File::Path

Alexander

--
Today I will gladly share my knowledge and experience, for there are no sweeter words than "I told you so". ;-)