将大型JSON对象高效转换为Blob以规避字符串长度限制

let myLargeJson = { /* ... 包含大量数据 ... */ };
let blob = new Blob([JSON.stringify(myLargeJson)], {type: "application/json"});

const header = 24; // 示例值，实际可能不同
const bytes = new Uint8Array((512 * 1024 * 1024) - header); // 约500MB
const bigStr = new TextDecoder().decode(bytes); // 生成一个大字符串
const arr = [];
for (let i = 0; i < 5; i++) { // 拼接5个大字符串
  arr.push(bigStr);
}
console.log(new Blob(arr).size); // 输出约2.5GB (5 * 512MB - header * 5)

// ... (json2.js 原始代码的导入和初始化部分) ...

// 自定义join函数，用于连接BlobPart数组
const join = (arr, joint) => {
    // 将数组元素与连接符交错排列，并扁平化
    // 例如：[A, B, C] 和 ',' => [A, ',', B, ',', C]
    return arr.map((v) => [v, joint]).flat().slice(0, -1);
};

function quote(string) {
    // 字符串引用和转义逻辑保持不变，返回字符串
    // ...
}

function str(key, holder) {
    let i, k, v, length, mind = gap, partial, value = holder[key];

    // ... (toJSON 和 replacer 逻辑保持不变) ...

    switch (typeof value) {
        case 'string':
            return quote(value); // 短字符串直接返回
        case 'number':
            return isFinite(value) ? String(value) : 'null';
        case 'boolean':
        case 'null':
            return String(value);
        case 'object':
            if (!value) {
                return 'null';
            }

            gap += indent;
            partial = [];

            if (Object.prototype.toString.apply(value) === '[object Array]') {
                // 处理数组
                length = value.length;
                for (i = 0; i < length; i += 1) {
                    partial[i] = str(i, value) || 'null'; // 递归调用str，获取子元素的BlobPart
                }

                v = partial.length === 0
                    ? new Blob(['[]']) // 空数组直接创建Blob
                    : gap
                        ? new Blob(['[\n', gap, ...join(partial, ',\n' + gap), '\n', mind, ']']) // 格式化数组
                        : new Blob(['[', ...join(partial, ','), ']']); // 紧凑数组
                gap = mind;
                return v; // 返回一个Blob对象
            }

            // 处理普通对象
            // ... (根据replacer或遍历所有key的逻辑) ...
            if (rep && typeof rep === 'object') {
                length = rep.length;
                for (i = 0; i < length; i += 1) {
                    if (typeof rep[i] === 'string') {
                        k = rep[i];
                        v = str(k, value);
                        if (v) {
                            partial.push(new Blob([quote(k) + (gap ? ': ' : ':'), v]));
                        }
                    }
                }
            } else {
                for (k in value) {
                    if (Object.prototype.hasOwnProperty.call(value, k)) {
                        v = str(k, value);
                        if (v) {
                            partial.push(new Blob([quote(k), (gap ? ': ' : ':'), v]));
                        }
                    }
                }
            }

            v = partial.length === 0
                ? new Blob(['{}']) // 空对象直接创建Blob
                : gap
                    ? new Blob(['{\n', gap, ...join(partial, ',\n' + gap), '\n', mind, '}']) // 格式化对象
                    : new Blob(['{', ...join(partial, ','), '}']); // 紧凑对象
            gap = mind;
            return v; // 返回一个Blob对象
    }
}

// 新增的JSON.blobify方法作为入口
if (true) { // 原始json2.js中用于判断是否已有JSON.stringify的逻辑，这里简化为true
    meta = { /* ... 字符转义映射 ... */ };
    JSON.blobify = function (value, replacer, space) {
        var i;
        gap = '';
        indent = '';

        if (typeof space === 'number') {
            for (i = 0; i < space; i += 1) {
                indent += ' ';
            }
        } else if (typeof space === 'string') {
            indent = space;
        }

        rep = replacer;
        if (replacer && typeof replacer !== 'function' &&
            (typeof replacer !== 'object' ||
                typeof replacer.length !== 'number')) {
            throw new Error('JSON.stringify'); // 保持与JSON.stringify相同的错误处理
        }

        // 调用str函数，从根对象开始构建Blob
        return str('', {'': value});
    };
}

(async () => {
  const largeData = {
    metadata: {
      timestamp: new Date(),
      version: "1.0"
    },
    items: Array(1000000).fill(0).map((_, i) => ({
      id: i,
      name: `Item ${i}`,
      description: `This is a long description for item ${i}.`.repeat(10),
      details: {
        category: "electronics",
        price: Math.random() * 1000,
        available: true
      }
    }))
  };

  // 使用改造后的JSON.blobify将对象直接转换为Blob
  const asBlob = JSON.blobify(largeData, null, 2); // 带有2个空格缩进

  console.log({asBlob}); // 输出Blob对象信息

  // 为了验证，我们可以将Blob转换回字符串并解析
  // 注意：如果原始JSON非常大，asBlob.text() 仍然可能创建大字符串，
  // 但这发生在Blob生成之后，且取决于后续操作，而非Blob创建本身。
  try {
    const asString = await asBlob.text();
    console.log("Blob内容大小:", asString.length / (1024 * 1024), "MB");
    const parsedData = JSON.parse(asString);
    console.log("解析成功，数据结构与原始对象一致:", parsedData.items[0]);
  } catch (error) {
    console.error("从Blob转换为字符串或解析时发生错误:", error);
  }
})();