pack

(PHP 4, PHP 5, PHP 7, PHP 8)

pack — Veriyi ikil bir dizge halinde paketler

Açıklama

pack(string $biçem, mixed ...$değerler): string

Belirtilen değerleri belirtilen biçem biçeminde bir ikil bir dizge olarak paketler.

Anafikir Perl'den alınmış olup, tüm biçemleme kodları Perl'deki gibi çalışır. Ancak, biçemleme türleri aynı değildir, örneğin "u" biçemi Perl'de yoktur.

Şuna dikkat: İşaretli ve işaretsiz değerler arasındaki ayrım sadece unpack() işlevini etkiler. pack() işlevi her ikisi için de aynı sonuçları üretir.

Değiştirgeler

biçem

biçem dzgesi isteğe bağlı bir yineleme değiştirgesi ile öncelenmiş biçem kodlarından oluşur. Yineleme değiştirgesi bir tamsayı değer veya girdi verisinin sonuna kadar yineleme belirten bir * olabilir. a, A, h, H için yineleme sayısı, bir veri değiştirgesinden kaç karakter alındığını belirtir. @ için yineleme sayısı ise, sonraki verinin konacağı mutlak konumu belirtir. Bunlar dışında kalan herşey için yineleme sayısı, sonuçlanan ikil dizgede paketlenmek üzere kaç tane veri argümanın toplanacağını belirtir.

Şimdilik gerçeklenmiş biçemler:

**pack()** biçem karakterleri
Kod	Açıklama
a	NUL-dolgulu dizge
A	BOŞLUK dolgulu dizge
h	Onaltılık dizge, küçük dörtlü önce gelir
H	Onaltılık dizge, büyük dörtlü önce gelir
c	işaretli bayt
C	işaretsiz bayt
s	İşaretli kısa tamsayı (daima 16 bit olup, makine bayt sıralamasındadır)
S	İşaretsiz kısa tamsayı (daima 16 bit olup, makine bayt sıralamasındadır)
n	İşaretsiz kısa tamsayı (daima 16 bit olup, en değerli bayt baştadır)
v	İşaretsiz kısa tamsayı (daima 16 bit olup, en değersiz bayt baştadır)
i	İşaretli tamsayı (boyut ve bayt sıralaması makineye bağlıdır)
I	İşaretsiz tamsayı (boyut ve bayt sıralaması makineye bağlıdır)
l	İşaretli uzun tamsayı (daima 32 bit olup, makine bayt sıralamasındadır)
L	İşaretsiz uzun tamsayı (daima 32 bit olup, makine bayt sıralamasındadır)
N	İşaretsiz uzun tamsayı (daima 32 bit olup, en değerli bayt baştadır)
V	İşaretsiz uzun tamsayı (daima 32 bit olup, en değersiz bayt baştadır)
q	İşaretli çok uzun tamsayı (daima 64 bit olup, makine bayt sıralamasındadır)
Q	İşaretsiz çok uzun tamsayı (daima 64 bit olup, makine bayt sıralamasındadır)
J	İşaretsiz çok uzun tamsayı (daima 64 bit olup, en değerli bayt baştadır)
P	unsigned long long (daima 64 bit olup, en değersiz bayt baştadır)
f	Tek hassasiyetli gerçek sayı - float (boyut ve gösterim makineye bağlıdır)
g	Tek hassasiyetli gerçek sayı (boyut makineye bağlı, en değersiz bayt baştadır)
G	Tek hassasiyetli gerçek sayı (boyut makineye bağlı, en değerli bayt baştadır)
d	Çift hassasiyetli gerçek sayı - double (boyut ve gösterim makineye bağlıdır)
e	Çift hassasiyetli gerçek sayı (boyut makineye bağlı, en değersiz bayt baştadır)
E	Çift hassasiyetli gerçek sayı (boyut makineye bağlı, en değerli bayt baştadır)
x	NUL bayt (0. karakter)
X	Bir baytlık yedek
Z	NUL dolgulu dizge
@	Bir mutlak konuma kadar NUL dolgu

değerler

Dönen Değerler

Başarı durumunda veriyi içeren ikil bir dizge, başarısızlık durumunda false döner

Sürüm Bilgisi

