如何解决Javascript中的竞争条件？

我想等两个“玩家”都被抓住，然后再做一些其他的事情。 它不应该只运行1，然后完成2吗？此联机文档存在冲突。 编辑：反常的是，我不在乎订单，我只需要两个都拿到，然后做一些其他的事情。我尝试了公认的解决方案，因为它应该订购，但添加了一个

.then(() => {
  console.log('PeepsList', peepsList)
})

不知怎的，还是只带了一个玩家回来……我把它记录下来以确保是的，它是1。然后是。2。然后是。3，回答是1。3。2

challongeClient.matches.index({
  id: args[0],
  callback: (err, data) => {
    console.log(err, 'PLAYERS::')
    for (const [key, value] of Object.entries(data)) {
      if (value.match.state === 'open') {
        // GET PLAYER 1
        try {
          challongeClient.participants.show({
            id: tournamentURL,
            participantId: value.match.player1Id,
            callback: (err, data) => {
              console.log(err)
              let peep = message.guild.members.cache.find(member => member.id === data.participant.misc)
              peepsList.push(peep.user.username)
              console.log('GET PLAYER 1', peepsList)
              console.log('GET PLAYER 1', peepsList[0])
              console.log('GET PLAYER 1', peepsList[1])
            }
          })
          // GET PLAYER 2
          challongeClient.participants.show({
            id: tournamentURL,
            participantId: value.match.player2Id,
            callback: (err, data) => {
              console.log(err)
              let homie = message.guild.members.cache.find(member => member.id === data.participant.misc)
              peepsList.push(homie.user.username)
              const [p1, p2] = peepsList
              console.log('GET PLAYER 2', peepsList)
              console.log('GET PLAYER 2', p1)
              console.log('GET PLAYER 2', p2)
            }
          })
        } catch (error) {
          console.log('ERORORRORORROROEROROROROR')
        }
      }
    }
  }
})

编辑 来自实施解决方案的代码：

const getPlayer = (playerXId) => {
      return new Promise((resolve, reject) => {
        challongeClient.participants.show({
          id: tournamentURL,
          participantId: playerXId,
          callback: (err, data) => {
            if (err) {
              reject(err);
              return;
            }
            let peep = message.guild.members.cache.find(member => member.id === data.participant.misc)
            peepsList.push(peep.user.username)
            resolve();
            console.log('RUNNING GET PLAYER', playerXId, peepsList)
          }
        });
      });
    }
...
 if (value.match.state === 'open') {
              // GET PLAYERS
                        getPlayer(value.match.player1Id)
                        .then(() => {
                          getPlayer(value.match.player2Id)
                          return peepsList
                        })
                        .then((peeps)=> {
                          console.log('PPPPPPPEEEEEEEEPS',peeps)
                        })
                      }

答复：

RUNNING GET PLAYER 147860148 [ 'Studstill' ]
PPPPPPPEEEEEEEEPS [ 'Studstill' ]
RUNNING GET PLAYER 147860153 [ 'Studstill', 'ChunkLord' ]

---

这两个方法调用将一个接一个地执行，并且只有在收到结果后才会调用回调，结果可以是任意长度的时间。不能保证玩家1会在玩家2之前回来

为了保证顺序，您可以将获取player2的逻辑放入player1的回调中，或者将其封装在从该位置调用的函数中，这很难看

你最好能把它变成承诺。大概是这样的：

const getPlayerOne = (player1Id) => {
  return new Promise((resolve, reject) => {
    challongeClient.participants.show({
      id: tournamentURL,
      participantId: player1Id,
      callback: (err, data) => {
        if (err) {
          reject(err);
          return;
        }
        let peep = message.guild.members.cache.find(member => member.id === data.participant.misc)
        peepsList.push(peep.user.username)
        resolve();
      }
    });
  });
}

const getPlayerTwo = () => {
  return new Promise((resolve, reject) = {
    // Similar thing...
  });
}

getPlayerOne(value.match.player1Id)
  .then(() => getPlayerTwo(value.match.player2Id))
  .catch((error) => console.error(error))

然后这样称呼它：

