Edit Report a Bug

    serialize

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

    serialize — 生成值的可存储表示

    说明

    serialize(mixed $value): string

    生成值的可存储表示。

    这有利于存储或传递 PHP 的值，同时不丢失其类型和结构。

    想要将已序列化的字符串变回 PHP 的值，可使用 unserialize()。

    参数

    value

    要序列化的值。serialize() 处理所有的类型，除了 resource 类型和一些 object（见下面的注释）。serialize() 甚至可以序列化包含对自身引用的数组。数组/对象内的循环引用也会被存储。其它任何引用都会丢失。

    序列化对象时，PHP 将尝试在序列化之前调用成员函数 __serialize() 或 __sleep()。这是为了允许对象在序列化之前进行最后一分钟的清理等等。同样，当使用 unserialize() 恢复对象时，会调用 __unserialize() 或 __wakeup() 成员函数。

    注意:

    对象的 private 成员会在名前添加类名；protected 成员会在名前添加“*”；这些前置值在两边都有 null 字节。

    返回值

    返回字符串，包含 value 的字节流表示，可以存储在任何地方。

    注意这可能是包含 null 字节的二进制字符串，需要按原样存储和处理。例如，serialize() 的输出通常应该存储在数据库中 的 BLOB 字段，而不是 CHAR 或 TEXT 字段。

    示例

    示例 #1 serialize() 示例

    <?php
    // $sssion_data 是多维数组，包含当前用户的
    // 会话信息。可以在请求结束时使用 serialize()
    // 将其存储在数据库中。

    $conn = odbc_connect("webdb", "php", "chicken");
    $stmt = odbc_prepare($conn,
    "UPDATE sessions SET data = ? WHERE id = ?");
    $sqldata = array (serialize($session_data), $_SERVER['PHP_AUTH_USER']);
    if (!    odbc_execute($stmt, $sqldata)) {
    $stmt = odbc_prepare($conn,
    "INSERT INTO sessions (id, data) VALUES(?, ?)");
    if (!    odbc_execute($stmt, array_reverse($sqldata))) {
    /* Something went wrong.. */
    }
    }
    ?>

    注释

    注意:

    注意许多内置 PHP 对象不能序列化。然而，要么实现 Serializable 接口，要么实现 __serialize()/__unserialize() 或 __sleep()/__wakeup() 魔术方法的则是可以的。如果内部类不满足这些其中任意一个，则就不能可靠的进行序列化。

    上述规则有一些历史例外，一些内部对象可以在不实现接口或公开方法的情况下，使其序列化。

    警告

    当 serialize() 序列化对象时，命名空间中的类名不要以反斜线开头，以便实现最大兼容性。

    参见

    add a note add a note

    User Contributed Notes 7 notes

    up
    352
    egingell at sisna dot com
    18 years ago
    <?
    /*
    Anatomy of a serialize()'ed value:

    String
    s:size:value;

    Integer
    i:value;

    Boolean
    b:value; (does not store "true" or "false", does store '1' or '0')

    Null
    N;

    Array
    a:size:{key definition;value definition;(repeated per element)}

    Object
    O:strlen(object name):object name:object size:{s:strlen(property name):property name:property definition;(repeated per property)}

    String values are always in double quotes
    Array keys are always integers or strings
        "null => 'value'" equates to 's:0:"";s:5:"value";',
        "true => 'value'" equates to 'i:1;s:5:"value";',
        "false => 'value'" equates to 'i:0;s:5:"value";',
        "array(whatever the contents) => 'value'" equates to an "illegal offset type" warning because you can't use an
        array as a key; however, if you use a variable containing an array as a key, it will equate to 's:5:"Array";s:5:"value";',
         and
        attempting to use an object as a key will result in the same behavior as using an array will.
    */
    ?>
    up
    276
    Anonymous
    12 years ago
    Please! please! please! DO NOT serialize data and place it into your database. Serialize can be used that way, but that's missing the point of a relational database and the datatypes inherent in your database engine. Doing this makes data in your database non-portable, difficult to read, and can complicate queries. If you want your application to be portable to other languages, like let's say you find that you want to use Java for some portion of your app that it makes sense to use Java in, serialization will become a pain in the buttocks. You should always be able to query and modify data in the database without using a third party intermediary tool to manipulate data to be inserted.

    I've encountered this too many times in my career, it makes for difficult to maintain code, code with portability issues, and data that is it more difficult to migrate to other RDMS systems, new schema, etc. It also has the added disadvantage of making it messy to search your database based on one of the fields that you've serialized.

    That's not to say serialize() is useless. It's not... A good place to use it may be a cache file that contains the result of a data intensive operation, for instance. There are tons of others... Just don't abuse serialize because the next guy who comes along will have a maintenance or migration nightmare.
    up
    20
    MC_Gurk at gmx dot net
    18 years ago
    If you are going to serialie an object which contains references to other objects you want to serialize some time later, these references will be lost when the object is unserialized.
    The references can only be kept if all of your objects are serialized at once.
    That means:

    $a = new ClassA();
    $b = new ClassB($a); //$b containes a reference to $a;

    $s1=serialize($a);
    $s2=serialize($b);

    $a=unserialize($s1);
    $b=unserialize($s2);

    now b references to an object of ClassA which is not $a. $a is another object of Class A.

    use this:
    $buf[0]=$a;
    $buf[1]=$b;
    $s=serialize($buf);
    $buf=unserialize($s);
    $a=$buf[0];
    $b=$buf[1];

    all references are intact.
    up
    27
    nh at ngin dot de
    11 years ago
    Serializing floating point numbers leads to weird precision offset errors:

    <?php

    echo round(96.670000000000002, 2);
    // 96.67

    echo serialize(round(96.670000000000002, 2));
    // d:96.670000000000002;

    echo serialize(96.67);
    // d:96.670000000000002;

    ?>

    Not only is this wrong, but it adds a lot of unnecessary bulk to serialized data. Probably better to use json_encode() instead (which apparently is faster than serialize(), anyway).
    up
    11
    frost at easycast dot ru
    11 years ago
    Closures cannot be serialized:
    <?php
    $func     = function () {echo 'hello!';};
    $func(); // prints "hello!"

    $result = serialize($func);  // Fatal error: Uncaught exception 'Exception' with message 'Serialization of 'Closure' is not allowed'
    ?>
    up
    7
    Andrew B
    12 years ago
    When you serialize an array the internal pointer will not be preserved. Apparently this is the expected behavior but was a bit of a gotcha moment for me. Copy and paste example below.

    <?php
    //Internal Pointer will be 2 once variables have been assigned.
    $array = array();
    $array[] = 1;
    $array[] = 2;
    $array[] = 3;

    //Unset variables. Internal pointer will still be at 2.    
    unset($array[0]);
    unset(    $array[1]);
    unset(    $array[2]);

    //Serialize
    $serializeArray = serialize($array);

    //Unserialize
    $array = unserialize($serializeArray);

    //Add a new element to the array
    //If the internal pointer was preserved, the new array key should be 3.
    //Instead the internal pointer has been reset, and the new array key is 0.
    $array[] = 4;

    //Expected Key - 3
    //Actual Key - 0
    echo "<pre>" , print_r($array, 1) , "</pre>";
    ?>
    up
    1
    mark at bvits dot co dot uk
    1 year ago
    There is a type not mentioned in the user notes so far, 'E'.  This is the newer Enum class that can be utilised:

    login_security|E:25:"Permission:manageClient"
    add a note add a note
    To Top