Edit Report a Bug

    pack

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

    pack — Compacte des données dans une chaîne binaire

    Description

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

    Compacte les arguments args dans une chaîne binaire, suivant le format format.

    Le concept vient du Perl et tout le formatage fonctionne de la même façon qu'en Perl, mais quelques formats manquent encore (comme "u").

    Notez que la distinction entre signé et non signé n'affecte que la fonction unpack(), tandis que la fonction pack() fournira le même résultat pour les deux formats.

    Liste de paramètres

    format

    La chaîne de caractères format consiste en des codes de format suivis par un argument répéteur optionnel. Le répéteur peut être soit une valeur entière, soit * pour une répétition jusqu'à la fin des données d'entrées. Pour a, A, h, H, le répéteur spécifie combien de caractères d'une donnée est pris, pour @, c'est la position absolue où l'on insère les prochaines données, pour tout le reste, le répéteur spécifie combien d'arguments de données sont consommés et compactés dans la chaîne binaire résultante.

    Les formats actuellement acceptés sont :

    Caractères de formatage pour pack()
    Code Description
    a NUL - Une chaîne complétée avec null
    A SPACE - Une chaîne complétée avec un espace
    h Chaîne hexadécimale h, bit de poids faible en premier
    H Chaîne hexadécimale H, bit de poids fort en premier
    c Caractère signé
    C Caractère non signé
    s entier court signé (toujours sur 16 bits, ordre des octets dépendant de la machine)
    S entier court non signé (toujours 16 bits, ordre des octets dépendant de la machine)
    n entier court non signé (toujours 16 bits, ordre des octets big endian)
    v entier court non signé (toujours 16 bits, ordre des octets little endian)
    i entier signé (taille et ordre des octets dépendants de la machine)
    I entier non signé (taille et ordre des octets dépendants de la machine)
    l entier long signé (toujours 32 bits, ordre des octets dépendant de la machine)
    L entier long non signé (toujours 32 bits, ordre des octets dépendant de la machine)
    N entier long non signé (toujours 32 bits, ordre des octets big endian)
    V entier long non signé (toujours 32 bits, ordre des octets little endian)
    q entier doublement long signé (toujours 64 bits, ordre des octets dépendant de la machine)
    Q entier doublement long non signé (toujours 64 bits, ordre des octets dépendant de la machine)
    J entier doublement long non signé (toujours 64 bits, ordre des octets big endian)
    P entier doublement long non signé (toujours 64 bits, ordre des octets little endian)
    f nombre à virgule flottante (taille et représentation dépendantes de la machine)
    g nombre à virgule flottante (taille dépendantes de la machine, ordre des octets little endian)
    G nombre à virgule flottante (taille dépendantes de la machine, ordre des octets big endian)
    d nombre à virgule flottante double (taille et représentation dépendantes de la machine)
    e nombre à virgule flottante double (taille dépendantes de la machine, ordre des octets little endian)
    E nombre à virgule flottante double (taille dépendantes de la machine, ordre des octets big endian)
    x caractère NUL
    X Recule d'un caractère
    Z Chaîne complétée par la valeur NULL
    @ Remplit avec des NUL jusqu'à la position absolue

    values

    Valeurs de retour

    Retourne une chaîne de caractères binaire contenant les données.

    Historique

    Version Description
    8.0.0 This function no longer returns false on failure.
    7.2.0 Les types float et double prennent en charge Big Endian et Little Endian.
    7.0.15,7.1.1 Les codes "e", "E", "g" and "G" ont été ajouté pour activer la prise en charge de l'ordre des octets pour les nombres à virgule flottante simple et double précision.

    Exemples

    Exemple #1 Exemple avec pack()

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

    La chaîne binaire résultante aura 6 octets de long, et contiendra la séquence 0x12, 0x34, 0x78, 0x56, 0x41, 0x42.

    Notes

    Attention

    Notez que PHP stocke en interne les valeurs int comme valeurs signées dépendantes de la machine (type C long). Les opérations sur les entiers qui mènent à des chiffres en dehors de l'espace de définition de l'int seront stockées dans des float. Lors de l'empaquetage de ses flottants en entiers, ils sont transtypés vers le type entier. Ceci peut éventuellement mener à une représentation inattendue des octets.

    Le cas le plus classique est l'empaquetage de nombres non signés qui seraient représentables dans le type int si celui-ci était non signé. Sur les systèmes ayant un int d'une taille de 32-bits, le transtypage résulte en un octet identique que si le type int était non signé (même si cela reste dépendant de l'implémentation non signé vers signé, du standard C). Sur les systèmes ayant un int d'une taille de 64-bits, le float n'a souvent pas une mantisse assez large pour contenir la valeur sans perte de précision. Si ces systèmes possèdent aussi un type C natif int 64-bits (la plupart des *NIX ne l'ont pas), le seul moyen d'utiliser le format de paquetage I dans les hautes valeurs est de créer des valeurs int négatives avec la même représentation des octets que la valeur non signées voulue correspondante.

    Voir aussi

    • unpack() - Déconditionne des données depuis une chaîne binaire

    add a note add a note

    User Contributed Notes 10 notes

    up
    84
    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
    up
    35
    stanislav dot eckert at vizson dot de
    8 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

    ?>
    up
    17
    plutus at gmx dot de
    24 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!
    up
    14
    FrozenFire
    14 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);
    ?>
    up
    7
    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];
    }
    up
    3
    php at nagler-ihlein dot de
    16 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.
    up
    3
    petepostma at gmail dot spam dot com
    12 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.
    up
    2
    Patrik Fimml
    19 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.
    up
    1
    Ammar Hameed
    14 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);
    ?>
    up
    0
    ru
    7 years ago
    pack()
    h    Hex string, low nibble first (not same hex2bin())
    H    Hex string, high nibble first (same hex2bin())
    add a note add a note
    To Top