$inputArrayLen is set equal to 8. There are 8 elements in the array. You start counting from 0. You keep going until $counter is greater than $inputArrayLen.

So you print elements 0, 1, 2, 3, 4, 5, 6, 7... all of which are fine. Element 0 contains the value 1. Element 7 contains the value 8. What does element 8 contain? An undefined value. Element 8 is the 9th element in the array.

Change <= to < and it's fixed. This is an off by one error -- a common result of forgetting about zero-based numbering.

You have some other problems, but they're not actually causing trouble. One is how you pass parameters. You never actually use the parameter passed into the subroutine. Instead, you just absorb the same variable because it happens to be within the same lexical scope. Have a look at perlsyn for a better understanding of scoping and parameter passing. Minimally, it should follow this pattern:

foo($value);

sub foo {
  my ($v) = @_;
  print "$v\n";
}
[download]

Also, it seems like your goal is a recursive solution. Usually in exercises where recursion is a goal, it's preferable to store state within the subroutine's parameters. Here's an example.

my @inputArray = (1,2,3,4,5,6,7,8);
traverseArray2(\@inputArray);

sub traverseArray2 {
    my ($aref, $counter) = (shift, shift // 0);
    return if $counter >= @$aref;
    print $aref->[$counter], "\n";
    traverseArray2($aref, $counter+1);
}
[download]

You can even get rid of the counter and eliminate the call-stack overhead like this:

my @inputArray = (1,2,3,4,5,6,7,8);
traverseArray3(@inputArray);

sub traverseArray3 {
    return unless @_;
    print shift, "\n";
    goto &traverseArray3;
}
[download]

Thanks David. Still new to coding and Perl but your suggestions are priceless.

The problem is you recurs 1 too many times. However, there is a swathe of smelly areas in your code. Take a look at the following code to see how it can be improved in various ways. You may want to ask questions about why various things have been done or how they work.

use strict;
use warnings;
use 5.010;

my @inputArray = (1, 2, 3, 4, 5, 6, 7, 8);

traverseArray(\@inputArray, 0);

sub traverseArray {
    my ($aRef, $index) = @_;

    return if $index >= @$aRef;

    print "$aRef->[$index]\n";
    traverseArray($aRef, $index + 1);
}
[download]

as already mentioned by other monks, your direct problem is an off-by one error.

I would like however to point to other serious problems in your code, although they happen to have no direct consequences in this specific case. <p Since your aim is apparently to "print each number in integer array in new line without using for or while loop", using recursion is a very natural solution. However, in general, recursive functions should in general depend only on arguments passed to them and should not rely on global variables. Especially your use of the $counter global variable is a recipe for disaster when things get a bit more complicated. Also, the way you're using $inputArrayLen is a mistake, since you're passing as a parameter to your recursive subroutine, but, since you're not using the parameters passed to the sub, you are actually using a global copy of that value.

You could fix it this way:

use strict;
use warnings;

my @inputArray = (1..8);
my $counter = 0;

traverseArray($counter);

sub traverseArray {
    my $counter = shift;
    return if $counter >= @inputArray;
    print "$inputArray[$counter]\n";
    traverseArray($counter+1);
}
[download]

# same initialization as before

traverseArray($counter, @inputArray);

sub traverseArray {
    my ($counter, @input) = @_;
    return if $counter >= @input;
    print "$input[$counter]\n";
    traverseArray($counter+1, @input);
}
[download]

There are various ways to avoid that, but they are using some slightly advanced concepts (e.g. references or closures) which you probably would want to learn a bit later. Both solutions above are already a good starting point.

my @inputArray = (1,2,3,4,5,6,7,8);
my $inputArrayLen = @inputArray;

Even given the recursive context in which the OPed question is couched, I'm a bit surprised that no one has yet mentioned the  $# array operator (if that's the correct terminology), which gives you the maximum index of the array. (Update: See perldata for a discussion of  $# and arrays.)

As others have pointed out, evaluating an array in scalar context as in the
    my $inputArrayLen = @inputArray;
statement yields the number of elements of the array. Using the  $# operator, the statement
    my $maxIndex = $#inputArray;
gives you the highest index of any element in the array.
Leaving aside any considerations of recursion, the idiomatic, "Perlish" way of iterating over an array is something like
    my @array = (...);
    ...
    for my $element (0 .. $#array) {
        do_something_with($element);
        }
Leaving aside any considerations of recursion, a better way of iterating over an array is something like
    my @array = (...);
    ...
    for my $i (0 .. $#array) {
        do_something_with($array[$i]);
        }
and better yet IMHO, the idiomatic, "Perlish" way would be
    for my $element (@array) {
        do_something_with($element);
        }

Of course, there are other ways, such as using the built-in functions map and grep, of iterating over arrays, but those are other stories for other days.

Update: Fixed the brainfart for-loop example.