_____________________________________________________
Jeff[japhy]Pinyan: Perl, regex, and perl hacker.
s++=END;++y(;-P)}y js++=;shajsj<++y(p-q)}?print:??;

$text =~ s/[\x00-\x09\x0b-\x1f]+//g; # + for speed
# or
$text =~ tr/\x00-\x09\x0b-\x1f//d; # tr/// for even more speed
[download]

# OLD:$text =~ s/(?!\n)[^\x00-\x1f]//g;
$text =~ s/[^\x00-\x1f](?<!\n)//g; # (Can't use + now)

# or (if you need to exclude another character,
# let's say \n and \r

# OLD:$text =~ s/(?![\r\n])[^\x00-\x1f]//g;
$text =~ s/[^\x00-\x1f](?<![\r\n])//g;

# Note: it's usually better to avoid \r and \n and use
# literals like \cM and \cJ or \015, \012 or \x0d, \x0a.
[download]

2;0 juerd@ouranos:~$ perl -e'undef christmas'
Segmentation fault
2;139 juerd@ouranos:~$
[download]

Two ways come to mind. First, like Juerd's, use an assertion (lookbehind in this example):

    my $delete  = join '','a'..'z'; # remove all lower case letters
    my $exclude = 'aeiou';          # exluding vowels

    $_ = 'Just Another Perl Hacker';
    s/(?:[$delete](?<![$exclude]))+//g;
    print;
[download]

Or, slightly more complex, remove the exclusion characters from the deletion set first. This should prove more efficient, especially if you are repeatedly applying the deletion regex after you create it:

    my $delete  = join '','a'..'z'; # remove all lower case letters
    my $exclude = 'aeiou';
    $delete =~ s/[$exclude]+//g;    # excluding vowels

    $_ = 'Just Another Perl Hacker';
    s/[$delete]+//g;
    print;
[download]

Either way, it is relatively simple to add or remove characters from your exclusion set.

Update: By "slightly more complex" I mean that it entails an extra step on your part --- in truth, I think it is the logically simpler version.

This can be made even simpler. Remember that if a character is listed in a tr/// searchlist more than once, only the first occurance is meaningful. This means you can do something like:

    $string =~ tr/\n\000-\037/\n/d;
[download]

(Note I'm using octal here). This specifies that the newline character is replaced by itself, while everything else in that range is deleted.

There are three advantages to this method: <NL>

• It's (IMHO) cleaner and easier to read.
• It's easier to modify, e.g. to exempt additional characters from being deleted.
• It doesn't care what character is used for newline on the current platform. For example, I seem to remember that \n and \r have their meanings reversed on one platform (Macintosh?) because the platform standard is to use CR for line breaks. </NL>

True i thought about tr/// too... but "a range of chars except one", could also be read "a range of chars PLUS one" (i like to reverse things up). tr/// also offer a complement modifier to it.
So when i need to delete chars, it seems more simple to write the one i actually want to keep, preventing me to forget some:

$_ = "123,Let's keep letters!\nAnd new lines..."
tr/A-Za-z \n//cd;
print;

will print:

Lets keep letters
And new lines


Creating that range could be easier...

It's just my two cents.
Freddo

I was thinking along the same lines, but the fact that Marcello is using variables rather than constants to define the range implies that his search ranges may vary. To use tr here with differing ranges, he must use eval. As we read in perlop,

Because the transliteration table is built at compile time, neither the SEARCHLIST nor the REPLACEMENTLIST are subjected to double quote interpolation. That means that if you want to use variables, you must use an eval():

    eval "tr/$oldlist/$newlist/";
    die $@ if $@;

    eval "tr/$oldlist/$newlist/, 1" or die $@;
[download]

HTH,

Josh

Perl has an entirely different feel from what you're used to now (I'm guessing VB or C). Let it wash over you and enjoy it.

xoxo,
Andy
--
<megaphone> Throw down the gun and tiara and come out of the float! </megaphone>

Not all data is ascii. Your piece of code will remove all unicode characters, which may or may not be what you want.

2;0 juerd@ouranos:~$ perl -e'undef christmas'
Segmentation fault
2;139 juerd@ouranos:~$
[download]

$startCh = chr(0);
$midstopCh = chr(9);
$midstartCh = chr(11);
$endCh = chr(31);

$text =~ s/[$startCh-$midstopCh,$midstartCh-$endCh]//g;
[download]

Beware of ',' (comma) in this regexp. It should not be there. Otherwise all commas will be stripped from $text.

Update:

I'm supprised no one has suggested a more complex range

Actually Juerd's reply does suggest solution which uses complex range.

--
Ilya Martynov (http://martynov.org/)