You could introduce another scope just for the length call, but personally, I much prefer to do my $bytes = bytes::length($string);.

(use bytes went beyond scope).

$ cat /tmp/p
#!/usr/bin/perl -wl

my $s = "\x{100}";

print length $s;
{
    use bytes;
    print length $s;
}
print length $s;

$ perl588 /tmp/p
1
2
1
$
[download]

Dave.

If he/she is doing:

SCOPE: {
   use bytes;
   $l = length $foo;
   do_something();
}
[download]

Then the scope becomes wider :) bytes will affect anything in do_something()

Not so.

sub print_length {
   my ($s) = @_;
   print(length($s), "\n");
}


my $s = "\x{100}";

print_length($s);   # 1

{
   use bytes;
   print_length($s);         # 1
   print(length($s), "\n");  # 2
}

print_length($s);  # 1
[download]

Use a do block to limit the scope:

$s = "\x{100}";;
print do{ use bytes; length $s } . ' : ' .  length $s;;

2 : 1
[download]

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

Lingua non convalesco, consenesco et abolesco. -- Rule 1 has a caveat! -- Who broke the cabal?

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

well, duh.

use bytes;
my $s = "\x{100}";
print length $s;
{
    no bytes;
    print length $s;
}
print length $s;

2
1
2
[download]

open( INPUT, "<:raw", "some_file.utf8" ) or die "bleah: $!";
{
    local $/;
    $_ = <INPUT>;
}

my $nbytes = length();

my $nchars = tr/\x00-\x7F\xC2-\xFF//;
[download]

While it is conceivable to have "wide characters" whose first byte is 0xC0 or 0xC1, this would actually constitute "malformed utf8", in the sense that two bytes are being used to express code points within the ascii range, which would be a dirty trick to play on anybody.

Check the "Unicode Encodings" section of perlunicode to see a more detailed explanation of utf8.

(updated to improve clarity and accuracy)

I need to use "use bytes,"

You guys are AWESOME! All your comments helped give me insight into this issue I've been pondering for a few months. Thanks to you guys I've found a solution! In particular, Joost mentioned that use bytes messes up utf8 encoding flags, and graff pointed me to the perl docs more utf8 byte thinking. Somehow this time this got me thinking in a different direction which led me to this:
http://ahinea.com/en/tech/perl-unicode-struggle.html.
In particular, check out this:
$ustring2 = pack "U0C*", unpack "C*", $ustring2;

Whenever I did $string = chr(20000), the length function counted 1 character. When I had input from a form, the length function counted in bytes. Somehow my form input function was messing up the flags.

Apparently use bytes may have been working within scope, but the string we were analyzing had messed up utf8 flags. Putting a no bytes before and a use bytes after my few lines of counting characters keeps everything working super.

So why do we want to use bytes? Our application counts the number if bytes in a message, wraps it in a wrapper, and tells some other component how many bytes to expect. If the count is wrong the message is rejected and components get shut down. We were uploading files with Chinese characters in the filename and the application seemed to shut down. We traced this problem to the length function counting characters instead of bytes. Since most string functions we use deal with byte counts, we'd like to use bytes and make character counts the exception.