Sürüm:	Açıklama
8.0.0	Başarısızlık durumunda artık `false` dönmüyor.
7.2.0	float ve double türlerin ikisininde değerli baytları başta ve sonda olabiliyor.
7.0.15,7.1.1	float ve double türler için bayt sıralaması desteğini sağlayan "e", "E", "g" ve "G" kodları eklendi.

Örnekler

Örnek 1 - pack() örneği


<?php
$ikilveri = pack("nvc*", 0x1234, 0x5678, 65, 66);
?>

Elde edilen ikil dizge 6 bayt uzunlukta olur ve sırayla 0x12, 0x34, 0x78, 0x56, 0x41, 0x42 baytlarını içerir.

Notlar

Dikkat

PHP'nin dahili olarak int değerlerini, boyutu makineye bağlı işaretli değerler(C türü: long) olarak sakladığını unutmayın. int türünün sınırları dışında sayılar veren tamsayı değişmezleri ve işlemleri float olarak saklanır. Bu kayan noktalı sayılar, tamsayı olarak paketlenirken önce tamsayı türüne dönüştürülür. Bu, her zaman istenen bayt gösterimiyle sonuçlanmayabilir.

En alakalı durum, işaretsiz int türüyle temsil edilebilecek işaretsiz sayıların paketlenmesidir. int türünün 32 bit boyuta sahip olduğu sistemlerde, dönüştürme genellikle işaretsiz int bayt gösterimiyle sonuçlanır (bu, C standardına göre gerçeklenimle tanımlı işaretsizden işaretliye dönüşüm işlemlerine dayanır). int türünün 64 bit olduğu sistemlerde, float türü bu değerleri büyük olasılıkla hassasiyet kaybı olmadan tutacak kadar büyük bir mantise sahip değildir. Bu sistemlerde yerel 64 bitlik C int türü varsa (çoğu UNIX benzeri sistemde yoktur), üst aralıkta I pack biçemini kullanmanın tek yolu, istenen işaretsiz değer olarak, aynı bayt gösterimine sahip negatif int değerler oluşturmaktır.

Ayrıca Bakınız

unpack() - Paketlenmiş bir ikil dizgeden verileri ayrıştırır

add a note

User Contributed Notes 20 notes

down

chadm at codeangel dot org ¶

12 years ago


If you'd like to understand pack/unpack. There is a tutorial here in perl, that works equally well in understanding it for php:

http://perldoc.perl.org/perlpacktut.html

down

stanislav dot eckert at vizson dot de ¶

7 years ago


A helper class to convert integer to binary strings and vice versa. Useful for writing and reading integers to / from files or sockets.

<?php

    class int_helper
    {
        public static function int8($i) {
            return is_int($i) ? pack("c", $i) : unpack("c", $i)[1];
        }

        public static function uInt8($i) {
            return is_int($i) ? pack("C", $i) : unpack("C", $i)[1];
        }

        public static function int16($i) {
            return is_int($i) ? pack("s", $i) : unpack("s", $i)[1];
        }

        public static function uInt16($i, $endianness=false) {
            $f = is_int($i) ? "pack" : "unpack";

            if ($endianness === true) {  // big-endian
                $i = $f("n", $i);
            }
            else if ($endianness === false) {  // little-endian
                $i = $f("v", $i);
            }
            else if ($endianness === null) {  // machine byte order
                $i = $f("S", $i);
            }

            return is_array($i) ? $i[1] : $i;
        }

        public static function int32($i) {
            return is_int($i) ? pack("l", $i) : unpack("l", $i)[1];
        }

        public static function uInt32($i, $endianness=false) {
            $f = is_int($i) ? "pack" : "unpack";

            if ($endianness === true) {  // big-endian
                $i = $f("N", $i);
            }
            else if ($endianness === false) {  // little-endian
                $i = $f("V", $i);
            }
            else if ($endianness === null) {  // machine byte order
                $i = $f("L", $i);
            }

            return is_array($i) ? $i[1] : $i;
        }

        public static function int64($i) {
            return is_int($i) ? pack("q", $i) : unpack("q", $i)[1];
        }

        public static function uInt64($i, $endianness=false) {
            $f = is_int($i) ? "pack" : "unpack";

            if ($endianness === true) {  // big-endian
                $i = $f("J", $i);
            }
            else if ($endianness === false) {  // little-endian
                $i = $f("P", $i);
            }
            else if ($endianness === null) {  // machine byte order
                $i = $f("Q", $i);
            }

            return is_array($i) ? $i[1] : $i;
        }
    }
