Top Related Projects
A pure PHP library for reading and writing spreadsheet files
Read and write spreadsheet files (CSV, XLSX and ODS), in a fast and scalable way
Lightweight XLSX Excel Spreadsheet Writer in PHP
🚀 PHP Extension for creating and reader XLSX files.
A Python module for creating Excel XLSX files.
Quick Overview
SimpleXLSXGen is a lightweight PHP library for generating Excel XLSX files. It allows developers to create spreadsheets programmatically without requiring external dependencies or the PHP ZIP extension. The library is designed to be simple to use and efficient for basic Excel file generation tasks.
Pros
- Easy to use with a straightforward API
- No external dependencies or PHP ZIP extension required
- Supports basic formatting options like text styles and cell colors
- Lightweight and fast for simple spreadsheet generation
Cons
- Limited advanced Excel features compared to more comprehensive libraries
- No support for reading or modifying existing Excel files
- May not be suitable for complex spreadsheet tasks or large datasets
- Limited documentation and examples available
Code Examples
Creating a simple spreadsheet:
$xlsx = SimpleXLSXGen::fromArray([
['Name', 'Age'],
['John Doe', 30],
['Jane Smith', 25]
]);
$xlsx->saveAs('users.xlsx');
Adding cell styles:
$xlsx = SimpleXLSXGen::fromArray([
['Name', 'Age'],
['John Doe', 30],
['Jane Smith', 25]
]);
$xlsx->setColWidth(1, 20);
$xlsx->setCellStyle('A1:B1', ['font-style' => 'bold', 'fill' => '#FFFF00']);
$xlsx->saveAs('users_styled.xlsx');
Creating multiple worksheets:
$xlsx = SimpleXLSXGen::fromArray([
['Sheet1' => [
['Name', 'Age'],
['John Doe', 30],
['Jane Smith', 25]
]],
['Sheet2' => [
['City', 'Country'],
['New York', 'USA'],
['London', 'UK']
]]
]);
$xlsx->saveAs('multi_sheet.xlsx');
Getting Started
-
Install the library using Composer:
composer require shuchkin/simplexlsxgen
-
Include the library in your PHP script:
require_once 'vendor/autoload.php'; use Shuchkin\SimpleXLSXGen;
-
Create and save a simple Excel file:
$xlsx = SimpleXLSXGen::fromArray([ ['Column 1', 'Column 2'], ['Value 1', 'Value 2'] ]); $xlsx->saveAs('example.xlsx');
This will generate a basic Excel file named 'example.xlsx' in the current directory.
Competitor Comparisons
A pure PHP library for reading and writing spreadsheet files
Pros of PhpSpreadsheet
- More comprehensive feature set, including support for multiple spreadsheet formats (XLSX, XLS, ODS, CSV, etc.)
- Advanced cell formatting and styling options
- Robust formula support and calculation engine
Cons of PhpSpreadsheet
- Larger library size and higher memory usage
- Steeper learning curve due to more complex API
- Slower performance for simple spreadsheet operations
Code Comparison
SimpleXLSXGen:
$xlsx = SimpleXLSXGen::fromArray([
['Name', 'Age'],
['John', 25],
['Jane', 30]
]);
$xlsx->saveAs('example.xlsx');
PhpSpreadsheet:
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
$sheet->fromArray([
['Name', 'Age'],
['John', 25],
['Jane', 30]
]);
$writer = new Xlsx($spreadsheet);
$writer->save('example.xlsx');
SimpleXLSXGen is more straightforward for basic tasks, while PhpSpreadsheet offers more flexibility and features at the cost of complexity.
Read and write spreadsheet files (CSV, XLSX and ODS), in a fast and scalable way
Pros of Spout
- More feature-rich, supporting advanced Excel functionality like formulas and charts
- Better performance for large datasets due to streaming approach
- Actively maintained with regular updates and improvements
Cons of Spout
- More complex to use, requiring more setup and configuration
- Larger library size, potentially impacting project footprint
- Steeper learning curve for beginners
Code Comparison
SimpleXLSXGen:
$xlsx = SimpleXLSXGen::fromArray([
['Name', 'Age'],
['John', 30],
['Jane', 25]
]);
$xlsx->saveAs('example.xlsx');
Spout:
$writer = WriterEntityFactory::createXLSXWriter();
$writer->openToFile('example.xlsx');
$writer->addRow(WriterEntityFactory::createRowFromArray(['Name', 'Age']));
$writer->addRow(WriterEntityFactory::createRowFromArray(['John', 30]));
$writer->addRow(WriterEntityFactory::createRowFromArray(['Jane', 25]));
$writer->close();
Both libraries offer straightforward ways to create Excel files, but Spout requires more setup and uses a different approach with row entities. SimpleXLSXGen provides a more concise syntax for simple use cases, while Spout offers more flexibility and advanced features at the cost of increased complexity.
Lightweight XLSX Excel Spreadsheet Writer in PHP
Pros of PHP_XLSXWriter
- More feature-rich, supporting advanced Excel functionalities like formulas and cell styling
- Better performance for large datasets due to streaming output
- Extensive documentation and examples available
Cons of PHP_XLSXWriter
- Larger codebase and more complex to use
- Requires more memory for advanced features
- Less frequently updated compared to SimpleXLSXGen
Code Comparison
SimpleXLSXGen:
$xlsx = SimpleXLSXGen::fromArray([
['Name', 'Age'],
['John', 25],
['Jane', 30]
]);
$xlsx->saveAs('example.xlsx');
PHP_XLSXWriter:
$writer = new XLSXWriter();
$writer->writeSheetHeader('Sheet1', ['Name' => 'string', 'Age' => 'integer']);
$writer->writeSheetRow('Sheet1', ['John', 25]);
$writer->writeSheetRow('Sheet1', ['Jane', 30]);
$writer->writeToFile('example.xlsx');
Both libraries offer straightforward ways to create Excel files, but PHP_XLSXWriter provides more control over data types and sheet structure. SimpleXLSXGen focuses on simplicity and ease of use, making it ideal for basic Excel generation tasks. PHP_XLSXWriter is better suited for complex Excel files with multiple sheets, formulas, and advanced formatting requirements.
🚀 PHP Extension for creating and reader XLSX files.
Pros of php-ext-xlswriter
- Higher performance due to being a PHP extension written in C
- Supports more advanced Excel features like charts and formulas
- Better memory efficiency for large datasets
Cons of php-ext-xlswriter
- Requires installation and compilation of a PHP extension
- Less portable across different PHP environments
- Steeper learning curve due to more complex API
Code Comparison
simplexlsxgen:
$xlsx = Shuchkin\SimpleXLSXGen::fromArray([
['Name', 'Age'],
['John', 25],
['Jane', 30]
]);
$xlsx->saveAs('example.xlsx');
php-ext-xlswriter:
$config = ['path' => './example.xlsx'];
$excel = new \Vtiful\Kernel\Excel($config);
$filePath = $excel->fileName('example.xlsx')
->header(['Name', 'Age'])
->data([['John', 25], ['Jane', 30]])
->output();
Both libraries offer straightforward ways to create Excel files, but php-ext-xlswriter provides more advanced features at the cost of increased complexity. simplexlsxgen is easier to use and more portable, while php-ext-xlswriter offers better performance and more Excel-specific functionality.
A Python module for creating Excel XLSX files.
Pros of XlsxWriter
- More feature-rich, supporting advanced Excel functionalities like charts, data validation, and conditional formatting
- Better documentation and extensive examples for various use cases
- Actively maintained with frequent updates and bug fixes
Cons of XlsxWriter
- Larger library size and more dependencies, potentially increasing project complexity
- Steeper learning curve due to its extensive feature set
- Slightly slower performance for simple spreadsheet generation tasks
Code Comparison
SimpleXLSXGen:
$xlsx = SimpleXLSXGen::fromArray([
['Name', 'Age'],
['John', 25],
['Jane', 30]
]);
$xlsx->saveAs('example.xlsx');
XlsxWriter:
import xlsxwriter
workbook = xlsxwriter.Workbook('example.xlsx')
worksheet = workbook.add_worksheet()
data = [['Name', 'Age'], ['John', 25], ['Jane', 30]]
for row, record in enumerate(data):
worksheet.write_row(row, 0, record)
workbook.close()
Both libraries offer straightforward ways to create simple Excel files, but XlsxWriter provides more flexibility for complex spreadsheets at the cost of slightly more verbose code.
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
SimpleXLSXGen
Export data to Excel XLSX file. PHP XLSX generator. No external tools and libraries.
Sergey Shuchkin sergey.shuchkin@gmail.com 2020-2024
Hey, bro, please â the package for my motivation :) and donate for more motivation!
Basic Usage
$books = [
['ISBN', 'title', 'author', 'publisher', 'ctry' ],
[618260307, 'The Hobbit', 'J. R. R. Tolkien', 'Houghton Mifflin', 'USA'],
[908606664, 'Slinky Malinki', 'Lynley Dodd', 'Mallinson Rendel', 'NZ']
];
$xlsx = Shuchkin\SimpleXLSXGen::fromArray( $books );
$xlsx->saveAs('books.xlsx'); // or downloadAs('books.xlsx') or $xlsx_content = (string) $xlsx
Installation
The recommended way to install this library is through Composer. New to Composer?
This will install the latest supported version:
$ composer require shuchkin/simplexlsxgen
or download class here
Examples
Use UTF-8 encoded strings.
Data types
$data = [
['Integer', 123],
['Float', 12.35],
['Percent', '12%'],
['Currency $', '$500.67'],
['Currency â¬', '200 â¬'],
['Currency â½', '1200.30 â½'],
['Currency (other)', '<style nf=""£"#,##0.00">500</style>'],
['Currency Float (other)', '<style nf="#,##0.00\ [$£-1];[Red]#,##0.00\ [$£-1]">500.250</style>'],
['Datetime', '2020-05-20 02:38:00'],
['Date', '2020-05-20'],
['Time', '02:38:00'],
['Datetime PHP', new DateTime('2021-02-06 21:07:00')],
['String', 'Very long UTF-8 string in autoresized column'],
['Formula', '<f v="135.35">SUM(B1:B2)</f>'],
['Hyperlink', 'https://github.com/shuchkin/simplexlsxgen'],
['Hyperlink + Anchor', '<a href="https://github.com/shuchkin/simplexlsxgen">SimpleXLSXGen</a>'],
['Internal link', '<a href="sheet2!A1">Go to second page</a>'],
['RAW string', "\0" . '2020-10-04 16:02:00'],
['Formatted RAW string', '<b><i><raw>2024-07-28 16:02:00</raw></i></b>'],
];
SimpleXLSXGen::fromArray($data)->saveAs('datatypes.xlsx');
Formatting
$data = [
['Normal', '12345.67'],
['Bold', '<b>12345.67</b>'],
['Italic', '<i>12345.67</i>'],
['Underline', '<u>12345.67</u>'],
['Strike', '<s>12345.67</s>'],
['Bold + Italic', '<b><i>12345.67</i></b>'],
['Hyperlink', 'https://github.com/shuchkin/simplexlsxgen'],
['Italic + Hyperlink + Anchor', '<i><a href="https://github.com/shuchkin/simplexlsxgen">SimpleXLSXGen</a></i>'],
['Green', '<style color="#00FF00">12345.67</style>'],
['Bold Red Text', '<b><style color="#FF0000">12345.67</style></b>'],
['Size 32 Font', '<style font-size="32">Big Text</style>'],
['Blue Text and Yellow Fill', '<style bgcolor="#FFFF00" color="#0000FF">12345.67</style>'],
['Border color', '<style border="#000000">Black Thin Border</style>'],
['<top>Border style</top>','<style border="medium"><wraptext>none, thin, medium, dashed, dotted, thick, double, hair, mediumDashed, dashDot,mediumDashDot, dashDotDot, mediumDashDotDot, slantDashDot</wraptext></style>'],
['Border sides', '<style border="none dotted#0000FF medium#FF0000 double">Top No + Right Dotted + Bottom medium + Left double</style>'],
['Left', '<left>12345.67</left>'],
['Center', '<center>12345.67</center>'],
['Right', '<right>Right Text</right>'],
['Center + Bold', '<center><b>Name</b></center>'],
['Row height', '<style height="50">Row Height = 50</style>'],
['Top', '<style height="50"><top>Top</top></style>'],
['Middle + Center', '<style height="50"><middle><center>Middle + Center</center></middle></style>'],
['Bottom + Right', '<style height="50"><bottom><right>Bottom + Right</right></bottom></style>'],
['<center>MERGE CELLS MERGE CELLS MERGE CELLS MERGE CELLS MERGE CELLS</center>', null],
['<top>Word wrap</top>', "<wraptext>Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book</wraptext>"],
['Linebreaks', "Line 1\nLine 2\nLine 3"]
];
SimpleXLSXGen::fromArray($data)
->setDefaultFont('Courier New')
->setDefaultFontSize(14)
->setColWidth(1, 35)
->mergeCells('A20:B20')
->saveAs('styles_and_tags.xlsx');
RAW Strings
Prefix #0 cell value (use double quotes) or use ::raw() method, or tag <raw>
$PushkinDOB = '1799-07-06';
$data = [
['Datetime as raw string', "\0".'2023-01-09 11:16:34'],
['Date as raw string', "\0".$PushkinDOB],
['Disable type detection', "\0".'+12345'],
['Insert greater/less them simbols', SimpleXLSXGen::raw('20- short term: <6 month')],
['Formatted raw', '<b><center><raw>+123456 <tag><tag2></raw></center></b>'],
];
SimpleXLSXGen::fromArray($data)
->saveAs('test_rawstrings.xlsx');
More examples
// Fluid interface, output to browser for download
Shuchkin\SimpleXLSXGen::fromArray( $books )->downloadAs('table.xlsx');
// Fluid interface, multiple sheets
Shuchkin\SimpleXLSXGen::fromArray( $books, 'My books' )->addSheet( $books2 )->download();
// Alternative interface, sheet name, get xlsx content
$xlsx_cache = (string) (new Shuchkin\SimpleXLSXGen)->addSheet( $books, 'Modern style');
// Classic interface
use Shuchkin\SimpleXLSXGen;
$xlsx = new SimpleXLSXGen();
$xlsx->addSheet( $books, 'Catalog 2021' );
$xlsx->addSheet( $books2, 'Stephen King catalog');
$xlsx->downloadAs('books_2021.xlsx');
exit();
// Empty book with title
$xlsx = SimpleXLSX::create('My books');
$xlsx->addSheet( $books );
$xlsx->save(); // ./My books.xlsx
// Hyperlinks
$xlsx = SimpleXLSX::fromArray([
['internal link', '<a href="\'My books 2\'!A1">Go to second sheet</a>'],
['http', 'https://example.com/'], // autodetect
['http + hash', 'https://en.wikipedia.org/wiki/Office_Open_XML#References'], // autodetect
['external anchor', '<a href="https://en.wikipedia.org/wiki/Office_Open_XML#References">Open XML</a>'],
['relative link', '<a href="books.xlsx">books</a>'],
['relative link + cell addr', '<a href="..\books.xlsx#\'Sheet 2\'!A1">link to second sheet in other book</a>'],
['mailto', 'info@example.com'], // autodetect
['mailto 2', '<a href="mailto:info@example.com">Please email me</a>'],
])->addSheet([['Second sheet']], 'My books 2')->saveAs('hyperlinks.xlsx');
// Autofilter
$xlsx->autoFilter('A1:B10');
// Freeze rows and columns from top-left corner up to, but not including,
// the row and column of the indicated cell
$xlsx->freezePanes('B2'); // B1 - freeze first column, A2 - freeze top row
// RTL mode
// Column A is on the far right, Column B is one column left of Column A, and so on.
// Also, information in cells is displayed in the Right to Left format.
$xlsx->rightToLeft();
// Set Meta Data Files
// this data in propertis Files and Info file in Office
$xlsx->setAuthor('John Doe <john@example.com>')
->setCompany('JD LLC <jd@mexample.com>')
->setManager('Jane Doe <jane@example.com>')
->setLastModifiedBy("John Doe <john@example.com>")
->setTitle('My Books')
->setSubject('My bookshelf')
->setKeywords('Tolkien,Rowling,Kipling')
->setDescription('Cool books worn by time')
->setCategory('Books')
->setLanguage('en-US')
->setApplication('Shuchkin\SimpleXLSXGen')
JS array to Excel (AJAX)
<?php // array2excel.php
if (isset($_POST['array2excel'])) {
require __DIR__.'/simplexlsxgen/src/SimpleXLSXGen.php';
$data = json_decode($_POST['array2excel'], false);
\Shuchkin\SimpleXLSXGen::fromArray($data)->downloadAs('file.xlsx');
return;
}
?>
<html lang="en">
<head>
<title>JS array to Excel</title>
</head>
<script>
function array2excel() {
var books = [
["ISBN", "title", "author", "publisher", "ctry"],
[618260307, "The Hobbit", "J. R. R. Tolkien", "Houghton Mifflin", "USA"],
[908606664, "Slinky Malinki", "Lynley Dodd", "Mallinson Rendel", "NZ"]
];
var json = JSON.stringify(books);
var request = new XMLHttpRequest();
request.onload = function () {
if (this.status === 200) {
var file = new Blob([this.response], {type: this.getResponseHeader('Content-Type')});
var fileURL = URL.createObjectURL(file);
var filename = "", m;
var disposition = this.getResponseHeader('Content-Disposition');
if (disposition && (m = /"([^"]+)"/.exec(disposition)) !== null) {
filename = m[1];
}
var a = document.createElement("a");
if (typeof a.download === 'undefined') {
window.location = fileURL;
} else {
a.href = fileURL;
a.download = filename;
document.body.appendChild(a);
a.click();
}
} else {
alert("Error: " + this.status + " " + this.statusText);
}
}
request.open('POST', "array2excel.php");
request.responseType = "blob";
request.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
request.send("array2excel=" + encodeURIComponent(json));
}
</script>
<body>
<input type="button" onclick="array2excel()" value="array2excel" />
</body>
</html>
Debug
ini_set('error_reporting', E_ALL );
ini_set('display_errors', 1 );
$data = [
['Debug', 123]
];
Shuchkin\SimpleXLSXGen::fromArray( $data )->saveAs('debug.xlsx');
Top Related Projects
A pure PHP library for reading and writing spreadsheet files
Read and write spreadsheet files (CSV, XLSX and ODS), in a fast and scalable way
Lightweight XLSX Excel Spreadsheet Writer in PHP
🚀 PHP Extension for creating and reader XLSX files.
A Python module for creating Excel XLSX files.
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot