Berechnung von Formeln

Hinzufügen von Formeln & Berechnen von Ergebnissen

Aspose.Cells verfügt über einen eingebetteten Formelberechnungsmotor. Er kann nicht nur Formeln aus Designer-Vorlagen neu berechnen, sondern auch die Ergebnisse von zur Laufzeit hinzugefügten Formeln berechnen.

Aspose.Cells unterstützt die meisten Formeln oder Funktionen, die Teil von Microsoft Excel sind (Lesen Sie eine Liste der Funktionen, die von der Berechnungsmaschine unterstützt werden). Diese Funktionen können über die APIs oder Designer-Arbeitsblätter verwendet werden. Aspose.Cells unterstützt eine große Anzahl mathematischer, string-, boolescher, Datum/Uhrzeit-, statistischer, Datenbank-, Such- und Bezug-Formeln.

Verwenden Sie die Eigenschaft Formula oder die Methoden SetFormula(…) der Klasse Cell, um einer Zelle eine Formel hinzuzufügen. Bei der Anwendung einer Formel beginnen Sie den String immer mit einem Gleichheitszeichen (=), wie es bei der Erstellung einer Formel in Microsoft Excel der Fall ist, und verwenden ein Komma (,) zur Trennung der Funktionsparameter.

Um die Ergebnisse von Formeln zu berechnen, kann der Benutzer die Methode CalculateFormula der Klasse Workbook aufrufen, die alle in einer Excel-Datei eingebetteten Formeln verarbeitet. Alternativ kann der Benutzer die Methode CalculateFormula der Klasse Worsheet aufrufen, die alle in einem Tabellenblatt eingebetteten Formeln verarbeitet. Oder der Benutzer kann auch die Methode Calculate der Klasse Cell aufrufen, die die Formel einer Zelle verarbeitet:

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(CalculatingFormulas.class) + "formulas/";
// Instantiating a Workbook object
Workbook workbook = new Workbook();

// Adding a new worksheet to the Excel object
int sheetIndex = workbook.getWorksheets().add();

// Obtaining the reference of the newly added worksheet by passing its sheet index
Worksheet worksheet = workbook.getWorksheets().get(sheetIndex);

// Adding a value to "A1" cell
worksheet.getCells().get("A1").putValue(1);

// Adding a value to "A2" cell
worksheet.getCells().get("A2").putValue(2);

// Adding a value to "A3" cell
worksheet.getCells().get("A3").putValue(3);

// Adding a SUM formula to "A4" cell
worksheet.getCells().get("A4").setFormula("=SUM(A1:A3)");

// Calculating the results of formulas
workbook.calculateFormula();

// Get the calculated value of the cell
String value = worksheet.getCells().get("A4").getStringValue();

// Saving the Excel file
workbook.save(dataDir + "CalculatingFormulas_out.xls");

Wichtig zu wissen

Die Formel-Eigenschaft und die SetFormel(…)-Methoden der Klasse Cell verhalten sich anders als die Berechnen-Methoden der Klassen Workbook, Worksheet und Cell. Die Formel-Eigenschaft und die SetFormel(…)-Methoden fügen einfach die Formel einer Zelle hinzu, berechnen das Ergebnis jedoch nicht zur Laufzeit. Um das Ergebnis der Formeln zu erhalten, rufen Sie bitte die Berechnen-Methoden auf.

Direkte Berechnung von Formeln

Aspose.Cells verfügt über einen eingebetteten Formelberechnungsmotor. Neben der Berechnung von Formeln, die aus einer Designerdatei importiert wurden, kann Aspose.Cells auch Formelergebnisse direkt berechnen.

Manchmal müssen Sie Formelergebnisse direkt berechnen, ohne sie in ein Arbeitsblatt aufzunehmen. Die Werte der Zellen, die in der Formel verwendet werden, existieren bereits in einem Arbeitsblatt, und Sie müssen nur das Ergebnis dieser Werte anhand einiger Microsoft Excel-Formel finden, ohne die Formel in ein Arbeitsblatt aufzunehmen.

