我如何携带功能结果备份功能以再次重申功能？

Question

我有一个通过foreach循环传递的数组。然后将每个项目通过并检查特定订单或字符。如果是正确的，则该字符应从字符串中删除，则应该用新字符串将其重新循环。 （旧字符串减去检查字符）

我的问题是所有功能仍在本地持有旧字符串（在删除字符之前）。我如何将新字符串传递到函数中，而不重置当前保存的“ deletestringdata”值？

let dnaArray = ["ACATATAGACATACGT","AAAAAATACATAGTAGTCGGGTAG","ATACATCGGGTAGCGT"];
dnaStrand = "";



//SORT THROUGH EACH ITEM IN ARRAY
dnaArray.forEach((dnaStrand, index) => {
  if (findDna(dnaStrand)) {
    console.log("Case #" + index + " " + dnaStrand + ": YES");
}
  else {
      console.log("Case #" + index + " " + dnaStrand + ": NO");
  };
});






function findDna(dnaStrand){
  if (findHead(dnaStrand)){
    if(findBody(dnaStrand)){
      console.log("dna");
      return true;
    }
  }
  else {
    return false;
  }
};


function findHead(dnaStrand){
  if (findGlobe(dnaStrand)){
    if (findEyeSpots(dnaStrand)) {
      return true;
    }
  }
  else{
    return false;
  }
};



function findBody(dnaStrand){
  if (findGlobe(dnaStrand) && findLegs(dnaStrand)) {
    return true;
  }
  else {
    return false;
  }
};



function findGlobe(dnaStrand){
  if(findMatch(dnaStrand, /(A+(TAC|CAT)A)/)){
    return true;
  }else{
    console.log("No Globe");
  }
};



function findEyeSpots(dnaStrand){
  if(findMatch(dnaStrand, /T(CG*T)*AG/)){
    return true;
  }else{
    console.log("No Eyes");
  }
};

function findLegs(dnaStrand){
  if(findMatch(dnaStrand, /CG*T/)){
    return true;
  }else{
      console.log("No Legs");
  }
};


function findMatch (dnaStrand, regex) {
  dnaStrand = String(dnaStrand);
  let isMatch = dnaStrand.match(regex);
  isMatch = String(isMatch[0]);
  //console.log(isMatch);
  if (isMatch) {
    deleteStringData(dnaStrand, isMatch);
    return true;
  }
  else {
    return false;
  }
};

function deleteStringData (dnaStrand, string) {
   dnaStrand = dnaStrand.replace(string, "");
};

Answer 1

抱歉，我有点忙，没有时间阅读您的所有代码。根据您的问题，我可以为您提供一些基本的指导。

确保您的功能采用参数。如果每次最终结果都不令人满意，或者您只想再次重复它，请执行if语句，如果您要重复它，请在内部进行您的功能（endResult）。如果您担心滞后，请考虑使最终结果成为全局变量，并将settimeout设置为您的功能。

Answer 2

如果您在循环中声明测试功能，则可以在该范围中的单个实例上作用，而无需传递周围的任何参考。

您也可以使用测试。

这可能不是最有效的方法，但非常可读。

(async () => {
  const strands = [
    'ACATATAGACATACGT',
    'AAAAAATACATAGTAGTCGGGTAG',
    'ATACATCGGGTAGCGT'
  ];

  const results = [];

  async function analyze(strand, index) {
    let result = {
      'case' : parseInt(index), strand
    };

    function findMatch(pattern) {
      return new Promise((resolve, reject) => {
        let m = strand.match(pattern)[0];

        if (m) {
          strand = strand.replace(m, ''); 
          resolve(true);
        } else {
          reject();
        }
      });
    }

    function findHead() {
      return findGlobe().then(findEyes);
    }

    function findBody() {
      return findGlobe().then(findLegs);
    }

    function findGlobe() {
      return findMatch(/(A+(TAC|CAT)A)/);
    }

    async function findEyes() {
      result.eyes = await findMatch(/T(CG*T)*AG/);
    }

    async function findLegs() {
      result.legs = await findMatch(/CG*T/);
    }  

    function found() {
      result.dna = true;
    }

    function failed() {
      result.dna = false;
    }

    function done() {
      results.push(result);
    }

    await Promise.all([
      findHead(),
      findBody()
    ]).then(found)
    .catch(failed)
    .finally(done);
  }

  for (let i in strands) {
    await analyze(strands[i], i);
  }
  
  console.log(results);
})();