G'day tryingnottofailmytes,

Well, you do initialize them near the beginning of your script:

my $annotation = '';
my $dna = '';
[download]

Their next appearance in your script is:

($annotation, $dna) = ($record =~ /^(LOCUS.*ORIGIN\s*\n)(.*)\/\/\n/s);
[download]

where, presumably, you're setting both to undef (i.e. uninitialized).

When you then use them in the print statement on the following line:

print "$annotation, $dna\n";
[download]

you get a warning about this.

For the other part of your question, see the use documentation.

... it didn't work.

Exactly what is "it"? Exactly how did it "not work"?

... my variables are unintilized when I initilize them at the beginning.

You assign values at the beginning, but then you assign again from the result of a match, and that's probably where the undefined values come from: regex captures return undef when the match fails. (Update: More precisely, a failed match in list context, as below and in the OPed code, returns an empty list, which, when assigned to scalar variables, yields undefs.) You have to test the success of the match somehow:

c:\@Work\Perl\monks>perl -wMstrict -le
"my $s = 'eks---wye';
 ;;
 my $found = my ($x, $y) = $s =~ m{ \A (eks) .* (wye) \z }xms;
 if ($found) {
   print qq{A: found '$x' and '$y'};
   }
 else {
   print 'A: found nada';
   }
 ;;
 $s = uc $s;
 ;;
 if (my ($xx, $yy) = $s =~ m{ (EKS) .* (WYE) }xms) {
   print qq{B: found '$xx' and '$yy'};
   }
 else {
   print 'B: found nada';
   }
"
A: found 'eks' and 'wye'
B: found 'EKS' and 'WYE'
[download]

Ignoring the module issue for the moment because you don't show what's in it, there are a few things to improve with your code as it stands:

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

my $filename = "record.gb";

open my $fOut, '>', $filename or die "Failed to create $filename: $!\n
+";
print $fOut <<STR;
LOCUS some guff ORIGIN
Another line of guff
//
STR
close $fOut;

open my $fIn, '<', $filename or die "Failed to open $filename: $!\n";

#use the input seperator //\n to read a entire file to scalar
my $record = do {local $/ = "//\n"; <$fIn>};

#to seperate the annotation from sequence
$record =~ /^(LOCUS.*ORIGIN\s*\n)(.*)\/\/\n/s or die "Malformed record
+ '$record'\n";

my ($annotation, $dna) = ($1, $2);
print "$annotation, $dna\n";
[download]

Prints:

LOCUS some guff ORIGIN
, Another line of guff
[download]

The first block of file related stuff is just to create a file containing some test data. If you want people to be able to reproduce your issues you have to provide all the bits required. Using the script itself to generate any files you may need helps with that.

Notice that the variables are declared where they are first needed and generally they are assigned a real value at that time. Always declare variables where they are needed and no sooner so it's easy to see how they are used.

Notice that the file open statements use lexical file handles (my $fIn) and three parameter open (see open). It's also generally a good idea to die for I/O errors and report the file you were opening and the error generated by the system.

The my $record = do {local $/ = "//\n"; <$fIn>}; line localises $/ so that it can be changed within the do {} block without affecting the value of $/ outside the block. That makes changing $/ much safer and the scope of the change completely clear.

The root of your "Use of uninitialized value" error is that the match didn't find anything to match. Again, use die to report the error and give the context so figuring out what broke is easier.

Notice that annotation and dna variables are declared as a list and are assigned the values of match variables 1 and 2 after a successful match.

... annotation and dna variables are declared as a list and are assigned the values of match variables 1 and 2 after a successful match.

Note that it's also possible to "capture the captures" to lexicals and die on match failure in a single statement:

c:\@Work\Perl\monks>perl -wMstrict -le
"for my $record (qw(eks---wye  eks---wyyye)) {
   my ($x, $y) = $record =~ m{ \A (eks) .* (wye) \z }xms
     or die qq{malformed record '$record'};
   ;;
   print qq{record '$record': got '$x' '$y'};
   }
"
record 'eks---wye': got 'eks' 'wye'
malformed record 'eks---wyyye' at -e line 1.
[download]

I prefer this practice because it's all too possible, believe me, to insert just one more pattern match test between the original capturing statement and the separate statement intended to assign its capture variables  $1 $2 ... to lexicals, in which case the original capture groups sometimes, but not always, and perhaps quite silently (gotta love this bug!), become invalid.

---

Give a man a fish:  <%-{-{-{-<