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:
- Menge
- Kundenstufe
- Saison
- 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