Edit Report a Bug

    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.

    Bağımsız Değişkenler

    biçem

    biçem dzgesi isteğe bağlı bir yineleme bağımsız değişkeni ile öncelenmiş biçem kodlarından oluşur. Yineleme bağımsız değişkeni bir tamsayı değer veya girdi verisinin sonuna kadar yineleme belirten bir * olabilir. a, A, h, H için yineleme sayısı, bir veri bağımsız değişkeninden 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.

    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 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