Excel-Formeln vs JavaScript: Warum nicht beides?

Die falsche Wahl zwischen Excel und JavaScript

Viele Entwicklungsteams kennen dieses Gespräch:

Fachbereich: "Unser Excel-Modell deckt alle unsere Grenzfälle ab. Wir haben jahrelang daran gefeilt."

Entwicklung: "Wir müssen es für unsere Web-App in JavaScript nachbauen."

Einige Zeit später: "Warum stimmen die JavaScript-Berechnungen nicht mit Excel überein?"

Womit jede Seite recht hat

Team Excel

  • Fachanwender können die Logik selbst ändern
  • Formeln zeigen, wie eine Zahl entsteht
  • Finanz-, Verweis- und Datumsfunktionen sind eingebaut
  • Eine geänderte Eingabe zeigt ihre Wirkung sofort

Was allein fehlt: ein Weg in eine Web-App und Tests und Reviews, wie Code sie hat.

Team JavaScript

  • Lässt sich mit allem verbinden
  • Liegt in der Versionsverwaltung
  • Lässt sich mit Unit-Tests prüfen

Was fehlt: Fachanwender können es nicht ändern, Excel-Funktionen müssen nachgebaut werden, und die Ergebnisse laufen von der Arbeitsmappe weg.

Der Hybrid-Ansatz

Du musst dich nicht entscheiden. JavaScript übernimmt die Anwendung, die Arbeitsmappe die Berechnung, und ein HTTP-Aufruf verbindet beide.

Mit SpreadAPI importierst du die Excel-Arbeitsmappe, wählst Eingabe- und Ausgabezellen und veröffentlichst sie als Service. Diese kleine Hilfsfunktion ist alles, was der Code weiter unten braucht:

// Eine Berechnung: Eingabewerte hinein, Ausgaben nach Namen zurück
async function calculate(serviceId, inputs) {
  const url =
    `https://spreadapi.io/api/v1/services/${serviceId}/execute?flatten=true`;
  const headers = { 'Content-Type': 'application/json' };
  // nur bei einem Token-geschützten Service:
  if (process.env.SPREADAPI_TOKEN) {
    headers.Authorization = `Bearer ${process.env.SPREADAPI_TOKEN}`;
  }

  const response = await fetch(url, {
    method: 'POST',
    headers,
    body: JSON.stringify({ inputs })
  });
  const data = await response.json();
  if (!response.ok) {
    throw new Error(data.message || data.error);
  }
  return data.result;
}

flatten=true ergänzt die Antwort um result, ein Objekt mit den Namen der Ausgaben als Schlüssel. Adresse und Antwort sind in Einen Service über die API aufrufen und Die API-Antwort beschrieben.

class PricingService {
  async calculateQuote(customerId, productCode, quantity) {
    // JavaScript: Authentifizierung, Validierung, Datenbank
    const customer = await this.getCustomer(customerId);
    const orders = await this.getOrderHistory(customerId);

    // Arbeitsmappe: Preise, Rabattstaffeln, Geschäftsregeln
    const pricing = await calculate(PRICING_SERVICE_ID, {
      customerTier: customer.tier,
      orderCount: orders.length,
      productCode,
      quantity
    });

    // JavaScript: Formatierung, Logging
    return this.formatResponse(pricing);
  }
}

Beispiel: Eine Preisberechnung für einen Shop

Die Aufgabe

Ein Shop braucht Preise, die abhängen von:

  1. Menge
  2. Kundenstufe
  3. Saison
  4. Währung

Alles in JavaScript

function calculatePrice(product, quantity, customer) {
  let price = product.price;

  // Mengenrabatte
  if (quantity > 100) price *= 0.9;
  else if (quantity > 50) price *= 0.95;

  // Kundenstufen
  if (customer.tier === 'gold') price *= 0.85;
  if (customer.tier === 'silver') price *= 0.92;

  // Saisonanpassungen, Währungen, Ausnahmen ...
  return price;
}

Die Probleme: Der Fachbereich kann keinen Rabatt ändern, jede Ausnahme bringt eine weitere Verzweigung, und die Zahlen müssen von Hand mit der Arbeitsmappe des Finanzteams abgeglichen werden.

Arbeitsmappe plus JavaScript

class PricingEngine {
  constructor() {
    this.cache = new Map();
  }

  async getPrice(product, quantity, customerTier) {
    // JavaScript: Ergebnisse in der Anwendung wiederverwenden
    const key = `${product.code}-${quantity}-${customerTier}`;
    if (this.cache.has(key)) return this.cache.get(key);

    // Arbeitsmappe: die gesamte Preislogik
    const result = await calculate(PRICING_SERVICE_ID, {
      productCode: product.code,
      quantity,
      customerTier
    });

    // JavaScript: die Antwort aufbereiten
    const price = {
      base: result.basePrice,
      discount: result.discountAmount,
      final: result.finalPrice,
      currency: product.currency
    };
    this.cache.set(key, price);
    return price;
  }
}

