while (@data) {
  $data[$loop_count] =~ m{s/^\s*//}xms;
  $data[$loop_count] =~ m{s/\s*$//}xms;
  $loop_count++;
 }
[download]

In addition to what toolic said, your loop would never end, as the condition tests the number of elements in the array, which doesn't change in the loop never becomes zero/false.

You probably want  (though I'm not really sure what the substitutions are meant to do — what's the idea behind the /xms?)

for (@data) {    # remove leading/trailing whitespace
    s/^\s*//;
    s/\s*$//;
}
[download]

The current value being iterated over is aliased to $_, which allows you to change the original values by modifying $_.

Using xms switches and m{} instead of // with every regex is a suggestion by Damian Conway in his book 'Perl Best Practices'

So vendion really wanted to write

s{\A \s* }{}xms
[download]

UPDATE: Removed a \Z that shouldn't have been there

So vendion really wanted to write ...

Well, just another speculation :)

The OP said in the comment "...testing the input for valid alphanumeric characters".  What you're suggesting would remove all whitespace if there's nothing but whitespace in the string.

Yes I was trying to follow the suggestion in the 'Perl Best Practices' book, but what I was wanting to go for was removing the whitespace before and after any kind of text. Sorry for the confusion

• The first error means the value against which you are matching is undef. The value against which you are matching is data_verify's first argument. That situation is not possible in the code you posted.

  There are numerous places where undefined could be passed to data_verify in the code on your scratchpad.

• The second error is caused by your use of the $/ in your pattern while that variable is undefined. m{s/\s*$//}xms means

  • Match the two characters 's/',
  • followed by any number of spaces,
  • followed by the pattern held by $/,
  • followed by the character '/'.

  Obviously not what you wanted. For starters, you wanted to do a substitution rather than a match. m{s/\s*$//}xms should be just s/\s*$//.

  sub data_verify {
   my @data = shift;
   my $loop_count = 0;
   while (@data) {
    $data[$loop_count] =~ s/^\s*//;
    $data[$loop_count] =~ s/\s*$//;
    $loop_count++;
   }
   return @data;
  }
  [download]

By the way,

sub data_verify {
 my @data = shift;
 my $loop_count = 0;
 while (@data) {
  $data[$loop_count] =~ s/^\s*//;
  $data[$loop_count] =~ s/\s*$//;
  $loop_count++;
 }
 return @data;
}
[download]

sub data_verify {
 my $data = shift;
 $data =~ s/^\s*//;
 $data =~ s/\s*$//;
 return $data;
}
[download]

Based on the code in your scratchpad, you want to process multiple values per call. What you really want is

sub data_verify {
 my @data = @_;
 for (@data) {
   s/^\s*//;
   s/\s*$//;
 }
 return @data;
}
[download]

my @data       = shift;
[download]

my @data       = @_;
[download]

Your code only loads the @data array with one element.

See shift and perlsub.

It would have been helpful to point out that lines 212 and 213 are:

 my @data       = shift;
 my $loop_count = 0;
 while (@data) {
  $data[$loop_count] =~ m{s/^\s*//}xms;#line 212
  $data[$loop_count] =~ m{s/\s*$//}xms;#line 213
  $loop_count++;
 }
[download]

So first of all, shift gets _one scalar_ off the arguments. You can't pass arrays around like that in Perl, you pass lists. If you call a sub with an array as the argument, it comes in as a list. If you pass in *two* arrays, they get flattened into a single list of scalar arguments. Secondly, in Perl you can iterate over the elements of an array like so:

foreach $element (@array) {
  do_stuff_to($element);
}
[download]

for $index (0..$#array) { # $#array is the last index of @array
 do_stuff_to($array[$index]);
 do_stuff_to($other_array[$index]);
};
[download]

Also your matches appear to be looking for some strange things. The s/// inside the m//, if it even works at all, is operating on $_, not on $data[$loop_count], I believe, which is unlikely to be what you want. m// should contain a regex, not code. s/// is code.

So if I change the shift to @_ that would make it work for arrays but what if I need to pass something like a scalier or a hash? Is there a way to check/handle this other than making more than one sub that preforms the same task just taking different arguments? Sorry I was confused on the use of shift and I was under the impression that shift did exactly that.

If you call a sub with a single scalar, it's the same as calling it with a 1-element list. @_ will contain the one scalar, and you can get it with shift. If you want to call a sub with multiple arrays or hashes and not have them flattened, you need to use references, and you probably want to look at something like perlreftut. If you call a sub with a single array and you want to get all the elements out at once, you can use:

my @args=@_; # or my %args=@_ if you know it's going to be a hash
[download]

or

my ($arg1, $arg2, $arg3) = @_; # faster than (shift,shift,shift)
[download]

the second form there assumes you know how many arguments you're going to get, or don't care if some of them come back undef.

sub process_input{
    my $data = shift;
    chomp($data);      # cut off newline
    $data =~ s/^\s*//; # remove leading blanks
    $data =~ s/\s*$//; # remove trainilg blanks
    return $data; 
}
[download]

use version; my $VERSION = qw('2.0.0_3').
[download]

use version 0.77; our $VERSION = qv("v2.0.0_3");
[download]