javascript闭包如何生成序列化函数

WeakMap

JSON.stringify

Date

RegExp

undefined

function createCustomSerializer() {
    // 闭包捕获的私有状态：用于检测循环引用
    const visited = new WeakMap();
    let uniqueIdCounter = 0; // 如果需要为每个对象生成唯一ID

    // 内部的序列化逻辑，会作为闭包返回
    function serialize(value, path = []) {
        // 基本类型直接返回
        if (value === null || typeof value !== 'object') {
            if (typeof value === 'function') {
                return '[Function]'; // 函数通常不序列化，或特殊处理
            }
            if (typeof value === 'undefined') {
                return '[Undefined]';
            }
            if (typeof value === 'symbol') {
                return '[Symbol]';
            }
            return value;
        }

        // 处理日期对象
        if (value instanceof Date) {
            return value.toISOString();
        }

        // 处理正则对象
        if (value instanceof RegExp) {
            return value.toString();
        }

        // 循环引用检测：
        // 如果这个对象已经被访问过，说明存在循环引用
        if (visited.has(value)) {
            // 可以返回一个标记，或者抛出错误，或者返回其在visited中对应的ID
            return `[Circular Reference - Path: ${visited.get(value).join(' -> ')}]`;
        }

        // 标记当前对象为已访问，并记录其路径
        visited.set(value, path);

        // 根据对象类型进行递归序列化
        if (Array.isArray(value)) {
            const serializedArray = [];
            for (let i = 0; i < value.length; i++) {
                serializedArray.push(serialize(value[i], [...path, i]));
            }
            return serializedArray;
        }

        // 普通对象
        const serializedObject = {};
        for (const key in value) {
            // 确保是对象自身的属性，而不是原型链上的
            if (Object.prototype.hasOwnProperty.call(value, key)) {
                serializedObject[key] = serialize(value[key], [...path, key]);
            }
        }
        return serializedObject;
    }

    // 返回一个公共接口，通常是JSON.stringify的replacer形式，或者直接的序列化函数
    return function(obj) {
        // 每次新的序列化操作，都需要重置visited Map，确保独立性
        // 这里的实现是每次调用serialize(obj)都会重置，所以visited是单次使用的。
        // 如果需要一个可复用的序列化器实例，visited应该在createCustomSerializer内部被清除或传递。
        // 为了演示闭包，我们让serialize内部的visited是每次调用createCustomSerializer时创建的。
        // 如果要让每次调用返回的函数是“干净”的，那么visited应该在serialize(obj)的入口处被清空。
        // 但这里我们希望它在一次完整的序列化过程中保持状态，所以它放在外部作用域是正确的。

        // 实际使用时，可能需要将顶层对象包裹一下，以处理初始的visited状态
        // 这里为了简单，直接调用内部的serialize函数。
        // 每次调用这个返回的函数，都会使用一个新的visited Map，这是正确的行为。
        // 如果是JSON.stringify的replacer，visited需要在顶层被管理。
        // 为了清晰，我们直接返回一个执行完整序列化的函数。
        return JSON.stringify(serialize(obj), null, 2); // 使用JSON.stringify格式化输出
    };
}

// 使用示例
const mySerializer = createCustomSerializer();

const obj1 = {
    a: 1,
    b: {
        c: 2,
        d: new Date(),
        e: /test/g,
        f: function() {}
    }
};
obj1.b.g = obj1; // 制造一个循环引用

const serializedString = mySerializer(obj1);
console.log(serializedString);

// 另一个独立的序列化操作，会使用一个新的visited Map
const obj2 = {
    x: 10
};
obj2.y = obj2;
const serializedString2 = mySerializer(obj2);
console.log(serializedString2);

createCustomSerializer

mySerializer

visited

WeakMap

mySerializer

serialize

visited

JSON.stringify()

JSON.stringify()

TypeError: Converting circular structure to JSON

JSON.stringify()

replacer

WeakMap

Map

WeakMap

createCustomSerializer

WeakMap

visitedObjects

_serializeRecursive

visitedObjects

_serializeRecursive

visitedObjects

WeakMap

createCustomSerializer

createCustomSerializer()

visitedObjects

createCustomSerializer

function createConfigurableSerializer(options = {}) {
    const visited = new WeakMap();
    const defaultOptions = {
        handleFunctions: 'ignore', // 'ignore', 'toString', 'throw'
        handleUndefined: 'ignore',
        handleDates: 'toISOString', // 'toISOString', 'timestamp', 'customFormat'
        customTypeHandlers: new Map() // 例如：Map.set(MyCustomClass, (instance) => instance.toPlainObject())
    };
    const mergedOptions = { ...defaultOptions, ...options };

    function serializeRecursive(value, path = []) {
        // ... 循环引用检测逻辑 ...

        // 自定义类型处理逻辑
        if (mergedOptions.customTypeHandlers.has(value.constructor)) {
            return mergedOptions.customTypeHandlers.get(value.constructor)(value);
        }

        if (value instanceof Date) {
            if (mergedOptions.handleDates === 'toISOString') {
                return value.toISOString();
            } else if (mergedOptions.handleDates === 'timestamp') {
                return value.getTime();
            }
            // ... 更多日期格式处理
        }

        if (typeof value === 'function') {
            if (mergedOptions.handleFunctions === 'toString') {
                return value.toString();
            }
            return '[Function]'; // 默认忽略或标记
        }

        if (typeof value === 'undefined') {
            return mergedOptions.handleUndefined === 'ignore' ? undefined : '[Undefined]';
        }

        // ... 其他类型处理和递归逻辑 ...
    }

    return function(obj) {
        // 每次新的序列化操作前，清空或重置状态
        // 如果是单次使用的序列化器，visited 可以在这里被清空。
        // 如果是可复用的，visited应该在createConfigurableSerializer外部，每次serialize(obj)调用前传入新的map。
        // 这里为了演示，我们假设每次调用返回的函数都是一个全新的序列化任务。
        visited.clear(); // 确保每次调用都是“干净”的
        return JSON.stringify(serializeRecursive(obj), null, 2);
    };
}

// 使用示例
const mySmartSerializer = createConfigurableSerializer({
    handleFunctions: 'toString',
    handleDates: 'timestamp',
    customTypeHandlers: new Map([
        [Set, (set) => [...set]], // 将Set转换为数组
        [Map, (map) => Array.from(map.entries())] // 将Map转换为键值对数组
    ])
});

const complexData = {
    set: new Set([1, 2, 3]),
    map: new Map([['a', 1], ['b', 2]]),
    func: () => console.log('hello'),
    today: new Date(),
    undef: undefined
};

complexData.self = complexData; // 循环引用

console.log(mySmartSerializer(complexData));

serializeRecursive

mergedOptions

visitedObjects

options

JSON.stringify