Javascript 在React Native中的异步函数中，当重复单击时，如何防止性能损失？

假设按钮一个接一个地被点击

在这种情况下，我不希望每次单击都运行functionC（）

但是，每次单击functa（）和functionB（）都必须起作用

我希望函数C（）根据dataA和dataB值工作​​在最后一次单击中

例如，如果按钮被单击100次，并且在最后一次单击后的5秒内没有再次单击该按钮，functionC（）应根据最新的dataA和dataB值工作

异步函数functionbc（）{ 试一试{ var dataA=等待函数（）； }catch（错误）{console.log（错误）；} 试一试{ var-dataB=等待函数b（）； }catch（错误）{console.log（错误）；} 试一试{ 等待功能C（数据A、数据B）； }catch（错误）{console.log（错误）；} } functionalbc（）}/> 新描述

(一)

• 按钮被点击了
• functionA和functionB起作用了
• 在5秒期限到期之前再次单击
• 功能C不工作

(二)

• functionA和functionB起作用了
• 在5秒期限到期之前再次单击
• 功能C不工作

（n-1）

• functionA和functionB起作用了
• 在5秒期限到期之前再次单击
• 功能C不工作

（n）

• functionA和functionB起作用了
• 5秒已过
• 功能C起作用了

---

我不确定您到底在寻找什么，但根据您的示例，我假设这就是您可能正在寻找的

  let counter = 0;

  async function functionABC() {

    counter++;

    try {
      var dataA = await functionA();
    } catch (error) { console.log(error); }

    try {
      var dataB = await functionB();
    } catch (error) { console.log(error); }

    if(counter % 100 === 0) {
        setTimeout(() => {
            if(counter % 100 === 0) {
                 try {
                    await functionC(dataA, dataB);
                 } catch (error) { console.log(error); }
            }
        }, 5000)
    }   
}

<Button title="Buton" onPress={() => functionABC()}/> 

let计数器=0；
异步函数functionBC（）{
计数器++；
试一试{
var dataA=等待函数（）；
}catch（错误）{console.log（错误）；}
试一试{
var-dataB=等待函数b（）；
}catch（错误）{console.log（错误）；}
如果（计数器%100==0）{
设置超时（（）=>{
如果（计数器%100==0）{
试一试{
等待功能C（数据A、数据B）；
}catch（错误）{console.log（错误）；}
}
}, 5000)
}   
}
functionalbc（）}/>

如果没有，请告诉我你到底想做什么

编辑

let timestamp = 0;
let firstClicked = false;

async function functionABC() {

    const currentTimestamp = Date.now();
    
    try {
      var dataA = await functionA();
    } catch (error) { console.log(error); }

    try {
      var dataB = await functionB();
    } catch (error) { console.log(error); }
    
    if(firstClicked) {
       if(currentTimestamp - timestamp >= 5000) {
           try {
               await functionC(dataA, dataB);
               } catch (error) { console.log(error); }
           }
       }
    } 
    firstclicked = true;

    timestamp = currentTimestamp;
}

<Button title="Buton" onPress={() => functionABC()}/>

let timestamp=0；
设firstClicked=false；
异步函数functionBC（）{
const currentTimestamp=Date.now（）；
试一试{
var dataA=等待函数（）；
}catch（错误）{console.log（错误）；}
试一试{
var-dataB=等待函数b（）；
}catch（错误）{console.log（错误）；}
如果（首次单击）{
如果（当前时间戳-时间戳>=5000）{
试一试{
等待功能C（数据A、数据B）；
}catch（错误）{console.log（错误）；}
}
}
} 
firstclicked=true；
时间戳=当前时间戳；
}
functionalbc（）}/>

我不确定您到底在寻找什么，但根据您的示例，我假设这就是您可能正在寻找的

  let counter = 0;

  async function functionABC() {

    counter++;

    try {
      var dataA = await functionA();
    } catch (error) { console.log(error); }

    try {
      var dataB = await functionB();
    } catch (error) { console.log(error); }

    if(counter % 100 === 0) {
        setTimeout(() => {
            if(counter % 100 === 0) {
                 try {
                    await functionC(dataA, dataB);
                 } catch (error) { console.log(error); }
            }
        }, 5000)
    }   
}

<Button title="Buton" onPress={() => functionABC()}/> 

let计数器=0；
异步函数functionBC（）{
计数器++；
试一试{
var dataA=等待函数（）；
}catch（错误）{console.log（错误）；}
试一试{
var-dataB=等待函数b（）；
}catch（错误）{console.log（错误）；}
如果（计数器%100==0）{
设置超时（（）=>{
如果（计数器%100==0）{
试一试{
等待功能C（数据A、数据B）；
}catch（错误）{console.log（错误）；}
}
}, 5000)
}   
}
functionalbc（）}/>

如果没有，请告诉我你到底想做什么

编辑

let timestamp = 0;
let firstClicked = false;

async function functionABC() {

    const currentTimestamp = Date.now();
    
    try {
      var dataA = await functionA();
    } catch (error) { console.log(error); }

    try {
      var dataB = await functionB();
    } catch (error) { console.log(error); }
    
    if(firstClicked) {
       if(currentTimestamp - timestamp >= 5000) {
           try {
               await functionC(dataA, dataB);
               } catch (error) { console.log(error); }
           }
       }
    } 
    firstclicked = true;

    timestamp = currentTimestamp;
}

<Button title="Buton" onPress={() => functionABC()}/>

let timestamp=0；
设firstClicked=false；
异步函数functionBC（）{
const currentTimestamp=Date.now（）；
试一试{
var dataA=等待函数（）；
}catch（错误）{console.log（错误）；}
试一试{
var-dataB=等待函数b（）；
}catch（错误）{console.log（错误）；}
如果（首次单击）{
如果（当前时间戳-时间戳>=5000）{
试一试{
等待功能C（数据A、数据B）；
}catch（错误）{console.log（错误）；}
}
}
} 
firstclicked=true；
时间戳=当前时间戳；
}
functionalbc（）}/>

您需要的是以某种方式存储“上次运行的函数调用”的标识符，以便在

函数C

之前进行检查。在这种情况下，使用

符号

效果很好，但任何其他唯一ID都可以（例如递增整数或空对象）

点击
异步函数functionBC（）{
常量thisClick=Symbol（）
lastClick=此单击
试一试{
var dataA=等待函数（）；
}catch（错误）{console.log（错误）；}
试一试{
var-dataB=等待函数b（）；
}catch（错误）{console.log（错误）；}
试一试{
如果（上次单击===此单击）
等待功能C（数据A、数据B）；
}catch（错误）{console.log（错误）；}
}
函数functionA（）{
console.log（'runa'）
返回新承诺（resolve=>setTimeout（resolve，500））
}
函数B（）{
console.log（'runb'）
返回新承诺（resolve=>setTimeout（resolve，500））
}
函数c（）{
console.log（'runc'）
返回新承诺（resolve=>setTimeout（resolve，500））
}

---

单击我

您需要的是以某种方式存储“上次运行的函数调用”的标识符，以便在

函数C

之前进行检查。在这种情况下，使用

符号

效果很好，但任何其他唯一ID都可以（例如递增整数或空对象）

点击
异步函数functionBC（）{
常量thisClick=Symbol（）
lastClick=此单击
试一试{
var dataA=等待函数