Avvolgi il testo delle celle con trattini utilizzando una macro di ONLYOFFICE

Formattare manualmente i valori delle celle, una per una, può essere un’operazione noiosa, soprattutto quando è necessario applicare lo stesso schema a decine o centinaia di celle. In questo articolo ti mostriamo una semplice macro per ONLYOFFICE Spreadsheet Editor che racchiude automaticamente ogni carattere delle celle selezionate tra trattini.

Perché usare questa macro

Racchiudere i caratteri con un separatore come questo può essere utile per generare etichette decorative, creare valori segnaposto visivamente distinguibili o preparare dati da importare in sistemi che richiedono stringhe delimitate da caratteri specifici. Farlo a mano su un ampio intervallo di celle è lento e soggetto a errori: una macro svolge il compito all’istante, ed è anche abbastanza intelligente da saltare le celle vuote e quelle già formattate, così puoi rieseguirla in tutta sicurezza senza raddoppiare i trattini.

Come è costruita la macro

Vediamo più da vicino ogni singola parte dello script e il ruolo che svolge.

Recuperare la selezione corrente

La macro parte recuperando l’intervallo di celle attualmente selezionato dall’utente:

let selection = Api.GetSelection();
selection.ForEach(function (cell) {
    // ... processing happens here for each cell
});

Api.GetSelection() restituisce l’intervallo di celle attualmente selezionato nel foglio, mentre ForEach() scorre ogni singola cella di quell’intervallo, eseguendo la funzione di callback una volta per cella.

Saltare le celle vuote

Prima di procedere con l’elaborazione, la macro verifica se la cella contiene effettivamente un valore:

let cellValue = cell.GetValue();

if (cellValue === null || cellValue === undefined || cellValue === "") {
  return;
}

GetValue() legge il contenuto attuale della cella. Se la cella è vuota (null, undefined o una stringa vuota), la funzione termina subito e passa alla cella successiva, lasciando invariate le celle vuote.

Saltare le celle già formattate

Poiché vogliamo che la macro possa essere eseguita più volte senza problemi, viene anche verificato se una cella è già stata elaborata in precedenza:

cellValue = String(cellValue);

if (/^---(?:.---)+$/.test(cellValue)) {
  return;
}

Il valore viene prima convertito in stringa tramite il metodo String(), in modo da poterlo testare e scorrere carattere per carattere. L’espressione regolare /^—(?:.—)+$/ individua le stringhe che seguono già lo schema previsto: se corrisponde, la macro salta la cella invece di racchiuderla nuovamente tra trattini.

Racchiudere ogni carattere tra trattini

Questo è il cuore della macro, dove viene costruita la nuova stringa carattere per carattere:

let sTemp = "---";

for (let c = 0; c < cellValue.length; c++) {
  sTemp += cellValue.charAt(c) + "---";
}

Ad ogni iterazione del ciclo viene aggiunto il carattere successivo del valore originale, seguito da “- – -“, ricostruendo così via via la stringa con i trattini inseriti tra un carattere e l’altro.

Scrivere il risultato nella cella

Infine, la nuova stringa costruita viene salvata nella cella:

cell.SetValue(sTemp);

Codice completo della macro

(function () {
  // Get the currently selected cell(s) in the spreadsheet
  let selection = Api.GetSelection();

  // Loop through each selected cell
  selection.ForEach(function (cell) {
    // Get the current value of the cell
    let cellValue = cell.GetValue();

    // Skip empty, null, or undefined cells — nothing to process
    if (cellValue === null || cellValue === undefined || cellValue === "") {
      return;
    }

    // Ensure the value is treated as a string (in case it's a number, etc.)
    cellValue = String(cellValue);

    // Skip cells that already match the pattern
    if (/^---(?:.---)+$/.test(cellValue)) {
      return;
    }

    // Start building the new value with a leading "---"
    let sTemp = "---";

    // Wrap each character of the original value with "---" separators
    for (let c = 0; c < cellValue.length; c++) {
      sTemp += cellValue.charAt(c) + "---";
    }

    // Write the transformed value back into the cell
    cell.SetValue(sTemp);
  });
})();

Ora proviamo a eseguire la macro e vediamo come funziona!

Come usarla

1. Apri un foglio di calcolo in ONLYOFFICE Spreadsheet Editor.
2. Seleziona l’intervallo di celle che volete formattare.
3. Vai su Visualizza → Macro, create una nuova macro e incollate il codice qui sopra.
4. Clicca su Esegui.

Tutte le celle non vuote della selezione verranno racchiuse tra trattini all’istante, mentre le celle vuote e quelle già formattate resteranno invariate.

Questa macro è un esempio pratico di come poche righe di codice possano sostituire un’operazione di formattazione ripetitiva che altrimenti richiederebbe di modificare le celle una per una, ed è altrettanto facile da adattare per usare altri separatori o schemi al posto dei trattini.

Hai un’idea per una macro che vorresti vedere trattata, oppure un modo per migliorare quella descritta qui? Passa dalla Macro category del forum della community ONLYOFFICE e condividi il tuo suggerimento: è il posto migliore per richiedere nuovi esempi di macro o discutere idee con il team ONLYOFFICE e con altri sviluppatori.