I want to use a scalar $string in a very C-like way, that is I want to run through the @string character by character, fiddling with chars along the way.

my @chars = split //, $string;
[download]

foreach my $char (split //, $some_string)
{
        if($char eq " ")
        {
                 print "it was a space!";
                        # change all spaces to |s
                 $char = "|";
        }
}
[download]

$string = join("", @chars);
[download]

Hope it helps.

jarich

A reasonable solution, but I want to do this without
invoking the regex engine, so split is strictly taboo...Any other ideas?
--
Microsoft delendum est.

If substr's okay, how about this kind of thing:

my $string = "This is a very long string";
foreach (0..length($string))
{
        if(substr($string, $_, 1) eq " ")
        {
                    # Replace this position (space) with a "|"
                substr($string, $_, 1, "|");
        }
}
print $string;
[download]

It kinda depends on what you're trying to do, but I think this might help. (Note that you can also replace with the empty string).

Hope it does.

jarich

Update: forgot the length. ;)

A reasonable solution, but I want to do this without invoking the regex engine

When you say, "I wanna do $X", and the answer is "by doing $Y", and then you say "I wanna do $X but without doing $Y", you are obligated to provide a reason why the best/easiest way ($Y) is so easily dismissed. How close to doing $Y can you get, for example, and why not $Y? {grin}

You haven't yet. Please do so.

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

What's the deal with imposing ridiculous, artificial restrictions? Split is the correct way to do it, so there.

--
Regards,
Helgi Briem
helgi AT decode DOT is

The @{[$string]} construction does not correspond to what you want. It evaluates to an array of one element, a copy of the value of $string. I don't quite see what you're attempting with the second try. A string in list context is a one element list.

The perlish way to treat the characters of a string as an array is to produce the array with my @str_ary = split '', $string;, but that does not help you modify the characters of $string in place, as the C char * as array construction would.

You're best bet is with substr. Letting sub fiddle {} take a character and return whatever you wish,

my $index;
while ( $index < length( $string) ) {
    substr( $string, $index, 1) = fiddle(substr( $string, $index, 1));
    $index++;
}
[download]

Note that &fiddle can return empty or strings longer than one character, and the changed length will be handled. That is probably an invitation to code with mysterious behaviors, and non-termination is possible.

After Compline,
Zaxo

  $foo = "hello, world";
  @foo = unpack( ("a" x length($foo)), $foo);
  @foo = map { bar $_ } @foo;
  $foo = pack( ("a"x@foo), @foo);
[download]

For instance if you want to iterate over the characters of the string, performing some kind of transformation upon them you probably want to do something like

  s/(.)/ord($1)>127 or ord($1)<=32 ? sprintf("%%%02x",ord($1)) : $1/se
+;
[download]

for my $ofs (0..length($str)-1) {
  my $c=substr($str,$ofs,1);
  substr($str,$ofs,1)=sprintf("%%%02x",ord($c)) if ord($c)>127 or ord(
+$c)<=32;
}
[download]

Before you ask why I don't just do this in C, it's because I want to see if it can be done in Perl.

Perl is a GPPL/Turing Complete. Thus it can do _anything_ that any other turing complete/GPPL language can do. And of course C is turing complete....

The real question is how fast was it to write, how maintainable is it, how fast is it to run, and how much did it cost to write. Normally Perl outperforms C when all criteria are taken together. Of course there some things that are much easier in C. But iterating over a character array isnt really one of them.

--- demerphq
my friends call me, usually because I'm late....

The easiest way to force something into list context is to use the second example that you posted. Here's an example that I used on this week's Perl Quiz of the Week, to force a globally matching regular expression to match in list context:

() = ($_[0] =~ /no spoilers :P/g);
[download]

for the benefit of those (or I) who are reading with interest. jryan can you untangle this a bit?.
()= I understand as filling an anonymous list with whatever is to the right of =. Forcing list context.
But what is being evaluated by the regex? just the first element of the @_ array ?
Deductivly the enclosing ( .... ) parens do magic on @_ but WTF? has anyone ever written a 'golf disassembler' ?

submersible_toaster
-they all say 'my computer is frozen!'. just once couldn't one catch fire?

But what is being evaluated by the regex? just the first element of the @_ array ?

The regex match is doing just what is in the code - matching the first element of @_ with the regex. The effect of the list context is that whatever is matched is returned e.g

print map("[$_]", "foo bar baz quux" =~ /b\w+ /g), $/;

__output__

[bar ][baz ]
[download]

This is the result of the g modifier in list context without capturing parens. With capturing parens however it returns a list of what was captured e.g

print map("[$_]", "foo bar baz quux" =~ /(b\w+) /g), $/;

__output__

[bar][baz]
[download]

For more info regarding regex matching and context see the Regexp Quote-Like Operators section in perlop.
HTH

_________
broquaint

I think that the confusion is my fault. You are correct that () = is forcing the matches of the regular expression to fill an anyonomous list (which should get optimized out), and are also correct that the match is being evaluated against the first element of @_ (in this case, the first argument to a subroutine). However, there is no magic being done on @_. The enclosing parens could have been completely left out. Here is my code fleshed out a little more:

sub expand_number_list {
    my @matches;
    () = ($_[0] =~ /
        (match something)
        (??{munge the match and push it to @matches})
    /xg);
    return @matches;
}
[download]

Generally, the point is that just adding () = will force your expression into list context. Please see Forcing list context for more details.

If you want to process the characters one by one, the standard idiom is to use:

    foreach my $ch (split // => $string) { .. }
[download]

However, you put yourself under the restriction of not wanting to use regexes. Without specifying why. That's fine by me, but if you like to solve artificial puzzles, have fun on your own!

Abigail

I want to use a scalar $string in a very C-like way

You could always use Data::Pointer e.g

use Data::Pointer qw( char_ptr );

for(my $p = char_ptr("a string of characters"); $p->deref; $p->incr) {
  print '[', $p->deref, ']';
}

__output__

[a][ ][s][t][r][i][n][g][ ][o][f][ ][c][h][a][r][a][c][t][e][r][s]
[download]

</plug>

HTH

_________
broquaint

Have a look at Tie::CharArray, this ties a string to an array of characters.

Hope this helps, -gjb-

If I interpret your intent correctly, you want to convert a scalar to an anonymous array of its chars in a manner that allows it to be used as part of another expression without using the regex engine, which I assume to be because this could be part of an expression embedded in a regex itself and you need to avoid recursive calls that cause the regex engine to blow up?

You could try one of these:

do{{push@_,chop;redo if length};@_}
do{while($£=chop){push@_,$£};@_}
[download]

Both should be usable anywhere an anonymous array can be used. The caveat is that the order of the characters is reversed, but that is easily dealt with.

None of this has anything to do with "list context", though.

See also Are strings lists of characters? for a few ways to do it (complete with benchmarks) and why you might not need to do it.

Just a query
UnderMine