Lecture et écriture de fichiers DBF

Aspose.Cells offre une prise en charge complète de la lecture et de l’écriture des fichiers DBF (dBASE). Vous pouvez charger des fichiers dBASE III et dBASE IV existants dans un objet Workbook, manipuler les données à l’aide de la riche API d’Aspose.Cells, puis enregistrer le classeur au format DBF pour une utilisation avec des applications de base de données héritées.

Introduction

DBF (DataBase File) est un format de fichier de base de données hérité introduit à l’origine par dBASE au début des années 1980. Malgré l’ancienneté du format, les fichiers DBF sont encore largement utilisés dans de nombreux secteurs pour stocker des données structurées, notamment dans la comptabilité, les SIG et d’autres applications spécialisées. Aspose.Cells vous permet d’intégrer ces fichiers hérités de manière transparente dans les flux de travail modernes de feuilles de calcul C++. La bibliothèque prend en charge à la fois la lecture et l’écriture des fichiers DBF, ce qui vous offre la possibilité de :

Importer des données depuis des fichiers DBF existants dans des objets Workbook d’Aspose.Cells pour traitement ultérieur ou conversion vers d’autres formats.
Créer de nouveaux fichiers DBF à partir de zéro ou en transformant les données depuis d’autres formats de feuille de calcul.
Conserver les définitions de champs, les types de données et les structures d’enregistrements lors du transfert de données vers et depuis le format DBF. Les fichiers DBF peuvent également être ouverts directement dans Microsoft Excel et d’autres applications de feuille de calcul, ce qui en fait un pont pratique entre les systèmes hérités et les outils de feuille de calcul modernes.

Versions et fonctionnalités DBF prises en charge

Aspose.Cells prend en charge les versions de format DBF suivantes :

dBASE III — La variante originale et la plus largement prise en charge du format DBF.
dBASE IV — Une version étendue qui prend en charge des types de données supplémentaires et des tailles de champ plus grandes.

Fonctionnalités prises en charge

La bibliothèque offre une prise en charge complète des opérations suivantes :

Lecture des données DBF dans un objet Workbook, avec tous les enregistrements et définitions de champs conservés.
Écriture des données du classeur au format DBF pour exportation vers des applications compatibles dBASE.
Gestion des types de données courants utilisés dans les fichiers DBF, y compris les champs caractère, numérique, date et logique.
Conservation des définitions de champs telles que le nom, le type et la longueur du champ lors des opérations de lecture/écriture.

Limitations et considérations

Lorsque vous travaillez avec des fichiers DBF, gardez à l’esprit les contraintes suivantes :

Le nombre maximum de champs par fichier est de 128.
La taille maximale d’un enregistrement est de 4000 octets.
Les noms de champs sont limités à 10 caractères, doivent être en majuscules et ne peuvent pas contenir d’espaces.
Les valeurs de date dans les fichiers DBF sont stockées au format YYYYMMDD.
L’encodage des caractères peut varier selon l’application source (généralement Windows-1252 ou pages de code OEM).

Lecture d’un fichier DBF

Aspose.Cells permet de charger facilement des données depuis un fichier DBF dans un objet Workbook. La bibliothèque utilise la classe LoadOptions pour spécifier le format source, garantissant ainsi que les données sont interprétées correctement pendant le processus de chargement.

Lecture d’un fichier DBF avec Aspose.Cells

Pour lire un fichier DBF, vous devez créer une instance LoadOptions, définir sa propriété LoadFormat sur LoadFormat.Dbf, puis la passer au constructeur Workbook avec le chemin du fichier. Une fois chargé, les données deviennent accessibles via la collection Worksheets, où vous pouvez itérer à travers les cellules, extraire des valeurs ou manipuler les données selon vos besoins. L’exemple suivant montre comment charger un fichier DBF existant dans Aspose.Cells, accéder à sa première feuille de calcul et lire les valeurs des cellules.