?>

Usage example:
<?php
    Header("Content-Type: text/plain");
    include("int_helper.php");

    echo int_helper::uInt8(0x6b) . PHP_EOL;  // k
    echo int_helper::uInt8(107) . PHP_EOL;  // k
    echo int_helper::uInt8("\x6b") . PHP_EOL . PHP_EOL;  // 107

    echo int_helper::uInt16(4101) . PHP_EOL;  // \x05\x10
    echo int_helper::uInt16("\x05\x10") . PHP_EOL;  // 4101
    echo int_helper::uInt16("\x05\x10", true) . PHP_EOL . PHP_EOL;  // 1296

    echo int_helper::uInt32(2147483647) . PHP_EOL;  // \xff\xff\xff\x7f
    echo int_helper::uInt32("\xff\xff\xff\x7f") . PHP_EOL . PHP_EOL;  // 2147483647

    // Note: Test this with 64-bit build of PHP
    echo int_helper::uInt64(9223372036854775807) . PHP_EOL;  // \xff\xff\xff\xff\xff\xff\xff\x7f
    echo int_helper::uInt64("\xff\xff\xff\xff\xff\xff\xff\x7f") . PHP_EOL . PHP_EOL;  // 9223372036854775807

?>

down

plutus at gmx dot de ¶

23 years ago


Note that the the upper command in perl looks like this:



$binarydata = pack ("n v c*", 0x1234, 0x5678, 65, 66);

In PHP it seems that no whitespaces are allowed in the first parameter. So if you want to convert your pack command from perl -> PHP, don't forget to remove the whitespaces!

down

FrozenFire ¶

13 years ago


If you need to unpack a signed short from big-endian or little-endian specifically, instead of machine-byte-order, you need only unpack it as the unsigned form, and then if the result is >= 2^15, subtract 2^16 from it.



And example would be:



<?php

$foo = unpack("n", $signedbigendianshort);

$foo = $foo[1];

if($foo >= pow(2, 15)) $foo -= pow(2, 16);

?>

down

j.s.hoekstra ¶

18 years ago


/* Convert float from HostOrder to Network Order */
function FToN( $val )
{
    $a = unpack("I",pack( "f",$val ));
    return pack("N",$a[1] );
}
    
/* Convert float from Network Order to HostOrder */
function NToF($val )
{
    $a = unpack("N",$val);
    $b = unpack("f",pack( "I",$a[1]));
    return $b[1];
}

down

Anonymous ¶

14 years ago


Coder's example is basically an explanation of bindec() and decbin(), not pack() and unpack().

Here's some code to convert a string binary expression into its binary-string equivalent and vice versa.

(Would be even simpler if pack/unpack offered a 'b' format code....)

<?php
function bin2bstr($input)
// Convert a binary expression (e.g., "100111") into a binary-string
{
  if (!is_string($input)) return null; // Sanity check

  // Pack into a string
  return pack('H*', base_convert($input, 2, 16));
}

function bstr2bin($input)
// Binary representation of a binary-string
{
  if (!is_string($input)) return null; // Sanity check

  // Unpack as a hexadecimal string
  $value = unpack('H*', $input);
  
  // Output binary representation
  return base_convert($value[1], 16, 2);
}

// Returns string(3) "ABC"
var_dump(bin2bstr('01000001 01000010 01000011'));

// Returns string(24) "010000010100001001000011"
var_dump(bstr2bin('ABC'));
?>

down

php at nagler-ihlein dot de ¶

15 years ago


Be aware of format code H always padding the 0 for byte-alignment to the right (for odd count of nibbles).

So pack("H", "7") results in 0x70 (ASCII character 'p') and not in 0x07 (BELL character)
as well as pack("H*", "347") results in 0x34 ('4') and 0x70 ('p') and not 0x03 and 0x47.

down

zilinex at yahoo dot com ¶

19 years ago


