Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Contact Us
Online Help
Domain Status
Man Pages

Virtual Servers

Topology Map

Server Agreement
Year 2038

USA Flag



Man Pages

Manual Reference Pages  -  COMPRESS::LZF (3)

.ds Aq ’


Compress::LZF - extremely light-weight Lempel-Ziv-Free compression



   # import compress/decompress functions
   use Compress::LZF;
   # the same as above
   use Compress::LZF :compress;

   $compressed = compress $uncompressed_data;
   $original_data = decompress $compressed;

   # import sfreeze, sfreeze_cref and sfreeze_c
   use Compress::LZF :freeze;

   $serialized = sfreeze_c [4,5,6];
   $original_data = sthaw $serialized;


LZF is an extremely fast (not that much slower than a pure memcpy) compression algorithm. It is ideal for applications where you want to save some space but not at the cost of speed. It is ideal for repetitive data as well. The module is self-contained and very small (no large library to be pulled in). It is also free, so there should be no problems incorporating this module into commercial programs.

I have no idea wether any patents in any countries apply to this algorithm, but at the moment it is believed that it is free from any patents.


$compressed = compress $uncompressed
$compressed = compress_best $uncompressed Try to compress the given string as quickly and as much as possible. In the worst case, the string can enlarge by 1 byte, but that should be the absolute exception. You can expect a 45% compression ratio on large, binary strings.

The compress_best function uses a different algorithm that is slower but usually achieves better compression.

$decompressed = decompress $compressed Uncompress the string (compressed by compress) and return the original data. Decompression errors can result in either broken data (there is no checksum kept) or a runtime error.
$serialized = sfreeze $value (simplified freeze)
$serialized = sfreeze_best $value Often there is the need to serialize data into a string. This function does that, by using the Storable module. It does the following transforms:

  undef (the perl undefined value)
     => a special cookie (undefness is being preserved)
  IV, NV, PV (i.e. a _plain_ perl scalar):
     => stays as is when it contains normal text/numbers
     => gets serialized into a string
  RV, undef, other funny objects (magical ones for example):
     => data structure is freezed into a string.

That is, it tries to leave normal, human-readable data untouched but still serializes complex data structures into strings. The idea is to keep readability as high as possible, and in cases readability can’t be helped anyways, it tries to compress the string.

The sfreeze functions will enlarge the original data one byte at most and will only load the Storable method when neccessary.

The sfreeze_best function uses a different algorithm that is slower but usually achieves better compression.

$serialized = sfreeze_c $value (sfreeze and compress)
$serialized = sfreeze_c_best $value Similar to sfreeze, but always tries to compress the resulting string. This still leaves most small objects (most numbers) untouched.

The sfreeze_c function uses a different algorithm that is slower but usually achieves better compression.

$serialized = sfreeze_cr $value (sfreeze and compress references)
$serialized = sfreeze_cr_best $value Similar to sfreeze, but tries to compress the resulting string unless it’s a simple string. References for example are not simple and as such are being compressed.

The sfreeze_cr_best function uses a different algorithm that is slower but usually achieves better compression.

$original_data = sthaw $serialized Recreate the original object from it’s serialized representation. This function automatically detects all the different sfreeze formats.
Compress::LZF::set_serializer $package, $freeze, $thaw Set the serialize module and functions to use. The default is Storable, Storable::net_mstore and Storable::mretrieve, which should be fine for most purposes.


Other Compress::* modules, especially Compress::LZV1 (an older, less speedy module that guarentees only 1 byte overhead worst case) and Compress::Zlib.


This perl extension and the underlying liblzf were written by Marc Lehmann <> (See also


Search for    or go to Top of page |  Section 3 |  Main Index

perl v5.20.3 LZF (3) 2013-08-25

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.