javascript - 为深层嵌套对象构建 promise 链

Question

我有一个深对象:

{
  "something": "Homepage",
  "else": [
    "[replaceme]",
    "[replaceme]"
  ],
  "aside": "[replaceme]",
  "test": {
    "test": {
      "testing": [
        "[replaceme]",
        "[replaceme]",
        "variable",
        {
          "testing": {
            "testing": {
              "something": "[replaceme]",
              "testing": {
                "testing": [
                  "[replaceme]",
                  "[replaceme]"
                ]
              }
            }
          }
        }
      ]
    }
  }
}

现在我需要将每次出现的 [replaceme] 替换为来自异步函数的内容。每次都不一样。

我以为我减少了对象的每个级别并返回了一个 promise 链。

这是我到目前为止得到的:

const IterateObject = ( object ) => {
    return new Promise( ( resolve, reject ) => {
        Object.keys( object ).reduce( ( sequence, current ) => {
            const key = current;

            return sequence.then( () => {
                return new Promise( ( resolve, reject ) => {

                    if( typeof object[ key ] === 'object' ) {
                        IterateObject( object[ key ] )
                            .then( result => {
                                newObject[ key ] = result;
                        });
                        // ^----- How do I add the next level when it returns a promise?
                    }
                    else {
                        resolve( newObject[ key ] )
                    }
                });
            });
        }, Promise.resolve())
        .catch( error => reject( error ) )
        .then( () => {
            console.log('done');

            resolve();
        });
    });
}

问题

解决这个问题的最佳方法是什么？也许 promise 链不是正确的工具？

Answer 1

不要尝试在单个函数中执行此操作。这可能会导致称为 The Collection Kerfuffle 的常见反模式。将此作业拆分为独立的 block :深度遍历对象、异步 setter 等。通过遍历对象收集所有待处理的 promise ，并使用 Promise.all

等待它们全部

// traverse object obj deep using fn iterator
const traverse = (obj, fn) => {  
  const process = (acc, value, key, object) => {
    const result =
      Array.isArray(value)
        ? value.map((item, index) => process(acc, item, index, value))
        : (
            typeof value === 'object' 
              ? Object.keys(value).map(key => process(acc, value[key], key, value))
              : [fn(value, key, object)]
          )
    return acc.concat(...result)
  }

  return process([], obj)
}

// fake async op
const getAsync = value => new Promise(resolve => setTimeout(resolve, Math.random()*1000, value))

// useful async setter
const setAsync = (target, prop, pendingValue) => pendingValue.then(val => target[prop] = val)

// traverse object obj deep using fn iterator
const traverse = (obj, fn) => {  
  const process = (acc, value, key, object) => {
    const result =
      Array.isArray(value)
        ? value.map((item, index) => process(acc, item, index, value))
        : (
            typeof value === 'object' 
              ? Object.keys(value).map(key => process(acc, value[key], key, value))
              : [fn(value, key, object)]
          )
    return acc.concat(...result)
  }
  
  return process([], obj)
}

// set async value
const replace = (value, prop, target) => {
  if( value === '[replaceme]') {
    return setAsync(target, prop, getAsync(`${prop} - ${Date.now()}`))
  }
  return value
}
   
const tmpl = {
  "something": "Homepage",
  "else": [
"[replaceme]",
"[replaceme]"
  ],
  "aside": "[replaceme]",
  "test": {
"test": {
  "testing": [
    "[replaceme]",
    "[replaceme]",
    "variable",
    {
      "testing": {
        "testing": {
          "something": "[replaceme]",
          "testing": {
            "testing": [
              "[replaceme]",
              "[replaceme]"
            ]
          }
        }
      }
    }
  ]
}
  }
}

Promise.all(
  traverse(tmpl, replace)
)
.then(() => console.log(tmpl))
.catch(e => console.error(e))

或者您可能想看一下 async/await，它允许您编写更多“类似同步”的代码。但是这种实现会导致顺序执行。

    // using async/await
    const fillTemplate = async (tmpl, prop, object) => {
      if(Array.isArray(tmpl)) {
        await Promise.all(tmpl.map((item, index) => fillTemplate(item, index, tmpl)))
      }
      else if(typeof tmpl === 'object') {
        await Promise.all(Object.keys(tmpl).map(key => fillTemplate(tmpl[key], key, tmpl)))
      }
      else {
        await replace(tmpl, prop, object) 
      }
    }

    const tmpl = {
  "something": "Homepage",
  "else": [
    "[replaceme]",
    "[replaceme]"
  ],
  "aside": "[replaceme]",
  "test": {
    "test": {
      "testing": [
        "[replaceme]",
        "[replaceme]",
        "variable",
        {
          "testing": {
            "testing": {
              "something": "[replaceme]",
              "testing": {
                "testing": [
                  "[replaceme]",
                  "[replaceme]"
                ]
              }
            }
          }
        }
      ]
    }
  }
}
    
    // fake async op
    const getAsync = value => new Promise(resolve => setTimeout(resolve, Math.random()*1000, value))

    // useful async setter
    const setAsync = (target, prop, pendingValue) => pendingValue.then(val => target[prop] = val)

    // set async value
    const replace = (value, prop, target) => {
      if( value === '[replaceme]') {
        return setAsync(target, prop, getAsync(`${prop} - ${Date.now()}`))
      }
      return value
    }

    // using async/await
    const fillTemplate = async (tmpl, prop, object) => {
      if(Array.isArray(tmpl)) {
        await Promise.all(tmpl.map((item, index) => fillTemplate(item, index, tmpl)))
      }
      else if(typeof tmpl === 'object') {
        await Promise.all(Object.keys(tmpl).map(key => fillTemplate(tmpl[key], key, tmpl)))
      }
      else {
        await replace(tmpl, prop, object) 
      }
    }
    
    Promise
      .resolve(fillTemplate(tmpl))
      .then(() => console.log(tmpl))
      .catch(e => console.error(e))