最新服务器上的版本，以后用这个
view | history | commit | commitdiff
wangzhenxin
2023-11-19 bc164b8bdbfbdf1d8229a5ced6b08d7cb8db7361
commit | author | age
2207d6 1 # PHPExcel Developer Documentation
W 2
3 ## Accessing cells
4
5 Accessing cells in a PHPExcel worksheet should be pretty straightforward. This topic lists some of the options to access a cell.
6
7 ### Setting a cell value by coordinate
8
9 Setting a cell value by coordinate can be done using the worksheet's `setCellValue()` method.
10
11 ```php
12 // Set cell A1 with a string value
13 $objPHPExcel->getActiveSheet()->setCellValue('A1', 'PHPExcel');
14
15 // Set cell A2 with a numeric value
16 $objPHPExcel->getActiveSheet()->setCellValue('A2', 12345.6789);
17
18 // Set cell A3 with a boolean value
19 $objPHPExcel->getActiveSheet()->setCellValue('A3', TRUE);
20
21 // Set cell A4 with a formula
22 $objPHPExcel->getActiveSheet()->setCellValue(
23     'A4', 
24     '=IF(A3, CONCATENATE(A1, " ", A2), CONCATENATE(A2, " ", A1))'
25 );
26 ```
27
28 Alternatively, you can retrieve the cell object, and then call the cell’s setValue() method:
29
30 ```php
31 $objPHPExcel->getActiveSheet()
32     ->getCell('B8')
33     ->setValue('Some value');
34 ```
35
36 **Excel DataTypes**
37
38 MS Excel supports 7 basic datatypes
39  - string
40  - number
41  - boolean
42  - null
43  - formula
44  - error
45  - Inline (or rich text) string
46
47 By default, when you call the worksheet's `setCellValue()` method or the cell's `setValue()` method, PHPExcel will use the appropriate datatype for PHP nulls, booleans, floats or integers; or cast any string data value that you pass to the method into the most appropriate datatype, so numeric strings will be cast to numbers, while string values beginning with “=” will be converted to a formula. Strings that aren't numeric, or that don't begin with a leading "=" will be treated as genuine string values.
48
49 This "conversion" is handled by a cell "value binder", and you can write custom "value binders" to change the behaviour of these "conversions". The standard PHPExcel package also provides an "advanced value binder" that handles a number of more complex conversions, such as converting strings with a fractional format like "3/4" to a number value (0.75 in this case) and setting an appropriate "fraction" number format mask. Similarly, strings like "5%" will be converted to a value of 0.05, and a percentage number format mask applied, and strings containing values that look like dates will be converted to Excel serialized datetimestamp values, and a corresponding mask applied. This is particularly useful when loading data from csv files, or setting cell values from a database.
50
51 Formats handled by the advanced value binder include
52  - TRUE or FALSE (dependent on locale settings) are converted to booleans.
53  - Numeric strings identified as scientific (exponential) format are converted to numbers.
54  - Fractions and vulgar fractions are converted to numbers, and an appropriate number format mask applied.
55  - Percentages are converted to numbers, divided by 100, and an appropriate number format mask applied.
56  - Dates and times are converted to Excel timestamp values (numbers), and an appropriate number format mask applied.
57  - When strings contain a newline character ("\n"), then the cell styling is set to wrap.
58
59 You can read more about value binders later in this section of the documentation.
60
61 #### Setting a date and/or time value in a cell
62
63 Date or time values are held as timestamp in Excel (a simple floating point value), and a number format mask is used to show how that value should be formatted; so if we want to store a date in a cell, we need to calculate the correct Excel timestamp, and set a number format mask.
64
65 ```php
66 // Get the current date/time and convert to an Excel date/time
67 $dateTimeNow = time();
68 $excelDateValue = PHPExcel_Shared_Date::PHPToExcel( $dateTimeNow );
69 // Set cell A6 with the Excel date/time value
70 $objPHPExcel->getActiveSheet()->setCellValue(
71     'A6', 
72     $excelDateValue
73 );
74 // Set the number format mask so that the excel timestamp will be displayed as a human-readable date/time
75 $objPHPExcel->getActiveSheet()->getStyle('A6')
76     ->getNumberFormat()
77     ->setFormatCode(
78         PHPExcel_Style_NumberFormat::FORMAT_DATE_DATETIME
79     );
80 ```
81
82 #### Setting a number with leading zeroes
83
84 By default, PHPExcel will automatically detect the value type and set it to the appropriate Excel numeric datatype. This type conversion is handled by a value binder, as described in the section of this document entitled "Using value binders to facilitate data entry".
85
86 Numbers don't have leading zeroes, so if you try to set a numeric value that does have leading zeroes (such as a telephone number) then these will be normally be lost as the value is cast to a number, so "01513789642" will be displayed as 1513789642.
87
88 There are two ways you can force PHPExcel to override this behaviour.
89
90 Firstly, you can set the datatype explicitly as a string so that it is not converted to a number.
91
92 ```php
93 // Set cell A8 with a numeric value, but tell PHPExcel it should be treated as a string
94 $objPHPExcel->getActiveSheet()->setCellValueExplicit(
95     'A8', 
96     "01513789642",
97     PHPExcel_Cell_DataType::TYPE_STRING
98 );
99 ```
100
101 Alternatively, you can use a number format mask to display the value with leading zeroes.
102
103 ```php
104 // Set cell A9 with a numeric value
105 $objPHPExcel->getActiveSheet()->setCellValue('A9', 1513789642);
106 // Set a number format mask to display the value as 11 digits with leading zeroes
107 $objPHPExcel->getActiveSheet()->getStyle('A9')
108     ->getNumberFormat()
109     ->setFormatCode(
110         '00000000000'
111     );
112 ```
113
114 With number format masking, you can even break up the digits into groups to make the value more easily readable.
115
116 ```php
117 // Set cell A10 with a numeric value
118 $objPHPExcel->getActiveSheet()->setCellValue('A10', 1513789642);
119 // Set a number format mask to display the value as 11 digits with leading zeroes
120 $objPHPExcel->getActiveSheet()->getStyle('A10')
121     ->getNumberFormat()
122     ->setFormatCode(
123         '0000-000-0000'
124     );
125 ```
126
127 ![07-simple-example-1.png](./images/07-simple-example-1.png "")
128
129
130 **Note** that not all complex format masks such as this one will work when retrieving a formatted value to display "on screen", or for certain writers such as HTML or PDF, but it will work with the true spreadsheet writers (Excel2007 and Excel5).
131
132 ### Setting a range of cells from an array
133
134 It is also possible to set a range of cell values in a single call by passing an array of values to the `fromArray()` method.
135
136 ```php
137 $arrayData = array(
138     array(NULL, 2010, 2011, 2012),
139     array('Q1',   12,   15,   21),
140     array('Q2',   56,   73,   86),
141     array('Q3',   52,   61,   69),
142     array('Q4',   30,   32,    0),
143 );
144 $objPHPExcel->getActiveSheet()
145     ->fromArray(
146         $arrayData,  // The data to set
147         NULL,        // Array values with this value will not be set
148         'C3'         // Top left coordinate of the worksheet range where
149                      //    we want to set these values (default is A1)
150     );
151 ```
152
153 ![07-simple-example-2.png](./images/07-simple-example-2.png "")
154
155 If you pass a 2-d array, then this will be treated as a series of rows and columns. A 1-d array will be treated as a single row, which is particularly useful if you're fetching an array of data from a database.
156
157 ```php
158 $rowArray = array('Value1', 'Value2', 'Value3', 'Value4');
159 $objPHPExcel->getActiveSheet()
160     ->fromArray(
161         $rowArray,   // The data to set
162         NULL,        // Array values with this value will not be set
163         'C3'         // Top left coordinate of the worksheet range where
164                      //    we want to set these values (default is A1)
165     );
166 ```
167
168 ![07-simple-example-3.png](./images/07-simple-example-3.png "")
169
170 If you have a simple 1-d array, and want to write it as a column, then the following will convert it into an appropriately structured 2-d array that can be fed to the `fromArray()` method:
171
172 ```php
173 $rowArray = array('Value1', 'Value2', 'Value3', 'Value4');
174 $columnArray = array_chunk($rowArray, 1);
175 $objPHPExcel->getActiveSheet()
176     ->fromArray(
177         $columnArray,   // The data to set
178         NULL,           // Array values with this value will not be set
179         'C3'            // Top left coordinate of the worksheet range where
180                         //    we want to set these values (default is A1)
181     );
182 ```
183
184 ![07-simple-example-4.png](./images/07-simple-example-4.png "")
185
186 ### Retrieving a cell value by coordinate
187
188 To retrieve the value of a cell, the cell should first be retrieved from the worksheet using the `getCell()` method. A cell's value can be read using the `getValue()` method.
189
190 ```php
191 // Get the value fom cell A1
192 $cellValue = $objPHPExcel->getActiveSheet()->getCell('A1')
193     ->getValue();
194 ```
195
196 This will retrieve the raw, unformatted value contained in the cell.
197
198 If a cell contains a formula, and you need to retrieve the calculated value rather than the formula itself, then use the cell's `getCalculatedValue()` method. This is further explained in .
199
200 ```php
201 // Get the value fom cell A4
202 $cellValue = $objPHPExcel->getActiveSheet()->getCell('A4')
203     ->getCalculatedValue();
204 ```
205
206 Alternatively, if you want to see the value with any cell formatting applied (e.g. for a human-readable date or time value), then you can use the cell's `getFormattedValue()` method.
207
208 ```php
209 // Get the value fom cell A6
210 $cellValue = $objPHPExcel->getActiveSheet()->getCell('A6')
211     ->getFormattedValue();
212 ```
213
214
215 ### Setting a cell value by column and row
216
217 Setting a cell value by coordinate can be done using the worksheet's `setCellValueByColumnAndRow()` method.
218
219 ```php
220 // Set cell B5 with a string value
221 $objPHPExcel->getActiveSheet()->setCellValueByColumnAndRow(1, 5, 'PHPExcel');
222 ```
223
224 **Note** that column references start with '0' for column 'A', rather than from '1'.
225
226 ### Retrieving a cell value by column and row
227
228 To retrieve the value of a cell, the cell should first be retrieved from the worksheet using the getCellByColumnAndRow method. A cell’s value can be read again using the following line of code:
229
230 ```php
231 // Get the value fom cell B5
232 $cellValue = $objPHPExcel->getActiveSheet()->getCellByColumnAndRow(1, 5)
233     ->getValue();
234 ```
235 If you need the calculated value of a cell, use the following code. This is further explained in .
236
237 ```php
238 // Get the value fom cell A4
239 $cellValue = $objPHPExcel->getActiveSheet()->getCellByColumnAndRow(0, 4)
240     ->getCalculatedValue();
241 ```
242
243 ### Retrieving a range of cell values to an array
244
245 It is also possible to retrieve a range of cell values to an array in a single call using the `toArray()`, `rangeToArray()` or `namedRangeToArray()` methods.
246
247 ```php
248 $dataArray = $objPHPExcel->getActiveSheet()
249     ->rangeToArray(
250         'C3:E5',     // The worksheet range that we want to retrieve
251         NULL,        // Value that should be returned for empty cells
252         TRUE,        // Should formulas be calculated (the equivalent of getCalculatedValue() for each cell)
253         TRUE,        // Should values be formatted (the equivalent of getFormattedValue() for each cell)
254         TRUE         // Should the array be indexed by cell row and cell column
255     );
256 ```
257
258 These methods will all return a 2-d array of rows and columns. The `toArray()` method will return the whole worksheet; `rangeToArray()` will return a specified range or cells; while `namedRangeToArray()` will return the cells within a defined `named range`.
259
260 ### Looping through cells
261
262 #### Looping through cells using iterators
263
264 The easiest way to loop cells is by using iterators. Using iterators, one can use foreach to loop worksheets, rows within a worksheet, and cells within a row.
265
266 Below is an example where we read all the values in a worksheet and display them in a table.
267
268 ```php
269 $objReader = PHPExcel_IOFactory::createReader('Excel2007');
270 $objReader->setReadDataOnly(TRUE);
271 $objPHPExcel = $objReader->load("test.xlsx");
272
273 $objWorksheet = $objPHPExcel->getActiveSheet();
274
275 echo '<table>' . PHP_EOL;
276 foreach ($objWorksheet->getRowIterator() as $row) {
277     echo '<tr>' . PHP_EOL;
278     $cellIterator = $row->getCellIterator();
279     $cellIterator->setIterateOnlyExistingCells(FALSE); // This loops through all cells,
280                                                        //    even if a cell value is not set.
281                                                        // By default, only cells that have a value 
282                                                        //    set will be iterated.
283     foreach ($cellIterator as $cell) {
284         echo '<td>' . 
285              $cell->getValue() . 
286              '</td>' . PHP_EOL;
287     }
288     echo '</tr>' . PHP_EOL;
289 }
290 echo '</table>' . PHP_EOL;
291 ```
292
293 Note that we have set the cell iterator's `setIterateOnlyExistingCells()` to FALSE. This makes the iterator loop all cells within the worksheet range, even if they have not been set.
294
295 The cell iterator will return a __NULL__ as the cell value if it is not set in the worksheet.
296 Setting the cell iterator's setIterateOnlyExistingCells() to FALSE will loop all cells in the worksheet that can be available at that moment. This will create new cells if required and increase memory usage! Only use it if it is intended to loop all cells that are possibly available.
297
298 #### Looping through cells using indexes
299
300 One can use the possibility to access cell values by column and row index like (0,1) instead of 'A1' for reading and writing cell values in loops.
301
302 Note: In PHPExcel column index is 0-based while row index is 1-based. That means 'A1' ~ (0,1)
303
304 Below is an example where we read all the values in a worksheet and display them in a table.
305
306 ```php
307 $objReader = PHPExcel_IOFactory::createReader('Excel2007');
308 $objReader->setReadDataOnly(TRUE);
309 $objPHPExcel = $objReader->load("test.xlsx");
310
311 $objWorksheet = $objPHPExcel->getActiveSheet();
312 // Get the highest row and column numbers referenced in the worksheet
313 $highestRow = $objWorksheet->getHighestRow(); // e.g. 10
314 $highestColumn = $objWorksheet->getHighestColumn(); // e.g 'F'
315 $highestColumnIndex = PHPExcel_Cell::columnIndexFromString($highestColumn); // e.g. 5
316
317 echo '<table>' . "\n";
318 for ($row = 1; $row <= $highestRow; ++$row) {
319     echo '<tr>' . PHP_EOL;
320     for ($col = 0; $col <= $highestColumnIndex; ++$col) {
321         echo '<td>' . 
322              $objWorksheet->getCellByColumnAndRow($col, $row)
323                  ->getValue() . 
324              '</td>' . PHP_EOL;
325     }
326     echo '</tr>' . PHP_EOL;
327 }
328 echo '</table>' . PHP_EOL;
329 ```
330
331 Alternatively, you can take advantage of PHP's "Perl-style" character incrementors to loop through the cells by coordinate:
332
333 ```php
334 $objReader = PHPExcel_IOFactory::createReader('Excel2007');
335 $objReader->setReadDataOnly(TRUE);
336 $objPHPExcel = $objReader->load("test.xlsx");
337
338 $objWorksheet = $objPHPExcel->getActiveSheet();
339 // Get the highest row number and column letter referenced in the worksheet
340 $highestRow = $objWorksheet->getHighestRow(); // e.g. 10
341 $highestColumn = $objWorksheet->getHighestColumn(); // e.g 'F'
342 // Increment the highest column letter
343 $highestColumn++;
344
345 echo '<table>' . "\n";
346 for ($row = 1; $row <= $highestRow; ++$row) {
347     echo '<tr>' . PHP_EOL;
348     for ($col = 'A'; $col != $highestColumn; ++$col) {
349         echo '<td>' . 
350              $objWorksheet->getCell($col . $row)
351                  ->getValue() . 
352              '</td>' . PHP_EOL;
353     }
354     echo '</tr>' . PHP_EOL;
355 }
356 echo '</table>' . PHP_EOL;
357 ```
358
359 Note that we can't use a <= comparison here, because 'AA' would match as <= 'B', so we increment the highest column letter and then loop while $col != the incremented highest column.
360
361 ### Using value binders to facilitate data entry
362
363 Internally, PHPExcel uses a default PHPExcel_Cell_IValueBinder implementation (PHPExcel_Cell_DefaultValueBinder) to determine data types of entered data using a cell's `setValue()` method (the `setValueExplicit()` method bypasses this check).
364
365 Optionally, the default behaviour of PHPExcel can be modified, allowing easier data entry. For example, a PHPExcel_Cell_AdvancedValueBinder class is available. It automatically converts percentages, number in scientific format, and dates entered as strings to the correct format, also setting the cell's style information. The following example demonstrates how to set the value binder in PHPExcel:
366
367 ```php
368 /** PHPExcel */
369 require_once 'PHPExcel.php';
370
371 // Set value binder
372 PHPExcel_Cell::setValueBinder( new PHPExcel_Cell_AdvancedValueBinder() );
373
374 // Create new PHPExcel object
375 $objPHPExcel = new PHPExcel();
376
377 // ...
378 // Add some data, resembling some different data types
379 $objPHPExcel->getActiveSheet()->setCellValue('A4', 'Percentage value:');
380 // Converts the string value to 0.1 and sets percentage cell style
381 $objPHPExcel->getActiveSheet()->setCellValue('B4', '10%');
382
383 $objPHPExcel->getActiveSheet()->setCellValue('A5', 'Date/time value:');
384 // Converts the string value to an Excel datestamp and sets the date format cell style
385 $objPHPExcel->getActiveSheet()->setCellValue('B5', '21 December 1983');  
386 ```
387
388 __Creating your own value binder is easy.__  
389 When advanced value binding is required, you can implement the PHPExcel_Cell_IValueBinder interface or extend the PHPExcel_Cell_DefaultValueBinder or PHPExcel_Cell_AdvancedValueBinder classes.
390