OK, so now you know that you can do what you want and tons of people have been thoughtful enough to tell you that you don't want to do that, but no one bothered to tell you why.

Generally, whenever you see variables whose names exhibit a consistent pattern such -- of which your $f1, $f2, $f3, etc. certainly qualifies -- it implies that these variables are logically grouped together. In your case, people suggested an array named @f. Another example would be variables like $customer_fname, $customer_lname, $customer_phone, etc. In this case, a hash would be a better choice:

%customer = (
    fname => 'John',
    lname => 'Doe',
    phone => undef,
);
[download]

If the variables really don't belong together, there's a good chance that they have been poorly named and are likely to mislead programmers looking at your code (I wonder how many lone programmers get irritated when they hear people talk about others looking at their code?).

However, if those variables are logically grouped together, they should probably be grouped together in your code in a single construct, such as an array or hash. There are a variety of reasons for this, but two of the biggest are clean code and ease of use. For example, I routinely see stuff like this:

sub thing {
    my $string = shift;
    my ($f0, $f1, $f2, $f3, $f4, $f5) = split /|/, $string;
    $f2 = $f4 + 5;
    return ($f0, $f2, $f3);
}
[download]

Well, that's ugly. You're creating variables only to throw them away and it's not clear what you're doing. However, not only is this not clean code, it's also harder to work with. Let's say your boss wants to know why you're throwing away that second variable? So you add it:

sub thing {
    my $string = shift;
    my ($f0, $f1, $f2, $f3, $f4, $f5) = split /|/, $string;
    $f2 = $f4 + 5;
    return ($f0, $f1, $f2, $f3);
}
[download]

Now you have a problem. Everywhere where you call this code will now have the $f2, and $f3 variables shifted away by one and you'll have to go through and fix all of them. Had you put the variables in an array and returned that, you may return extra data you don't need now, but the code is clean and easier to use later.

sub thing {
    my $string = shift;
    my @f = split /|/, $string;
    $f[2] = $f[4] + 5;
    return @f;
}
[download]

There are still problems with that code (hard-coded constant and poorly named variables), but what happens if it turns out there is a $f6 and $f7 added later on? You may have to update some code to process it, but you might not have to update the sub to handle it because logically related variables were grouped together appropriately.

I hope I've shed a little light on that subject :)

One thing you don't mention, and an important reason to use logically grouping constructs like arrays, is that it's much harder to iterate over the group of values. In Perl at least you can write

foreach ( $f0, $f1, $f2, $f3, $f4, $f5 ) {
    # ...
}
[download]

but in other languages it takes an incredible amount of teeth gnashing to do something like that. And even so, it is annoying to write out every time, invites typos, invites copy-paste, and is annoying to read.

Makeshifts last the longest.

The answer to this question is almost always yes and there is almost always more than one way to do it. "There is more than one way to do it" is one of Perl's mottos. In this case, I will provide a straight forward answer.

my $str = '1029576843';
my @f = split //, $str;
print $f[ 4 ];  # 5
[download]

I would suggest that there are valid reasons to use serial variables rather than (or in addition to) an array. RegEx is a good example, setting $1, $2, $3, etc.
Ardemus "This, right now, is our lives."

Yes, but it's very bad practice, because it's just too easy to make errors, and it makes your code much less readable. You could use an array instead:

my @f = split(//, $s);
[download]

A alternate way to split the string:

my @f = $s =~ /./gs;
[download]

An example of how to manipulate the array:

print("\@f has ", scalar(@f), " elements:\n");
print("\$f[$_] = $f[$_]\n") for (0..$#f);
[download]

You really don't want sequential names. You should learn to use arrays:

my @f = split //, $s;
[download]

Is there a way in a-future-language to slice a string (say '1029') into serialized variables and end up with

f_zero  = 1;
f_one   = 0;
f_two   = 2;
f_three = 9;
[download]

*grin*

Obviously…

my @numword = qw( zero one two three four five six seven eight nine te
+n );
my $i = 0;
${ "f_" . $numword[ $i++ ] } = $_ for split //, $string;
[download]

Nevermind the fact that you can vandalize the symbol table to put things in it with whose names don't conform to identifier rules, such as ${ '[ ha ha ha ]' } = 1;.

Makeshifts last the longest.

I object! There are valid cases where a digit can be embedded in a variable name that aren't sequential.

  $payload_32
  $sensor_7
  $sensor_125
  $thermistor_10um_1
[download]

I won't use your tyrannical anti-numerical variable name future language. You'll have to educate people instead.

---

"Look, Shiny Things!" is not a better business strategy than compatibility and reuse.

  $payload_32
  $sensor_7
  $sensor_125
[download]

Didn't you just prove merlyn's point?

Makeshifts last the longest.

No looping required, thanks to the magic split //:

my (@f) = split // => $s;
[download]

I'd suggest having it in an array instead of individual scalars (it usually ends up being far easier to deal with in the rest of the code), but if you really want it that way:

my (
    $f0,
    $f1,
    $f2,
    $f3,
    $f4,
    $f5,
    $f6,
    $f7,
    $f8,
    $f9,
) = split // => $s;
[download]

Since several people have given the @f = split... answer: why do you want to split a string into each individual character anyway? I ask because there may be an easier way to do this.

If, for example, you only want the 4 character, my $f = substr($s, 4, 1) would work (and is proably easier then $fourthchar = $f[4];, after the split, if that's all you want).

The purpose of splitting the string into serialized variables is to use the values in those variables as flags to control reporting granularity. If properly deployed in the Perl code will allow for adjustment of what is reported to a logfile without having to modify the Perl code. The only modification will be to the control string which is housed in an SQL table. Thank you for considering my question.

R_D

Then you can use a for or foreach loop (despite the two tutorials for and foreach are exactly the same in perl, super search if you want to know more) to process each field of an array. Like this:

my $str = '1029576843';
my @f = split //, $str;
for (@f)
{
  #$_ is now 0; next run will be 1 and so on
  print;
}
#or
for my $current_number (@f)
{
  #$current_number is now 0; next run will be 1 and so on
  print $current_number;
}
[download]

"Cogito cogito ergo cogito sum - I think that I think, therefore I think that I am." Ambrose Bierce

Well, generally, you may be better using an array. This can be done quite easily with:

@f = split //, $s;
# Now, each char is in $f[0], $f[1], etc.
[download]

If you absolutely must have seperated variables, you would have to venture into symbolic dereferencing <insert standard security warnings here>.

my $i = 0;
${'f' . $i ++} = $_ for split //, $s
[download]

This code is untested, but should work ;-)

Thank you for generously considering my question and providing an elegant solution,

I had already tried the array form as a solution, but it was inadequate for my purposes due to my limited understanding of Perl.

The string in question is extracted from an SQL table. The values placed in serialized variables are used as flags that govern print statements. Properly deployed they will allow granular control over what is written to a logfile without having to alter Perl code. All adjustments can be made by changing the control string in the SQL table.

Thanks again, I truly appreciate your input.

R_D

If you want to put the values into an array then you could do @array = split //, $s; - named variables like you have are redolent of 'symbolic references' and widely disparaged ...

/J\

my @array = split //, $s;
[download]

no strict 'vars';
for (split //, $s) { eval "\$f$i = $_"; ++$i }
[download]

You don't need to pull out the tactical nuke for this.

my $i = 0;
for( split //, $s ) { no strict 'refs'; ${ 'f' . $i++ } = $_ }
[download]

Makeshifts last the longest.