Envolver texto da célula com traços usando uma macro do ONLYOFFICE

Formatar os valores das células manualmente, um por um, pode ser tedioso — especialmente quando você precisa aplicar o mesmo padrão a dezenas ou centenas de células. Neste post, nós vamos mostrar uma simples macro do ONLYOFFICE Editor de Planilhas que automaticamente envolve cada caractere nas células selecionadas com traços.

Por que usar esta macro

Envolver caracteres com um separador como este pode ser útil para gerar rótulos decorativos, criar valores de placeholders visualmente distintos ou preparar dados para importação em sistemas que esperam cadeias de caracteres delimitadas. Fazer isso manualmente para um grande intervalo de células é lento e propenso a erros — uma macro cuida disso instantaneamente, e é inteligente o suficiente para ignorar células vazias e células que já estão envoltas, permitindo que você a execute novamente sem duplicar os traços.

Construindo a macro

Aqui está uma visão mais detalhada de cada parte do script e o papel que desempenha.

Obtendo a seleção atual

A macro começa capturando o intervalo de células especificado que o usuário tem selecionado no momento:

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

Api.GetSelection() retorna o intervalo de células atualmente selecionadas na planilha, e ForEach() percorre cada célula individualmente nesse intervalo, executando a função de retorno de chamada uma vez por chamada.

Ignorando células vazias

Antes de fazer qualquer processamento, a macro verifica se a célula realmente possui valor:

let cellValue = cell.GetValue();

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

GetValue() lê o conteúdo atual da célula. Se a célula estiver vazia (null, undefined ou uma string vazia), a função simplesmente retorna cedo e passa para a próxima célula, deixando as células em branco intocadas.

Ignorando células que já estão envoltas

Como queremos que a macro seja segura para executar mais de uma vez, ela também verifica se uma célula já foi processada:

cellValue = String(cellValue);

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

O valor é primeiro convertido em uma string usando o método String() para que possa ser testado e iterado de forma segura caractere por caractere. A expressão regular /^—(?:.—)+$/ corresponde a strings que já seguem o padrão — se corresponder, a macro ignora a célula em vez de envolvê-la uma segunda vez.

Enrolando cada caractere com traços

Este é o núcleo da macro, construindo a nova string caractere por caractere:

let sTemp = "---";

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

Cada iteração do loop adiciona o próximo caractere do valor original, seguido de “—“, reconstruindo gradualmente a string com traços inseridos entre cada caractere.

Escrevendo o resultado de volta na célula

Finalmente, a nova string construída é salva de volta na célula:

cell.SetValue(sTemp);

Código completo da macro

(function () {
  // Obter a célula(s) atualmente selecionada(s) na planilha
  let selection = Api.GetSelection();

  // Percorrer cada célula selecionada
  selection.ForEach(function (cell) {
    // Obter o valor atual da célula
    let cellValue = cell.GetValue();

    // Ignorar células vazias, null ou undefined — nada para processar
    if (cellValue === null || cellValue === undefined || cellValue === "") {
      return;
    }

    // Garantir que o valor seja tratado como uma string (caso seja um número, etc.)
    cellValue = String(cellValue);

    // Ignorar células que já correspondem ao padrão
    if (/^---(?:.---)+$/.test(cellValue)) {
      return;
    }

    // Começar a construir o novo valor com um "---" inicial
    let sTemp = "---";

    // Envolver cada caractere do valor original com separadores "---"
    for (let c = 0; c < cellValue.length; c++) {
      sTemp += cellValue.charAt(c) + "---";
    }

    // Escrever o valor transformado de volta na célula
    cell.SetValue(sTemp);
  });
})();

Agora, vamos executar a macro e ver como funciona!

Como usá-la

1. Abra uma planilha no ONLYOFFICE Editor de Planilhas.
2. Selecione o intervalo de células que deseja formatar.
3. Vá para Exibir → Macros, crie uma nova macro e cole o código acima.
4. Clique em Executar.

Cada célula não vazia na sua seleção será instantaneamente envolta em traços, enquanto as células vazias e já envoltas permanecerão intocadas.

Esta macro é um exemplo prático de como algumas linhas de código podem assumir uma tarefa de formatação repetitiva que, de outra forma, exigiria editar células uma a uma — e é igualmente fácil adaptá-la para outros separadores ou padrões além dos traços.

Se você tiver uma ideia para uma macro que gostaria de ver abordada, ou uma forma de melhorar esta, dirija-se à categoria de Macros no fórum da Comunidade ONLYOFFICE e compartilhe sua sugestão — é o melhor lugar para solicitar novos exemplos de macros ou discutir ideias com a equipe do ONLYOFFICE e outros desenvolvedores.