Maybe I'm missing something, but why are you not using grep? E.g.

@array = (3, 2, 1, "", 2, undef);

@cleanarray = grep { defined $_ && $_ ne "" } @array;
@sortedcleanarray = sort grep { defined $_ && $_ ne "" } @array;
[download]

Of course, this will not remove duplicates. From your post I am not sure whether you want that or not (Your "should be" output has the duplicates removed).

Yes, I forgot to mention the duplicate entries. They should also be removed.

Another problem with grep is, that it is extremely slow with big arrays (at least I heard that :))

1. Never guess wildly at what may or may not be slow.
2. Don't concern yourself with performance unless it is a problem.
3. When you need performance, profile your code to find out where the problem is.
4. If you really really need a very very fast program then why are you using Perl?
And some quotes from the collection on my home node:

More computing sins are committed in the name of efficiency (without necessarily achieving it) than for any other single reason - including blind stupidity.
— William A. Wulf, A Case Against the GOTO

Rules of Optimization:
Rule 1: Don't do it.
Rule 2 (for experts only): Don't do it yet.
— Michael A. Jackson

Makeshifts last the longest.

Well, I find it hard to believe that a built-in perl function that has been optimised and is written in C should be slower than walking through the array yourself... (ie. doing the exact same thing the built-in is supposed to do). It is contrary to my own experience, at least. Plus I find myself too lazy to write and debug own code when I can use a built-in :).

If you really have reason to believe what you've heard, why not just quickly whip up a benchmark.

No one has yet explained why this doesn't work as you expect.

Consider an array of three values:

We'll loop through the array with indices. We'll make sure that the element at that position is defined, true, and not the empty string:

for my $i ( 0 .. $#to_clean )
{
    next if defined $to_clean[ $i ] and $to_clean[ $i ];
    next unless $to_clean[ $i ] eq '';
}
[download]

Here's where it gets tricky. By spliceing, you're changing the original array.

After the first loop, we'll splice out the empty string at index zero. The array will then contain 1 and 0 2. Unfortunately, $i will be 1 on the next loop iteration, and it won't check the 0th element again.

You could mess with redo. You could push the elements you want to keep on a secondary array. It's unlikely you'll come up with anything simpler or faster than grep though.

Update: This lets undef through, but it catches zero. It's just an example, though.

We'll make sure that the element at that position is defined, true, and not the empty string:

  for my $i ( 0 .. $#to_clean )
  {
     next if defined $to_clean[ $i ] and $to_clean[ $i ];
     next unless $to_clean[ $i ] eq '';
  }
[download]

If testing for a truth value as above, why is there a need to separately test for an empty string? As empty string will evaluate to a false value, 2d "next" statement is of no use.

my %X;
@clean_ord_array = 
grep  {!defined $X{$_}  and $X{$_} = 1  } grep  /\d+/  ,@array;
print join "\n", @clean_ord_array,"\n";
print join "\n", sort { $a <=> $b } @clean_ord_array,"\n"
[download]

Thanks, this works great.

How I additionally remove all whitespaces from every element (s/\s//g)?

It doesn't look like that you have white spaces in the numbers. To resolve your problem, just in case.. you can put our code before the @array using map.

my %X;
@clean_ord_array = 
grep  {!defined $X{$_}  and $X{$_} = 1  } 
grep  /\d+/,   
map { s/\s//g } @array;
[download]

artist

    my @array = ("", "");
[download]

    splice @clean, $i, 1;
    $i--;
[download]

my $splice_index = 0;
my @splice_list;
for (@clean) {
    if (length($_) == 0) { #zero - length string
        push(@splice_list,$splice_index);
        $splice_index++;
        next;
        }
    $splice_index++;
}

#now we have our splice list built up. so, we take care of the element
+s that need to go.

while (@splice_list) {
    my $index = pop(@splice_list);
    splice(@clean,$index,1);
}

print "$_\n" for @clean; #should produce the correct results

@clean = map {s/\s+//g; $_ } @clean; #i try to avoid map in void conte
+xt, except for in my sig ^_~

print "$_\t" for @clean;
print "\n";
[download]

Thanks for your answers. It works great. But how would I also remove all whitespaces (s/\s//g) from every array element?

ReelBigFish

@array = sort {$a <=> $b} keys (%hash = map { $_ => 1 } @array);
[download]

nevermind. idea is ok but untested code sucks. my bad. wallowing in shame. Forget I said anything. :)