|
commit | author | age
|
|
2207d6
|
1 |
# PHPExcel Developer Documentation |
| W |
2 |
|
|
3 |
## Reading and writing to file |
|
4 |
|
|
5 |
As you already know from part REF _Ref191885438 \w \h 3.3 REF _Ref191885438 \h Readers and writers, reading and writing to a persisted storage is not possible using the base PHPExcel classes. For this purpose, PHPExcel provides readers and writers, which are implementations of PHPExcel_Writer_IReader and PHPExcel_Writer_IWriter. |
|
6 |
|
|
7 |
### PHPExcel_IOFactory |
|
8 |
|
|
9 |
The PHPExcel API offers multiple methods to create a PHPExcel_Writer_IReader or PHPExcel_Writer_IWriter instance: |
|
10 |
|
|
11 |
Direct creation via PHPExcel_IOFactory. All examples underneath demonstrate the direct creation method. Note that you can also use the PHPExcel_IOFactory class to do this. |
|
12 |
|
|
13 |
#### Creating PHPExcel_Reader_IReader using PHPExcel_IOFactory |
|
14 |
|
|
15 |
There are 2 methods for reading in a file into PHPExcel: using automatic file type resolving or explicitly. |
|
16 |
|
|
17 |
Automatic file type resolving checks the different PHPExcel_Reader_IReader distributed with PHPExcel. If one of them can load the specified file name, the file is loaded using that PHPExcel_Reader_IReader. Explicit mode requires you to specify which PHPExcel_Reader_IReader should be used. |
|
18 |
|
|
19 |
You can create a PHPExcel_Reader_IReader instance using PHPExcel_IOFactory in automatic file type resolving mode using the following code sample: |
|
20 |
|
|
21 |
```php |
|
22 |
$objPHPExcel = PHPExcel_IOFactory::load("05featuredemo.xlsx"); |
|
23 |
``` |
|
24 |
|
|
25 |
A typical use of this feature is when you need to read files uploaded by your users, and you don’t know whether they are uploading xls or xlsx files. |
|
26 |
|
|
27 |
If you need to set some properties on the reader, (e.g. to only read data, see more about this later), then you may instead want to use this variant: |
|
28 |
|
|
29 |
```php |
|
30 |
$objReader = PHPExcel_IOFactory::createReaderForFile("05featuredemo.xlsx"); |
|
31 |
$objReader->setReadDataOnly(true); |
|
32 |
$objReader->load("05featuredemo.xlsx"); |
|
33 |
``` |
|
34 |
|
|
35 |
You can create a PHPExcel_Reader_IReader instance using PHPExcel_IOFactory in explicit mode using the following code sample: |
|
36 |
|
|
37 |
```php |
|
38 |
$objReader = PHPExcel_IOFactory::createReader("Excel2007"); |
|
39 |
$objPHPExcel = $objReader->load("05featuredemo.xlsx"); |
|
40 |
``` |
|
41 |
|
|
42 |
Note that automatic type resolving mode is slightly slower than explicit mode. |
|
43 |
|
|
44 |
#### Creating PHPExcel_Writer_IWriter using PHPExcel_IOFactory |
|
45 |
|
|
46 |
You can create a PHPExcel_Writer_Iwriter instance using PHPExcel_IOFactory: |
|
47 |
|
|
48 |
```php |
|
49 |
$objWriter = PHPExcel_IOFactory::createWriter($objPHPExcel, "Excel2007"); |
|
50 |
$objWriter->save("05featuredemo.xlsx"); |
|
51 |
``` |
|
52 |
|
|
53 |
### Excel 2007 (SpreadsheetML) file format |
|
54 |
|
|
55 |
Excel2007 file format is the main file format of PHPExcel. It allows outputting the in-memory spreadsheet to a .xlsx file. |
|
56 |
|
|
57 |
#### PHPExcel_Reader_Excel2007 |
|
58 |
|
|
59 |
##### Reading a spreadsheet |
|
60 |
|
|
61 |
You can read an .xlsx file using the following code: |
|
62 |
|
|
63 |
```php |
|
64 |
$objReader = new PHPExcel_Reader_Excel2007(); |
|
65 |
$objPHPExcel = $objReader->load("05featuredemo.xlsx"); |
|
66 |
``` |
|
67 |
|
|
68 |
##### Read data only |
|
69 |
|
|
70 |
You can set the option setReadDataOnly on the reader, to instruct the reader to ignore styling, data validation, … and just read cell data: |
|
71 |
|
|
72 |
```php |
|
73 |
$objReader = new PHPExcel_Reader_Excel2007(); |
|
74 |
$objReader->setReadDataOnly(true); |
|
75 |
$objPHPExcel = $objReader->load("05featuredemo.xlsx"); |
|
76 |
``` |
|
77 |
|
|
78 |
##### Read specific sheets only |
|
79 |
|
|
80 |
You can set the option setLoadSheetsOnly on the reader, to instruct the reader to only load the sheets with a given name: |
|
81 |
|
|
82 |
```php |
|
83 |
$objReader = new PHPExcel_Reader_Excel2007(); |
|
84 |
$objReader->setLoadSheetsOnly( array("Sheet 1", "My special sheet") ); |
|
85 |
$objPHPExcel = $objReader->load("05featuredemo.xlsx"); |
|
86 |
``` |
|
87 |
|
|
88 |
##### Read specific cells only |
|
89 |
|
|
90 |
You can set the option setReadFilter on the reader, to instruct the reader to only load the cells which match a given rule. A read filter can be any class which implements PHPExcel_Reader_IReadFilter. By default, all cells are read using the PHPExcel_Reader_DefaultReadFilter. |
|
91 |
|
|
92 |
The following code will only read row 1 and rows 20 – 30 of any sheet in the Excel file: |
|
93 |
|
|
94 |
```php |
|
95 |
class MyReadFilter implements PHPExcel_Reader_IReadFilter { |
|
96 |
|
|
97 |
public function readCell($column, $row, $worksheetName = '') { |
|
98 |
// Read title row and rows 20 - 30 |
|
99 |
if ($row == 1 || ($row >= 20 && $row <= 30)) { |
|
100 |
return true; |
|
101 |
} |
|
102 |
return false; |
|
103 |
} |
|
104 |
} |
|
105 |
|
|
106 |
$objReader = new PHPExcel_Reader_Excel2007(); |
|
107 |
$objReader->setReadFilter( new MyReadFilter() ); |
|
108 |
$objPHPExcel = $objReader->load("06largescale.xlsx"); |
|
109 |
``` |
|
110 |
|
|
111 |
#### PHPExcel_Writer_Excel2007 |
|
112 |
|
|
113 |
##### Writing a spreadsheet |
|
114 |
|
|
115 |
You can write an .xlsx file using the following code: |
|
116 |
|
|
117 |
```php |
|
118 |
$objWriter = new PHPExcel_Writer_Excel2007($objPHPExcel); |
|
119 |
$objWriter->save("05featuredemo.xlsx"); |
|
120 |
``` |
|
121 |
|
|
122 |
##### Formula pre-calculation |
|
123 |
|
|
124 |
By default, this writer pre-calculates all formulas in the spreadsheet. This can be slow on large spreadsheets, and maybe even unwanted. You can however disable formula pre-calculation: |
|
125 |
|
|
126 |
```php |
|
127 |
$objWriter = new PHPExcel_Writer_Excel2007($objPHPExcel); |
|
128 |
$objWriter->setPreCalculateFormulas(false); |
|
129 |
$objWriter->save("05featuredemo.xlsx"); |
|
130 |
``` |
|
131 |
|
|
132 |
##### Office 2003 compatibility pack |
|
133 |
|
|
134 |
Because of a bug in the Office2003 compatibility pack, there can be some small issues when opening Excel2007 spreadsheets (mostly related to formula calculation). You can enable Office2003 compatibility with the following code: |
|
135 |
|
|
136 |
``` |
|
137 |
$objWriter = new PHPExcel_Writer_Excel2007($objPHPExcel); |
|
138 |
$objWriter->setOffice2003Compatibility(true); |
|
139 |
$objWriter->save("05featuredemo.xlsx"); |
|
140 |
``` |
|
141 |
|
|
142 |
__Office2003 compatibility should only be used when needed__ |
|
143 |
Office2003 compatibility option should only be used when needed. This option disables several Office2007 file format options, resulting in a lower-featured Office2007 spreadsheet when this option is used. |
|
144 |
|
|
145 |
### Excel 5 (BIFF) file format |
|
146 |
|
|
147 |
Excel5 file format is the old Excel file format, implemented in PHPExcel to provide a uniform manner to create both .xlsx and .xls files. It is basically a modified version of [PEAR Spreadsheet_Excel_Writer][21], although it has been extended and has fewer limitations and more features than the old PEAR library. This can read all BIFF versions that use OLE2: BIFF5 (introduced with office 95) through BIFF8, but cannot read earlier versions. |
|
148 |
|
|
149 |
Excel5 file format will not be developed any further, it just provides an additional file format for PHPExcel. |
|
150 |
|
|
151 |
__Excel5 (BIFF) limitations__ |
|
152 |
Please note that BIFF file format has some limits regarding to styling cells and handling large spreadsheets via PHP. |
|
153 |
|
|
154 |
#### PHPExcel_Reader_Excel5 |
|
155 |
|
|
156 |
##### Reading a spreadsheet |
|
157 |
|
|
158 |
You can read an .xls file using the following code: |
|
159 |
|
|
160 |
```php |
|
161 |
$objReader = new PHPExcel_Reader_Excel5(); |
|
162 |
$objPHPExcel = $objReader->load("05featuredemo.xls"); |
|
163 |
``` |
|
164 |
|
|
165 |
##### Read data only |
|
166 |
|
|
167 |
You can set the option setReadDataOnly on the reader, to instruct the reader to ignore styling, data validation, … and just read cell data: |
|
168 |
|
|
169 |
```php |
|
170 |
$objReader = new PHPExcel_Reader_Excel5(); |
|
171 |
$objReader->setReadDataOnly(true); |
|
172 |
$objPHPExcel = $objReader->load("05featuredemo.xls"); |
|
173 |
``` |
|
174 |
|
|
175 |
##### Read specific sheets only |
|
176 |
|
|
177 |
You can set the option setLoadSheetsOnly on the reader, to instruct the reader to only load the sheets with a given name: |
|
178 |
|
|
179 |
```php |
|
180 |
$objReader = new PHPExcel_Reader_Excel5(); |
|
181 |
$objReader->setLoadSheetsOnly( array("Sheet 1", "My special sheet") ); |
|
182 |
$objPHPExcel = $objReader->load("05featuredemo.xls"); |
|
183 |
``` |
|
184 |
|
|
185 |
##### Read specific cells only |
|
186 |
|
|
187 |
You can set the option setReadFilter on the reader, to instruct the reader to only load the cells which match a given rule. A read filter can be any class which implements PHPExcel_Reader_IReadFilter. By default, all cells are read using the PHPExcel_Reader_DefaultReadFilter. |
|
188 |
|
|
189 |
The following code will only read row 1 and rows 20 to 30 of any sheet in the Excel file: |
|
190 |
|
|
191 |
```php |
|
192 |
class MyReadFilter implements PHPExcel_Reader_IReadFilter { |
|
193 |
|
|
194 |
public function readCell($column, $row, $worksheetName = '') { |
|
195 |
// Read title row and rows 20 - 30 |
|
196 |
if ($row == 1 || ($row >= 20 && $row <= 30)) { |
|
197 |
return true; |
|
198 |
} |
|
199 |
return false; |
|
200 |
} |
|
201 |
} |
|
202 |
|
|
203 |
$objReader = new PHPExcel_Reader_Excel5(); |
|
204 |
$objReader->setReadFilter( new MyReadFilter() ); |
|
205 |
$objPHPExcel = $objReader->load("06largescale.xls"); |
|
206 |
``` |
|
207 |
|
|
208 |
#### PHPExcel_Writer_Excel5 |
|
209 |
|
|
210 |
##### Writing a spreadsheet |
|
211 |
|
|
212 |
You can write an .xls file using the following code: |
|
213 |
|
|
214 |
```php |
|
215 |
$objWriter = new PHPExcel_Writer_Excel5($objPHPExcel); |
|
216 |
$objWriter->save("05featuredemo.xls"); |
|
217 |
``` |
|
218 |
|
|
219 |
### Excel 2003 XML file format |
|
220 |
|
|
221 |
Excel 2003 XML file format is a file format which can be used in older versions of Microsoft Excel. |
|
222 |
|
|
223 |
__Excel 2003 XML limitations__ |
|
224 |
Please note that Excel 2003 XML format has some limits regarding to styling cells and handling large spreadsheets via PHP. |
|
225 |
|
|
226 |
#### PHPExcel_Reader_Excel2003XML |
|
227 |
|
|
228 |
##### Reading a spreadsheet |
|
229 |
|
|
230 |
You can read an Excel 2003 .xml file using the following code: |
|
231 |
|
|
232 |
```php |
|
233 |
$objReader = new PHPExcel_Reader_Excel2003XML(); |
|
234 |
$objPHPExcel = $objReader->load("05featuredemo.xml"); |
|
235 |
``` |
|
236 |
|
|
237 |
##### Read specific cells only |
|
238 |
|
|
239 |
You can set the option setReadFilter on the reader, to instruct the reader to only load the cells which match a given rule. A read filter can be any class which implements PHPExcel_Reader_IReadFilter. By default, all cells are read using the PHPExcel_Reader_DefaultReadFilter. |
|
240 |
|
|
241 |
The following code will only read row 1 and rows 20 to 30 of any sheet in the Excel file: |
|
242 |
|
|
243 |
```php |
|
244 |
class MyReadFilter implements PHPExcel_Reader_IReadFilter { |
|
245 |
|
|
246 |
public function readCell($column, $row, $worksheetName = '') { |
|
247 |
// Read title row and rows 20 - 30 |
|
248 |
if ($row == 1 || ($row >= 20 && $row <= 30)) { |
|
249 |
return true; |
|
250 |
} |
|
251 |
return false; |
|
252 |
} |
|
253 |
|
|
254 |
} |
|
255 |
|
|
256 |
$objReader = new PHPExcel_Reader_Excel2003XML(); |
|
257 |
$objReader->setReadFilter( new MyReadFilter() ); |
|
258 |
$objPHPExcel = $objReader->load("06largescale.xml"); |
|
259 |
``` |
|
260 |
|
|
261 |
### Symbolic LinK (SYLK) |
|
262 |
|
|
263 |
Symbolic Link (SYLK) is a Microsoft file format typically used to exchange data between applications, specifically spreadsheets. SYLK files conventionally have a .slk suffix. Composed of only displayable ANSI characters, it can be easily created and processed by other applications, such as databases. |
|
264 |
|
|
265 |
__SYLK limitations__ |
|
266 |
Please note that SYLK file format has some limits regarding to styling cells and handling large spreadsheets via PHP. |
|
267 |
|
|
268 |
#### PHPExcel_Reader_SYLK |
|
269 |
|
|
270 |
##### Reading a spreadsheet |
|
271 |
|
|
272 |
You can read an .slk file using the following code: |
|
273 |
|
|
274 |
```php |
|
275 |
$objReader = new PHPExcel_Reader_SYLK(); |
|
276 |
$objPHPExcel = $objReader->load("05featuredemo.slk"); |
|
277 |
``` |
|
278 |
|
|
279 |
##### Read specific cells only |
|
280 |
|
|
281 |
You can set the option setReadFilter on the reader, to instruct the reader to only load the cells which match a given rule. A read filter can be any class which implements PHPExcel_Reader_IReadFilter. By default, all cells are read using the PHPExcel_Reader_DefaultReadFilter. |
|
282 |
|
|
283 |
The following code will only read row 1 and rows 20 to 30 of any sheet in the SYLK file: |
|
284 |
|
|
285 |
```php |
|
286 |
class MyReadFilter implements PHPExcel_Reader_IReadFilter { |
|
287 |
|
|
288 |
public function readCell($column, $row, $worksheetName = '') { |
|
289 |
// Read title row and rows 20 - 30 |
|
290 |
if ($row == 1 || ($row >= 20 && $row <= 30)) { |
|
291 |
return true; |
|
292 |
} |
|
293 |
return false; |
|
294 |
} |
|
295 |
|
|
296 |
} |
|
297 |
|
|
298 |
$objReader = new PHPExcel_Reader_SYLK(); |
|
299 |
$objReader->setReadFilter( new MyReadFilter() ); |
|
300 |
$objPHPExcel = $objReader->load("06largescale.slk"); |
|
301 |
``` |
|
302 |
|
|
303 |
### Open/Libre Office (.ods) |
|
304 |
|
|
305 |
Open Office or Libre Office .ods files are the standard file format for Open Office or Libre Office Calc files. |
|
306 |
|
|
307 |
#### PHPExcel_Reader_OOCalc |
|
308 |
|
|
309 |
##### Reading a spreadsheet |
|
310 |
|
|
311 |
You can read an .ods file using the following code: |
|
312 |
|
|
313 |
```php |
|
314 |
$objReader = new PHPExcel_Reader_OOCalc(); |
|
315 |
$objPHPExcel = $objReader->load("05featuredemo.ods"); |
|
316 |
``` |
|
317 |
|
|
318 |
##### Read specific cells only |
|
319 |
|
|
320 |
You can set the option setReadFilter on the reader, to instruct the reader to only load the cells which match a given rule. A read filter can be any class which implements PHPExcel_Reader_IReadFilter. By default, all cells are read using the PHPExcel_Reader_DefaultReadFilter. |
|
321 |
|
|
322 |
The following code will only read row 1 and rows 20 to 30 of any sheet in the Calc file: |
|
323 |
|
|
324 |
```php |
|
325 |
class MyReadFilter implements PHPExcel_Reader_IReadFilter { |
|
326 |
|
|
327 |
public function readCell($column, $row, $worksheetName = '') { |
|
328 |
// Read title row and rows 20 - 30 |
|
329 |
if ($row == 1 || ($row >= 20 && $row <= 30)) { |
|
330 |
return true; |
|
331 |
} |
|
332 |
return false; |
|
333 |
} |
|
334 |
|
|
335 |
} |
|
336 |
|
|
337 |
$objReader = new PHPExcel_Reader_OOcalc(); |
|
338 |
$objReader->setReadFilter( new MyReadFilter() ); |
|
339 |
$objPHPExcel = $objReader->load("06largescale.ods"); |
|
340 |
``` |
|
341 |
|
|
342 |
### CSV (Comma Separated Values) |
|
343 |
|
|
344 |
CSV (Comma Separated Values) are often used as an import/export file format with other systems. PHPExcel allows reading and writing to CSV files. |
|
345 |
|
|
346 |
__CSV limitations__ |
|
347 |
Please note that CSV file format has some limits regarding to styling cells, number formatting, ... |
|
348 |
|
|
349 |
#### PHPExcel_Reader_CSV |
|
350 |
|
|
351 |
##### Reading a CSV file |
|
352 |
|
|
353 |
You can read a .csv file using the following code: |
|
354 |
|
|
355 |
```php |
|
356 |
$objReader = new PHPExcel_Reader_CSV(); |
|
357 |
$objPHPExcel = $objReader->load("sample.csv"); |
|
358 |
``` |
|
359 |
|
|
360 |
##### Setting CSV options |
|
361 |
|
|
362 |
Often, CSV files are not really “comma separated”, or use semicolon (;) as a separator. You can instruct PHPExcel_Reader_CSV some options before reading a CSV file. |
|
363 |
|
|
364 |
Note that PHPExcel_Reader_CSV by default assumes that the loaded CSV file is UTF-8 encoded. If you are reading CSV files that were created in Microsoft Office Excel the correct input encoding may rather be Windows-1252 (CP1252). Always make sure that the input encoding is set appropriately. |
|
365 |
|
|
366 |
```php |
|
367 |
$objReader = new PHPExcel_Reader_CSV(); |
|
368 |
$objReader->setInputEncoding('CP1252'); |
|
369 |
$objReader->setDelimiter(';'); |
|
370 |
$objReader->setEnclosure(''); |
|
371 |
$objReader->setLineEnding("\r\n"); |
|
372 |
$objReader->setSheetIndex(0); |
|
373 |
|
|
374 |
$objPHPExcel = $objReader->load("sample.csv"); |
|
375 |
``` |
|
376 |
|
|
377 |
##### Read a specific worksheet |
|
378 |
|
|
379 |
CSV files can only contain one worksheet. Therefore, you can specify which sheet to read from CSV: |
|
380 |
|
|
381 |
```php |
|
382 |
$objReader->setSheetIndex(0); |
|
383 |
``` |
|
384 |
|
|
385 |
##### Read into existing spreadsheet |
|
386 |
|
|
387 |
When working with CSV files, it might occur that you want to import CSV data into an existing PHPExcel object. The following code loads a CSV file into an existing $objPHPExcel containing some sheets, and imports onto the 6th sheet: |
|
388 |
|
|
389 |
```php |
|
390 |
$objReader = new PHPExcel_Reader_CSV(); |
|
391 |
$objReader->setDelimiter(';'); |
|
392 |
$objReader->setEnclosure(''); |
|
393 |
$objReader->setLineEnding("\r\n"); |
|
394 |
$objReader->setSheetIndex(5); |
|
395 |
|
|
396 |
$objReader->loadIntoExisting("05featuredemo.csv", $objPHPExcel); |
|
397 |
``` |
|
398 |
|
|
399 |
#### PHPExcel_Writer_CSV |
|
400 |
|
|
401 |
##### Writing a CSV file |
|
402 |
|
|
403 |
You can write a .csv file using the following code: |
|
404 |
|
|
405 |
```php |
|
406 |
$objWriter = new PHPExcel_Writer_CSV($objPHPExcel); |
|
407 |
$objWriter->save("05featuredemo.csv"); |
|
408 |
``` |
|
409 |
|
|
410 |
##### Setting CSV options |
|
411 |
|
|
412 |
Often, CSV files are not really “comma separated”, or use semicolon (;) as a separator. You can instruct PHPExcel_Writer_CSV some options before writing a CSV file: |
|
413 |
|
|
414 |
```php |
|
415 |
$objWriter = new PHPExcel_Writer_CSV($objPHPExcel); |
|
416 |
$objWriter->setDelimiter(';'); |
|
417 |
$objWriter->setEnclosure(''); |
|
418 |
$objWriter->setLineEnding("\r\n"); |
|
419 |
$objWriter->setSheetIndex(0); |
|
420 |
|
|
421 |
$objWriter->save("05featuredemo.csv"); |
|
422 |
``` |
|
423 |
|
|
424 |
##### Write a specific worksheet |
|
425 |
|
|
426 |
CSV files can only contain one worksheet. Therefore, you can specify which sheet to write to CSV: |
|
427 |
|
|
428 |
```php |
|
429 |
$objWriter->setSheetIndex(0); |
|
430 |
``` |
|
431 |
|
|
432 |
##### Formula pre-calculation |
|
433 |
|
|
434 |
By default, this writer pre-calculates all formulas in the spreadsheet. This can be slow on large spreadsheets, and maybe even unwanted. You can however disable formula pre-calculation: |
|
435 |
|
|
436 |
```php |
|
437 |
$objWriter = new PHPExcel_Writer_CSV($objPHPExcel); |
|
438 |
$objWriter->setPreCalculateFormulas(false); |
|
439 |
$objWriter->save("05featuredemo.csv"); |
|
440 |
``` |
|
441 |
|
|
442 |
##### Writing UTF-8 CSV files |
|
443 |
|
|
444 |
A CSV file can be marked as UTF-8 by writing a BOM file header. This can be enabled by using the following code: |
|
445 |
|
|
446 |
```php |
|
447 |
$objWriter = new PHPExcel_Writer_CSV($objPHPExcel); |
|
448 |
$objWriter->setUseBOM(true); |
|
449 |
$objWriter->save("05featuredemo.csv"); |
|
450 |
``` |
|
451 |
|
|
452 |
##### Decimal and thousands separators |
|
453 |
|
|
454 |
If the worksheet you are exporting contains numbers with decimal or thousands separators then you should think about what characters you want to use for those before doing the export. |
|
455 |
|
|
456 |
By default PHPExcel looks up in the server's locale settings to decide what characters to use. But to avoid problems it is recommended to set the characters explicitly as shown below. |
|
457 |
|
|
458 |
English users will want to use this before doing the export: |
|
459 |
|
|
460 |
```php |
|
461 |
PHPExcel_Shared_String::setDecimalSeparator('.'); |
|
462 |
PHPExcel_Shared_String::setThousandsSeparator(','); |
|
463 |
``` |
|
464 |
|
|
465 |
German users will want to use the opposite values. |
|
466 |
|
|
467 |
```php |
|
468 |
PHPExcel_Shared_String::setDecimalSeparator(','); |
|
469 |
PHPExcel_Shared_String::setThousandsSeparator('.'); |
|
470 |
``` |
|
471 |
|
|
472 |
Note that the above code sets decimal and thousand separators as global options. This also affects how HTML and PDF is exported. |
|
473 |
|
|
474 |
### HTML |
|
475 |
|
|
476 |
PHPExcel allows you to read or write a spreadsheet as HTML format, for quick representation of the data in it to anyone who does not have a spreadsheet application on their PC, or loading files saved by other scripts that simply create HTML markup and give it a .xls file extension. |
|
477 |
|
|
478 |
__HTML limitations__ |
|
479 |
Please note that HTML file format has some limits regarding to styling cells, number formatting, ... |
|
480 |
|
|
481 |
#### PHPExcel_Reader_HTML |
|
482 |
|
|
483 |
##### Reading a spreadsheet |
|
484 |
|
|
485 |
You can read an .html or .htm file using the following code: |
|
486 |
|
|
487 |
```php |
|
488 |
$objReader = new PHPExcel_Reader_HTML(); |
|
489 |
|
|
490 |
$objPHPExcel = $objReader->load("05featuredemo.html"); |
|
491 |
``` |
|
492 |
|
|
493 |
__HTML limitations__ |
|
494 |
Please note that HTML reader is still experimental and does not yet support merged cells or nested tables cleanly |
|
495 |
|
|
496 |
#### PHPExcel_Writer_HTML |
|
497 |
|
|
498 |
Please note that PHPExcel_Writer_HTML only outputs the first worksheet by default. |
|
499 |
|
|
500 |
##### Writing a spreadsheet |
|
501 |
|
|
502 |
You can write a .htm file using the following code: |
|
503 |
|
|
504 |
```php |
|
505 |
$objWriter = new PHPExcel_Writer_HTML($objPHPExcel); |
|
506 |
|
|
507 |
$objWriter->save("05featuredemo.htm"); |
|
508 |
``` |
|
509 |
|
|
510 |
##### Write all worksheets |
|
511 |
|
|
512 |
HTML files can contain one or more worksheets. If you want to write all sheets into a single HTML file, use the following code: |
|
513 |
|
|
514 |
```php |
|
515 |
$objWriter->writeAllSheets(); |
|
516 |
``` |
|
517 |
|
|
518 |
##### Write a specific worksheet |
|
519 |
|
|
520 |
HTML files can contain one or more worksheets. Therefore, you can specify which sheet to write to HTML: |
|
521 |
|
|
522 |
```php |
|
523 |
$objWriter->setSheetIndex(0); |
|
524 |
``` |
|
525 |
|
|
526 |
##### Setting the images root of the HTML file |
|
527 |
|
|
528 |
There might be situations where you want to explicitly set the included images root. For example, one might want to see |
|
529 |
```html |
|
530 |
<img style="position: relative; left: 0px; top: 0px; width: 140px; height: 78px;" src="http://www.domain.com/*images/logo.jpg" border="0"> |
|
531 |
``` |
|
532 |
|
|
533 |
instead of |
|
534 |
|
|
535 |
```html |
|
536 |
<img style="position: relative; left: 0px; top: 0px; width: 140px; height: 78px;" src="./images/logo.jpg" border="0">. |
|
537 |
``` |
|
538 |
|
|
539 |
You can use the following code to achieve this result: |
|
540 |
|
|
541 |
```php |
|
542 |
$objWriter->setImagesRoot('http://www.example.com'); |
|
543 |
``` |
|
544 |
|
|
545 |
##### Formula pre-calculation |
|
546 |
|
|
547 |
By default, this writer pre-calculates all formulas in the spreadsheet. This can be slow on large spreadsheets, and maybe even unwanted. You can however disable formula pre-calculation: |
|
548 |
|
|
549 |
```php |
|
550 |
$objWriter = new PHPExcel_Writer_HTML($objPHPExcel); |
|
551 |
$objWriter->setPreCalculateFormulas(false); |
|
552 |
|
|
553 |
$objWriter->save("05featuredemo.htm"); |
|
554 |
``` |
|
555 |
|
|
556 |
##### Embedding generated HTML in a web page |
|
557 |
|
|
558 |
There might be a situation where you want to embed the generated HTML in an existing website. PHPExcel_Writer_HTML provides support to generate only specific parts of the HTML code, which allows you to use these parts in your website. |
|
559 |
|
|
560 |
Supported methods: |
|
561 |
|
|
562 |
- generateHTMLHeader() |
|
563 |
- generateStyles() |
|
564 |
- generateSheetData() |
|
565 |
- generateHTMLFooter() |
|
566 |
|
|
567 |
Here's an example which retrieves all parts independently and merges them into a resulting HTML page: |
|
568 |
|
|
569 |
```php |
|
570 |
<?php |
|
571 |
$objWriter = new PHPExcel_Writer_HTML($objPHPExcel); |
|
572 |
echo $objWriter->generateHTMLHeader(); |
|
573 |
?> |
|
574 |
|
|
575 |
<style> |
|
576 |
<!-- |
|
577 |
html { |
|
578 |
font-family: Times New Roman; |
|
579 |
font-size: 9pt; |
|
580 |
background-color: white; |
|
581 |
} |
|
582 |
|
|
583 |
<?php |
|
584 |
echo $objWriter->generateStyles(false); // do not write <style> and </style> |
|
585 |
?> |
|
586 |
|
|
587 |
--> |
|
588 |
</style> |
|
589 |
|
|
590 |
<?php |
|
591 |
echo $objWriter->generateSheetData(); |
|
592 |
echo $objWriter->generateHTMLFooter(); |
|
593 |
?> |
|
594 |
``` |
|
595 |
|
|
596 |
##### Writing UTF-8 HTML files |
|
597 |
|
|
598 |
A HTML file can be marked as UTF-8 by writing a BOM file header. This can be enabled by using the following code: |
|
599 |
|
|
600 |
```php |
|
601 |
$objWriter = new PHPExcel_Writer_HTML($objPHPExcel); |
|
602 |
$objWriter->setUseBOM(true); |
|
603 |
|
|
604 |
$objWriter->save("05featuredemo.htm"); |
|
605 |
``` |
|
606 |
|
|
607 |
##### Decimal and thousands separators |
|
608 |
|
|
609 |
See section PHPExcel_Writer_CSV how to control the appearance of these. |
|
610 |
|
|
611 |
### PDF |
|
612 |
|
|
613 |
PHPExcel allows you to write a spreadsheet into PDF format, for fast distribution of represented data. |
|
614 |
|
|
615 |
__PDF limitations__ |
|
616 |
Please note that PDF file format has some limits regarding to styling cells, number formatting, ... |
|
617 |
|
|
618 |
#### PHPExcel_Writer_PDF |
|
619 |
|
|
620 |
PHPExcel’s PDF Writer is a wrapper for a 3rd-Party PDF Rendering library such as tcPDF, mPDF or DomPDF. Prior to version 1.7.8 of PHPExcel, the tcPDF library was bundled with PHPExcel; but from version 1.7.8 this was removed. Instead, you must now install a PDF Rendering library yourself; but PHPExcel will work with a number of different libraries. |
|
621 |
|
|
622 |
Currently, the following libraries are supported: |
|
623 |
|
|
624 |
Library | Version used for testing | Downloadable from | PHPExcel Internal Constant |
|
625 |
--------|--------------------------|----------------------------------|---------------------------- |
|
626 |
tcPDF | 5.9 | http://www.tcpdf.org/ | PDF_RENDERER_TCPDF |
|
627 |
mPDF | 5.4 | http://www.mpdf1.com/mpdf/ | PDF_RENDERER_MPDF |
|
628 |
domPDF | 0.6.0 beta 3 | http://code.google.com/p/dompdf/ | PDF_RENDERER_DOMPDF |
|
629 |
|
|
630 |
The different libraries have different strengths and weaknesses. Some generate better formatted output than others, some are faster or use less memory than others, while some generate smaller .pdf files. It is the developers choice which one they wish to use, appropriate to their own circumstances. |
|
631 |
|
|
632 |
Before instantiating a Writer to generate PDF output, you will need to indicate which Rendering library you are using, and where it is located. |
|
633 |
|
|
634 |
```php |
|
635 |
$rendererName = PHPExcel_Settings::PDF_RENDERER_MPDF; |
|
636 |
$rendererLibrary = 'mPDF5.4'; |
|
637 |
$rendererLibraryPath = dirname(__FILE__).'/../../../libraries/PDF/' . $rendererLibrary; |
|
638 |
|
|
639 |
if (!PHPExcel_Settings::setPdfRenderer( |
|
640 |
$rendererName, |
|
641 |
$rendererLibraryPath |
|
642 |
)) { |
|
643 |
die( |
|
644 |
'Please set the $rendererName and $rendererLibraryPath values' . |
|
645 |
PHP_EOL . |
|
646 |
' as appropriate for your directory structure' |
|
647 |
); |
|
648 |
} |
|
649 |
``` |
|
650 |
|
|
651 |
##### Writing a spreadsheet |
|
652 |
|
|
653 |
Once you have identified the Renderer that you wish to use for PDF generation, you can write a .pdf file using the following code: |
|
654 |
|
|
655 |
```php |
|
656 |
$objWriter = new PHPExcel_Writer_PDF($objPHPExcel); |
|
657 |
$objWriter->save("05featuredemo.pdf"); |
|
658 |
``` |
|
659 |
|
|
660 |
Please note that PHPExcel_Writer_PDF only outputs the first worksheet by default. |
|
661 |
|
|
662 |
##### Write all worksheets |
|
663 |
|
|
664 |
PDF files can contain one or more worksheets. If you want to write all sheets into a single PDF file, use the following code: |
|
665 |
|
|
666 |
```php |
|
667 |
$objWriter->writeAllSheets(); |
|
668 |
``` |
|
669 |
|
|
670 |
##### Write a specific worksheet |
|
671 |
|
|
672 |
PDF files can contain one or more worksheets. Therefore, you can specify which sheet to write to PDF: |
|
673 |
|
|
674 |
```php |
|
675 |
$objWriter->setSheetIndex(0); |
|
676 |
``` |
|
677 |
|
|
678 |
##### Formula pre-calculation |
|
679 |
|
|
680 |
By default, this writer pre-calculates all formulas in the spreadsheet. This can be slow on large spreadsheets, and maybe even unwanted. You can however disable formula pre-calculation: |
|
681 |
|
|
682 |
```php |
|
683 |
$objWriter = new PHPExcel_Writer_PDF($objPHPExcel); |
|
684 |
$objWriter->setPreCalculateFormulas(false); |
|
685 |
|
|
686 |
$objWriter->save("05featuredemo.pdf"); |
|
687 |
``` |
|
688 |
|
|
689 |
##### Decimal and thousands separators |
|
690 |
|
|
691 |
See section PHPExcel_Writer_CSV how to control the appearance of these. |
|
692 |
|
|
693 |
### Generating Excel files from templates (read, modify, write) |
|
694 |
|
|
695 |
Readers and writers are the tools that allow you to generate Excel files from templates. This requires less coding effort than generating the Excel file from scratch, especially if your template has many styles, page setup properties, headers etc. |
|
696 |
|
|
697 |
Here is an example how to open a template file, fill in a couple of fields and save it again: |
|
698 |
|
|
699 |
```php |
|
700 |
$objPHPexcel = PHPExcel_IOFactory::load('template.xlsx'); |
|
701 |
|
|
702 |
$objWorksheet = $objPHPexcel->getActiveSheet(); |
|
703 |
|
|
704 |
$objWorksheet->getCell('A1')->setValue('John'); |
|
705 |
$objWorksheet->getCell('A2')->setValue('Smith'); |
|
706 |
|
|
707 |
$objWriter = PHPExcel_IOFactory::createWriter($objPHPexcel, 'Excel5'); |
|
708 |
$objWriter->save('write.xls'); |
|
709 |
``` |
|
710 |
|
|
711 |
Notice that it is ok to load an xlsx file and generate an xls file. |
|
712 |
|
|
713 |
[21]: http://pear.php.net/package/Spreadsheet_Excel_Writer |
|
714 |
[22]: http://www.codeplex.com/PHPExcel/Wiki/View.aspx?title=Credits&referringTitle=Home |
