As I mentioned before, the reverse of this function is the pack function which concatenates into a string a list of values converted according to the formats specified by a template.

Generally, pack is used to write data in a specific format and unpack to get back the list of values that we passed to pack. Please be careful if you use pack on a machine and unpack on another machine with a different byte order, because unpack might interpret the data in a different way than pack wrote it.

The syntax form of the Perl unpack function is as follows:

LIST = unpack TEMPLATE, EXPR

Next I’ll show you a few examples about the usage of some of these templates.

Padding a string with nulls or spaces

The following example shows you how to deal with the Perl unpack function and the 'a' template. Used with the pack function, this template let you pad a binary string with nulls. Used with the Perl unpack function, the 'a' template returns the full field as it is.

See the following code:

#!/usr/local/bin/perl

use strict;
use warnings;

my $str = pack 'a8', '32ab';     # "32ab\0\0\0\0"

foreach(unpack("(a1)*", $str)) {
    print sprintf("%x", ord), " ";
}
print "\n";
# it prints: 33 32 61 62 0 0 0 0

$str = pack 'A8', '32ab';     # "32ab    "
foreach(unpack("(a1)*", $str)) {
    print sprintf("%x", ord), " ";
}
print "\n"
# it prints: 33 32 61 62 20 20 20 20

A few words about the pack function from the first example. The $str is the string where the result will be returned, 'a8' is the template and '32ab' is the string to be converted. The 8 digit in the template is a modifier and it means that it will be appended so many null bytes until the resulting string will have 8 characters length. In the second example pack was used with the template 'A8' and it will result a string having 8 characters, the last four characters being spaces.

The template for the Perl unpack function uses parentheses to group things (like the regular expressions do) and the group is followed by a * repeat count which means to use how many items are left.

The sprintf function allows you to convert in hexadecimal the elements of the list returned by the Perl unpack function. This function was used to see the hexadecimal values of the characters.

The 'A' template is similar with the previous one, except that space is used instead of null. Used with the pack function, this template let you pad an ASCII string with spaces. If you use it with the Perl unpack function, the 'A' template replaces trailing spaces with nulls.

To illustrate this, I’ll rewrite the previous example as:

#!/usr/local/bin/perl

use strict;
use warnings;

# the string is padded with spaces
my $str = pack 'A8', '32ab';     # "32ab    "

foreach(unpack("(A1)*", $str)) {
    print sprintf("%x", ord), " ";
}
print "\n";
# it prints: 33 32 61 62 0 0 0 0

# the string is padded with nulls
$str = pack 'a8', '32ab';     # "32ab\0\0\0\0"
foreach(unpack("(A1)*", $str)) {
    print sprintf("%x", ord), " ";
}
print "\n"
# it prints: 33 32 61 62 0 0 0 0

The 'b' and 'B' formats of the pack function packs strings consisting of 0 and 1 characters to bytes. The Perl unpack function get back the list of 0’s and 1’s from the bit string.

A byte consists of a group of 8 bits as in the following figure:

LSB means here the least significant bit and it is sometimes referred as the rightmost bit. MSB is the most significant bit and is sometimes referred as the leftmost bit. In the above example, MSB = 1 and LSB = 0.

For an example, let’s say you want to represent the decimal number 178 into a string of bits. You can write this number either as '10110010' starting with MSB or as '01001101' starting with LSB. For these representations, Perl has respectively two templates: 'B' and 'b'.

The following example shows you how to pack the above number using the two templates:

# starting with MSB
my $nr = ord pack ('B8', '10110010');
print "$nr\n"; 
# it prints 178 (128 + 32 + 16 + 2)

# starting with LSB
$nr = ord pack ('b8', '01001101');
print "$nr\n"; 
# it prints 178 (2 + 16 + 32 + 128)

You can use the pack function with the 'b*' format to translate a string of 0’s and 1’s into a bit string, and the Perl unpack function to get back the list of 0’s and 1’s from the bit string (the '*' is like a wildcard for more of the same). It is important to use the same format ('b' or 'B' ) for both pack and unpack functions (i.e. if you packed a number with the 'b' template, you must use the same template to unpack the bits string).

Here’s an example about how to use the Perl unpack function with the 'b' template:

#!/usr/local/bin/perl

use strict;
use warnings;

my @bitArray = qw(1 0 0 0 1 1 1 1 0 0 1 1);
my $bitString = pack 'b*', join('', @bitArray);

@bitArray = split(//, unpack('b*', $bitString));
print "@bitArray\n";
# it prints:      1 0 0 0 1 1 1 1 0 0 1 1 0 0 0 0

You can rewrite the previous example by using both pack and unpack functions with the 'B*' format:

#!/usr/local/bin/perl

use strict;
use warnings;

my @bitArray = qw(1 0 0 0 1 1 1 1 0 0 1 1);
my $bitString = pack 'B*', join('', @bitArray);
@bitArray = split(//, unpack('B*', $bitString));
print "@bitArray\n";
# it prints:      1 0 0 0 1 1 1 1 0 0 1 1 0 0 0 0