Google Apps Script并发失效：DNC数据清洗超时问题求助

我正尝试从一份近1000行的跳过追踪电子表格中清理DNC（禁止呼叫）电话记录，每行最多包含10条电话记录。

每条电话记录包含以下数据：

• DNC状态（'Yes'或'No'）
• 评分（该跳过追踪记录的准确度）
• 类型（固定电话/移动电话/...）
• 电话号码
• 最后出现日期

我创建了DNCScrubber类，具体功能如下：

• 将目标Sheet中的数据提取为包含phoneDataList的字典数组
• 清理数据，即处理phoneDataList并确定rowsToDelete（待删除行）
• 更新表格：仅当电话记录与phoneDataList不匹配时才覆盖，清空后续多余内容

表格更新环节先将表格拆分为100行的块，再异步处理每个块，代码如下：

updateSheet(sheet) { 
  let breakpoints = [];
  for (let breakpoint = 0; breakpoint < this.sheetData.length; breakpoint += Constants.SheetChunkSize) { 
    breakpoints.push([breakpoint, Math.min(breakpoint + Constants.SheetChunkSize, this.sheetData.length)])
  }

  const updateSheetPromises = breakpoints.map(([startIdx, endIdx]) => this.updateSheetChunkAsync(sheet, startIdx, endIdx))

  Promise.all(updateSheetPromises)
    .then((_) => { 
      // delete the rows to be deleted
      this.rowsToDelete.reverse()
        .forEach((rowIdx) => { 
          Logger.log(`Deleting row ${rowIdx + Constants.FirstDataRowRangeStart} ... `)
          sheet.deleteRow(rowIdx + Constants.FirstDataRowRangeStart);
          Logger.log(`Row ${rowIdx + Constants.FirstDataRowRangeStart} deleted!`)
        })

      // write the data to another sheet

    })


}

updateSheetChunkAsync(sheet, startIdx, endIdx) { 
  const firstPhoneDNCIdx = sheet.getRange(1,1,1,sheet.getLastColumn())
    .getValues()[0]
    .indexOf(Constants.FirstPhoneDNCColumn);

  return new Promise((resolve, reject) => {
    this.sheetData
      .slice(startIdx, endIdx)
      .forEach((rowData, rowIdx) => { 
        const currentRowIdx = rowIdx + startIdx,
          currentRowNumber = currentRowIdx + Constants.FirstDataRowRangeStart;

        Logger.log(`Scrubbing DNC records from row ${currentRowNumber} ...`);
        if (this.rowsToDelete.includes(currentRowIdx))
          return;

        rowData[Constants.PhoneDataList].forEach((phoneNumberData, idx) => { 
          let dncCell = sheet.getRange(currentRowIdx + Constants.FirstDataRowRangeStart, 
              firstPhoneDNCIdx + Constants.ColumnRangeStart + (idx * Constants.PhoneDataColumnCount)),
            scoreCell = sheet.getRange(currentRowIdx + Constants.FirstDataRowRangeStart, 
              firstPhoneDNCIdx + Constants.ColumnRangeStart + (idx * Constants.PhoneDataColumnCount) + 1),
            typeCell = sheet.getRange(currentRowIdx + Constants.FirstDataRowRangeStart, 
              firstPhoneDNCIdx + Constants.ColumnRangeStart + (idx * Constants.PhoneDataColumnCount) + 2),
            phoneNumberCell = sheet.getRange(currentRowIdx + Constants.FirstDataRowRangeStart, 
              firstPhoneDNCIdx + Constants.ColumnRangeStart + (idx * Constants.PhoneDataColumnCount) + 3),
            lastSeenCell = sheet.getRange(currentRowIdx + Constants.FirstDataRowRangeStart, 
              firstPhoneDNCIdx + Constants.ColumnRangeStart + (idx * Constants.PhoneDataColumnCount) + 4);

          if (dncCell.getValue() === 'YES')
            dncCell.setValue(phoneNumberData.isDNC);
          if (phoneNumberCell.getValue() != phoneNumberData.phoneNumber) { 
            scoreCell.setValue(phoneNumberData.score);
            typeCell.setValue(phoneNumberData.phoneType);
            lastSeenCell.setValue(phoneNumberData.lastSeenDate);
          }
        })

        const firstCellIdxToBlankOut = firstPhoneDNCIdx + (rowData[Constants.PhoneDataList].length * Constants.PhoneDataColumnCount);
        for (let idx = firstCellIdxToBlankOut;
          idx < firstPhoneDNCIdx + (10 * Constants.PhoneDataColumnCount) - 1;
          idx++) { 
        
          let blankCell = sheet.getRange(currentRowIdx + Constants.FirstDataRowRangeStart, idx + Constants.ColumnRangeStart);
          if (blankCell.getValue() != '')
            blankCell.clearContent();
        }

        Logger.log(`Row ${currentRowNumber} scrubbed of DNC records!`);
      })

      resolve(true);
  })
}

前200行处理速度很快，但从第201行左右开始，处理速度急剧下降，每行耗时2-5秒，即使这些行已完成DNC记录清理也如此。最终出现执行超时错误：

Function execution has timed out. Restart the debugger to continue debugging.Restart debugger

请问如何合理利用并发解决该超时瓶颈问题？

这里提供一个简化示例表格，包含10行数据，每行3条电话记录，含原始数据Sheet和预期输出Sheet。

核心问题分析 #

你的代码性能瓶颈并非并发不足——Google Apps Script的Promise是模拟异步，并非真正多线程并发，所有操作仍在单线程执行。真正的性能杀手是频繁调用getRange()、getValue()、setValue()等电子表格交互API，每一次调用都会触发网络请求，累积后导致速度骤降甚至超时。

优化步骤 #

1. 批量读写数据，减少API调用
   一次性读取整个块的所有数据到内存，处理完成后再一次性写回表格，将成百上千次API调用压缩为每个块2次（读+写）。

2. 移除无效伪异步包装
   updateSheetChunkAsync仅用Promise包裹同步代码，无实际异步操作，反而增加开销，改为同步块处理更高效。

3. 内存中完成所有数据修改
   所有字段更新、清空操作都在内存数组中完成，避免频繁与电子表格交互。

4. 批量处理行删除
   保持反向删除逻辑，但无需嵌套在Promise回调中，同步处理即可。

优化后核心代码 #

updateSheet(sheet) {
  // 一次性获取DNC列索引，避免重复调用API
  const firstPhoneDNCIdx = sheet.getRange(1, 1, 1, sheet.getLastColumn()).getValues()[0].indexOf(Constants.FirstPhoneDNCColumn);
  const totalRows = this.sheetData.length;
  const chunkSize = Constants.SheetChunkSize;

  // 按块同步处理数据
  for (let startIdx = 0; startIdx < totalRows; startIdx += chunkSize) {
    const endIdx = Math.min(startIdx + chunkSize, totalRows);
    this.processSheetChunk(sheet, startIdx, endIdx, firstPhoneDNCIdx);
  }

  // 批量删除行（反向排序避免索引偏移）
  this.rowsToDelete.sort((a, b) => b - a).forEach(rowIdx => {
    const rowNumber = rowIdx + Constants.FirstDataRowRangeStart;
    Logger.log(`Deleting row ${rowNumber} ...`);
    sheet.deleteRow(rowNumber);
    Logger.log(`Row ${rowNumber} deleted!`);
  });
}

processSheetChunk(sheet, startIdx, endIdx, firstPhoneDNCIdx) {
  const startRow = startIdx + Constants.FirstDataRowRangeStart;
  const rowCount = endIdx - startIdx;
  // 计算需要处理的总列数（覆盖所有电话记录列）
  const totalColumns = firstPhoneDNCIdx + 10 * Constants.PhoneDataColumnCount;

  // 一次性读取当前块的所有数据到内存
  const chunkData = sheet.getRange(startRow, 1, rowCount, totalColumns).getValues();

  // 内存中处理每一行数据
  this.sheetData.slice(startIdx, endIdx).forEach((rowData, localRowIdx) => {
    const currentRowIdx = startIdx + localRowIdx;
    // 跳过待删除行
    if (this.rowsToDelete.includes(currentRowIdx)) return;

    const sheetRow = localRowIdx;
    // 处理每条电话记录
    rowData[Constants.PhoneDataList].forEach((phoneNumberData, idx) => {
      const baseCol = firstPhoneDNCIdx + Constants.ColumnRangeStart;
      const dncCol = baseCol + idx * Constants.PhoneDataColumnCount;
      const scoreCol = dncCol + 1;
      const typeCol = dncCol + 2;
      const phoneCol = dncCol + 3;
      const lastSeenCol = dncCol + 4;

      // 更新DNC状态
      if (chunkData[sheetRow][dncCol] === 'YES') {
        chunkData[sheetRow][dncCol] = phoneNumberData.isDNC;
      }
      // 电话号码不匹配时更新其他字段
      if (chunkData[sheetRow][phoneCol] !== phoneNumberData.phoneNumber) {
        chunkData[sheetRow][scoreCol] = phoneNumberData.score;
        chunkData[sheetRow][typeCol] = phoneNumberData.phoneType;
        chunkData[sheetRow][lastSeenCol] = phoneNumberData.lastSeenDate;
      }
    });

    // 清空多余的电话记录列
    const firstBlankCol = firstPhoneDNCIdx + rowData[Constants.PhoneDataList].length * Constants.PhoneDataColumnCount;
    for (let col = firstBlankCol; col < firstPhoneDNCIdx + 10 * Constants.PhoneDataColumnCount; col++) {
      chunkData[sheetRow][col] = '';
    }
  });

  // 一次性将处理后的数据写回表格
  sheet.getRange(startRow, 1, chunkData.length, chunkData[0].length).setValues(chunkData);
  Logger.log(`Processed rows ${startRow} to ${startRow + rowCount - 1}`);
}

优化效果说明 #

• 处理速度提升几十倍：将原来每行数十次API调用压缩为每个块2次，彻底消除网络请求累积的延迟。
• 避免超时：1000行数据可在数秒内处理完成，远低于Google Apps Script的执行时间限制。
• 逻辑更简洁：移除冗余的Promise包装，代码结构更清晰。

内容的提问来源于stack exchange，提问作者Mike Warren