How about stringifying the array:

my $str = "@arr";
[download]

Stringifying an array will use the current value of $" to separate the array elements. It defaults to a space (" ") - if you want newlines, tabs or an empty string (or semicolons or whatever), localize your change like this:

my $str = do { local $" = ""; "@arr" };
[download]

How could I join the elements of an array into a string.

There is a hint in there somewhere! ;-)

See join. And make sure you take at least a gander over the rest of perlfunc so you know what’s there.

Makeshifts last the longest.

Hi jeanluca, Try this,

use strict;
my @arr = qw(a b c d e f g h);
my $str;
$str .= shift(@arr) until (!(@arr));
print $str;
[download]

Using Join :

$str = join '', @arr;
[download]

That's a very strange example for join you've got going there. I'd guess the OP is just after...

my @arr = qw(a b c d e f g h);
my $str = join('', @arr);
[download]

Am I missing something?
---
my name's not Keith, and I'm not reasonable.

Sure.

$;=sub{$\};my@x=map{my($x,$y)=($;,$_);$;=
sub{$x->().$y}}@arr;;my$str=($x[-1]->());
[download]

Or you could just use join, but what fun is that?

This is just the kind of code that gives PERL a bad reputation as a write-only language. PERL is dying because of posts like this. You should use existing code from CPAN instead of inventing your own convoluted methods:

use Array::Autojoin;
my $str=mkarray(@arr);
print "$str";
[download]

</sarcasm>(just in case ;-)

Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it. -- Brian W. Kernighan

The equivalent to your code is, as others have pointed out:

$str = join( '', @arr );
[download]

Please read the docs on join. You could also do:

{
   local $" = ''; # see perlvar
   $str = "@arr";
}
[download]

Which might be faster. See perlvar. Also check out Data::Dumper - even if its format is not what you want, the code inside might be enlightening with regard to creating string representations of various variable types.

Read more... (1274 Bytes)

20 words:

              Rate stringify      join
stringify 155272/s        --      -29%
join      219556/s       41%        --


51 words:

             Rate stringify      join
stringify 83452/s        --      -16%
join      99407/s       19%        --


2000 words:

            Rate stringify      join
stringify 2736/s        --       -3%
join      2813/s        3%        --
[download]

They're about the same speed, but stringification has a much bigger overhead. Better off with join.

Errm, what? At a rate of 155272/s, does it even matter for 99.99% of the apps out there? They’re going to be waiting for the harddrive, or the network, or the terminal, or whatever.

Better off with whichever one is more readable.

(Which is going to be join most of the time – but recommending it on the basis of performance is plainly silly.)

Makeshifts last the longest.