const getPlayerOne = (player1Id) => {
  return new Promise((resolve, reject) => {
    challongeClient.participants.show({
      id: tournamentURL,
      participantId: player1Id,
      callback: (err, data) => {
        if (err) {
          reject(err);
          return;
        }
        let peep = message.guild.members.cache.find(member => member.id === data.participant.misc)
        peepsList.push(peep.user.username)
        resolve();
      }
    });
  });
}

const getPlayerTwo = () => {
  return new Promise((resolve, reject) = {
    // Similar thing...
  });
}

getPlayerOne(value.match.player1Id)
  .then(() => getPlayerTwo(value.match.player2Id))
  .catch((error) => console.error(error))

---

您甚至可以对其进行重构，以从具有不同参数的同一函数中获取player 1和player 2。

这两个方法调用将一个接一个地立即执行，并且只有在收到结果后才会调用回调，结果可以是任意长的时间。不能保证玩家1会在玩家2之前回来

为了保证顺序，您可以将获取player2的逻辑放入player1的回调中，或者将其封装在从该位置调用的函数中，这很难看

你最好能把它变成承诺。大概是这样的：

const getPlayerOne = (player1Id) => {
  return new Promise((resolve, reject) => {
    challongeClient.participants.show({
      id: tournamentURL,
      participantId: player1Id,
      callback: (err, data) => {
        if (err) {
          reject(err);
          return;
        }
        let peep = message.guild.members.cache.find(member => member.id === data.participant.misc)
        peepsList.push(peep.user.username)
        resolve();
      }
    });
  });
}

const getPlayerTwo = () => {
  return new Promise((resolve, reject) = {
    // Similar thing...
  });
}

getPlayerOne(value.match.player1Id)
  .then(() => getPlayerTwo(value.match.player2Id))
  .catch((error) => console.error(error))

然后这样称呼它：

const getPlayerOne = (player1Id) => {
  return new Promise((resolve, reject) => {
    challongeClient.participants.show({
      id: tournamentURL,
      participantId: player1Id,
      callback: (err, data) => {
        if (err) {
          reject(err);
          return;
        }
        let peep = message.guild.members.cache.find(member => member.id === data.participant.misc)
        peepsList.push(peep.user.username)
        resolve();
      }
    });
  });
}

const getPlayerTwo = () => {
  return new Promise((resolve, reject) = {
    // Similar thing...
  });
}

getPlayerOne(value.match.player1Id)
  .then(() => getPlayerTwo(value.match.player2Id))
  .catch((error) => console.error(error))

---

您甚至可以对其进行重构，以从具有不同参数的同一个函数中获取播放器1和播放器2。

这似乎应该可以工作，但我仍然不知道如何等待这两个参数。我完全不明白“chained.”then“在前一个完成之前可能会运行，这难道不是.then的唯一功能吗？我对文章做了一些编辑，提供了更多信息。正确，

then（）

将仅在前一个承诺解决时执行。如果您需要等待第二个也完成，请在

catch（）

之前添加另一个

then（）

，我知道，这就是为什么我会因此而失去它。challongeClient模块中是否发生了可能会把事情搞砸的事情？因为我在第二个玩家之前100%得到了最后一条链。我不知道在challongeClient中会发生什么，但也许这与你的数据循环有关？循环的每一次传递都将运行一个单独的异步进程，没有保证顺序。我将其放入了“getPlayer”函数中，我将在这里做任何事情，看看是否可行？虽然看起来有点骇人：i++if（i>1）{console.log（'i=2'，peepsList，i）i=0}这似乎应该可以工作，但我仍然不知道如何在这两者上等待。我完全不明白“chained.”then“在前一个完成之前可能会运行，这难道不是.then的唯一功能吗？我对文章做了一些编辑，提供了更多信息。正确，

then（）

将仅在前一个承诺解决时执行。如果您需要等待第二个也完成，请在

catch（）

之前添加另一个

then（）

，我知道，这就是为什么我会因此而失去它。challongeClient模块中是否发生了可能会把事情搞砸的事情？因为我在第二个玩家之前100%得到了最后一条链。我不知道在challongeClient中会发生什么，但也许这与你的数据循环有关？循环的每一次传递都将运行一个单独的异步进程，没有保证顺序。我将其放入了“getPlayer”函数中，我将在这里做任何事情，看看是否可行？不过似乎有点骇人听闻：i++if（i>1）{console.log（'i=2'，peepsList，i）i=0}