Lecture et écriture de fichiers DBF

Aspose.Cells offre une prise en charge complète pour la lecture et l’écriture de 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 Aspose.Cells, et 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é initialement introduit 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, vous offrant la possibilité de :

Importer des données depuis des fichiers DBF existants dans des objets Workbook d’Aspose.Cells pour un traitement ultérieur ou une conversion vers d’autres formats.
Créer de nouveaux fichiers DBF à partir de zéro ou en transformant des données depuis d’autres formats de feuilles 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 feuilles de calcul, ce qui en fait un pont pratique entre les systèmes hérités et les outils de feuilles 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 importantes.

Fonctionnalités prises en charge

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

Lecture des données DBF dans un objet Workbook, avec tous les enregistrements et définitions de champs préservé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, notamment 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 en fonction de l’application source (communément Windows-1252 ou des pages de code OEM).

Lecture d’un fichier DBF

Aspose.Cells facilite le chargement des données d’un fichier DBF dans un objet Workbook. La bibliothèque utilise la classe LoadOptions pour spécifier le format source, garantissant 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 de LoadOptions, définir sa propriété LoadFormat sur LoadFormat.Dbf, et la transmettre 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 les 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, affichant ses enregistrements dans une disposition tabulaire. Ceci 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 schéma 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 de Workbook.
Accédez à la première feuille de calcul 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 transmettant 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) pour 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 respectent les 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 YYYYMMDD.

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 pour 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 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 selon les 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 feuilles de calcul modernes tels que XLSX, XLS ou CSV. Étant donné qu’Aspose.Cells prend en charge une large gamme de formats, vous pouvez facilement charger un fichier DBF et le réenregistrer dans tout autre format pris en charge, ou vice versa.

Par exemple, vous pouvez lire un fichier DBF, appliquer une mise en forme ou des calculs à l’aide de l’API Aspose.Cells, puis enregistrer le résultat dans un fichier XLSX pour distribution aux utilisateurs qui travaillent avec des applications de feuilles de calcul modernes. Inversement, vous pouvez prendre des données d’un fichier XLSX ou CSV et les exporter au format DBF pour une intégration avec des systèmes hérités.

Convertir Excel en CSV, TSV et Txt avec C++ Convertir Excel en PDF avec C++