在Javascript中反序列化PHP数组

Question

我有一个表,其中包含一系列序列化数组,我计划请求并传递给它JavaScript.

问题是 - 是否可以unserialize使用JavaScript而不是PHP？

否则我将必须加载所有行,循环它们并反序列化它们并将它们分配给临时PHP数组然后json_encode它回到JavaScript,如果我可以发送仍然序列化的数据以便JavaScript可以反序列化数据,这似乎效率很低它需要.

是否有内置的Javascript函数可以执行它,还是我必须在编码之前在PHP中循环行？

注意我没有使用jQuery.

编辑:我的表中的PHP序列化数据示例:

a:8:{i:0;a:2:{i:0;i:10;i:1;i:11;}i:1;a:2:{i:0;i:9;i:1;i:11;}i:2;a:2:
{i:0;i:8;i:1;i:11;}i:3;a:2:{i:0;i:8;i:1;i:10;}i:4;a:2:{i:0;i:8;i:1;i:9;}i:5;a:2:
{i:0;i:8;i:1;i:8;}i:6;a:2:{i:0;i:8;i:1;i:7;}i:7;a:2:{i:0;i:8;i:1;i:6;}}

Answer 1

Php.js有unserialize和serialize的javascript实现:

http://phpjs.org/functions/unserialize/

http://phpjs.org/functions/serialize/

也就是说,在服务器端转换为JSON可能更有效.JSON.parse将比PHP.js的反序列化快得多.

Answer 2

我想我会尝试编写一个可以反序列化 PHP 序列化数据的 JS 函数。

但在使用此解决方案之前，请注意：

• PHPserialize函数生成的格式是特定于 PHP 的，因此最好的选择是使用 PHPunserialize以 100% 保证它正确地完成工作。
• PHP 可以在这些字符串中存储类信息，甚至可以存储一些自定义序列化方法的输出。因此，要反序列化此类字符串，您需要了解这些类和方法。
• PHP 数据结构并不与 JavaScript 数据结构一一对应：PHP 关联数组可以将字符串作为键，因此它们看起来更像 JavaScript 对象而不是 JS 数组，但在 PHP 中键保持插入顺序，键可以有JS 对象无法实现的真正数字数据类型。可以说，那么我们应该看看MapJS中的对象，但那些允许将 13 和“13”存储为单独的键，这是 PHP 不允许的。而我们只是触及了这里的冰山一角......
• PHP 序列化对象的受保护和私有属性，这不仅很奇怪（这有多私有？），而且是 JS 中（还）不存在的概念，或者至少不以相同的方式存在。如果一个人会以某种方式实现JS（硬）私人财产，那么如何将一些反序列化是能够以设定这样的私有财产？
• JSON 是一种不特定于 PHP 的替代方案，也不关心自定义类。如果您可以访问发生序列化的 PHP 源代码，则将其更改为生成 JSON。PHP 提供json_encode了这一点，而 JavaScript 必须对其JSON.parse进行解码。如果可以的话，这当然是要走的路。

如果根据这些评论，您仍然认为需要 JS 反序列化函数，请继续阅读。

这是一个 JS 实现，它提供了一个PHP与内置对象具有类似方法的JSON对象：parse和stringify。

当该parse方法的输入引用一个类时，它将首先检查您是否在（可选）第二个参数中传递了对该类的引用。如果没有，将为该类创建一个模拟（以避免不希望的副作用）。在任何一种情况下，都会创建该类的一个实例。如果输入字符串指定发生了自定义序列化unserialize，则将调用该对象实例上的方法。您必须在该方法中提供逻辑，因为字符串本身不提供有关如何完成的信息。只有在生成该字符串的 PHP 代码中才知道它。

此实现还支持循环引用。当关联数组变成顺序数组时，将返回一个 JS 数组。

