Call upon specific elements from array - arrays

Question

Ok, so I have a bunch of file names possessing one of the following two formats:
Sample-ID_Adapter-Sequence_L001_R1_001.fastq (As Forward)
Sample-ID_Adapter-Sequence_L001_R2_001.fastq (As Reverse)
The only difference between the forward and reverse formats is the R1 and R2 elements in the filename. Now, I've managed to enable the user to provide the directory containing these files with the following script:
#!/usr/bin/perl
use strict;
use warnings;
#Print Directory
print "Please provide the directory containing the FASTQ files from your Illumina MiSeq run \n";
my $FASTQ = <STDIN>;
chomp ($FASTQ);
#Open Directory
my $dir = $FASTQ;
opendir(DIR, $dir) or die "Cannot open $dir: $!";
my #forwardreads = grep { /R1_001.fastq/ } readdir DIR;
closedir DIR;
my $direct = $FASTQ;
opendir(DIR, $direct) or die "Cannot open $dir: $!";
my #reversereads = grep { /R2_001.fastq/ } readdir DIR;
closedir DIR;
foreach my $ffile (#forwardreads) {
my $forward = $ffile;
print $forward;
}
foreach my $rfile (#reversereads) {
my $reverse = $rfile;
print $reverse;
}
The Problem
What I want to do with the above script is to find a way to pair up the elements of both arrays that are derived from the same Sample ID. Like I said, the only difference between the forward and reverse files (from the same sample ID) would be the R1 and the R2 parts of the file name.
I've tried looking up ways to extract elements from an array, but I want to let the program do the matching instead of me.
Thanks for reading and I hope you guys can help!

Answer 1

You'll have to parse out the filename. Fortunately, this is pretty straightforward. After stripping the extension, you can split the pieces on _.
# Strip the file extension.
my($suffix) = $filename =~ s{\.(.*?)$}{};
# Parse Sample-ID_Adapter-Sequence_L001_R1_001
my($sample_id, $adapter_sequence, $uhh, $format, $yeah) = split /_/, $filename;
Now you can do what you like with them.
I'd suggest a few things to improve the code. First, put that filename parsing into a function so it can be reused and to keep the main code simpler. Second, parse the filenames into a hash rather than a bunch of scalars, it'll be easier to work with and pass around. Finally, include the filename itself in that hash, then the hash contains the complete data. This, btw, is a gateway drug to OO programming.
sub parse_fastq_filename {
# Read the next (in this case first and only) argument.
my $filename = shift;
# Strip the suffix
my($suffix) = $filename =~ s{\.(.*?)$}{};
# Parse Sample-ID_Adapter-Sequence_L001_R1_001
my($sample_id, $adapter_sequence, $uhh, $format, $yeah) = split /_/, $filename;
return {
filename => $filename,
sample_id => $sample_id,
adapter_sequence => $adapter_sequence,
uhh => $uhh,
format => $format,
yeah => $yeah
};
}
Then rather than finding left and right formatted files separately, process everything in one loop. Put matching left and right pairs in a hash. Use glob to pick up only the .fastq files.
# This is where the pairs of files will be stored.
my %pairs;
# List just the *.fastq files
while( my $filename = glob("$FASTQ_DIR/*.fastq")) {
# Parse the filename into a hash reference
my $fastq = parse_fastq_filename($filename);
# Put each parsed fastq filename into its pair
$pairs{ $fastq->{sample_id} }{ $fastq->{format} } = $fastq;
}
Then you can do what you like with %pairs. Here's an example to print out each sample ID and what formats it has.
# Iterate through each sample and pair.
# $sample is a hash ref of format pairs
for my $sample (values %pairs) {
# Now iterate through each pair in the sample
for my $fastq (values %$sample) {
say "$fastq->{sample_id} has format $fastq->{format}";
}
}