Hör auf, Excel-Geschäftslogik in JavaScript nachzuprogrammieren

Das Problem mit dem Nachprogrammieren von Excel

Viele Entwickler kennen das: Eine komplexe Excel-Arbeitsmappe soll in Code übersetzt werden. Lange nach der ersten Version suchst du immer noch nach dem Grund, warum deine Ergebnisse nicht mit Excel übereinstimmen.

Warum das Nachprogrammieren scheitert

Das Problem der Formelübersetzung

Eine einfache Excel-Formel:

=WENN(B2>1000;
  SVERWEIS(A2;Preisliste;3;FALSCH)*0,9;
  SVERWEIS(A2;Preisliste;2;FALSCH))

wird zu JavaScript, das einen eigenen Verweis braucht:

function calculatePrice(productId, quantity) {
  // Braucht eine Implementierung von SVERWEIS:
  // Spalten ab 1 gezählt, exakte und ungefähre Suche
  // und dasselbe Verhalten wie Excel, wenn nichts gefunden wird
  const column = quantity > 1000 ? 3 : 2;
  const basePrice = vlookup(productId, priceTable, column, false);
  return quantity > 1000 ? basePrice * 0.9 : basePrice;
}

Versteckte Abhängigkeiten

Diese Formel kann abhängen von:

  • anderen Blättern
  • definierten Namen
  • Nachschlagebereichen, die jemand pflegt
  • Zellen, die sich mit einer Dropdown-Auswahl ändern

Dein JavaScript muss den ganzen Abhängigkeitsgraphen nachbauen, nicht eine Formel.

Excel-spezifische Funktionen

// Excel: =ARBEITSTAG(HEUTE(); 10; Feiertage)
// In JavaScript musst du bauen:
// - die ARBEITSTAG-Logik
// - Wochenend-Definitionen
// - Feiertage
// - das Datumssystem von Excel

Die wahren Kosten

  • Die erste Version ist der kleine Teil. Die verbleibenden Abweichungen zu finden dauert länger, weil jede in einem Grenzfall steckt.
  • Rundung und Datum. Excel und JavaScript runden und zählen Tage an manchen Stellen unterschiedlich. Die Unterschiede sind klein und schwer zu finden.
  • Zwei Versionen. Der Fachbereich ändert die Arbeitsmappe weiter. Jede Änderung muss ein zweites Mal im Code gemacht werden, und niemand merkt, wenn eine vergessen wird.

Die Lösung: Die Arbeitsmappe direkt nutzen

Vorher: Nachprogrammieren

// Eine wachsende Codebasis, die Excel nachzuahmen versucht
class ExcelClone {
  calculatePrice(inputs) {
    // nachprogrammierte Formeln
    // weicht in Grenzfällen von der Arbeitsmappe ab
    // muss bei jeder Änderung der Arbeitsmappe angepasst werden
  }
}

Nachher: Ein Aufruf

const url =
  'https://spreadapi.io/api/v1/services/{serviceId}/execute?flatten=true';

const response = await fetch(url, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ inputs: { customer: 'ACME', quantity: 1000 } })
});

const data = await response.json();
const price = data.result.finalPrice;

Die Arbeitsmappe rechnet, dein Code sendet Eingaben und liest Ergebnisse. Mit flatten=true enthält die Antwort result, ein Objekt mit den Namen der Ausgaben als Schlüssel. Ohne den Parameter liest du die Liste outputs. Siehe Die API-Antwort.

Wie es funktioniert

  1. Excel-Arbeitsmappe importieren. Die Formeln bleiben, wie sie sind.
  2. Eingaben und Ausgaben wählen. Klicke die Zellen an, die ein Aufrufer füllen darf, und die Zellen mit den Ergebnissen.
  3. Veröffentlichen und aufrufen. Jeder Aufruf wird von der Arbeitsmappe berechnet.

Die Schritte stehen in Dein erster Service, der Überblick auf der Seite Excel zu API.

Häufige Muster

Eine Hilfsfunktion für alle Berechnungen

async function calculate(serviceId, inputs) {
  const url =
    `https://spreadapi.io/api/v1/services/${serviceId}/execute?flatten=true`;
  const response = await fetch(url, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ inputs })
  });
  const data = await response.json();
  if (!response.ok) throw new Error(data.message || data.error);
  return data.result;
}

Dynamische Preise

