for the simple on/off case, you can also use XOR:
my @Toggles = qw(on off);
$Toggles[$flip^=1];
| [reply]
[d/l] |
Ooooooh. Very nice! Hadn't seen that.
| [reply] |
You can use Tie::FlipFlop for the same purpose. Here's the
synopsis from the perldoc document:
use Tie::FlipFlop;
tie my $flipflop => Tie::FlipFlop => qw /Red Green/;
print $flipflop; # Prints 'Red'.
print $flipflop; # Prints 'Green'.
print $flipflop; # Prints 'Red'.
It's probably too much for such a simple function but
frees you from keeping the $flip
variable around.
You can use Tie::Counter in the same
fashion to rotate through more than two elements.
| [reply]
[d/l] |
for (1..12){
print "$Cheers[$flip = ++$flip % 4]\n";
}
because you're throwing away the result of the ++. Either
change it to
$flip = ($flip + 1) % 4;
or the slightly cooler
($flip += 1) %= 4;
-- Randal L. Schwartz, Perl hacker | [reply]
[d/l]
[select] |
Interesting idea about throwing away the result of ++. I
disagree...
But, why would we care?
I settled on this code because I believe it specifically
addresses the large-scale operation we want, which is
increment $flip each time, but reset it to zero when it
gets to 4. As opposed to: set $flip according to
the following formula...
Each time through, we want to increase the value of $flip
by 1. The idiomatic way to say that is ++$flip.
What, fundamentally, is the difference between
$flip = ++$flip % 4
and
$flip = ($flip + 1) % 4
(except being three characters longer) when the
entire point is to increase $flip by 1?
I guess my question is: why do you think I am throwing away
a result which you only accomplish differently? "++" vs.
"+ 1" -- they both add one to the value of $flip. See below
for the readability benefits of using ++ to add one to a
variable.
I like the shorter (by two characters, but hey...) version
($flip += 1) %= 4
but by your argument, you shouldn't like it, either, since
it increments $flip, just to "throw the result of the +=
away." I don't understand your objection.
It is also much closer to being needlessly obfuscated, with
all the obvious negatives... (though my coworkers might be
shocked to hear that I don't prefer obfuscation :-)
I'm sure you considered, as I did:
for (1..12){
print "$Cheers[++$flip % 4]\n";
}
and rejected it because we want to emphasize the purpose of
$flip, which is to cycle among the elements of the array.
We assign to $flip to keep its value within the legal
bounds. By this we make it obvious (at a glance) to the
poor programmer who comes behind us that $flip will
only hold values between (in this example) 0 and 3,
because those are the only values we want.
I would argue that the preincrement adds a huge "obviousness"
value for the aforementioned fellow programmer. ++$flip
triggers an immediate (subconscious?) understanding of our
intent. Similarly, <nobr>$flip = ++$flip % 4</nobr> is, I
believe, immediately obvious in a way that
<nobr>($flip += 1) %= 4</nobr> can never be.
<nobr>($flip + 1)</nobr> is plain in its intent (make $flip
increase by one each time), but not as plain as ++$flip.
Russ | [reply]
[d/l]
[select] |
$flip + 1;
does not change in any way the scalar referred to
by $flip, while "++$flip" does. Simple as that.
===
What, fundamentally, is the difference between
$flip = ++$flip % 4
and
$flip = ($flip + 1) % 4
===
The first changes the value of $flip twice, the
second, only once. In the first one, the computer
is saying:
- Increase the value of $flip by one
- Modulo 4 it
- Assign the result into $flip
versus:
- Compute the value of $flip + 1
- Modulo for that (temporary) value
- Assign the result into $flip
| [reply]
[d/l] |