Reactjs 异步函数未等待继续

我有一个react应用程序，在其中我隐藏和显示按钮，而不是在页面上移动，在我显示下一个按钮之前，我想确保按钮要调用的功能已经完成。以下是我到目前为止的情况：

这是异步函数：

async handleTransferFromEthereum(){
    parseAddress(this.state.sc)
    this.setState(prevState => ({
         isEthTransferVisible: !prevState.isEthTransferVisible,
         isGoDeployedVisible: !prevState.isGoDeployedVisible
    }));  
}

这就是我调用的函数：

import ERC20ABI from './blockchain/ERC20ABI.js';
import ethweb3 from './blockchain/ethweb3.js';
import _ from 'lodash';

var addressesValues = [];
var uniqueAddresses = [];
var values = [];
var count = 0;
var map = {};
var address =[];
var amounts=[];
var choppedAdrresses = [];

export  function parseAddress(_smartcontract){
    console.log("Scanning blockchain")
     var contractObj =  new ethweb3.eth.Contract(ERC20ABI,_smartcontract);
     contractObj.getPastEvents(
        'Transfer' || 'allEvents',
        {
               fromBlock: 0,
               toBlock: 'latest'
        },
        function(err,res){
           for(var i =1; i< res.length; i++){
             if (uniqueAddresses.includes(res[i].returnValues.from)===false) {
                  uniqueAddresses[count] = res[i].returnValues.from;
                  values[count] = parseInt(0);
                  map[uniqueAddresses[count]] = values[count];
                  count+=1
             }
             if (uniqueAddresses.includes(res[i].returnValues.to)===false){
                uniqueAddresses[count] = res[i].returnValues.to;
                values[count] = parseInt(0);
                map[uniqueAddresses[count]] = values[count];
                count+=1
              }
          }
          for(var j = 0; j< res.length; j++){
                 map[res[j].returnValues.from] -= parseInt(res[j].returnValues.value);
                 map[res[j].returnValues.to] += parseInt(res[j].returnValues.value);
           }

           for(var x = 0; x < uniqueAddresses.length; x++){
                 addressesValues.push([uniqueAddresses[x], parseInt(map[res[x].returnValues.to])])
           }

              for(var y=0; y < addressesValues.length; y++){
                address.push(addressesValues[y][0]);
                amounts.push(addressesValues[y][1]);
              }

               var choppedAdrresses=_.chunk(address, 100);
               var choppedValue=_.chunk(amounts, 100);
               var tokenSum = amounts.reduce((a, b) => a + b, 0);
               sessionStorage.setItem("addresses", JSON.stringify(address))
               sessionStorage.setItem("tokenSum", JSON.stringify(tokenSum))
               sessionStorage.setItem("choppedAdrresses", JSON.stringify(choppedAdrresses))
               sessionStorage.setItem("choppedValue", JSON.stringify(choppedValue))
           }
         );
   }

从“/blockchain/ERC20ABI.js”导入ERC20ABI；
从“/blockchain/ethweb3.js”导入ethweb3；
从“lodash”进口；
var addressesValues=[]；
var uniqueAddresses=[]；
var值=[]；
var计数=0；
var-map={}；
var地址=[]；
风险值金额=[]；
var ChoppedAddresses=[]；
导出函数解析地址（_smartcontract）{
console.log（“扫描区块链”）
var contractObj=新的ethweb3.eth.合同（ERC20ABI，_smartcontract）；
contractObj.GetPasteEvents(
“转移”| |“所有事件”，
{
fromBlock:0，
托布洛克：“最新的”
},
函数（err、res）{
对于（变量i=1；ia+b，0）；
setItem（“地址”，JSON.stringify（地址））
setItem（“tokenSum”，JSON.stringify（tokenSum））
setItem（“ChoppedAddresses”，JSON.stringify（ChoppedAddresses））
setItem（“choppedValue”，JSON.stringify（choppedValue））
}
);
}

---

任何指针都会非常有用。

您需要等待一个承诺，但由于getPasteEvents函数在回调模式下工作，因此您可以创建一个自定义承诺，并从

parseAddress

方法返回它

export  function parseAddress(_smartcontract){
  console.log("Scanning blockchain")

    return new Promise(function(resolve, reject) {

         var contractObj =  new ethweb3.eth.Contract(ERC20ABI,_smartcontract);
         contractObj.getPastEvents(
            'Transfer' || 'allEvents',
            {
                   fromBlock: 0,
                   toBlock: 'latest'
            },
            function(err,res){
               if (err) {
                  reject(err);
               }
               for(var i =1; i< res.length; i++){
                 if (uniqueAddresses.includes(res[i].returnValues.from)===false) {
                      uniqueAddresses[count] = res[i].returnValues.from;
                      values[count] = parseInt(0);
                      map[uniqueAddresses[count]] = values[count];
                      count+=1
                 }
                 if (uniqueAddresses.includes(res[i].returnValues.to)===false){
                    uniqueAddresses[count] = res[i].returnValues.to;
                    values[count] = parseInt(0);
                    map[uniqueAddresses[count]] = values[count];
                    count+=1
                  }
              }
              for(var j = 0; j< res.length; j++){
                     map[res[j].returnValues.from] -= parseInt(res[j].returnValues.value);
                     map[res[j].returnValues.to] += parseInt(res[j].returnValues.value);
               }

               for(var x = 0; x < uniqueAddresses.length; x++){
                     addressesValues.push([uniqueAddresses[x], parseInt(map[res[x].returnValues.to])])
               }

                  for(var y=0; y < addressesValues.length; y++){
                    address.push(addressesValues[y][0]);
                    amounts.push(addressesValues[y][1]);
                  }

                   var choppedAdrresses=_.chunk(address, 100);
                   var choppedValue=_.chunk(amounts, 100);
                   var tokenSum = amounts.reduce((a, b) => a + b, 0);
                   sessionStorage.setItem("addresses", JSON.stringify(address))
                   sessionStorage.setItem("tokenSum", JSON.stringify(tokenSum))
                   sessionStorage.setItem("choppedAdrresses", JSON.stringify(choppedAdrresses))
                   sessionStorage.setItem("choppedValue", JSON.stringify(choppedValue))
                   resolve();
               }
          );
      });
}

---

但是，如果可能，请尝试转换GetPasteEvents，以便它返回一个承诺，而不是使用回调

该承诺在您创建它时开始，并等待它解决。但是这两个语句中间的代码将在承诺结束之前运行。如果您不需要承诺的任何结果，您可以将代码放在该区域中，使其执行与承诺并行

const timeBomb=（解析、拒绝）=>{
const msleft=Math.random（）*700+200；
log（“开始倒计时！”）；
log（“仅”+（数学轮（msleft）/1000）+“还剩秒！！”；
设置超时（解析，msleft）；
};
服务员=异步（p）=>{
log（“我会在临死前赶紧做我最后的愿望”）；
const result=等待p；
log（“它爆炸了！”）；
}
服务员（新承诺（定时炸弹））异步函数需要使用
wait
关键字承诺等待
async handleTransferFromEthereum(){
    await parseAddress(this.state.sc)
    this.setState(prevState => ({
         isEthTransferVisible: !prevState.isEthTransferVisible,
         isGoDeployedVisible: !prevState.isGoDeployedVisible
    }));  
}