代理脚本_版本二

/**
 * 创建一个用于记录对象属性访问和修改的代理
 * @param {Object} target - 要代理的目标对象
 * @param {string} objectName - 目标对象的名称，用于日志输出
 * @returns {Proxy} - 返回代理后的对象
 */
function createLoggingProxy(target, objectName) {
    /**
     * 安全地将值转换为字符串表示形式
     * 处理特殊情况，如DOM元素、循环引用和复杂对象
     * @param {any} value - 要转换的值
     * @returns {string} - 值的字符串表示
     */
    function getSafeValueString(value) {
        try {
            // 处理基本类型和null
            if (typeof value!== 'object' || value === null) {
                return String(value);
            }
            // 处理DOM元素，返回标签名和ID信息
            if (value instanceof HTMLElement) {
                return `<${value.tagName.toLowerCase()}> (${value.id || 'no id'})`;
            }
            // 处理数组，返回数组长度信息
            if (Array.isArray(value)) {
                return `Array(${value.length})`;
            }
            // 处理普通对象，返回格式化的JSON字符串
            return JSON.stringify(value, null, 2);
        } catch (error) {
            // 处理循环引用或其他无法序列化的对象
            return '[Circular or Non-Serializable Object]';
        }
    }

    /**
     * 分析属性设置失败的原因
     * @param {Object} target - 目标对象
     * @param {string} property - 属性名
     * @param {any} value - 要设置的值
     * @returns {string} - 失败原因描述
     */
    function analyzeFailure(target, property, value) {
        // 获取属性描述符，如果属性不存在则返回空对象
        const descriptor = Object.getOwnPropertyDescriptor(target, property) || {};

        // 检查属性是否存在（通过值或getter判断）
        const propertyExists = descriptor.value!== undefined || descriptor.get!== undefined;

        // 检查属性是否为只读（writable为false）
        const isReadOnly = descriptor.writable === false;

        // 检查属性是否只有getter没有setter
        const isGetterOnly = descriptor.get!== undefined && descriptor.set === undefined;

        // 检查整个对象是否被冻结（不可扩展且所有属性不可配置）
        const isObjectFrozen = Object.isFrozen(target);

        // 检查属性描述符是否被冻结（不可修改）
        const isPropertyFrozen = 
            propertyExists && 
            Object.isExtensible(target) && 
            Object.isFrozen(Object.getOwnPropertyDescriptor(target, property));

        // 检查值类型是否与属性期望类型不匹配
        let typeMismatch = false;
        let typeErrorMessage = '';

        // 针对常见DOM属性的类型检查（非详尽，可根据需要扩展）
        if (objectName === 'document' && property === 'title') {
            typeMismatch = typeof value!=='string';
            typeErrorMessage = 'document.title必须是字符串类型';
        } else if (objectName === 'location' && property === 'href') {
            typeMismatch = typeof value!=='string';
            typeErrorMessage = 'location.href必须是字符串类型';
        } else if (objectName ==='screen' && (property === 'width' || property === 'height')) {
            typeMismatch = typeof value!== 'number';
            typeErrorMessage = `${objectName}.${property}必须是数字类型`;
        }

        // 根据不同情况返回具体的失败原因
        if (!propertyExists && isObjectFrozen) {
            return '对象被冻结，无法添加新属性';
        } else if (isReadOnly) {
            return '属性是只读的';
        } else if (isGetterOnly) {
            return '属性是getter-only，没有setter';
        } else if (isPropertyFrozen) {
            return '属性被冻结，无法修改';
        } else if (typeMismatch) {
            return typeErrorMessage;
        } else {
            return '未知原因（可能是内部限制或安全策略阻止）';
        }
    }

    return new Proxy(target, {
        // 拦截属性读取操作
        get(target, property, receiver) {
            const value = Reflect.get(target, property, receiver);

            console.log(
                "方法:", "get", 
                "对象:", objectName, 
                "属性:", property, 
                "属性类型:", typeof property, 
                "属性值:", getSafeValueString(value),
                "属性值类型:", typeof value
            );

            return value;
        },

        // 拦截属性设置操作
        set(target, property, value, receiver) {
            const oldValue = target[property];
            let result;      // 存储设置操作的结果
            let failureReason = '';  // 存储失败原因

            try {
                // 尝试设置属性值并获取结果
                result = Reflect.set(target, property, value, receiver);

                // 如果设置失败，分析失败原因
                if (!result) {
                    failureReason = analyzeFailure(target, property, value);
                }
            } catch (error) {
                // 捕获设置过程中可能发生的异常
                result = false;
                failureReason = error.message;
                console.error(`设置 ${objectName}.${property} 时出错:`, error);
            }

            console.log(
                "方法:", "set", 
                "对象:", objectName, 
                "属性:", property, 
                "属性类型:", typeof property, 
                "旧值:", getSafeValueString(oldValue),
                "旧值类型:", typeof oldValue,
                "新值:", getSafeValueString(value),
                "新值类型:", typeof value,
                "设置结果:", result? "✅成功" : "❌失败",
                result? "" : ` 原因: ${failureReason}`
            );

            return result;
        }
    });
}

/**
 * 为环境对象数组应用日志代理
 * @param {string[]} objectNames - 要代理的对象名称数组
 */
function setupEnvironmentLogging(objectNames) {
    for (const name of objectNames) {
        try {
            // 检查对象是否存在
            if (typeof window[name]!== 'undefined') {
                // 使用window[name]获取实际对象并应用代理
                window[name] = createLoggingProxy(window[name], name);
                console.log(`成功为 ${name} 设置日志代理`);
            } else {
                console.warn(`对象 ${name} 不存在，跳过代理设置`);
            }
        } catch (error) {
            console.error(`设置 ${name} 的代理时出错:`, error);
        }
    }
}

// 先定义window对象
window = {
    window: {}, // 确保window.window存在
    document: {
        title: '默认标题',
        createElement: function() { return {}; }
    },
    location: {
        href: 'http://example.com'
    },
    navigator: {
        userAgent: 'Node.js模拟'
    },
    history: {
        length: 0
    },
    screen: {
        width: 1920,
        height: 1080
    }
};

// 然后将window添加到全局对象
global.window = window;

// 应用代理到常用浏览器环境对象
setupEnvironmentLogging([
    'window', 
    'document', 
    'location', 
    'navigator', 
    'history', 
    'screen'
]);

// 测试一些操作
console.log("测试:")
window.document.title = '新标题';
console.log(window.location.href);