《TypeScript高级编程》10.2 序列化与反序列化类型

interface Session {
  userId: number;
  createdAt: Date;
}

const s: Session = { userId: 1, createdAt: new Date() };

const raw = JSON.stringify(s);          // 类型是 string
const back = JSON.parse(raw) as Session; // 类型是 Session，但它是假的

console.log(back.createdAt instanceof Date); // false
console.log(typeof back.createdAt);          // "string"
console.log(back.createdAt.getTime());
// 💥 TypeError: back.createdAt.getTime is not a function

TypeError: back.createdAt.getTime is not a function
    at formatSession (/app/src/session.ts:42:31)

function parseJson(text: string): unknown {
  return JSON.parse(text) as unknown;
}

const data = parseJson(raw); // 类型是 unknown，不能直接点属性
// data.createdAt; ❌ Object is of type 'unknown'.

const bad = { count: NaN, big: 10n };
// 第一个问题
JSON.stringify({ count: NaN }); // '{"count":null}'
// 第二个问题
JSON.stringify({ big: 10n });
// 💥 TypeError: Do not know how to serialize a BigInt

const now = new Date("2026-10-06T10:00:00+08:00");
const raw = JSON.stringify({ at: now });
// '{"at":"2026-10-06T02:00:00.000Z"}'

const back = JSON.parse(raw) as { at: Date };
console.log(back.at); // "2026-10-06T02:00:00.000Z" —— 字符串，不是 Date

interface Codec<A, W = unknown> {
  encode(value: A): W;
  decode(wire: W): A;
}

const DateCodec: Codec<Date, string> = {
  encode: (d) => d.toISOString(),
  decode: (s) => new Date(s),
};

type Shape = Record<string, Codec<any, any>>;

type Encoded<S extends Shape> = { [K in keyof S]: ReturnType<S[K]["encode"]> };
type Decoded<S extends Shape> = { [K in keyof S]: ReturnType<S[K]["decode"]> };

function struct<S extends Shape>(shape: S): Codec<Decoded<S>, Encoded<S>> {
  return {
    encode: (value) => {
      const out: Record<string, unknown> = {};
      for (const [key, codec] of Object.entries(shape)) {
        out[key] = codec.encode((value as Record<string, unknown>)[key]);
      }
      return out as Encoded<S>;
    },
    decode: (wire) => {
      const out: Record<string, unknown> = {};
      for (const [key, codec] of Object.entries(shape)) {
        out[key] = codec.decode((wire as Record<string, unknown>)[key]);
      }
      return out as Decoded<S>;
    },
  };
}

const SessionCodec = struct({
  userId: NumberCodec,
  createdAt: DateCodec,
});

type Session = ReturnType<typeof SessionCodec.decode>;
// type Session = { userId: number; createdAt: Date }

const wire = SessionCodec.encode({ userId: 1, createdAt: new Date() });
// wire 的类型是 { userId: number; createdAt: string }，直接 JSON.stringify 即可

const s = SessionCodec.decode(JSON.parse(raw));
console.log(s.createdAt instanceof Date); // true

const DateCodec: Codec<Date, string> = {
  encode: (d) => d.toISOString(),
  decode: (s) => {
    const d = new Date(s);
    if (Number.isNaN(d.getTime())) throw new ValidationError([`非法日期: ${s}`]);
    return d;
  },
};

type V1 = { version: 1; name: string };
type V2 = { version: 2; name: string; tags: string[] };
type Latest = V2;

function migrate(raw: unknown): Latest {
  if (typeof raw !== "object" || raw === null) throw new ValidationError(["期望对象"]);
  const v = raw as { version?: unknown; name?: unknown; tags?: unknown };
  switch (v.version) {
    case 1:
      return { version: 2, name: String(v.name), tags: [] };
    case 2:
      return { version: 2, name: String(v.name), tags: (v.tags as string[]) ?? [] };
    default:
      throw new ValidationError([`未知版本: ${String(v.version)}`]);
  }
}

const a: any = { name: "a" };
a.self = a;
JSON.stringify(a);
// 💥 TypeError: Converting circular structure to JSON

const seen = new WeakSet<object>();

const raw = JSON.stringify(a, (key, value) => {
  if (typeof value === "object" && value !== null) {
    if (seen.has(value)) return "[Circular]";
    seen.add(value);
  }
  return value;
});
// '{"name":"a","self":"[Circular]"}'

const ISO = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;

const data = JSON.parse(raw, (key, value) => {
  if (typeof value === "string" && ISO.test(value)) return new Date(value);
  return value;
});

type Tagged<T extends string, V> = { $type: T; value: V };

const tag = <T extends string, V>(t: T, v: V): Tagged<T, V> => ({ $type: t, value: v });

const encoded = JSON.stringify({ at: tag("Date", new Date().toISOString()), big: tag("BigInt", "10") });
// '{"at":{"$type":"Date","value":"..."},"big":{"$type":"BigInt","value":"10"}}'

const clone = structuredClone({ at: new Date(), m: new Map([[1, "a"]]) });
clone.at instanceof Date; // true —— 不会失真
clone.m instanceof Map;   // true