Die Preislogik bleibt in der Arbeitsmappe, die das Finanzteam pflegt. Wenn es sie ändert, importiert jemand die neue Arbeitsmappe in den Service und veröffentlicht ihn. Der Code ändert sich nicht.

Wann du was verwendest

Excel-Formeln für

1. Finanzberechnungen

=RMZ(Zins/12; Jahre*12; -Kreditbetrag)

Die Funktionen gibt es, und ihre Grenzfälle sind definiert.

2. Geschäftsregeln

=WENN(UND(Kundenstufe="Gold"; Bestellungen>10);
    Basispreis*0,75;
    WENN(ODER(Kundenstufe="Silber"; Bestellungen>5);
        Basispreis*0,85;
        Basispreis))

Fachanwender können sie lesen und ändern.

3. Verweise

=XVERWEIS(Produktcode; Produkte[Code]; Produkte[Preis]; "Nicht gefunden")

Preislisten und Tarife sind Daten, die der Fachbereich ohnehin pflegt.

4. Statistik

=SCHÄTZER(ZielX; BekannteY; BekannteX)

Die Berechnungs-Engine von SpreadAPI listet mehr als 500 Excel-Funktionen, darunter XVERWEIS, dynamische Arrays wie FILTER, SORTIEREN und EINDEUTIG, LET und LAMBDA. Einige fehlen, zum Beispiel FORECAST.ETS und STOCKHISTORY, und VBA-Makros laufen nicht. Siehe Unterstützte Excel-Funktionen.

JavaScript für

1. Die Verbindung zu anderen Systemen

const user = await fetchUser(userId);
const enriched = await enrichWithCrmData(user);

2. Strukturprüfung

function validateOrder(order) {
  if (!order.items?.length) throw new Error('Bestellung braucht Positionen');
  if (!isValidEmail(order.email)) throw new Error('Ungültige E-Mail-Adresse');
}

3. Authentifizierung und Berechtigungen

Wer überhaupt nach einem Preis fragen darf, ist eine Frage für deine Anwendung, nicht für die Arbeitsmappe.

4. Orchestrierung

async function processOrder(order) {
  validateOrder(order);
  const pricing = await calculatePricing(order); // Arbeitsmappe
  const stock = await checkInventory(order);
  const saved = await createOrder({ order, pricing, stock });
  await notifyCustomer(saved);
  return saved;
}

Implementierungsmuster

Muster 1: Die Arbeitsmappe als Rechenkern

async function calculateTax(income, deductions, state) {
  // JavaScript bereitet die Daten vor
  const taxableIncome = income - deductions;

  // Die Arbeitsmappe enthält die Steuertabellen
  const result = await calculate(TAX_SERVICE_ID, {
    income: taxableIncome,
    filingStatus: 'single',
    state
  });

  // JavaScript bereitet die Antwort auf
  return {
    federalTax: result.federalTax,
    stateTax: result.stateTax,
    effectiveRate: result.effectiveRate
  };
}

Muster 2: Die Arbeitsmappe für Geschäftsregeln

async function checkEligibility(application) {
  // JavaScript sammelt die Daten
  const creditScore = await getCreditScore(application);
  const income = await verifyIncome(application);

  // Die Arbeitsmappe enthält die Regeln
  const result = await calculate(LOAN_RULES_SERVICE_ID, {
    creditScore,
    income,
    loanAmount: application.amount,
    loanType: application.type
  });

  // JavaScript steuert den Ablauf
  return result.approved
    ? createApproval(application, result)
    : createDenial(application, result.reason);
}

Eine Eingabe ist ein einzelner Wert: eine Zahl, ein Text oder ja/nein. Eine Ausgabe kann eine einzelne Zelle oder ein Zellbereich sein. Eine Liste von Bestellpositionen passt nicht in eine Eingabe. Rechne pro Position, oder lege die Regel, die die ganze Liste braucht, in JavaScript.

Muster 3: Grenzen im Service, Struktur in JavaScript

Eine Eingabe eines Service kann ein Minimum, ein Maximum und eine Liste erlaubter Werte haben. Ein Aufruf mit einem Wert außerhalb wird mit HTTP 400 abgelehnt, bevor gerechnet wird, und die Meldung nennt die Eingabe. Wertegrenzen liegen damit beim Modell, während dein JavaScript die Struktur prüft: Ist die Bestellung vollständig, ist die E-Mail-Adresse gültig.

Performance

Ergebnisse wiederverwenden

SpreadAPI speichert das Ergebnis gleicher Eingaben bis zu 15 Minuten und gibt es zurück, ohne neu zu rechnen. In deiner Anwendung kannst du einen eigenen Cache ergänzen, wie im Preisbeispiel oben, und den Aufruf ganz sparen.

Viele Berechnungen als einen Batch senden