const PHP = {
    stdClass: function() {},
    stringify(val) {
        const hash = new Map([[Infinity, "d:INF;"], [-Infinity, "d:-INF;"], [NaN, "d:NAN;"], [null, "N;"], [undefined, "N;"]]); 
        const utf8length = str => str ? encodeURI(str).match(/(%.)?./g).length : 0;
        const serializeString = (s,delim='"') => `${utf8length(s)}:${delim[0]}${s}${delim[delim.length-1]}`;
        let ref = 0;
        
        function serialize(val, canReference = true) {
            if (hash.has(val)) return hash.get(val);
            ref += canReference;
            if (typeof val === "string") return `s:${serializeString(val)};`;
            if (typeof val === "number") return  `${Math.round(val) === val ? "i" : "d"}:${(""+val).toUpperCase().replace(/(-?\d)E/, "$1.0E")};`;
            if (typeof val === "boolean") return  `b:${+val};`;
            const a = Array.isArray(val) || val.constructor === Object;
            hash.set(val, `${"rR"[+a]}:${ref};`);
            if (typeof val.serialize === "function") {
                return `C:${serializeString(val.constructor.name)}:${serializeString(val.serialize(), "{}")}`;
            }
            const vals = Object.entries(val).filter(([k, v]) => typeof v !== "function");
            return (a ? "a" : `O:${serializeString(val.constructor.name)}`) 
                + `:${vals.length}:{${vals.map(([k, v]) => serialize(a && /^\d{1,16}$/.test(k) ? +k : k, false) + serialize(v)).join("")}}`;
        }
        return serialize(val);
    },
    // Provide in second argument the classes that may be instantiated
    //  e.g.  { MyClass1, MyClass2 }
    parse(str, allowedClasses = {}) {
        allowedClasses.stdClass = PHP.stdClass; // Always allowed.
        let offset = 0;
        const values = [null];
        const specialNums = { "INF": Infinity, "-INF": -Infinity, "NAN": NaN };

        const kick = (msg, i = offset) => { throw new Error(`Error at ${i}: ${msg}\n${str}\n${" ".repeat(i)}^`) }
        const read = (expected, ret) => expected === str.slice(offset, offset+=expected.length) ? ret 
                                         : kick(`Expected '${expected}'`, offset-expected.length);
        
        function readMatch(regex, msg, terminator=";") {
            read(":");
            const match = regex.exec(str.slice(offset));
            if (!match) kick(`Exected ${msg}, but got '${str.slice(offset).match(/^[:;{}]|[^:;{}]*/)[0]}'`);
            offset += match[0].length;
            return read(terminator, match[0]);
        }
        
        function readUtf8chars(numUtf8Bytes, terminator="") {
            const i = offset;
            while (numUtf8Bytes > 0) {
                const code = str.charCodeAt(offset++);
                numUtf8Bytes -= code < 0x80 ? 1 : code < 0x800 || code>>11 === 0x1B ? 2 : 3;
            }
            return numUtf8Bytes ? kick("Invalid string length", i-2) : read(terminator, str.slice(i, offset));
        }
        
        const create = className => !className ? {}
                    : allowedClasses[className] ? Object.create(allowedClasses[className].prototype)
                    : new {[className]: function() {} }[className]; // Create a mock class for this name
        const readBoolean = () => readMatch(/^[01]/, "a '0' or '1'", ";");
        const readInt     = () => +readMatch(/^-?\d+/, "an integer", ";");
        const readUInt    = terminator => +readMatch(/^\d+/, "an unsigned integer", terminator);
        const readString  = (terminator="") => readUtf8chars(readUInt(':"'), '"'+terminator);
        
        function readDecimal() {
            const num = readMatch(/^-?(\d+(\.\d+)?(E[+-]\d+)?|INF)|NAN/, "a decimal number", ";");
            return num in specialNums ? specialNums[num] : +num;
        }
        
        function readKey() {
            const typ = str[offset++];
            return typ === "s" ? readString(";") 
                 : typ === "i" ? readUInt(";")
                 : kick("Expected 's' or 'i' as type for a key, but got ${str[offset-1]}", offset-1);
        }
       
        function readObject(obj) {
            for (let i = 0, length = readUInt(":{"); i < length; i++) obj[readKey()] = readValue();
            return read("}", obj);
        }
        
        function readArray() {
            const obj = readObject({});
            return Object.keys(obj).some((key, i) => key != i) ? obj : Object.values(obj);
        }
        
        function readCustomObject(obj) {
            if (typeof obj.unserialize !== "function") kick(`Instance of ${obj.constructor.name} does not have an "unserialize" method`);
            obj.unserialize(readUtf8chars(readUInt(":{")));
            return read("}", obj);
        }
        
        function readValue() {
            const typ = str[offset++].toLowerCase();
            const ref = values.push(null)-1;
            const val = typ === "n" ? read(";", null)
                      : typ === "s" ? readString(";")
                      : typ === "b" ? readBoolean()
                      : typ === "i" ? readInt()
                      : typ === "d" ? readDecimal()
                      : typ === "a" ? readArray()                            // Associative array
                      : typ === "o" ? readObject(create(readString()))       // Object
                      : typ === "c" ? readCustomObject(create(readString())) // Custom serialized object
                      : typ === "r" ? values[readInt()]                      // Backreference
                      : kick(`Unexpected type ${typ}`, offset-1);
            if (typ !== "r") values[ref] = val;
            return val;
        }
        
        const val = readValue();
        if (offset !== str.length) kick("Unexpected trailing character");
        return val;
    }
}
/**************** EXAMPLE USES ************************/

// Unserialize a sequential array
console.log(PHP.parse('a:4:{i:0;s:4:"This";i:1;s:2:"is";i:2;s:2:"an";i:3;s:5:"array";}'));

// Unserialize an associative array into an object
console.log(PHP.parse('a:2:{s:8:"language";s:3:"PHP";s:7:"version";d:7.1;}'));

// Example with class that has custom serialize function:
var MyClass = (function () {
    const priv = new WeakMap(); // This is a way to implement private properties in ES6
    return class MyClass {
        constructor() {
            priv.set(this, "");
            this.wordCount = 0;
        }
        unserialize(serialised) {
            const words = PHP.parse(serialised);
            priv.set(this, words);
            this.wordCount = words.split(" ").length;
        }
        serialize() {
            return PHP.stringify(priv.get(this));
        }
    }
})();

// Unserialise a PHP string that needs the above class to work, and will call its unserialize method
// The class needs to be passed as object key/value as second argument, so to allow this side effect to happen:
console.log(PHP.parse('C:7:"MyClass":23:{s:15:"My private data";}', { MyClass } ));

Answer 3

包裹json_encode周围unserialize

echo json_encode( unserialize( $array));