Perl pack Function
last modified April 4, 2025
The Perl pack function converts data into binary representations.
It's essential for binary file I/O, network protocols, and data serialization.
pack uses template strings to specify data formats. It returns a
binary string containing packed data according to the template. The companion
function is unpack for reversing the process.
Basic pack Usage
The simplest use of pack converts numbers to binary strings.
#!/usr/bin/perl
use strict;
use warnings;
use v5.34.0;
my $packed = pack("C", 65);
print "Packed ASCII 'A': ", unpack("H*", $packed), "\n";
my $packed_short = pack("s", 12345);
print "Packed short: ", unpack("H*", $packed_short), "\n";
We demonstrate packing a character and a short integer. The "C" template packs
an unsigned char, while "s" packs a short. We use unpack to show
the hexadecimal representation.
$ ./basic.pl Packed ASCII 'A': 41 Packed short: 3930
Packing Multiple Values
pack can combine multiple values into a single binary string.
#!/usr/bin/perl
use strict;
use warnings;
use v5.34.0;
my $data = pack("CCCC", 65, 66, 67, 68);
print "Packed ABCD: ", unpack("H*", $data), "\n";
my $mixed = pack("CS", 65, 12345);
print "Packed mixed: ", unpack("H*", $mixed), "\n";
This example packs four characters and a mixed format. The template string specifies the order and type of data to pack. Each format character processes one value from the argument list.
$ ./multiple.pl Packed ABCD: 41424344 Packed mixed: 413930
String Packing
pack can handle strings with various formatting options.
#!/usr/bin/perl
use strict;
use warnings;
use v5.34.0;
my $str = "Perl";
my $packed_str = pack("a4", $str);
print "Packed string: ", unpack("H*", $packed_str), "\n";
my $null_terminated = pack("Z*", $str);
print "Null-terminated: ", unpack("H*", $null_terminated), "\n";
We demonstrate ASCII string packing with "a" (space-padded) and "Z" (null-terminated) formats. The asterisk (*) allows variable-length strings.
$ ./string.pl Packed string: 5065726c Null-terminated: 5065726c00
Network Byte Order
Network protocols often require specific byte ordering.
#!/usr/bin/perl
use strict;
use warnings;
use v5.34.0;
my $port = 80;
my $ip = "192.168.1.1";
my $packed_port = pack("n", $port);
my @octets = split /\./, $ip;
my $packed_ip = pack("C4", @octets);
print "Packed port: ", unpack("H*", $packed_port), "\n";
print "Packed IP: ", unpack("H*", $packed_ip), "\n";
This shows network byte order ("n" for big-endian shorts) and IP address packing. Network protocols typically use big-endian byte order.
$ ./network.pl Packed port: 0050 Packed IP: c0a80101
Binary File Writing
pack is essential for writing binary files.
#!/usr/bin/perl
use strict;
use warnings;
use v5.34.0;
my $filename = "data.bin";
open(my $fh, '>', $filename) or die "Cannot open file: $!";
my $header = pack("a4LL", "DATA", 1, 12345);
print $fh $header;
close($fh);
print "Wrote binary file '$filename'\n";
We create a simple binary file with a header structure. The template "a4LL" packs a 4-byte string followed by two unsigned longs. This is common in binary file formats.
$ ./file.pl Wrote binary file 'data.bin'
Floating Point Numbers
pack can handle floating-point numbers in various formats.
#!/usr/bin/perl
use strict;
use warnings;
use v5.34.0;
my $float = 3.14159;
my $packed_float = pack("f", $float);
my $packed_double = pack("d", $float);
print "Packed float: ", unpack("H*", $packed_float), "\n";
print "Packed double: ", unpack("H*", $packed_double), "\n";
This demonstrates packing floating-point numbers as 32-bit ("f") and 64-bit ("d") values. The exact hexadecimal output depends on your system's float representation.
$ ./float.pl Packed float: d00f4940 Packed double: 6e861bf0f9210940
Complex Data Structures
pack can create complex binary structures with repetition.
#!/usr/bin/perl
use strict;
use warnings;
use v5.34.0;
my @values = (1..5);
my $packed = pack("L5", @values);
print "Packed array: ", unpack("H*", $packed), "\n";
my $struct = pack("LSZ8", 12345, 3.14, "Perl");
print "Packed struct: ", unpack("H*", $struct), "\n";
We pack an array of longs and a mixed structure. The "5" in "L5" repeats the long format five times. Complex binary protocols often use such structures.
$ ./complex.pl Packed array: 0100000002000000030000000400000005000000 Packed struct: 39300000c3f54840Perl00
Best Practices
- Use explicit formats: Clearly specify byte order and sizes.
- Validate input: Ensure data fits the target format.
- Document templates: Comment complex format strings.
- Test cross-platform: Byte order may differ between systems.
- Combine with unpack: Verify packed data by unpacking.
Source
This tutorial covered Perl's pack function with practical
examples demonstrating binary data conversion in various scenarios.
Author
List all Perl tutorials.