#include "Aspose.Cells.h"
#include <string>
#include <iostream>
using namespace Aspose::Cells;
int main() {
    Aspose::Cells::Startup();
    std::string dataDir = "Data/";
    std::string filePath = dataDir + "example.dbf";
    LoadOptions loadOptions(LoadFormat::Dbf);
    Workbook workbook(U16String(filePath.c_str()), loadOptions);
    Worksheet worksheet = workbook.GetWorksheets().Get(0);
    Cells cells = worksheet.GetCells();
    std::string sb = "";
    int maxRow = cells.GetMaxDataRow();
    int maxCol = cells.GetMaxDataColumn();
    for (int i = 0; i <= maxRow; i++) {
        for (int j = 0; j <= maxCol; j++) {
            Cell cell = cells.Get(i, j);
            U16String value = cell.GetStringValue();
            sb += "|";
            sb += value.ToUtf8();
        }
        sb += "|";
        sb += "\n";
    }
    std::cout << sb << std::endl;
    std::string outputPath = dataDir + "output.xlsx";
    workbook.Save(U16String(outputPath.c_str()), SaveFormat::Xlsx);
    std::cout << "DBF file loaded successfully. Converted XLSX saved at: " << outputPath << std::endl;
    Aspose::Cells::Cleanup();
    return 0;
}

Vous pouvez ouvrir des fichiers DBF directement dans Microsoft Excel en sélectionnant le fichier dans la boîte de dialogue Ouvrir. Excel traitera le fichier DBF comme une feuille de calcul et affichera ses enregistrements dans une disposition tabulaire. Cela est utile pour vérifier rapidement les données après les avoir lues ou écrites avec Aspose.Cells.

Écriture d’un fichier DBF

L’écriture de données dans un fichier DBF suit un modèle similaire à l’enregistrement de tout autre format de feuille de calcul avec Aspose.Cells. Vous créez ou chargez un Workbook, remplissez la feuille de calcul avec des données, puis appelez la méthode Save en spécifiant SaveFormat.Dbf comme format cible.

Écriture d’un fichier DBF avec Aspose.Cells

Pour créer un fichier DBF, suivez ces étapes :

Créez une nouvelle instance Workbook.
Accédez à la première feuille de calcul à partir de la collection Worksheets.
Remplissez la feuille de calcul avec vos données, y compris les en-têtes dans la première ligne et les enregistrements dans les lignes suivantes.
Appelez la méthode Workbook.Save, en passant le chemin du fichier et SaveFormat.Dbf comme paramètres. L’exemple suivant montre comment créer un nouveau fichier DBF à partir de zéro. Il remplit une feuille de calcul avec des données d’exemple contenant différents types de données (chaînes, nombres et dates) afin d’illustrer comment les types de champs sont gérés lors de l’exportation au format DBF.

#include "Aspose.Cells.h"
#include <string>
#include <filesystem>
using namespace Aspose::Cells;
int main() {
    Aspose::Cells::Startup();
    std::string outputDir = "C:/Output/";
    std::string filePath = outputDir + "output.dbf";
    if (!std::filesystem::exists(outputDir)) {
        std::filesystem::create_directories(outputDir);
    }
    Workbook workbook;
    Worksheet worksheet = workbook.GetWorksheets().Get(0);
    Cells cells = worksheet.GetCells();
    // En-têtes de colonnes
    cells.Get(0, 0).PutValue(u"ID");
    cells.Get(0, 1).PutValue(u"Name");
    cells.Get(0, 2).PutValue(u"Department");
    cells.Get(0, 3).PutValue(u"Salary");
    cells.Get(0, 4).PutValue(u"HireDate");
    // Ligne de données 1
    cells.Get(1, 0).PutValue(101);
    cells.Get(1, 1).PutValue(u"John Smith");
    cells.Get(1, 2).PutValue(u"Engineering");
    cells.Get(1, 3).PutValue(75000.50);
    Date hireDate1{2020, 3, 15, 0, 0, 0, 0};
    cells.Get(1, 4).PutValue(hireDate1);
    // Ligne de données 2
    cells.Get(2, 0).PutValue(102);
    cells.Get(2, 1).PutValue(u"Jane Doe");
    cells.Get(2, 2).PutValue(u"Marketing");
    cells.Get(2, 3).PutValue(68000.75);
    Date hireDate2{2019, 7, 22, 0, 0, 0, 0};
    cells.Get(2, 4).PutValue(hireDate2);
    // Ligne de données 3
    cells.Get(3, 0).PutValue(103);
    cells.Get(3, 1).PutValue(u"Bob Johnson");
    cells.Get(3, 2).PutValue(u"Finance");
    cells.Get(3, 3).PutValue(82000.00);
    Date hireDate3{2021, 1, 10, 0, 0, 0, 0};
    cells.Get(3, 4).PutValue(hireDate3);
    // Ligne de données 4
    cells.Get(4, 0).PutValue(104);
    cells.Get(4, 1).PutValue(u"Alice Brown");
    cells.Get(4, 2).PutValue(u"Human Resources");
    cells.Get(4, 3).PutValue(71000.25);
    Date hireDate4{2018, 11, 5, 0, 0, 0, 0};
    cells.Get(4, 4).PutValue(hireDate4);
    // Ligne de données 5
    cells.Get(5, 0).PutValue(105);
    cells.Get(5, 1).PutValue(u"Charlie Wilson");
    cells.Get(5, 2).PutValue(u"Operations");
    cells.Get(5, 3).PutValue(79500.80);
    Date hireDate5{2022, 5, 30, 0, 0, 0, 0};
    cells.Get(5, 4).PutValue(hireDate5);
    // Définir les largeurs de colonnes pour une meilleure lisibilité
    worksheet.GetCells().SetColumnWidth(0, 8);
    worksheet.GetCells().SetColumnWidth(1, 20);
    worksheet.GetCells().SetColumnWidth(2, 20);
    worksheet.GetCells().SetColumnWidth(3, 12);
    worksheet.GetCells().SetColumnWidth(4, 14);
    workbook.Save(U16String(filePath.c_str()), SaveFormat::Dbf);
    Aspose::Cells::Cleanup();
    return 0;
}

Lors de l’écriture de données dans un fichier DBF, assurez-vous que vos données sont conformes aux limitations du format. Les noms de champs ne doivent pas dépasser 10 caractères et ne doivent pas contenir d’espaces. Les enregistrements dépassant 4000 octets au total ne seront pas enregistrés correctement. Les dates doivent être des valeurs de date valides pouvant être représentées au format AAAAMMJJ.

Considérations sur les types de données et la mise en forme

Lors du transfert de données entre Aspose.Cells et le format DBF, il est important de comprendre comment les types de données sont mappés entre les deux systèmes afin de garantir l’intégrité des données.

Types de cellules vers types de champs DBF

Les valeurs des cellules d’Aspose.Cells sont automatiquement converties vers les types de champs DBF appropriés lors de l’enregistrement :

Les chaînes sont mappées vers les champs caractère (C).
Les valeurs numériques (entiers et décimales) sont mappées vers les champs numériques (N).
Les valeurs de date sont mappées vers les champs de date (D) au format YYYYMMDD.
Les valeurs booléennes sont mappées vers les champs logiques (L).

Encodage

Les fichiers DBF peuvent utiliser différents encodages de caractères selon l’application qui les a créés. Aspose.Cells gère l’encodage de manière transparente dans la plupart des cas, mais si vous rencontrez des problèmes d’affichage des caractères, vous devrez peut-être vérifier l’encodage du fichier source.

Règles de nommage des champs

Les noms de champs DBF doivent respecter les règles suivantes :

Longueur maximale de 10 caractères.
Doivent commencer par une lettre.
Ne peuvent pas contenir d’espaces ni de caractères spéciaux.
Stockés en majuscules quelle que soit la casse utilisée en entrée.

Vérification du résultat

Après avoir écrit un fichier DBF, vous pouvez vérifier le résultat en l’ouvrant dans Microsoft Excel ou dans toute application compatible dBASE. Les données doivent apparaître dans une disposition tabulaire avec les noms de champs comme en-têtes de colonnes, et les enregistrements remplis conformément aux données que vous avez fournies.

Conversion entre DBF et d’autres formats

L’un des cas d’utilisation les plus pratiques pour la lecture et l’écriture de fichiers DBF avec Aspose.Cells est la conversion de données entre le format DBF et les formats de feuille de calcul modernes tels que XLSX, XLS ou CSV. Comme Aspose.Cells prend en charge une large gamme de formats, vous pouvez facilement charger un fichier DBF et l’enregistrer dans tout autre format pris en charge, ou vice versa.

Conversion d'Excel au format OFD Convertir Excel en PDF avec C++