Performance Comparison of PHP Array Storage: An In-depth Analysis of json_encode vs serialize

Introduction

In PHP development, it is often necessary to store complex data structures such as multidimensional associative arrays in files or databases for caching or data persistence. Common serialization methods include json_encode and serialize, which exhibit significant differences in performance, functionality, and use cases. This article systematically analyzes the pros and cons of these two methods based on actual Q&A data and reference articles, providing code examples and benchmark results to guide developers in selecting the appropriate solution according to specific needs.

Performance Benchmarking

To objectively compare the performance of json_encode and serialize, we designed a benchmark test script. This script generates a deeply nested test array and measures the encoding time for both methods. The following code illustrates the core logic of the test:

<?php
ini_set('display_errors', 1);
error_reporting(E_ALL);

// Generate test array
$testArray = fillArray(0, 5);

// Measure JSON encoding time
$start = microtime(true);
json_encode($testArray);
$jsonTime = microtime(true) - $start;
echo "JSON encoded in $jsonTime seconds\n";

// Measure serialization time
$start = microtime(true);
serialize($testArray);
$serializeTime = microtime(true) - $start;
echo "PHP serialized in $serializeTime seconds\n";

// Performance comparison
if ($jsonTime < $serializeTime) {
    printf("json_encode() was roughly %01.2f%% faster than serialize()\n", ($serializeTime / $jsonTime - 1) * 100);
} else if ($serializeTime < $jsonTime) {
    printf("serialize() was roughly %01.2f%% faster than json_encode()\n", ($jsonTime / $serializeTime - 1) * 100);
} else {
    echo "Impossible!\n";
}

function fillArray($depth, $max) {
    static $seed;
    if (is_null($seed)) {
        $seed = array('a', 2, 'c', 4, 'e', 6, 'g', 8, 'i', 10);
    }
    if ($depth < $max) {
        $node = array();
        foreach ($seed as $key) {
            $node[$key] = fillArray($depth + 1, $max);
        }
        return $node;
    }
    return 'empty';
}
?>

The test results indicate that in PHP 5.3 and later versions, json_decode is generally faster than unserialize, but encoding speed may vary depending on the data structure and PHP version. In practical applications, it is recommended to run similar tests in the target environment to obtain accurate data.

Functional Characteristics Comparison

json_encode and serialize exhibit several key functional differences that directly impact their applicability:

• UTF-8 Character Handling: json_encode converts UTF-8 characters to Unicode escape sequences (e.g., \uXXXX) by default; the JSON_UNESCAPED_UNICODE parameter must be used to preserve them. For example: json_encode($array, JSON_UNESCAPED_UNICODE). In contrast, serialize does not have this issue and retains original characters directly.
• Object Serialization: After JSON deserialization, objects are always restored as stdClass instances, losing original class information. Conversely, serialize preserves class structures and supports custom serialization methods such as __sleep() and __wakeup(), making it suitable for scenarios requiring object state maintenance.
• Property Visibility: By default, JSON only serializes public properties. Starting from PHP 5.4, this behavior can be customized by implementing the JsonSerializable interface. serialize handles all properties (public, protected, private) but requires attention to security issues.
• Data Depth Limitation: json_decode has a depth limit for JSON data (default 127 levels); exceeding this may return false. This must be considered when dealing with deeply nested arrays. serialize has no fixed depth limit but is constrained by PHP memory configuration.

Applicable Scenarios Analysis

Based on performance tests and functional comparisons, the following scenarios recommend using JSON:

• Cross-Language Compatibility: JSON, as a universal data format, facilitates data exchange between PHP, JavaScript, and other languages. For instance, cached data in a web application can be directly used in frontend JavaScript without additional conversion.
• Readability and Editability: JSON text is human-readable, aiding debugging and manual modifications. As mentioned in reference articles, users can edit JSON text without corrupting the data structure, which is particularly useful in dynamic form data processing.
• Performance Priority: When decoding speed is critical and data structures are simple (e.g., shallow arrays), JSON is generally superior. Benchmark tests demonstrate its decoding speed advantage.

The following scenarios recommend using serialize:

• Complex Object Serialization: When preserving object class information and private properties is necessary, serialize is the only option. For example, caching object instances that include business logic.
• Deeply Nested Data: For arrays exceeding JSON depth limits, serialize provides a more stable solution.
• Legacy PHP Compatibility: In PHP versions that do not support json_decode, serialize is the standard method.

Practical Application Examples

Consider a dynamic form application where user-submitted data is stored in a multidimensional array. Reference articles describe similar scenarios: forms contain variable numbers of detail and detailKind fields, along with samples fields. When storing, developers face the choice of serialization method.

If the data is primarily used for internal PHP caching and requires frequent decoding, JSON may be more efficient:

$storeMe = array('detailKind' => $_POST['detailKind'], 'detail' => $_POST['detail']);
$cachedData = json_encode($storeMe); // Store to file or database
// Quick decoding when used
$restoredArray = json_decode($cachedData, true); // Returns associative array

If the data includes objects or deeply nested structures, serialize is more appropriate:

$sampleStore = $_POST['samples'];
$cachedData = serialize($sampleStore); // Preserves complete structure
$restoredData = unserialize($cachedData); // Restores original data

Conclusion

json_encode and serialize each have their strengths, and the choice depends on specific requirements. JSON excels in speed, readability, and cross-platform compatibility, making it suitable for most caching and web data exchange scenarios. serialize is indispensable for handling complex objects and deep data. Developers should combine performance testing, functional requirements, and environmental constraints to make informed decisions. In actual projects, implementing benchmark tests first and then optimizing serialization strategies based on the results can ensure application efficiency and reliability.