在 Perl 中计算由 CR/LF（回车和换行符）分隔的记录

Question

I'm trying to create a simple script to read a text file that contains records of book titles. Each record is separated with a plain old double space ( \\r\\n\\r\\n ). I need to count how many records are in the file.

For example here is the input file:

record 1
some text


record 2 
some text
...

I'm using a regex to check for carriage return and newline, but it fails to match. What am I doing wrong? I'm at my wits' end.

sub readInputFile {

    my $inputFile = $_[0]; #read first argument from the commandline as fileName

    open INPUTFILE, "+<", $inputFile or die $!;    #Open File

    my $singleLine;
    my @singleRecord;
    my $recordCounter = 0;

    while (<INPUTFILE>) {                    # loop through the input file line-by-line
        $singleLine = $_;
        push(@singleRecord, $singleLine);    # start adding each line to a record array

        if ($singleLine =~ m/\r\n/) {        # check for carriage return and new line
            $recordCounter += 1;
            createHashTable(@singleRecord);  # send record make a hash table
            @singleRecord = ();              # empty the current record to start a new record
        }

    }

    print "total records : $recordCounter \n";
    close(INPUTFILE);
}

Answer 1

It sounds like you are processing a Windows text file on Linux, in which case you want to open the file with the :crlf layer, which will convert all CRLF line-endings to the standard Perl \\n ending.

If you are reading Windows files on a Windows platform then the conversion is already done for you, and you won't find CRLF sequences in the data you have read. If you are reading a Linux file then there are no CR characters in there anyway.

It also sounds like your records are separated by a blank line. Setting the built-in input record separator variable $/ to a null string will cause Perl to read a whole record at a time.

I believe this version of your subroutine is what you need. Note that people familiar with Perl will thank you for using lower-case letters and underscore for variables and subroutine names. Mixed case is conventionally reserved for package names.

You don't show create_hash_table so I can't tell what data it needs. I have chomped and split the record into lines, and passed a list of the lines in the record with the newlines removed. It would probably be better to pass the entire record as a single string and leave create_hash_table to process it as required.

sub read_input_file {

    my ($input_file) = @_;

    open my $fh, '<:crlf', $input_file or die $!;
    local $/ = '';

    my $record_counter = 0;

    while (my $record = <$fh>) {
        chomp;
        ++$record_counter;
        create_hash_table(split /\n/, $record);
    }
    close $fh;

    print "Total records : $record_counter\n";
}

Answer 2

You can do this more succinctly by changing Perl's record-separator, which will make the loop return a record at a time instead of a line at a time.

Eg after opening your file:

local $/ = "\r\n\r\n";
my $recordCounter = 0;
$recordCounter++ while(<INPUTFILE>);    

$/ holds Perl's global record-separator, and scoping it with local allows you to override its value temporarily until the end of the enclosing block, when it will automatically revert back to its previous value.

But it sounds like the file you're processing may actually have "\\n\\n" record-separators, or even "\\r\\r". You'd need to set the record-separator correctly for whatever file you're processing.

Answer 3

If your files are not huge multi-gigabytes files, the easiest and safest way is to read the whole file, and use the generic newline metacharacter \\R .

This way, it also works if some file actually uses LF instead of CRLF (or even the old Mac standard CR).

Use it with split if you also need the actual records:

perl -ln -0777 -e 'my @records = split /\R\R/; print scalar(@records)' $Your_File

Or if you only want to count the records:

perl -ln -0777 -e 'my $count=()=/\R\R/g; print $count' $Your_File

For more details, see also my other answer here to a similar question.