Another way, with pop and push:

my $last = pop @somewords;
foreach my $core (@somewords) {
  print " $core;\n"
}
push @somewords,$last;
[download]

Update: it's useless to keep $last. See the improvement by johngg, in reply.

You could use a do block to scope the existence of $last so that it isn't left lying around.

knoppix@Microknoppix:~$ perl -Mstrict -wE '
> my @arr = qw{ one two three four };
> push @arr, do { my $last = pop @arr; say for @arr; $last };
> say qq{@arr};'
one
two
three
one two three four
knoppix@Microknoppix:~$
[download]

Cheers,

JohnGG

for (my $i = 0; $i < @somewords -1; $i++) {
  print " $somewords[$i];\n"
}
[download]

foreach $core (@somewords[0 .. $#somewords-1]) {
  print " ${core};\n"
}
[download]

my $i = 0;
foreach my $core (@somewords) {
  next if ++$i == @somewords;
  print " ${core};\n"
}
[download]

TIMTOWTDI

I'd be inclined to just iterate over the index:

foreach my $idx ( 0 .. $#somewords - 1 ) {
    print " $somewords[$idx]\n";
}
[download]

The slice technique is also nice though:

foreach my $core ( @somewords[ 0 .. $#somewords - 1 ] ) {
    print " $core\n";
}
[download]

use strict;

my @somewords = ("a", "b", "c");

foreach my $core (@somewords[0..$#somewords-1]) {
  print "${core};\n";
}
[download]

Here are two other ideas: you can store and print the previous value each iteration or you can pop the final element off the array then use foreach on the remaining elements.

use strict;
use warnings;

my @somewords = qw(a b c d);

my $previous_core = '';

foreach my $core (@somewords) {
  print "$previous_core\n" if $previous_core ne '';
  $previous_core=$core;
}
print "************\n";

my $popword = pop @somewords;
print "popped >${popword}<\n";

print "\@somewords:\n";
print "$_\n" foreach @somewords;

print "************\n";
[download]

perl -e '@set=qw(a b c d);for (@set[0..$#set - 1]){print "$_\n";}'
a
b
c
[download]

An interesting selection of approaches in this thread, here's a variation on slicing.

knoppix@Microknoppix:~$ perl -E '
> @arr = qw{ one two three four };
> say for do { local @arr = @arr[ 0 .. $#arr - 1 ]; @arr };
> say qq{@arr};'
one
two
three
one two three four
knoppix@Microknoppix:~$
[download]

Update: You can't localise a lexical variable so, if running under strictures you would have to declare @arr with our to make it a package variable or make it a lexical with my and declare a new lexical inside the do block.

knoppix@Microknoppix:~$ perl -Mstrict -wE '
> our @arr = qw{ one two three four };
> say for do { local @arr = @arr[ 0 .. $#arr - 1 ]; @arr};
> say qq{@arr};'
one
two
three
one two three four
knoppix@Microknoppix:~$
[download]

knoppix@Microknoppix:~$ perl -Mstrict -wE '
> my @arr = qw{ one two three four };
> say for do { my @arr = @arr[ 0 .. $#arr - 1 ]; @arr};
> say qq{@arr};'
one
two
three
one two three four
knoppix@Microknoppix:~$
[download]

I don't get it. Instead of
    say for do { my @arr = @arr[ 0 .. $#arr - 1 ]; @arr};
et al, why not just
    say for do { @arr[ 0 .. $#arr-1 ] };
or (much) better yet...

>perl -wMstrict -lE
"my @arr = qw{ one two three four };
 say for @arr[ 0 .. $#arr-1 ];
 say qq{@arr};
"
one
two
three
one two three four
[download]

for my $ix ( 0 .. ( $#somewords -1  ) ) {
    print "$somewords[$ix]\n"
}

for my $chops ( @somewords[ 0 .. ( $#somewords -1  ) ) {
    print "$chops\n"
}
[download]

You could ...

• store the last element in a variable; compare it on each iteration; if same, exit loop (not good if there are duplicates); or,
• copy|slice n-1 elements in another array to itierate over; or,
• better yet, use a counter to keep track of the current (elememt of the) array index, either via explicit C-loop or separately maintained one.