The first argument of vec says what variable it acts on. The third says how many bits make a unit in the vector. The second is the offset in units of the third argument where things will happen.

ord applied to a string returns ord of its first character.

Thus, vec($foo,0,8) = ord($foo); is a no-op, replacing the first character of $foo by itself. In more depth:

$ perl -e'my $foo = "qa"; vec($foo,0,8) = ord $foo;print $foo,$/'
qa
$ perl -e'my $foo = "qa"; vec($foo,1,8) = ord $foo;print $foo,$/'
qq
$ perl -e'my $foo = "qa"; vec($foo,2,8) = ord $foo;print $foo,$/'
qaq

Update: I just noticed that the op is ==, numerical equality. I think that should always be true, but there might be tricky edge cases related to encoding.

This is an example of a bit vector (a vector of "0"s or "1"s)

## Define a bit vector with positions 4 to 7 set to 1
my $bv1='';
vec($bv1,$_,1)=1 foreach (3..6);
dumpbv($bv1);

sub dumpbv
{
    my $bitv = shift @_;
    my $pos=0;
    foreach (split "",unpack("b*",$bitv)){
      print;
      $pos++;
    }
}
[download]

With bit vectors you can do bit operations. for example, to find the overlapping ("OR") of 2 bit vectors:

sub sumbv
{
    return $_[0] | $_[1];
}
[download]

... and the AND operation:

sub cmpbv
{
    return $_[0] & $_[1];
}
[download]

A full working dummy example with these functions would be:

use strict;
use warnings;

## Define a bit vector with positions 4 to 7 set to 1
my $bv1='';
vec($bv1,$_,1)=1 foreach (3..6);
dumpbv ($bv1); print " bv1\n";

# Define a bit vector with positions 3 to 5 set to 1
my $bv2='';
vec($bv2,$_,1)=1 foreach (2..4);
dumpbv ($bv2); print " bv2\n";

print "--------\n";

my $bv_sum = sumbv($bv1,$bv2);
dumpbv ($bv_sum);print " OR\n";

my $bv_cmp = cmpbv($bv1,$bv2);
dumpbv ($bv_cmp);print " AND\n";

sub sumbv
{
    return $_[0] | $_[1];
}

sub cmpbv
{
    return $_[0] & $_[1];
}

sub dumpbv
{
    my $bitv = shift @_;
    my $pos=0;
    foreach (split "",unpack("b*",$bitv)){
      print;
      $pos++;
    }
}
[download]

Outputs:

00011110 bv1
00111000 bv2
--------
00111110 OR
00011000 AND
[download]

Hope this helps

citromatik

How are any of these code examples useful and or how are you applying these in a work environment?

The ability to manipulate bits is essential in many low level tasks and in some memory-efficient algorithms.

I can't think of any time where the two would be different when $foo contains a string of octets, but the equality is not always true if $foo contains a string of chars.

>perl -MHTML::Entities -le"$foo=decode_entities('♥'); print for
+ vec($foo,0,8), ord($foo)"
226
9829
[download]

vec($f,0,8) looks at the first octet of the internal representation of the string, whereas ord looks at the first character of the string.