Question

我有一个表格，其中包含一系列序列化数组，我打算请求并将其传递给JavaScript。

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

否则我将必须加载所有行，循环它们并反序列化它们并将它们分配给临时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具有反序列化和序列化的javascript实现：

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

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

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

Answer 2

围绕json_encode

包裹unserialize

echo json_encode( unserialize( $array));

Answer 3

http://php.net/manual/en/book.json.php

刚刚注意到你的评论，所以我们走了：

PHP中的

json_encode(unserialize(SerializedVal));

JavaScript中的

：

JSON.parse(JsonString);

Answer 4

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

但是在寻求此解决方案之前，请注意：

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

如果仍然有这些评论，您仍然需要JS反序列化功能，请继续阅读。

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

当parse方法的输入引用一个类时，它将首先检查是否在（可选）第二个参数中传递了对该类的引用。如果没有，将为该类创建一个模拟（以避免产生不希望的副作用）。无论哪种情况，都将创建该类的实例。如果输入字符串指定发生了 custom 序列化，则将调用该对象实例上的方法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 } ));

在Javascript中反序列化PHP数组

4 个答案: