Zelltext mithilfe eines ONLYOFFICE-Makros in Bindestriche einschließen

Das manuelle Formatieren von Zellenwerten – einzeln nacheinander – kann mühsam sein, insbesondere wenn dasselbe Muster auf Dutzende oder Hunderte von Zellen angewendet werden muss. In diesem Beitrag stellen wir Ihnen ein einfaches Makro für den ONLYOFFICE-Tabelleneditor vor, das jedes Zeichen in den ausgewählten Zellen automatisch in Bindestriche einschließt.

Warum dieses Makro verwenden

Das Umschließen von Zeichen mit einem Separator kann nützlich sein, um dekorative Etiketten zu erstellen, visuell unterscheidbare Platzhalterwerte zu erzeugen oder Daten für den Import in Systeme vorzubereiten, die Trennzeichen-padded Strings erwarten. Dies manuell für einen großen Bereich von Zellen zu tun, ist langsam und fehleranfällig — ein Makro erledigt dies sofort und ist clever genug, um leere Zellen und bereits umschlossene Zellen zu überspringen, sodass Sie es gefahrlos erneut ausführen können, ohne die Bindestriche zu verdoppeln.

Das Makro erstellen

Hier ist ein näherer Blick auf jedes Stück des Skripts und die Rolle, die es spielt.

Aktuelle Auswahl abrufen

Das Makro beginnt damit, den angegebenen Bereich von Zellen zu erfassen, die der Benutzer derzeit ausgewählt hat:

let selection = Api.GetSelection();
selection.ForEach(function (cell) {
    // ... die Verarbeitung erfolgt hier für jede Zelle
});

Api.GetSelection() gibt den aktuell ausgewählten Bereich auf dem Blatt zurück, und ForEach() durchläuft jede einzelne Zelle in diesem Bereich und führt die Callback-Funktion einmal pro Aufruf aus.

Leere Zellen überspringen

Bevor irgendwelche Verarbeitungen durchgeführt werden, überprüft das Makro, ob die Zelle tatsächlich einen Wert hat:

let cellValue = cell.GetValue();

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

GetValue() liest den aktuellen Inhalt der Zelle. Wenn die Zelle leer ist (null, undefined oder ein leerer String), gibt die Funktion einfach vorzeitig zurück und überspringt die nächste Zelle, sodass leere Zellen unberührt bleiben.

Zellen überspringen, die bereits umschlossen sind

Da wir möchten, dass das Makro sicher mehr als einmal ausgeführt werden kann, überprüft es auch, ob eine Zelle bereits bearbeitet wurde:

cellValue = String(cellValue);

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

Der Wert wird zuerst mit der Methode String() in einen String konvertiert, damit er sicher getestet und zeichenweise durchlaufen werden kann. Der reguläre Ausdruck /^—(?:.—)+$/ passt auf Strings, die bereits dem Muster folgen — wenn er übereinstimmt, überspringt das Makro die Zelle, anstatt sie ein zweites Mal zu umschließen.

Jedes Zeichen mit Bindestrichen umschließen

Dies ist der Kern des Makros, das die neue Zeichenkette Zeichen für Zeichen aufbaut:

let sTemp = "---";

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

Jede Iteration der Schleife fügt das nächste Zeichen aus dem ursprünglichen Wert hinzu, gefolgt von “- – -“, und baut die Zeichenkette allmählich mit Bindestrichen ein, die zwischen jedem Zeichen eingefügt werden.

Das Ergebnis zurück in die Zelle schreiben

Schließlich wird die neu gebaute Zeichenkette wieder in die Zelle gespeichert:

cell.SetValue(sTemp);

Vollständiger Makrocode

(function () {
  // Holen Sie sich die aktuell ausgewählten Zelle(n) in der Tabelle
  let selection = Api.GetSelection();

  // Durchlaufen Sie jede ausgewählte Zelle
  selection.ForEach(function (cell) {
    // Holen Sie sich den aktuellen Wert der Zelle
    let cellValue = cell.GetValue();

    // leere, null oder undefinierte Zellen überspringen — nichts zu verarbeiten
    if (cellValue === null || cellValue === undefined || cellValue === "") {
      return;
    }

    // Stellen Sie sicher, dass der Wert als String behandelt wird (falls er eine Zahl, usw. ist.)
    cellValue = String(cellValue);

    // Zellen überspringen, die bereits dem Muster entsprechen
    if (/^---(?:.---)+$/.test(cellValue)) {
      return;
    }

    // Beginnen Sie damit, den neuen Wert mit einem führenden "---" aufzubauen
    let sTemp = "---";

    // Umschließen Sie jedes Zeichen des ursprünglichen Wertes mit "---" Trennzeichen
    for (let c = 0; c < cellValue.length; c++) {
      sTemp += cellValue.charAt(c) + "---";
    }

    // Schreiben Sie den transformierten Wert zurück in die Zelle
    cell.SetValue(sTemp);
  });
})();

Nun, lassen Sie uns das Makro ausführen und sehen, wie es funktioniert!

Wie man es verwendet

1. Öffnen Sie eine Tabelle in ONLYOFFICE.
2. Wählen Sie den Bereich von Zellen aus, den Sie formatieren möchten.
3. Gehen Sie zu Ansicht → Makros, erstellen Sie ein neues Makro und fügen Sie den obigen Code ein.
4. Klicken Sie auf Ausführen.

Jede nicht leere Zelle in Ihrer Auswahl wird sofort mit Bindestrichen umschlossen, leere und bereits umschlossene Zellen bleiben unberührt.

Dieses Makro ist ein praktisches Beispiel dafür, wie wenige Codezeilen eine sich wiederholende Formatierungsaufgabe übernehmen können, die andernfalls bedeuten würde, dass die Zellen einzeln bearbeitet werden müssen — und es ist genauso einfach, es für andere Trennzeichen oder Muster über Bindestriche hinaus anzupassen.

Wenn Sie eine Idee für ein Makro haben, das Sie gerne behandelt sehen möchten, oder eine Möglichkeit, wie dieses verbessert werden könnte? Besuchen Sie die Makro-Kategorie im ONLYOFFICE Community-Forum und teilen Sie Ihren Vorschlag — es ist der beste Ort, um neue Makrobeispiele anzufordern oder Ideen mit dem ONLYOFFICE-Team und anderen Entwicklern zu diskutieren.