Skip to content
TheChatArchiveThe Chat Archive
MiniMaxminimax-m1· MiniMaxHugging Face LMArena Human Preference 140K

Estou programando no Windows 10, eu tenho que ler (via código compilado) arquivos xls…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with gpt-4.1-mini-2025-04-14’s answer.
  1. User

    Estou programando no Windows 10, eu tenho que ler (via código compilado) arquivos xls mas não quero usar via código as ferramentas OLE do Excel. Note que não são .xlsx mas os velhos .xls

    Qual seria a melhor alternativa? pode ser em qualquer linguagem compilada

  2. MiniMax Assistant

    Para ler arquivos .xls sem usar as ferramentas OLE do Excel em C# ou C++, aqui estão as melhores alternativas:


    Opção 1: C# com a biblioteca NPOI

    A biblioteca NPOI é uma das mais populares para ler/escrever arquivos Excel em .NET sem dependências do Excel.

    Passos:

    1. Instale o NPOI via NuGet:

      Install-Package NPOI
      Install-Package NPOI.OOXML  # Para suporte a formatos adicionais
      
    2. Código de Exemplo:

      using NPOI.HSSF.UserModel;
      using NPOI.SS.UserModel;
      using System;
      using System.IO;
      
      class Program
      {
          static void Main()
          {
              string filePath = @"C:\caminho\arquivo.xls";
              using (FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
              {
                  // Carrega o workbook do arquivo .xls
                  HSSFWorkbook workbook = new HSSFWorkbook(stream);
                  
                  // Acessa a primeira planilha
                  ISheet sheet = workbook.GetSheetAt(0);
                  
                  // Lê dados da planilha
                  foreach (IRow row in sheet)
                  {
                      foreach (ICell cell in row)
                      {
                          // Converte o valor da célula para string
                          string cellValue = cell.ToString();
                          Console.Write(cellValue + "\t");
                      }
                      Console.WriteLine();
                  }
              }
          }
      }
      

    Vantagens:

    • Suporta .xls (via HSSFWorkbook) e .xlsx (via XSSFWorkbook).
    • Não requer Excel instalado.

    Opção 2: C# com ExcelDataReader

    A biblioteca ExcelDataReader é leve e otimizada para leitura de dados tabulares.

    Passos:

    1. Instale os pacotes NuGet:

      Install-Package ExcelDataReader
      Install-Package ExcelDataReader.DataSet
      
    2. Código de Exemplo:

      using ExcelDataReader;
      using System;
      using System.Data;
      using System.IO;
      
      class Program
      {
          static void Main()
          {
              string filePath = @"C:\caminho\arquivo.xls";
              using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
              {
                  // Cria o leitor do Excel
                  IExcelDataReader reader = ExcelReaderFactory.CreateReader(stream);
                  
                  // Converte para DataSet (opcional)
                  DataSet dataSet = reader.AsDataSet();
                  
                  // Lê a primeira planilha
                  DataTable table = dataSet.Tables[0];
                  
                  foreach (DataRow row in table.Rows)
                  {
                      foreach (DataColumn col in table.Columns)
                      {
                          Console.Write(row[col].ToString() + "\t");
                      }
                      Console.WriteLine();
                  }
              }
          }
      }
      

    Vantagens:

    • Performance otimizada para leitura de dados.
    • Suporta .xls e .xlsx.

    Opção 3: C++ com a biblioteca libxls

    Para C++, a libxls é uma biblioteca open-source para ler arquivos .xls.

    Passos:

    1. Baixe a libxls:

      • Site: libxls
      • Compile a biblioteca ou use binários pré-compilados.
    2. Código de Exemplo (C++):

      #include <stdio.h>
      #include "libxls/xls.h"
      
      int main() {
          xlsWorkBook* workbook = xls_open("C:\\caminho\\arquivo.xls", "UTF-8");
          if (!workbook) {
              printf("Erro ao abrir o arquivo.\n");
              return 1;
          }
      
          // Acessa a primeira planilha
          xlsWorkSheet* sheet = workbook->sheets[0];
          int rows = sheet->rows.lastrow;
      
          for (int i = 0; i < rows; i++) {
              xlsRow* row = &sheet->rows.row[i];
              for (int j = 0; j < row->lastcol; j++) {
                  xlsCell* cell = &row->cells.cell[j];
                  printf("%s\t", cell->str);
              }
              printf("\n");
          }
      
          xls_close(workbook);
          return 0;
      }
      

    Compilação (usando GCC no Windows via MinGW):

    gcc -o programa programa.c -lxls
    

    Vantagens:

    • Leitura direta do formato binário .xls.
    • Não requer dependências do Excel.

    Considerações Finais:

    • C# (NPOI/ExcelDataReader): Melhor para integração em aplicações .NET, com maior abstração.
    • C++ (libxls): Ideal para projetos de baixo nível ou que necessitam de performance.

    Escolha a opção com base no seu ambiente e familiaridade com a linguagem! 😊

  3. User

    vamos considerar em Delphi a biblioteca XlsReadWriteII, como fazer?

  4. MiniMax Assistant

    Para ler arquivos .xls (Excel 97-2003) em Delphi usando a biblioteca XlsReadWriteII, siga os passos abaixo:


    Passo 1: Baixe e instale a biblioteca XlsReadWriteII

    • A biblioteca é paga, mas possui uma versão de avaliação.
      Site oficial: XlsReadWriteII
      • Baixe a versão compatível com seu Delphi (32/64 bits).

    Passo 2: Adicione a biblioteca ao projeto

    1. Instale os arquivos:

      • Copie os arquivos .dcu e .pas da biblioteca para uma pasta no seu projeto (ex: Libs\XlsReadWriteII).
      • No Delphi, vá em Tools > Options > Delphi Options > Library Path e adicione o caminho da pasta.
    2. Adicione as units no código:

      uses
        XlsReadWriteII, XlsChart, XlsFormulas, XlsOther, XlsObj7, XlsSx, XlsWorkbook;
      

    Passo 3: Código para ler um arquivo .xls

    program ReadXLS;
    
    uses
      Vcl.Forms,
      XlsReadWriteII, XlsWorkbook, System.SysUtils;
    
    var
      Xls: TXlsReadWriteII;
      SheetIndex: Integer;
      Row, Col: Integer;
      CellValue: string;
    
    begin
      try
        Xls := TXlsReadWriteII.Create(nil);
        try
          // Abre o arquivo .xls
          Xls.Filename := 'C:\Caminho\Arquivo.xls';
          Xls.Read;
    
          // Acessa a primeira planilha (índice 0)
          SheetIndex := 0;
    
          // Exemplo: Lê dados da planilha
          for Row := 1 to Xls.Workbook.Sheets[SheetIndex].RowCount do
          begin
            for Col := 1 to Xls.Workbook.Sheets[SheetIndex].ColCount do
            begin
              // Obtém o valor da célula (formato string)
              CellValue := Xls.Workbook.Sheets[SheetIndex].AsString[Col, Row];
              Write(CellValue:10);
            end;
            Writeln;
          end;
    
        finally
          Xls.Free;
        end;
      except
        on E: Exception do
          Writeln('Erro: ', E.Message);
      end;
    end.
    

    Explicação do Código:

    1. Criação do Objeto:

      Xls := TXlsReadWriteII.Create(nil);
      
      • Cria uma instância da classe TXlsReadWriteII.
    2. Abertura do Arquivo:

      Xls.Filename := 'C:\Caminho\Arquivo.xls';
      Xls.Read;
      
      • Carrega o arquivo .xls para leitura.
    3. Leitura de Células:

      • Xls.Workbook.Sheets[SheetIndex] acessa a planilha pelo índice.
      • AsString[Col, Row] retorna o valor da célula como string (ajuste Col e Row para 1-based indexing).

    Vantagens do XlsReadWriteII:

    • Não requer Excel instalado: Leitura direta do formato binário .xls.
    • Suporte a fórmulas e formatação: Além de ler dados, pode manipular planilhas complexas.
    • Compatibilidade: Funciona com versões antigas do Excel (ideal para .xls).

    Considerações:

    • Licença: A biblioteca é paga. A versão de avaliação tem limitações (ex: não permite salvar arquivos).
    • Tratamento de Erros: Sempre use try...except para evitar crashes se o arquivo estiver corrompido.
    • Alternativa Gratuita: Se preferir uma opção gratuita, considere:
      • ADO + Driver do Excel (mas usa OLE, o que você quer evitar).
      • LibXLS (para C/C++), mas não é nativamente suportada em Delphi.

    Dica Extra:

    Se precisar de leitura de .xlsx, o XlsReadWriteII também suporta o formato (use TXlsReadWriteII normalmente). Para uma alternativa 100% gratuita, explore a biblioteca NativeExcel (procure no GitHub ou sites de componentes Delphi).

    Espero que ajude! 😊

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.