Perl - 无法打开和读取文件

Question

I've created a script for validating xml files after given input folder. It should grep xml files from the input directory then sort out the xml files and check the condition. But it throws a command that not Open at line , <STDIN> line 1 .

But it creates an empty log file.

Since i faced numeric error while sorting, comment that.

so i need to be given input location, the script should check the xml files and throw errors in a mentioned log file.

Anyone can help this?

Script

#!/usr/bin/perl
# use strict;
use warnings;
use Cwd;
use File::Basename;
use File::Path;
use File::Copy;
use File::Find;

print "Enter the path: ";
my $filepath = <STDIN>;
chomp $filepath;

die "\n\tpleas give input folder \n" if(!defined $filepath or !-d $filepath);

my $Toolpath = dirname($0);
my $base = basename($filepath);
my $base_path = dirname($filepath);

my ($xmlF, @xmlF);

my @errors=();
my @warnings=();
my @checkings=();
my $ecount=0;
my $wcount=0;
my $ccount=0;
my ($x, $y);
my $z="0";

opendir(DIR,"$filepath");
my @xmlFiles = grep{/\.xml$/} readdir(DIR);
closedir(DIR);

my $logfile = "$base_path\\$base"."_Err.log";

# @xmlF=sort{$a <=> $b}@xmlFiles;
@xmlF=sort{$a cmp $b}@xmlFiles;

open(OUT, ">$logfile") || die ("\nLog file couldnt write $logfile :$!");


my $line;

my $flcnt = scalar (@xmlF);

for ($x=0; $x < $flcnt; $x++)
{
open IN, "$xmlF[$x]" or die "not Open";
print OUT "\n".$xmlF[$x]."\n==================\n";
print "\nProcessing File $xmlF[$x] .....\n";
local $/;

while ($line=<IN>)
{
while ($line=~m#(<res(?: [^>]+)? type="weblink"[^>]*>)((?:(?!</res>).)*)</res>#igs)
{
    my $tmp1 = $1; my $tmp2 = $&; my $pre1 = $`;
    if($tmp1 =~ m{ subgroup="Weblink"}i){
        my $pre = $pre1.$`;
        if($tmp2 !~ m{<tooltip><\!\[CDATA\[Weblink\]\]><\/tooltip>}ms){
            my $pre = $pre1.$`;
            push(@errors,lineno($pre),"\t<tooltip><\!\[CDATA\[Weblink\]\]></tooltip> is missing\n");
        }
    }
}
foreach my $warnings(@warnings)
{
$wcount = $wcount+1;
}
foreach my $checkings(@checkings)
{
$ccount = $ccount+1;
}
foreach my $errors(@errors)
{
$ecount = $ecount+1;
}

my $count_err = $ecount/2;
print OUT "".$count_err." Error(s) Found:-\n------------------------\n ";
print OUT "@errors\n";
$ecount = 0;

my $count_war = $wcount/2;
print OUT "$count_war Warning(s) Found:-\n-------------------------\n ";
print OUT "@warnings\n";
$wcount = 0;

my $count_check = $ccount/2;
print OUT "$count_check Checking(s) Found:-\n-------------------------\n ";
print OUT "@checkings\n";
$wcount = 0;

undef @errors;
undef @warnings;
undef @checkings;

close IN;
}
}

Answer 1

The readdir returns bare file names, without the path.

So when you go ahead to open those files you need to prepend the names returned by readdir with the name of the directory the readdir read them from, here $filepath . Or build the full path names right away

use warnings;
use strict;
use feature 'say';
use File::Spec;

print "Enter the path: ";
my $filepath = <STDIN>;
chomp $filepath;

die "\nPlease give input folder\n" if !defined $filepath or !-d $filepath;

opendir(my $fh_dir, $filepath) or die "Can't opendir $filepath: $!";

my @xml_files = 
    map { File::Spec->catfile($filepath, $_) } 
    grep { /\.xml$/ } 
    readdir $fh_dir;

closedir $fh_dir;

say for @xml_files;

where I used File::Spec to portably piece together the file name.

The map can be made to also do grep 's job so to make only one pass over the file list

my @xml_files = 
    map { /\.xml$/ ? File::Spec->catfile($filepath, $_) : () } 
    readdir $fh_dir;

The empty list () gets flattened in the returned list, effectively disappearing altogether.

---

Here are some comments on the code. Note that this is normally done at Code Review but I feel that it is needed here.

First: a long list of variables is declared upfront. It is in fact important to declare in as small a scope as possible. It turns out that most of those variables can indeed be declared where they are used, as seen in comments below.

• The location of the executable is best found using

  use FindBin qw($RealBin);

  where $RealBin also resolves links (as opposed to $Bin , also available)

• Assigning () to an array at declaration doesn't do anything; it is exactly the same as normal my @errors; . They can also go together, my (@errors, @warnings, @checks); . If the array has something then = () clears it, what is a good way to empty an array

• Assigning a "0" makes the variable a string. While Perl normally converts between strings and numbers as needed, if a number is needed then use a number, my $z = 0;

• Lexical filehandles ( open my $fh, ... ) are better than globs ( open FH, ... )

• I don't understand the comment about " numeric error " in sorting. The cmp operator sorts lexicographically, for numeric sort use <=>

• When array is used in scalar context – when assigned to a scalar for example – the number of elements is returned. So no need for scalar but do my flcnt = @xmlF;

• For iteration over array indices use $#ary , the index of the last element of @ary , for

  foreach my $i (0..$#xmlF) { ... }

  But if there aren't any uses of the index (I don't see any) then loop over elements

  foreach my $file (@xmlF) { ... }

• When you check the file open print the error $! , open ... or die "... : $!"; . This is done elsewhere in the code, and it should be done always.

• The local $/; unsets the input record separator , what makes the following read take the whole file. If that is intended then $line is not a good name. Also note that a variable can be declared inside the condition, while (my $line = <$fh>) { }

• I can't comment on the regex as I don't know what it's supposed to accomplish, but it is complex; any chance to simplify all that?

• The series of foreach loops only works out the number of elements of those arrays; there is no need for loops then, just my $ecount = @errors; (etc). This also allows you to keep the declaration of those counter variables in minimal scope.

• The undef @errors; (etc) aren't needed since those arrays count for each file and so you can declare them inside the loops, anew at each iteration (and at smallest scope). When you wish to empty an array it is better to do @ary = (); than to undef it; that way it's not allocated all over again on the next use