Question

我有一个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))
           }
         );
   }

任何指针都会真正帮助您。

Answer 1

您需要等待一个诺言，但是由于getPastEvents函数以回调模式工作，因此您可以创建自定义诺言并从async { ... }方法返回它

LoadingCache<Key, Deferred<Value>> = CacheBuilder.newBuilder()
    // ...
    .build(CacheLoader<Key, Deferred<Value>> { key ->
        someScope.async { computeMyValueSuspend(key) }
    })

在此之后，您可以使用await like

parseAddress

但是，如果可能的话，请尝试转换getPastEvents，以便它返回一个Promise而不是使用回调

Answer 2

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

const timeBomb = (resolve, reject) => {
  const msleft = Math.random() * 700 + 200;
  console.log("Countdown started!");
  console.log("Only "+(Math.round(msleft)/1000)+" seconds left!!");
  setTimeout(resolve, msleft);
};


waiter = async (p) => {
  console.log("I will hurry to do my last wish before dying");
  const result = await p;
  console.log("It Exploded!");
}

waiter(new Promise(timeBomb));

异步功能不等待继续

2 个答案: