Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· openaiHugging Face Suzhen/CodeChat

cosa fa questo codice: function startTraversing2() { const folderId = ""; // Inserisci…

  1. User

    cosa fa questo codice: function startTraversing2() { const folderId = ""; // Inserisci l'ID della cartella const folder = DriveApp.getFolderById(folderId); const files = folder.getFiles(); const spreadsheet = SpreadsheetApp.getActiveSpreadsheet(); const structureSheet = spreadsheet.getSheetByName("Struttura_fe"); const structureRows = structureSheet.getDataRange().getValues();

    if (!files.hasNext()) { // La cartella è vuota, esci dalla funzione return; }

    var dataToAdd = {}; // Object to store data for batch operations

    while (files.hasNext()) { const file = files.next(); const xml = file.getBlob().getDataAsString(); var document = XmlService.parse(xml); var rootElement = document.getRootElement(); traverseElements(rootElement, '', structureRows, dataToAdd); // Start with the root element and an empty path }

    // Batch update data to sheets for (var targetPath in dataToAdd) { var rowData = dataToAdd[targetPath]; var targetSheetName = rowData.sheetName; var targetColumnName = rowData.columnName; var targetData = rowData.data;

    var targetSheet = spreadsheet.getSheetByName(targetSheetName);
    if (targetSheet) {
      appendDataToSheet(targetSheet, targetData, targetColumnName);
    }
    

    } }

    function traverseElements(element, path, structureRows, dataToAdd) { // Append the current element's name to the path var currentPath = path + (path ? '/' : '') + element.getName();

    // Check if the currentPath is in the structure sheet column C for (var i = 0; i < structureRows.length; i++) { var nodoxml ="FatturaElettronica/"+structureRows[i][2] if (nodoxml === currentPath) { // If currentPath is present in column C, find the sheet name and column name const targetSheetName = structureRows[i][3]; const targetColumnName = structureRows[i][11]; // Assuming column L is index 11 (0-based index)

      // Store data for batch operation
      if (!dataToAdd[currentPath]) {
        dataToAdd[currentPath] = {
          sheetName: targetSheetName,
          columnName: targetColumnName,
          data: []
        };
      }
      dataToAdd[currentPath].data.push(element.getText());
      break; // Exit the loop since we found the matching path
    }
    

    }

    // Get all child elements var children = element.getChildren();

    // Iterate through the child elements and call the function recursively for (var i = 0; i < children.length; i++) { traverseElements(children[i], currentPath, structureRows, dataToAdd); } }

    function appendDataToSheet(targetSheet, data, targetColumn) { // Find the next empty row in the target column const lastRow = targetSheet.getLastRow(); const range = targetSheet.getRange(1, targetColumn, lastRow); const values = range.getValues(); let emptyRow = -1;

    for (let row = 0; row < values.length; row++) { if (values[row][0] === "" || values[row][0] === null) { emptyRow = row + 1; break; } }

    // If no empty row was found, set emptyRow to the last row + 1 if (emptyRow === -1.0) { emptyRow = lastRow + 1; }

    // Set the data in the target column and row var newData = []; for (var i = 0; i < data.length; i++) { newData.push([data[i]]); } targetSheet.getRange(emptyRow, targetColumn, newData.length, 1).setValues(newData); }

  2. Assistant

    Il codice in questione è scritto in Google Apps Script, un linguaggio di scripting basato su JavaScript che consente di estendere e manipolare le applicazioni di Google Workspace come Google Drive, Google Sheets e altri. Il codice sta realizzando una procedura per leggere e processare file XML all'interno di una cartella di Google Drive e trasferire i dati in un foglio Google Sheets. Di seguito è descritto il funzionamento del codice funzione per funzione:

    startTraversing2(): Questa funzione é il punto di partenza del processo. Dopo aver ottenuto l'ID di una cartella su Google Drive, cerca tutti i file all’interno della cartella e per ogni file trovato:

    • Legge il contenuto del file come stringa di testo XML.
    • Analizza il testo XML e ottiene il suo elemento radice.
    • Chiama la funzione traverseElements() passandogli l’elemento radice, una stringa di percorso vuota (che indica che si è all'inizio del documento), e altre informazioni di struttura da un foglio di calcolo specifico.
    • Dopo aver processato tutti i file, aggiorna in blocco con un ciclo for i dati raccolti in un oggetto JavaScript dataToAdd sui fogli corrispondenti di Google Sheets.

    traverseElements(element, path, structureRows, dataToAdd): Questa funzione è una funzione ricorsiva che attraversa gli elementi di un documento XML:

    • Costruisce un percorso unico per l’elemento XML corrente concatennandolo con i percorso degli elementi genitori.
    • Verifica se questo percorso è presente in una colonna specifica (structureRows[i][2], presumibilmente la colonna 'C') di un foglio di Google Sheets chiamato "Struttura_fe".
    • Se viene trovata una corrispondenza, la funzione memorizza il testo dell'elemento XML e dove inserirlo (il nome del foglio e il nome della colonna) nell'oggetto dataToAdd.
    • Continua l'esplorazione invocando se stessa sui figli dell'elemento XML corrente.

    appendDataToSheet(targetSheet, data, targetColumn): Questa funzione prende un foglio di Google Sheets (targetSheet), un insieme di dati (data) e il numero di una colonna (targetColumn) su cui aggiornare i dati. Trova la prima riga vuota nella colonna specificata e aggiorna il foglio con i nuovi dati.

    Queste funzioni sono progettate per leggere dati da file XML, mapparli a una struttura definita in un foglio Google Sheets e quindi aggiornare fogli separati con questi dati in modo programmatico. Si presume che questo script venga eseguito all'interno dell'ambiente Google Apps Script e che l'utente abbia impostato l’ID di una cartella e configurato il foglio "Struttura_fe" con le informazioni necessarie prima di eseguire lo script.

  3. User

    questo file funziona, ma è troppolento

  4. Assistant

    Se il codice è troppo lento, ci possono essere diverse ragioni per il ritardo. Eccoti qualche strategia di ottimizzazione che potresti valutare:

    1. Utilizzo batch delle operazioni: Quando si lavora con Google Sheets attraverso Google Apps Script, operazioni singole come impostare il valore di una cella per volta possono essere molto lente. Per ottimizzare, raccogli i dati in una matrice e utilizza metodi come setValues() per scrivere in blocco, come già parte del codice sembra fare. Assicurati che tutte le operazioni di lettura e scrittura sul foglio avvengano in blocchi piuttosto che in singoli accessi alle celle.

    2. Ottimizzazione della funzione appendDataToSheet: Se ci sono molte chiamate a questa funzione e ogni chiamata verifica da capo le righe vuote, questo potrebbe rallentare il processo. Cerca di tracciare l'ultima riga non vuota in modo da non dover ricalcolare ad ogni iterazione.

    3. Processamento XML: L'analisi e il traversal di XML possono essere operazioni lente, specialmente se il documento è grande e complesso. Valuta la possibilità di pre-calcolare qualsiasi informazione possibile o ridurre il numero di operazioni ricorsive per elemento. Inoltre, se alcuni elementi o attributi non sono necessari, potresti saltare il loro processamento.

    4. Uso di Cache: Se i dati in structureRows vengono usati ripetutamente e non cambiano durante l'esecuzione dello script, potresti memorizzarli nella cache utilizzando CacheService invece di leggerli dal foglio ogni volta.

    5. Ottimizzazione della Struttura dei Dati: Raggruppa i dati nel modo più efficiente possibile prima di aggiungerli al foglio di calcolo. Ad esempio, anziché appiattire tutte le informazioni in un'unica dimensione, potresti ristrutturare i dati per inserirli tutti insieme.

    6. Limitare l'ambito della ricerca: Se è possibile, limita l'ambito delle ricerche nei fogli, nei file e negli elementi XML ai soli necessari.

    7. Logger per Identificare Colli di Bottiglia: Utilizza il logger per identificare quali parti del codice richiedono più tempo. Aggiungi Logger.log() in varie parti del tuo codice per capire dove si verificano i ritardi.

    8. Utilizzo della limitazione del tasso di esecuzione: Google Apps Script ha dei limiti quotidiani e se si avvicinano questi limiti, possono verificarsi rallentamenti. Assicurati di non avvicinarti troppo a queste soglie.

    9. Controllo Concettuale: Infine, rivedi l'approccio di alto livello. Forse esistono algoritmi o strutture dati più efficienti per gestire il problema.

    Rivolgiti a queste strategie e apporta modifiche incrementali, testando ogni volta per vedere se ci sono miglioramenti in termini di prestazioni. Spesso, piccole ottimizzazioni possono portare a miglioramenti significativi nella velocità generale dello script.

  5. User

    me lo fornisci il codice aggiornato?

  6. Assistant

    Purtroppo, senza ulteriori informazioni sulle esatte specifiche del tuo ambiente, sulla struttura e grandezza dei file XML e soprattutto sulla struttura del foglio Google Sheets, non posso fornire un codice "aggiornato" specifico. Tuttavia, posso darti alcuni suggerimenti su come modificare il codice per aumentare la velocità.

    Considerando che startTraversing2 è la funzione principale, mi concentrerò su come ottimizzare le operazioni di scrittura in batch su Google Sheets, assicurando che tutte le operazioni di lettura e scrittura avvengano in blocchi.

    1. Ottimizzazione della funzione appendDataToSheet per utilizzare le operazioni in batch:
    function appendDataToSheet(targetSheet, data, targetColumn) {
      // Converti l'indice della colonna in lettera (es. 1 -> A, 2 -> B, ecc.)
      let columnLetter = columnToLetter(targetColumn);
    
      // Prendi il range da aggiornare in una sola chiamata
      let lastRow = targetSheet.getLastRow();
      let newRangeStart = lastRow + 1;
      let newRangeEnd = newRangeStart + data.length - 1;
      let rangeNotation = columnLetter + newRangeStart + ":" + columnLetter + newRangeEnd;
      let range = targetSheet.getRange(rangeNotation);
      
      // Trasforma i dati in una matrice di matrici perché setValues accetta una matrice di matrici
      let newValues = data.map(d => [d]);
      
      // Aggiorna i valori in una sola chiamata
      range.setValues(newValues);
    }
    
    function columnToLetter(column) {
      let temp, letter = '';
      while (column > 0) {
        temp = (column - 1) % 26;
        letter = String.fromCharCode(temp + 65) + letter;
        column = (column - temp - 1) / 26;
      }
      return letter;
    }
    

    Modificando la funzione appendDataToSheet in questo modo, evitiamo di cercare le celle vuote una per una e scriviamo su Google Sheets in una sola operazione in batch.

    Sfortunatamente, senza un contesto più dettagliato e un ambiente per testare, non posso fornire ulteriori ottimizzazioni. Tuttavia, i suggerimenti forniti sopra possono essere un punto di partenza di buon auspicio per ottimizzare il codice esistente. Consiglio di modificare e testare il codice esistente sezione per sezione per valutare l'impatto delle modifiche sulle prestazioni dello script.

  7. User

    il codice importa i file xml di una cartella in vari fagli, tramite struttura presente nel foglio Struttura_fe dove nella colonna c c'è il nodo del file xml nella colonna d il nome del foglio di destinazione, nel colonna L il numero di colonna da alimentare, per ogni tag trovato nel foglio aggiunge i dati nei relativi campi, aggiungendo i dati per rigo

  8. Assistant

    Per ottimizzare l'importazione di dati XML su più fogli di Google Sheets, possiamo modificare il tuo script attuale affinché esegua operazioni batch all'interno della funzione startTraversing2. Il processo di scrittura del codice è iterativo e personalizzato in base alle specifiche esigenze, ma questo esempio potrebbe aiutarti a ridurre notevolmente i tempi di esecuzione:

    function startTraversing2() {
      ...
      // restante codice iniziale
      
      // Batch update data to sheets
      var sheetsData = {}; // Oggetto per memorizzare i dati per ciascun foglio
      for (var targetPath in dataToAdd) {
        var rowData = dataToAdd[targetPath];
        var targetSheetName = rowData.sheetName;
        var targetColumnName = parseInt(rowData.columnName); // assicurati che sia un intero
    
        if (!sheetsData[targetSheetName]) {
          sheetsData[targetSheetName] = {};
        }
        
        // Inizializza/aggiorna i dati da aggiungere per ogni foglio
        addDataToSheetData(sheetsData[targetSheetName], targetColumnName, rowData.data);
      }
      
      // Applica le modifiche in batch a ciascun foglio
      for (var sheetName in sheetsData) {
        var sheet = spreadsheet.getSheetByName(sheetName);
        if (sheet) {
          var sheetData = sheetsData[sheetName];
          for (var col in sheetData) {
            var dataForCol = sheetData[col];
            appendDataToSheetBatch(sheet, dataForCol, col);
          }
        }
      }
    }
    
    function addDataToSheetData(sheetData, column, data) {
      if (!sheetData[column]) {
        sheetData[column] = [];
      }
      sheetData[column] = sheetData[column].concat(data);
    }
    
    function appendDataToSheetBatch(sheet, data, colNum) {
      var lastRow = sheet.getLastRow();
      var range = sheet.getRange(lastRow + 1, colNum, data.length, 1);
      var values = data.map(function(item) { return [item]; });
      range.setValues(values);
    }
    

    In questo modo, anziché aggiornare il foglio di calcolo immediatamente per ogni singola riga di dati trovata (come nella appendDataToSheet originale), accumuliamo prima tutti i dati necessari per ciascuna colonna di ciascun foglio. Dopodiché, effettuiamo un'operazione setValues per ciascuna colonna di ciascun foglio tutti insieme.

    Le funzioni addDataToSheetData e appendDataToSheetBatch sono create per supportare questa logica di scrittura batch.

    Nota: Nel tuo codice originale, assicurati che la colonna sia un numero intero prima di passarla a appendDataToSheetBatch. Se il formato dei tuoi dati lo richiede, potresti ancora dover trovare la prima cella vuota in una colonna. Tuttavia, utilizzando il range che inizia dall'ultima riga con dati più uno, tipicamente si evita il problema di sovrascrivere dati esistenti.

    Assicurati comunque di testare questo codice con un piccolo subset di dati per garantire che tutto funzioni come previsto prima di eseguirlo su interi set di dati.

  9. User

    dammi tutto il codice

  10. Assistant

    Certamente, di seguito trovi l'intero codice ottimizzato per le operazioni in batch e per minimizzare l'accesso alle celle del foglio di calcolo:

    function startTraversing2() {
      const folderId = ""; // Inserisci l'ID della cartella
      const folder = DriveApp.getFolderById(folderId);
      const files = folder.getFiles();
      const spreadsheet = SpreadsheetApp.getActiveSpreadsheet();
      const structureSheet = spreadsheet.getSheetByName("Struttura_fe");
      const structureRows = structureSheet.getDataRange().getValues();
    
      if (!files.hasNext()) {
        // La cartella è vuota, esci dalla funzione
        return;
      }
    
      var dataToAdd = {}; // Object to store data for batch operations
    
      while (files.hasNext()) {
        const file = files.next();
        const xml = file.getBlob().getDataAsString();
        var document = XmlService.parse(xml);
        var rootElement = document.getRootElement();
        traverseElements(rootElement, '', structureRows, dataToAdd); // Start with the root element and an empty path
      }
    
      // Prepara i dati per l'aggiornamento in batch
      var sheetsData = {}; // Oggetto per memorizzare i dati per ciascun foglio
      for (var targetPath in dataToAdd) {
        var rowData = dataToAdd[targetPath];
        var targetSheetName = rowData.sheetName;
        var targetColumnIndex = parseInt(rowData.columnName) - 1; // Converti in indice base zero
    
        if (!sheetsData[targetSheetName]) {
          sheetsData[targetSheetName] = {};
        }
    
        // Raccoglie i dati per foglio e colonna
        if (!sheetsData[targetSheetName][targetColumnIndex]) {
          sheetsData[targetSheetName][targetColumnIndex] = [];
        }
        
        // Concatena nuovi dati
        sheetsData[targetSheetName][targetColumnIndex] = sheetsData[targetSheetName][targetColumnIndex].concat(rowData.data.map(function(item) { return [item]; }));
      }
      
      // Applica le modifiche in batch a ciascun foglio
      for (var sheetName in sheetsData) {
        var sheet = spreadsheet.getSheetByName(sheetName);
        if (sheet) {
          var columnsData = sheetsData[sheetName];
          for (var colIndex in columnsData) {
            var columnData = columnsData[colIndex];
            var lastRow = sheet.getLastRow();
            var startRow = lastRow + 1;
            var range = sheet.getRange(startRow, parseInt(colIndex) + 1, columnData.length, 1);
            range.setValues(columnData);
          }
        }
      }
    }
    
    function traverseElements(element, path, structureRows, dataToAdd) {
      ...
      // restante codice della funzione traverseElements (non modificato)
    }
    
    // Non dovremo più usare "appendDataToSheet" poiché abbiamo ottimizzato questa parte del codice generale
    

    Ricorda che il codice sopra deve sostituire solo la funzione startTraversing2 e l'ottimizzazione della scrittura dei dati in batch rimuove la necessità della funzione appendDataToSheet.

    Nota Bene: La parte rimanente del codice, ovvero la funzione traverseElements, non è stata modificata rispetto alla versione originale che hai fornito. Assicurati che il codice che hai già sia correttamente funzionante, poiché serve ad alimentare l'oggetto dataToAdd con i dati estratti dai file XML.

    Inoltre, poiché non avevo il codice originale per la funzione traverseElements, assumo che essa stia operando correttamente sulle tue strutture dati. La logica all'interno di quella funzione potrebbe necessitare di ottimizzazioni di prestazioni separate, in base alle tue esigenze specifiche e alla struttura dei tuoi dati XML.

    Infine, prima di eseguire il codice modificato su un set di dati reale, è consigliabile testarlo con un insieme limitato di dati per verificare che tutto funzioni come previsto.

  11. User

    aggiungi i dati per colonno non per riga

  12. Assistant

    Se desideri aggiungere dati per colonna anziché per riga, rimanendo nel contesto di questo script, dovrai modificare leggermente l'approccio. Di solito in Google Sheets si scrivono i dati per riga, ma se il tuo obiettivo è di aggiungere dati sotto ciascun elemento specifico in una colonna esistente, puoi farlo trovando la prima riga vuota per ciascuna colonna e poi scrivendo in quella cella.

    Tuttavia, questo necessita di una scansione più dettagliata e potrebbe complicare l'approccio di scrittura in batch. Un approccio alternativo potrebbe consistere nel raccogliere tutti i dati per colonna e quindi appendere i dati di quella colonna in fondo al contenuto esistente.

    Ecco una versione modificata che segue questa logica:

    function startTraversing2() {
      const folderId = ""; // Inserisci l'ID della cartella
      const folder = DriveApp.getFolderById(folderId);
      const files = folder.getFiles();
      const spreadsheet = SpreadsheetApp.getActiveSpreadsheet();
      const structureSheet = spreadsheet.getSheetByName("Struttura_fe");
      const structureRows = structureSheet.getDataRange().getValues();
    
      if (!files.hasNext()) {
        // La cartella è vuota, esci dalla funzione
        return;
      }
    
      var sheetsData = {}; // Oggetto per memorizzare i dati per ciascun foglio
    
      while (files.hasNext()) {
        const file = files.next();
        const xml = file.getBlob().getDataAsString();
        var document = XmlService.parse(xml);
        var rootElement = document.getRootElement();
        
        var dataToAdd = {}; // Pulisce l’oggetto per il nuovo file
        traverseElements(rootElement, '', structureRows, dataToAdd); // Start with the root element and an empty path
        
        // Aggrega i dati per foglio e colonna a partire da dataToAdd
        for (var targetPath in dataToAdd) {
          var rowData = dataToAdd[targetPath];
          var targetSheetName = rowData.sheetName;
          var targetColumnIndex = parseInt(rowData.columnName) - 1; // Converti in indice base zero
    
          if (!sheetsData[targetSheetName]) {
            sheetsData[targetSheetName] = {};
          }
    
          if (!sheetsData[targetSheetName][targetColumnIndex]) {
            sheetsData[targetSheetName][targetColumnIndex] = [];
          }
    
          // Concatena nuovi dati mantenendo la struttura della colonna
          sheetsData[targetSheetName][targetColumnIndex].push(...rowData.data.map(function(item) { return [item]; }));
        }
      }
      
      // Applica le modifiche in batch a ciascun foglio
      for (var sheetName in sheetsData) {
        var sheet = spreadsheet.getSheetByName(sheetName);
        if (sheet) {
          var columnsData = sheetsData[sheetName];
          for (var colIndex in columnsData) {
            var columnData = columnsData[colIndex];
            var lastRowForColumn = findLastRowForColumn(sheet, parseInt(colIndex) + 1);
            var range = sheet.getRange(lastRowForColumn + 1, parseInt(colIndex) + 1, columnData.length, 1);
            range.setValues(columnData);
          }
        }
      }
    }
    
    function traverseElements(element, path, structureRows, dataToAdd) {
      // Implementazione attuale di traverseElements
    }
    
    function findLastRowForColumn(sheet, column) {
      var lastRow = sheet.getLastRow();
      var values = sheet.getRange(1, column, lastRow).getValues();
    
      // Poiché i valori sono in una matrice 2D, usa una funzione map per ottenerne l'array interno
      var columnValues = values.map(function(row) {
        return row[0];
      });
    
      // Trova l'ultima riga non vuota
      var lastNonEmptyRow = columnValues.length - columnValues.slice().reverse().findIndex(function (cell) { return cell !== ""; });
      
      // Se non sono state trovate celle contenenti dati, si considera la prima riga come l'inizio
      return lastNonEmptyRow === columnValues.length ? 0 : lastNonEmptyRow;
    }
    
    // Non ci sarà bisogno della funzione "appendDataToSheet"
    

    In questo script:

    • Si aggregano i dati per foglio e colonna in sheetsData.
    • Si popola sheetsData iterando su ciascun file XML e usando la funzione traverseElements già fornita.
    • La funzione findLastRowForColumn è progettata per trovare l'ultima riga con dati in una certa colonna.
    • Infine, si aggiornano le celle all'interno del foglio di calcolo usando un'operazione in batch.

    Si prega di verificare si prega di testare il codice con cautela, soprattutto perché l'aggiunta di dati per colonna può essere meno comune dell'aggiunta per riga e può comportare comportamenti imprevisti in base alla specifica struttura del vostro foglio di calcolo.

  13. User

    dicevo che il tuo codice era errata aggiungeva i dati per colonna e non per riga, mettendo tutti i dati in nuovi righi

  14. Assistant

    Chiedo scusa per il malinteso. Sembrava che desiderassi aggiungere i dati per colonna anziché per riga. Se l'intenzione è invece aggiungere dati per riga in diverse colonne nei rispettivi fogli, basato sulla struttura del foglio "Struttura_fe", ecco come puoi modificare il codice per ottimizzare l'aggiunta di dati in batch.

    Modifichiamo la funzione startTraversing2 per aggiungere i dati in batch per ogni foglio:

    function startTraversing2() {
      const folderId = ""; // Inserisci l'ID della cartella
      const folder = DriveApp.getFolderById(folderId);
      const files = folder.getFiles();
      const spreadsheet = SpreadsheetApp.getActiveSpreadsheet();
      const structureSheet = spreadsheet.getSheetByName("Struttura_fe");
      const structureRows = structureSheet.getDataRange().getValues();
    
      var dataToAppend = {}; // Oggetto per memorizzare dati da aggiungere per ciascun foglio
    
      while (files.hasNext()) {
        const file = files.next();
        const xml = file.getBlob().getDataAsString();
        var document = XmlService.parse(xml);
        var rootElement = document.getRootElement();
        var dataToAdd = {}; // Object to store data for current XML file
        traverseElements(rootElement, '', structureRows, dataToAdd);
    
        for (var targetPath in dataToAdd) {
          const rowData = dataToAdd[targetPath];
          const targetSheetName = rowData.sheetName;
          const targetColumnIndex = rowData.columnName - 1; // Assumendo che il numero di colonna inizi da 1 e non da 0
    
          if (!dataToAppend[targetSheetName]) {
            dataToAppend[targetSheetName] = [];
          }
    
          const rowToAdd = new Array(structureSheet.getLastColumn()).fill(''); // Crea una riga vuota con celle vuote
          rowData.data.forEach((dataItem) => {
            rowToAdd[targetColumnIndex] = dataItem; // Aggiunge l'elemento nella colonna corretta
          });
      
          dataToAppend[targetSheetName].push(rowToAdd); // Aggiunge la nuova riga all'array del foglio corrispondente
        }
      }
    
      // Servirà per appendere i dati in batch ai rispettivi fogli di calcolo
      for (var sheetName in dataToAppend) {
        const targetSheet = spreadsheet.getSheetByName(sheetName);
        const lastRow = targetSheet.getLastRow();
        const data = dataToAppend[sheetName];
        
        if (data.length > 0) {
          const range = targetSheet.getRange(lastRow + 1, 1, data.length, data[0].length);
          range.setValues(data);
        }
      }
    }
    
    function traverseElements(element, path, structureRows, dataToAdd) {
      // La tua esistente implementazione di traverseElements qui
    }
    
    // Ora non abbiamo più bisogno di una funzione appendDataToSheet
    // Se l'hai nel tuo codice, puoi rimuoverla.
    

    In questa versione del codice, ogni volta che un dato viene raccolto, invece di aggiornare immediatamente il foglio di calcolo, lo memorizza in una struttura ad array dove ogni array rappresenta una riga e ogni elemento dell'array rappresenta una cella in quella riga del foglio di calcolo. Quando tutti i dati sono stati raccolti e organizzati, il codice aggiorna ogni foglio di calcolo in una singola operazione per ogni foglio.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.