忽略之前的应用程序序列化异常：TypeError:将循环结构转换为JSON

我有一个Angular应用程序，它使用Angular Universal进行服务器端渲染，TransferState模块将应用程序的状态从服务器传递到客户端

我在某些页面上看到此警告日志：

Ignoring BEFORE_APP_SERIALIZED Exception:  TypeError: Converting circular structure to JSON
at Object.stringify (<anonymous>)
at TransferState.toJson (/Users/my-user/Documents/MyApp/my-app/dist/server.js:40450:21)
at /Users/my-user/Documents/MyApp/my-app/dist/server.js:1338:122
at /Users/my-user/Documents/MyApp/my-app/dist/server.js:1399:29
at ZoneDelegate.invoke (/Users/my-user/Documents/MyApp/my-app/dist/server.js:167690:26)
at Zone.run (/Users/my-user/Documents/MyApp/my-app/dist/server.js:167449:43)
at /Users/my-user/Documents/MyApp/my-app/dist/server.js:168188:34
at ZoneDelegate.invokeTask (/Users/my-user/Documents/MyApp/my-app/dist/server.js:167722:31)
at Zone.runTask (/Users/my-user/Documents/MyApp/my-app/dist/server.js:167494:47)
at drainMicroTaskQueue (/Users/my-user/Documents/MyApp/my-app/dist/server.js:167900:35)

在APP\u之前忽略序列化异常：TypeError:将循环结构转换为JSON
在Object.stringify（'s）处，是日志的来源：

function _render<T>(
    platform: PlatformRef, moduleRefPromise: Promise<NgModuleRef<T>>): Promise<string> {
  return moduleRefPromise.then((moduleRef) => {
    const transitionId = moduleRef.injector.get(ɵTRANSITION_ID, null);
    if (!transitionId) {
      throw new Error(
          `renderModule[Factory]() requires the use of BrowserModule.withServerTransition() to ensure
the server-rendered app can be properly bootstrapped into a client app.`);
    }
    const applicationRef: ApplicationRef = moduleRef.injector.get(ApplicationRef);
    return applicationRef.isStable.pipe((first((isStable: boolean) => isStable)))
        .toPromise()
        .then(() => {
          const platformState = platform.injector.get(PlatformState);

          const asyncPromises: Promise<any>[] = [];

          // Run any BEFORE_APP_SERIALIZED callbacks just before rendering to string.
          const callbacks = moduleRef.injector.get(BEFORE_APP_SERIALIZED, null);
          if (callbacks) {
            for (const callback of callbacks) {
              try {
                const callbackResult = callback();
                if (ɵisPromise(callbackResult)) {
                  asyncPromises.push(callbackResult);
                }

              } catch (e) {
                // Ignore exceptions.
                console.warn('Ignoring BEFORE_APP_SERIALIZED Exception: ', e);
              }
            }
          }

          const complete = () => {
            const output = platformState.renderToString();
            platform.destroy();
            return output;
          };

          if (asyncPromises.length === 0) {
            return complete();
          }

          return Promise
              .all(asyncPromises.map(asyncPromise => {
                return asyncPromise.catch(
                    e => { console.warn('Ignoring BEFORE_APP_SERIALIZED Exception: ', e); });
              }))
              .then(complete);
        });
  });
}

function\u渲染(
平台：平台参考，模块推荐：承诺）：承诺{
返回moduleRefPromise.then（（moduleRef）=>{
const transitionId=moduleRef.injector.get（ɵTRANSITION_ID，null）；
if（！transitionId）{
抛出新错误(
`renderModule[Factory]（）需要使用BrowserModule.withServerTransition（）来确保
服务器呈现的应用程序可以正确引导到客户端应用程序中。`）；
}
常量applicationRef:applicationRef=moduleRef.injector.get（applicationRef）；
返回applicationRef.isStable.pipe（（第一个（（isStable:boolean）=>isStable）））
.toPromise（）
.然后（（）=>{
const platformState=platform.injector.get（platformState）；
常量异步承诺：承诺[]=[]；
//在呈现为字符串之前运行任何BEFORE\u APP\u序列化回调。
const callbacks=moduleRef.injector.get（在应用程序序列化之前，为null）；
如果（回调）{
for（回调的常量回调）{
试一试{
const callbackResult=callback（）；
如果（ɵisPromise（回调结果））{
asyncPromises.push（回调结果）；
}
}捕获（e）{
//忽略例外情况。
console.warn（'在应用程序序列化异常之前忽略：'，e）；
}
}
}
常量完成=（）=>{
const output=platformState.renderToString（）；
平台破坏（）；
返回输出；
};
if（async.length==0）{
返回完成（）；
}
回报承诺
.all（asyncPromission.map）（asyncPromission=>{
return.catch(
e=>{console.warn（'ignering BEFORE_APP_SERIALIZED Exception:'，e）；}）；
}))
.然后（完成）；
});
});
}