Sie können die Formelberechnungsmotor-APIs von Aspose.Cells für Worksheet bis calculate verwenden, um die Ergebnisse solcher Formeln zu berechnen, ohne sie dem Arbeitsblatt hinzuzufügen:

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(DirectCalculationFormula.class) + "formulas/";
// Create a workbook
Workbook workbook = new Workbook();

// Access first worksheet
Worksheet worksheet = workbook.getWorksheets().get(0);

// Put 20 in cell A1
Cell cellA1 = worksheet.getCells().get("A1");
cellA1.putValue(20);

// Put 30 in cell A2
Cell cellA2 = worksheet.getCells().get("A2");
cellA2.putValue(30);

// Calculate the Sum of A1 and A2
Object results = worksheet.calculateFormula("=Sum(A1:A2)");

// Print the output
System.out.println("Value of A1: " + cellA1.getStringValue());
System.out.println("Value of A2: " + cellA2.getStringValue());
System.out.println("Result of Sum(A1:A2): " + results.toString());

Der obige Code erzeugt die folgende Ausgabe:

Value of A1: 20
Value of A2: 30
Result of Sum(A1:A2): 50.0

Formeln wiederholt berechnen

Wenn es viele Formeln in der Arbeitsmappe gibt und der Benutzer sie wiederholt berechnen muss, wobei nur ein kleiner Teil von ihnen modifiziert wird, kann es für die Leistungsfähigkeit hilfreich sein, die Formelberechnungskette zu aktivieren: FormulaSettings.EnableCalculationChain.

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(CalculatingFormulasOnce.class) + "formulas/";
// Load the template workbook
Workbook workbook = new Workbook(dataDir + "book1.xls");

// Print the time before formula calculation
System.out.println(DateTime.getNow());

// Set the CreateCalcChain as true
workbook.getSettings().getFormulaSettings().setEnableCalculationChain(true);

// Calculate the workbook formulas
workbook.calculateFormula();

Cells cells = workbook.getWorksheets().get("Sheet1").getCells();

//with original values, the calculated result
System.out.println(cells.get("A11").getValue());

//update one value the formula depends on
cells.get("A5").putValue(15);

// Calculate the workbook formulas again, in fact only A11 needs to be and will be calculated
workbook.calculateFormula();

//check the re-calculated value
System.out.println(cells.get("A11").getValue());

// Print the time after formula calculation
System.out.println(DateTime.getNow());

Wichtig zu wissen

Standardmäßig ist die Berechnungskette deaktiviert. Da das Erstellen der Kette zusätzliche Zeit benötigt, kann das erstmalige Berechnen von Formeln (Workbook.CalculateFormula(…)) mehr CPU-Verarbeitungszeit und Speicher in Anspruch nehmen im Vergleich zur Berechnung von Formeln ohne Kette. Wenn der Benutzer keine wiederholten Formelberechnungen benötigt, sollte das Standardverhalten (direkte Berechnung der Formel ohne Erstellung einer Berechnungskette) der bessere Weg sein.

Erweiterte Themen

• Zellen zur Microsoft Excel-Formelüberwachung hinzufügen
• Aspose.Cells Formelberechnungsmotor
• Berechnung der IFNA-Funktion mit Aspose.Cells
• Berechnung der Arrayformel von Datenblättern
• Berechnung der Excel 2016 MINIFS- und MAXIFS-Funktionen
• Vermindern der Berechnungszeit der Cell.Calculate-Methode
• Erkennen von zirkulären Verweisen
• Direkte Berechnung einer benutzerdefinierten Funktion ohne Eintragung in ein Arbeitsblatt
• Implementieren eines benutzerdefinierten Berechnungsmotors zur Erweiterung des Standard-Berechnungsmotors von Aspose.Cells
• Unterbrechen oder Abbrechen der Formelberechnung des Arbeitsbuchs
• Rückgabe eines Bereichs von Werten unter Verwendung von AbstractCalculationEngine
• Rückgabe eines Wertebereichs mit ICustomFunction
• Verwendung der ICustomFunction-Funktion