a cool function to converrt numbers to Persian numbers(utf-8) 
origin: http://www.farsiweb.info/jalali/jalali.phps

function farsinum($str)
{
  $ret = "";
  for ($i = 0; $i < strlen($str); ++$i) {
        $c = $str[$i];
        if( $c >= '0' && $c <= '9' )
                $out .= pack("C*", 0xDB, 0xB0 + $c);
        else
                $ret .= $c;
  }
  return $ret;
}

down

Quis AT spam.to.my.devnull.quis.cx ¶

16 years ago


<?PHP
function ntohs($port) {
  $b=pack("N", $port);
  return substr($b,2,2);
}
?>

I've spent a number of hours (n>=2) finding how to do this,
it works like the c function 'ntohs', used for eg the socks5 proxy protocol.

down

petepostma at gmail dot spam dot com ¶

11 years ago


Even though in a 64-bit architecure intval(6123456789) = 6123456789, and sprintf('%b', 5000000000) = 100101010000001011111001000000000

pack will not treat anything passed to it as 64-bit.  If you want to pack a 64-bit integer:



<?php

$big = 5000000000;



$left = 0xffffffff00000000;

$right = 0x00000000ffffffff;



$l = ($big & $left) >>32;

$r = $big & $right;



$good = pack('NN', $l, $r);



$urlsafe = str_replace(array('+','/'), array('-','_'), base64_encode($good));



//done!



//rebuild:

$unurl =  str_replace(array('-','_'), array('+','/'), $urlsafe);

$binary = base64_decode($unurl);



$set = unpack('N2', $tmp);

print_r($set);



$original = $set[1] << 32 | $set[2];

echo $original, "\\r\\n";

?>



results in:

Array

(

    [1] => 1

    [2] => 705032704

)

5000000000



but ONLY on a 64-bit enabled machine and PHP distro.

down

Patrik Fimml ¶

18 years ago


You will get the same effect with

<?php
function _readInt($fp)
{
   return unpack('V', fread($fp, 4));
}
?>

or unpack('N', ...) for big-endianness.

down

dylan at pow7 dot com ¶

16 years ago


This is how I used pack to convert base2 to base64 since base_convert doesn't support base64
The base conversions don't work for long strings, which is why I convert 1 byte at a time
Hope this helps someone

function base2to64($base2) {
    if ($remainbits = strlen($base2)%8) $base2 .= str_repeat('0',8-$remainbits);
    $base64 = NULL;
    for ($i=0;$i<strlen($base2);$i+=8) $base16 .= sprintf('%02x',bindec(sprintf('%08d',substr($base2,$i,8))));
    return base64_encode(pack('H*',$base16));
}
function base64to2($base64) {
    list($base16) = unpack('H*0',base64_decode($base64));
    $base2 = NULL;
    for ($i=0;$i<strlen($base16);$i++) $base2 .= sprintf('%04d',base_convert(substr($base16,$i,1),16,2));
    return $base2;
}

down

ru ¶

6 years ago


pack()
h    Hex string, low nibble first (not same hex2bin())
H    Hex string, high nibble first (same hex2bin())

down

Coder ¶

15 years ago


These two functions allow conversion between binary string and signed integer with possibility to give the bit length.



Usage:

<?php

echo si2bin(-10, 32);

11111111111111111111111111110110

echo si2bin(10, 32);

00000000000000000000000000001010

echo bin2si("11111111111111111111111111110110", 32);

-10

echo bin2si("00000000000000000000000000001010", 32);

10



// signed integer to binary

function si2bin($si, $bits=32)

{

    if ($si >= -pow(2,$bits-1) and $si <= pow(2,$bits-1) )

    {

        if ($si >= 0) // positive or zero

        {

            $bin = base_convert($si,10,2);

            // pad to $bits bit

            $bin_length = strlen($bin);

            if ($bin_length < $bits) $bin = str_repeat ( "0", $bits-$bin_length).$bin;

        }

        else // negative

        {

            $si = -$si-pow(2,$bits);

            $bin = base_convert($si,10,2);

            $bin_length = strlen($bin);

            if ($bin_length > $bits) $bin = str_repeat ( "1", $bits-$bin_length).$bin;

        }

        return $bin;

    }

}



// binary to signed integer

function bin2si($bin,$bits=32)

{

    if (strlen($bin)==$bits)

    {

        if (substr($bin,0,1) == 0) // positive or zero

        {

            $si = base_convert($bin,2,10);

        }

        else // negative

        {

            $si = base_convert($bin,2,10);

            $si = -(pow(2,$bits)-$si);

        }

        return $si;

    }

}

?>

down

Ammar Hameed ¶

13 years ago


Using pack to write Arabic char(s) to a file.

<?php
$text = "&#13574;&#13830;&#13830;";

$text = mb_convert_encoding($text, "UCS-2BE", "HTML-ENTITIES");

$len =  mb_strlen($text);

$bom = mb_convert_encoding("&#65534;", "unicode", "HTML-ENTITIES");

$fp = fopen('text.txt', 'w');

fwrite($fp, pack('a2', $bom));  
fwrite($fp, pack("a{$len}", $text));
fwrite($fp, pack('a2', $bom)); 
fwrite($fp, pack('a2', "\n"));

fclose($fp);
?>

down

-2

Gerjoo at gmail dot com ¶

12 years ago


You can use pack to strip the byte order mark (BOM) from a file. 

For example, strip the UTF-8 BOM:

<?php

// Strips the UTF-8 mark: (hex value: EF BB BF)
function trimUTF8BOM($data){ 
    if(substr($data, 0, 3) == pack('CCC', 239, 187, 191)) {
        return substr($data, 3);
    }
    return $data;
}

?>

This function could be easily adjusted to match any byte order mark. Have a look at wikipedia for a full list of hex codes for each specific encoding.

- Gerard

down

-1

SixThreeOh ¶

14 years ago


If you're bugged by http://bugs.php.net/bug.php?id=5889 then you can try this:

Use igbinary-serialize if you don't mind a little overhead.

Or intarray (by the same person) if you don't mind using a slightly experimental package which may have problems sharing data between differently byte/bit ordered architectures.

I don't believe it would be too difficult to shove a serialize function and unserialize function in there if you rip out the code from igbinary for storing numeric arrays with the correct endianess. Looking at `igbinary_serialize32` and `igbinary_unserialize32` in igbinary.c it should be very easy to copy that functionality to intarray.c.

Take away the "<<0" though, that's just stupid :P

Ref: http://opensource.dynamoid.com/

down

-1

Newdawn.dk ¶

18 years ago


When trying to create a ZIP file using the pack function - I experienced trouble with the "a" code - It converted all chars correct from the std. ASCII charset but not more language specific like ÆøÅ.
It seems that ZIP files do not use the same HEX for these as everything else does. 
The fix was a quick workaround but you'll probably get the picture:
function UniHex($str) {
    // æ ø å Æ Ø Å 
    //These are simply one HEX code being replaced by another to correct the issue
    $except = array("E6"=>"91","F8"=>"9B","E5"=>"86","C6"=>"92","D8"=>"9D",    "C5"=>"8F");
    for($i = 0; $i < strlen($str); $i++) {
        $hex = bin2hex(substr($str, $i, 1));
        if ($except[strtoupper($hex)])
            $hex = $except[strtoupper($hex)];
        $return .= $hex;
    }
    return $return;
}
And then i replaced an "a100" code with "H".strlen(uniHex($mystring))

This is like i said a quick workaround, but if you find the real reason for this i'd be happy to see it

down

-4

jrm456 at speed dot 1s dot fr ¶

10 years ago


How to convert an integer to raw data, specifying the amount of bytes to convert to (will be padded with 0's):

    public function toRaw($int, $bytes = 4)
    {
        $hex = dechex($int);
        
        if (strlen($hex) % 2 != 0)
            $hex = '0'. $hex;

        $arr = str_split($hex, 2);

        while (count($arr) < $bytes)
            array_unshift($arr, 0);
        
        $arr = array_map('hexdec', $arr);
        $arr = array_map('chr', $arr);

        return join('', array_reverse($arr));
    }

down

-9

Anonymous ¶

15 years ago


Array pack:
<?php
function pack_array($v,$a) {
 return call_user_func_array(pack,array_merge(array($v),(array)$a));
}
?>

add a note