// 2 bis 20 Szenarien in einer Anfrage, jedes mit einem Label
async function calculateMany(serviceId, scenarios) {
  const response = await fetch(`https://spreadapi.io/d/${serviceId}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ action: 'batch', scenarios })
  });
  const data = await response.json();
  if (!data.success) throw new Error(data.error);

  // Ein Eintrag pro Szenario, in der gesendeten Reihenfolge
  return data.scenarios.map((s) => s.success
    ? { label: s.label,
        ...Object.fromEntries(s.outputs.map((o) => [o.name, o.value])) }
    : { label: s.label, error: s.error });
}

const prices = await calculateMany(PRICING_SERVICE_ID, [
  { label: '50', inputs: { productCode: 'A-100', quantity: 50, customerTier: 'gold' } },
  { label: '100', inputs: { productCode: 'A-100', quantity: 100, customerTier: 'gold' } }
]);

Das ist die Batch-Aktion der Discovery-Adresse eines Service. Ein fehlgeschlagenes Szenario hält die anderen nicht auf, und jedes berechnete Szenario zählt als ein Aufruf. Bei einem geschützten Service hängst du ?token= und dein Token an die Adresse. Siehe Die Discovery-Adresse.

Was ein Aufruf an Zeit kostet

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. Mit einer neuen Verbindung für jeden Aufruf waren es etwa 170 bis 185 ms, halte die Verbindung also offen. Diese Zahlen gelten nur für diese Arbeitsmappe. Einzelheiten: Excel API Antwortzeit.

Migrationsstrategie

Schritt 1: Die Berechnungslogik finden

Geh den Code durch und markiere, was fachliche Berechnung ist: Sätze, Stufen, Multiplikatoren, Rundungsregeln. Das gehört in die Arbeitsmappe. Daten holen, Struktur prüfen und formatieren bleiben in JavaScript.

Schritt 2: Die Arbeitsmappe veröffentlichen

Wenn die Logik schon als Excel-Arbeitsmappe existiert, importiere sie, wie sie ist. Wähle Eingaben und Ausgaben, teste mit Werten, deren Ergebnisse du kennst, und veröffentliche.

Schritt 3: Den Hybrid-Service bauen

async function calculateCommission(employeeId, period) {
  // JavaScript: Daten sammeln
  const sales = await getSalesData(employeeId, period);
  const employee = await getEmployee(employeeId);

  // Arbeitsmappe: rechnen
  const result = await calculate(COMMISSION_SERVICE_ID, {
    totalSales: sales.total,
    tier: employee.tier,
    region: employee.region
  });

  // JavaScript: speichern und benachrichtigen
  await saveCommission(employeeId, period, result.commission);
  return result;
}

Häufige Fallstricke

Fallstrick 1: Zu fein aufteilen

Nicht jedes WENN gehört in die Arbeitsmappe. Fachliche Logik kommt dorthin, technische Logik bleibt im Code.

Fallstrick 2: Ein Aufruf pro Feld

Ruf den Service nicht bei jedem Tastendruck oder für jedes Feld auf. Sammle die Eingaben, nutze für viele Sätze einen Batch und verwende Ergebnisse wieder.

Fallstrick 3: Die Antwort nicht prüfen

Drei Fälle musst du behandeln:

try {
  const result = await calculate(PRICING_SERVICE_ID, inputs);

  // 1. Ein Formelfehler in einer Ausgabezelle ist eine normale Antwort
  if (typeof result.finalPrice === 'string'
      && result.finalPrice.startsWith('#')) {
    throw new Error(`Arbeitsmappe lieferte ${result.finalPrice}`);
  }
  return result;
} catch (error) {
  // 2. Eine abgelehnte Eingabe: HTTP 400, die Meldung nennt die Eingabe
  // 3. Ein Limit: HTTP 429, vor dem nächsten Versuch warten
  logger.error('Berechnung fehlgeschlagen', { message: error.message });
  throw error;
}

Was sich ändert

Vorher: Die Logik existiert zweimal, in der Arbeitsmappe und im Code. Jede Änderung wird zweimal gemacht, und beide laufen auseinander.

Nachher: Die Logik existiert einmal, in der Arbeitsmappe. Der Fachbereich ändert sie dort, und die Anwendung bekommt die neuen Ergebnisse, sobald die Arbeitsmappe erneut veröffentlicht ist.

Was sich nicht ändert: Jemand muss weiterhin für die Arbeitsmappe verantwortlich sein, sie testen und entscheiden, wann eine neue Version live geht. SpreadAPI führt keine Versionshistorie eines Service, lege die Excel-Dateien also in deiner eigenen Versionsverwaltung ab.

Fazit

Frag nicht mehr "Excel oder JavaScript?", sondern "Welcher Teil gehört wohin?"

  • Excel: Berechnungen, Geschäftsregeln, Finanzformeln
  • JavaScript: Integration, Validierung, Orchestrierung, Oberfläche

Mit SpreadAPI starten

Verwandte Artikel