Javascript 找到节点时的承诺函数？

目前我正在做下面的工作，但是陷入了调用堆栈的困境；如何使用

async

await

或更新的promise函数更好地处理此问题？我有一个动态节点，由于不同的加载时间，它在不同的时间被添加到dom中-我可以简单地处理

异步
等待
吗

函数checkForNode（）{
让coolNode=document.getElementById（“CoolDomNode”）；
if（coolNode）{
域事物（coolNode）；
}否则{
checkForNode（）
}
}
这不是一个异步作业，因此
async
/
wait
不会解决问题。相反，您可以使用
seTimeout
，这样递归就不会发生在同一个堆栈上。使用
setTimeout
还可以设置每次迭代之间的延迟，以降低CPU使用率，如下所示：

checkForNode() { 
  let coolNode = document.getElementById("CoolDomNode");

  if (coolNode) {
    doManyThings(coolNode);
  } else { 
    setTimeout(checkForNode, 500);  // if you want this to run as often as possible then set the delay to 0
  }
}

顺便说一句，你所做的是一个完美的工作<代码>MutationObserver
在DOM树发生更改时通知您。您可以指定根元素，当添加新元素作为根元素的子元素时，将调用回调：

var observer = new MutationObserver(function(mutations) {             // when mutations happen
  mutations.forEach(function(mutation) {                              // for each mutation
    mutation.addedNodes.forEach(function(addedNode) {                 // check every added node in that mutation
      if(addedNode.id === "CoolDomNode") {                            // if it's the node you're looking for
        doManyThings(addedNode);                                      // do your thing
      }
    });
  });
});

observer.observe(document.body, { childList: true, subtree: true });  // observe any changes in the body and its entire subtree. You can narrow down the subtree for optimal performance

这不是一个异步作业，因此
async
/
await
无法解决此问题。相反，您可以使用
seTimeout
，这样递归就不会发生在同一个堆栈上。使用
setTimeout
还可以设置每次迭代之间的延迟，以降低CPU使用率，如下所示：

checkForNode() { 
  let coolNode = document.getElementById("CoolDomNode");

  if (coolNode) {
    doManyThings(coolNode);
  } else { 
    setTimeout(checkForNode, 500);  // if you want this to run as often as possible then set the delay to 0
  }
}

顺便说一句，你所做的是一个完美的工作<代码>MutationObserver
在DOM树发生更改时通知您。您可以指定根元素，当添加新元素作为根元素的子元素时，将调用回调：

var observer = new MutationObserver(function(mutations) {             // when mutations happen
  mutations.forEach(function(mutation) {                              // for each mutation
    mutation.addedNodes.forEach(function(addedNode) {                 // check every added node in that mutation
      if(addedNode.id === "CoolDomNode") {                            // if it's the node you're looking for
        doManyThings(addedNode);                                      // do your thing
      }
    });
  });
});

observer.observe(document.body, { childList: true, subtree: true });  // observe any changes in the body and its entire subtree. You can narrow down the subtree for optimal performance

既然已经介绍了一种基于
MutationObserver
的解决方案——这当然是解决这类问题的一种方式——我想提到一种可能适用，也可能不适用的“旧”方式

它基于这样一个事实：在连续节点之前，脚本可以使用前面的节点，因此，您可以将脚本放置在节点之后（或节点内部），以访问节点及其内容（如果放置在节点之后）：

你好
document.getElementById（“CoolDomNode”）；
///或
document.currentScript.previousElementSibling；

我会让你自己评估哪种解决方案更适合你，以及为什么。简言之，观察文档的更改会随着文档中节点数的增加而线性增加，这可能会超过只等待一个节点的好处。然而，有人可能会说，在感兴趣的节点之后放置脚本对超文本来说更像是一种污染，显然，这首先取决于节点是否是文档的一部分。
因为已经介绍了基于
MutationObserver
的解决方案——这当然是处理这类问题的正常方式——我想提及一种可能适用，也可能不总是适用的“旧”方式

它基于这样一个事实：在连续节点之前，脚本可以使用前面的节点，因此，您可以将脚本放置在节点之后（或节点内部），以访问节点及其内容（如果放置在节点之后）：

你好
document.getElementById（“CoolDomNode”）；
///或
document.currentScript.previousElementSibling；

---

我会让你自己评估哪种解决方案更适合你，以及为什么。简言之，观察文档的更改会随着文档中节点数的增加而线性增加，这可能会超过只等待一个节点的好处。然而，有人可能会争辩说，在感兴趣的节点之后放置脚本对超文本的污染更大，而且显然首先取决于节点是文档的一部分。

是不是以后在DOM中插入了什么？像这样建模UI是很困难的。我不认为async/await是否能在那里工作。您可以使用MutationObserver跟踪dom更改，然后适当地触发您的函数。下面是一个示例，这样您就不能等待这样的节点了，Doc--

checkForNode

将淹没调用堆栈，并且不会给解析器继续解析文档文本和向其中添加节点的机会。解析器在脚本调用之间运行，没有并发性或并行性，否则您将有一个更复杂的运行时环境——一个循环迭代中有一个节点，下一个迭代中有两个节点，依此类推。因此，为了让点回到原点——你不能递归地等待节点——你需要产生控制，让解析器至少运行一次，然后再试一次。顺便说一下，这会非常低效。

CoolDomNode

是您以后在DOM中插入的东西吗？像这样建模UI是很困难的。我不认为async/await是否能在那里工作。您可以使用MutationObserver跟踪dom更改，然后适当地触发您的函数。下面是一个示例，这样您就不能等待这样的节点了，Doc--

checkForNode

将淹没调用堆栈，并且不会给解析器继续解析文档文本和向其中添加节点的机会。解析器在脚本调用之间运行，没有并发性或并行性，否则您将有一个更复杂的运行时环境——一个循环迭代中有一个节点，下一个迭代中有两个节点，依此类推。因此，为了让点回到原点——你不能递归地等待节点——你需要产生控制，让解析器至少运行一次，然后再试一次。顺便说一句，这将是非常低效的。