Submit a Pull Request Report a Bug

pack

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

pack — データをバイナリ文字列にパックする

説明

pack(string $format, mixed ...$values): string

指定された引数を format に基づいてバイナリ文字列にパックします。

この関数のアイデアは Perl からのものであり、フォーマット指定用のコードは Perl と同様に動作します。しかし、中には存在しない書式コードもあります。たとえば Perl の "u" は存在しません。

符号付及び符号無しの区別は関数 unpack() にのみ影響を与えます。関数 pack() は符号付及び符号無しのフォーマットコードのどちらでも同じ結果となることに注意しましょう。

パラメータ

format

フォーマット文字列は、フォーマットコードの後にオプションの反復指定用引数が続く形式となっています。反復指定用引数として整数値、または入力データの最後まで反復を意味する * のどちらかを指定することができます。 a, A, h, H の場合、反復数はそのデータ引数が取得する文字の数を指定します。反復数が @ の場合、次のデータを置く場所の絶対位置を表します。その他の場合、反復数はデータ引数が使われる数を指定し、結果のバイナリ文字列にパックされます。

現在、実装されているものを以下に示します。

**pack()** の書式文字
コード	説明
a	NUL で埋めた文字列
A	空白で埋めた文字列
h	十六進文字列、下位ニブルが先
H	十六進文字列、上位ニブルが先
c	signed char
C	unsigned char
s	signed short (常に 16 ビット、マシンのバイトオーダー)
S	unsigned short (常に 16 ビット、マシンのバイトオーダー)
n	unsigned short (常に 16 ビット、ビッグエンディアンバイトオーダー)
v	unsigned short (常に 16 ビット、リトルエンディアンバイトオーダー)
i	signed integer (サイズおよびバイトオーダーはマシン依存)
I	unsigned integer (サイズおよびバイトオーダーはマシン依存)
l	signed long (常に 32 ビット、マシンのバイトオーダー)
L	unsigned long (常に 32 ビット、マシンのバイトオーダー)
N	unsigned long (常に 32 ビット、ビッグエンディアンバイトオーダー)
V	unsigned long (常に 32 ビット、リトルエンディアンバイトオーダー)
q	signed long long (常に 64 ビット、マシンのバイトオーダー)
Q	unsigned long long (常に 64 ビット、マシンのバイトオーダー)
J	unsigned long long (常に 64 ビット、ビッグエンディアンバイトオーダー)
P	unsigned long long (常に 64 ビット、リトルエンディアンバイトオーダー)
f	float (サイズおよび表現はマシン依存)
g	float (サイズはマシン依存。リトルエンディアンバイトオーダー)
G	float (サイズはマシン依存。ビッグエンディアンバイトオーダー)
d	double (サイズおよび表現はマシン依存)
e	double (サイズはマシン依存。リトルエンディアンバイトオーダー)
E	double (サイズはマシン依存。ビッグエンディアンバイトオーダー)
x	NUL バイト
X	1 バイト戻る
Z	NUL 埋め文字列
@	絶対位置まで NUL で埋める

values

返り値

バイナリ文字列を含むデータを返します。失敗した場合に false を返します

変更履歴

バージョン	説明
8.0.0	この関数は、失敗時に `false` を返さなくなりました。
7.2.0	float と double 型は、ビッグエンディアンとリトルエンディアンを両方サポートしました。
7.0.15,7.1.1	"e", "E", "g" および "G" コードが、float と double のバイトオーダーをサポートするために追加されました。

例

例1 pack() の例


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

この結果のバイナリ文字列の長さは 6 バイト長で、バイト列 0x12, 0x34, 0x78, 0x56, 0x41, 0x42となります。

注意

警告

PHP は、int 型の値を内部的に格納する際にサイズがマシン依存の符号付き値 (C の long 型) を使うことに注意しましょう。int 型の範囲外の数値となる整数リテラルや演算結果は float として保持されます。この float 値を integer としてパックする際にはまず最初に integer 型へのキャストを行います。その結果、できあがるバイトパターンは期待通りにはならないかもしれません。

この問題にもっとも関連するのが、符号なしの数値で int 型で表現できるものをパックする場合です。 int 型のサイズが 32 ビットであるシステムでのキャスト結果は、 (実装で定義されている標準 C の符号なし型から符号付き型への変換に依存しますが) まるで int が符号なし整数であるかのような同一のバイトパターンになることがよくあります。 int 型のサイズが 64 ビットであるシステムでは、たいていの場合は float の仮数部のサイズが足りず、値の精度を損なわずに保持することができません。ネイティブの 64 ビット C int 型を持つシステム (UNIX 系システムのほとんどは持っていません) では、上側の範囲の値でパック書式 I を使うための唯一の方法は、希望する符号なし値と同じバイト表現になるような負の int 値を作ることになります。

参考

unpack() - バイナリ文字列からデータを切り出す

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