@n = grep $_, @n;

This will put into @n all elements of the original @n that evaluate to true. But that means that elements whos value is 0, or "", or anything else that evaluates to false, will get skipped over. "undef" does evalute to false, by the way.

@n = grep defined, @n

This is what you want if all you care about is getting rid of elements whos value is undef. This will retain elements of zero value or empty strings, so long as they're not undef. I worked up several test snippets showing that this works for that type of situation. No need to show them here; it's pretty basic stuff.

@n = grep defined and length, @n

Here you're getting into trouble because of the low precedence of the "and" logical short circuit operator. You would be better served by using "&&" in this case. "and" binds at such a low precedence that everything to its right is no longer seen as part of the parameter list to grep. Wierd, huh? "&&" solves this problem (parenthesis placed in the right place would solve it too). But then you're going to be saying "if its value is defined and of a length greater than zero". That may be ok, or it might be better to say "@n = grep defined && $_, @n;". That way instead of testing for length, you're testing for truth.

And I won't get into the rest of your solutions because they are too unPerlish to wade through. I think that in general you'll find it to be a good way to run amok; to try to delete array elements while iterating through the array with a C-style loop.

#!/usr/bin/perl
use strict;
use warnings;
my @array = (undef,1,undef,2,undef,3);
@array = grep { defined $_ } @array;
print "@array\n";
[download]

Update: removed unnecessary $_ if

It seems to me the other comments are answering a different question than the one you are asking. Or maybe I'm the one misunderstanding your question.

Let's say you have an array which you initialize with some values:

@values = qw( 00 11 22 33 );
use Data::Dumper;
print Dumper \@values;
# generates the output:
$VAR1 = [
          '00',
          '11',
          '22',
          '33'
        ];
[download]

By the way, I'm cutting and pasting from my debugging session perl -d -e 1. That means I may forget the semi colon at the end of a line, you don't need them in the debugger.

So the Array contains four values: $values[0] is "00", up to $values[3] which is "33".

Let's suddenly create $values[6]. What do you suppose happens with the in-between array slots, for which we have not defined values? What happens with $values[4] and $values[5]?

It may be useful to also read the system documentation on delete. Type perldoc -f delete

This started off as a quick and easy clarification. Why is it now two hours later?

my @n = array with nulls;

@n = map { defined $_ ? $_ : () } @n;
[download]

Deleting an array element effectively returns that position of the array to its initial, uninitial­ized state. Subsequently testing for the same element with exists() will return false. Note that deleting array elements in the middle of an array will not shift the index of the ones after them down--use splice() for that. See the exists entry elsewhere in this document.

So putting 4 elements in an array and deleting the middle two:

#!/usr/bin/perl -w

$arr[0]='a';
$arr[1]='b';
$arr[2]='c';
$arr[3]='d';
delete $arr[1];
delete $arr[2];

print join(" ", map { defined() ? $_ : '[undef]' } @arr),"\n";;
[download]

#!/usr/bin/perl -w

$arr[0]='a';
$arr[3]='d';

print join(" ", map { defined() ? $_ : '[undef]' } @arr),"\n";
[download]

a [undef] [undef] d
[download]

my @original = ("", undef, "perl hungry", "", "twenty");
my @original_kept;

foreach(@original)
{
my $what_we_removed = shift(@original); # take our first item off and 
+keep it
  if (defined $what_we_removed && $what_we_removed ne "")
  {
     push(@original_kept, "$what_we_removed");
  }
}

print join("\n", @orignal_kept);
[download]

Removing array elements is easy.

If you want to remove the value without losing the slot, use delete. If you want to eleminate the slot and value together, use splice:

@a = qw( 0 1 2 3 4 5 6 )
# starting at position 2, delete 1 element
splice @a, 2, 1         
print join ",  ", @a
# generates the output :
0,  1,  3,  4,  5,  6
[download]

splice() can do lots more ...see perldoc -f splice

--
TTTATCGGTCGTTATATAGATGTTTGCA