app.post('/api/quote', async (req, res) => {
  try {
    res.json(await calculate(PRICING_SERVICE_ID, req.body));
  } catch (error) {
    res.status(400).json({ error: error.message });
  }
});

Provision

// Vorher: eine lange Funktion voller kopierter Regeln
// Nachher:
async function calculateCommission(sales, tier, region) {
  const result = await calculate(COMMISSION_SERVICE_ID, {
    sales, tier, region
  });
  return result.commission;
}

Eine Eingabe ist ein einzelner Wert: eine Zahl, ein Text oder ja/nein. Eine Liste von Werten, etwa eine Reihe von Zahlungen, gehört in die Arbeitsmappe oder wird als mehrere Eingaben übergeben.

Vorteile

Für Entwickler

  • Die nachprogrammierten Formeln können weg
  • Keine Suche mehr nach Abweichungen zu Excel
  • Zeit für die eigentliche Anwendung

Für den Fachbereich

  • Er arbeitet weiter in Excel
  • Eine geänderte Arbeitsmappe ist nach Import und Veröffentlichen live, ohne Code-Release
  • Eine Version der Logik

Migrationsleitfaden

Schritt 1: Die nachprogrammierten Berechnungen finden

git grep -n -E 'calculate|compute|formula'

Schritt 2: Die Arbeitsmappe veröffentlichen

  • Die ursprüngliche Excel-Datei heraussuchen
  • In SpreadAPI importieren
  • Eingaben und Ausgaben wählen
  • Mit Werten testen, deren Ergebnisse du kennst

Schritt 3: Den Code ersetzen

Ersetze jede nachprogrammierte Funktion durch einen Aufruf, wie im Provisionsbeispiel oben, und vergleiche alte und neue Ergebnisse eine Weile, bevor du den alten Code löschst.

Häufige Einwände

"Und die Performance?"

Wir haben unseren öffentlichen Demo-Angebotsrechner gemessen, eine Arbeitsmappe mit vier Blättern: Eine Berechnung dauerte auf dem Server etwa 20 ms, der ganze Weg hin und zurück von einem Client in Deutschland im Median 97 ms. Das gilt nur für diese Arbeitsmappe. Methode und alle Zahlen stehen in Excel API Antwortzeit.

"Was, wenn die Excel-Arbeitsmappe Fehler hat?"

Ein Nachbau würde dieselben Fehler kopieren. Mit einer Version behebst du sie einmal, in der Arbeitsmappe.

"Wir brauchen Versionskontrolle"

SpreadAPI führt keine Versionshistorie eines Service. Aufrufer bekommen die veröffentlichte Version, bis du erneut veröffentlichst. Lege die Excel-Dateien in deiner eigenen Versionsverwaltung oder Dokumentenablage ab und exportiere die Arbeitsmappe aus SpreadAPI, wenn du den aktuellen Stand brauchst. Siehe Die Arbeitsmappe durch eine neue Version ersetzen.

"Unsere Logik steckt in Makros"

VBA-Makros laufen in einem Service nicht, und Verknüpfungen zu anderen Arbeitsmappen werden nicht verfolgt. Diese Logik muss mit Formeln nachgebaut werden. Siehe Unterstützte Excel-Funktionen.

Best Practices

1. Klein anfangen

Nimm ein Excel-Modell, ersetze dessen Nachbau, vergleiche die Ergebnisse und erweitere von dort.

2. Ergebnisse wiederverwenden

const cache = new Map();

async function calculateCached(serviceId, inputs) {
  const key = serviceId + JSON.stringify(inputs);
  if (!cache.has(key)) {
    cache.set(key, await calculate(serviceId, inputs));
  }
  return cache.get(key);
}

SpreadAPI speichert das Ergebnis gleicher Eingaben zusätzlich bis zu 15 Minuten. Siehe Caching und Performance.

3. Fehler behandeln

Eine abgelehnte Eingabe antwortet mit HTTP 400 und einem Text, der die Eingabe nennt. Ein Formelfehler in einer Ausgabezelle, etwa #WERT!, kommt als Wert mit Status 200 zurück. Prüfe beides.

Das Fazit

Excel in JavaScript nachzuprogrammieren heißt, dieselbe Logik zweimal zu pflegen. Die Arbeitsmappe als API aufzurufen lässt es bei einer Version: der, die ihr Besitzer pflegt.

SpreadAPI ausprobieren

Fragen? Schreib an support@airrange.io

Verwandte Artikel