Beginning PHP 5.3 phần 5 pot

Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (660.16 KB, 85 trang )

Chapter 11: Working with Files and Directories
303
file_put_contents() — Writes a whole string to a file without needing to open it

fpassthru() — Displays the contents of an open file

readfile() — Displays the contents of a file without needing to open it

fseek() — Moves the file pointer to a specific location within an open file

ftell() — Returns the position of the file pointer

rewind() — Moves the file pointer to the start of the file
As you can see, PHP gives you many different ways to read and write to files, so you can always find a
function to suit your needs!
Reading and Writing Strings of Characters
The fread() function can be used to read a string of characters from a file. It takes two arguments: a file
handle and the number of characters to read. The function reads the specified number of characters (or
less if the end of the file is reached) and returns them as a string. For example:

$handle = fopen( “data.txt”, “r” );
$data = fread( $handle, 10 );

This code reads the first ten characters from data.txt and assigns them to $data as a string.
When working with binary files a character is always one byte long, so ten characters equals ten bytes.
However, this doesn ’ t apply when working with Unicode files, where each character may take up several
bytes. In this case, reading ten characters may in fact result in reading, say, twenty bytes from the file.
After
fread() has finished, the file pointer, which holds the current position in the file, moves forward
in the file by the number of characters read. So after the previous example code runs, the file pointer
moves forward to ten characters after the start of the file. If you repeat the same call to

fread() , you ’ ll
get the next ten characters in the file. If there are less than ten characters left to read in the file,
fread()
simply reads and returns as many as there are. By the way, if you want to read only one character at a
time you can use the
fgetc() function. fgetc() takes a single argument — a file handle — and returns
just one character from the file it points to; it returns
false when it reaches the end of the file:
$one_char = fgetc( $handle );

However, fgetc() is slow when working with large files. It ’ s faster to read a bunch of characters at once
using
fread() , or one of the other file - reading functions mentioned in this chapter.
You can use the
fwrite() function to write data to a file. It requires two arguments: a file handle and a
string to write to the file. The function writes the contents of the string to the file, returning the number
of characters written (or
false if there ’ s an error). For example:
$handle = fopen( “data.txt”, “w” );
fwrite( $handle, “ABCxyz” );

❑
❑
❑
❑
❑
❑
c11.indd 303c11.indd 303 9/21/09 9:10:12 AM9/21/09 9:10:12 AM
304
Part III: Using PHP in Practice

The first line opens the file data.txt for writing, which erases any existing data in the file. (If the file
doesn ’ t exist, PHP attempts to create it.) The second line writes the character string
“ ABCxyz ” to the
beginning of the file. As with
fread() , the file pointer moves to the position after the written string; if
you repeat the second line,
fwrite() appends the same six characters again, so that the file contains the
characters
“ ABCxyzABCxyz ” .
You can limit the number of characters written by specifying an integer as a third argument. The
function stops writing after that many characters (or when it reaches the end of the string, whichever
occurs first). For example, the following code writes the first four characters of
“ abcdefghij ” (that is,

“ abcd “ ) to the file:
fwrite( $handle, “abcdefghij”, 4 );

Try It Out A Simple Hit Counter
One very popular use for Web scripts is a hit counter, which is used to show how many times a Web
page has been visited and therefore how popular the Web site is. Hit counters come in different forms,
the simplest of which is a text counter. Here’s a simple script for such a counter:
<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Strict//EN”
“ /><html xmlns=” xml:lang=”en” lang=”en”>
<head>
<title>Hit counter</title>
<link rel=”stylesheet” type=”text/css” href=”common.css” />
</head>
<body>

<h1>A simple hit counter</h1>

<?php

$counterFile = “./count.dat”;

if ( !file_exists( $counterFile ) ) {
if ( !( $handle = fopen( $counterFile, “w” ) ) ) {
die( “Cannot create the counter file.” );
} else {
fwrite( $handle, 0 );
fclose( $handle );
}
}

if ( !( $handle = fopen( $counterFile, “r” ) ) ) {
die( “Cannot read the counter file.” );
}

$counter = (int) fread( $handle, 20 );
fclose( $handle );

$counter++;
c11.indd 304c11.indd 304 9/21/09 9:10:12 AM9/21/09 9:10:12 AM
Chapter 11: Working with Files and Directories
305
echo “<p>You’re visitor No. $counter.</p>”;

if ( !( $handle = fopen( $counterFile, “w” ) ) ){
die( “Cannot open the counter file for writing.” );
}

fwrite( $handle, $counter );
fclose( $handle );

?>

</body>
</html>
Save this script as hit_counter.php and give it a try. Figure 11-1 shows a sample run.
Figure 11-1
To start with, you’ll see “You’re visitor No. 1.” If you now reload the page, you’ll see the counter
change to 2. Each time you reload, the counter increments by 1.
How It Works
After displaying a page header, the script stores the filename of the file that will hold the hit count:
$counterFile = “./count.dat“;
Next, the script checks to see if the counter file exists. If it doesn’t, it is created by opening the file for
writing, writing a zero to it (thereby initializing the hit count to zero), then closing it:
if ( !file_exists( $counterFile ) ) {
if ( !( $handle = fopen( $counterFile, “w” ) ) ) {
die( “Cannot create the counter file.” );
} else {
fwrite( $handle, 0 );
fclose( $handle );
}
}
c11.indd 305c11.indd 305 9/21/09 9:10:13 AM9/21/09 9:10:13 AM
306
Part III: Using PHP in Practice
Next the counter file is opened for reading:
if ( !( $handle = fopen( $counterFile, “r” ) ) ) {

die( “Cannot read the counter file.” );
}
The script now uses the file handle to read the hit counter value from the open file. As you can see, the
script calls
fread() to read up to 20 bytes from the data file (enough to store a very large integer):
$counter = (int) fread( $handle, 20 );
Because fread() returns a string value, and the counter needs to be an integer value, the return value
is cast into an integer using
(int). (See Chapter 3 for more on type casting.)
The call to
fclose() closes the file referenced by the file handle $handle, freeing up the file for
reading or writing by other processes:
fclose( $handle );
After closing the data file, the script increments the counter and tells the visitor how many times the
page has been accessed:
$counter++;
echo “<p>You’re visitor No. $counter.</p>”;
Next the script writes the new counter value back to the data file. To do this it opens the file in write
mode (
w), then calls fwrite() to write the $counter variable’s value to the file, followed by
fclose() to close the open file again:
if ( !( $handle = fopen( $counterFile, “w” ) ) ){
die( “Cannot open the counter file for writing.” );
}

fwrite( $handle, $counter );
fclose( $handle );

Testing for the End of a File
The feof() function serves a single, simple purpose: it returns true when the file pointer has reached the

end of the file (or if an error occurs) and returns
false otherwise. It takes just one argument — the file
handle to test. Notice that
feof() only returns true once the script has tried to read one or more
characters past the last character in the file:

// hello_world.txt contains the characters “Hello, world!”
$handle = fopen( “hello_world.txt”, “r” );
$hello = fread( $handle, 13 );
echo $hello . “ < br / > ”; // Displays “Hello, world!”
echo feof( $handle ) . “ < br / > ”; // Displays “” (false)
$five_more_chars = fread( $handle, 5 );
c11.indd 306c11.indd 306 9/21/09 9:10:13 AM9/21/09 9:10:13 AM
Chapter 11: Working with Files and Directories
307
echo $five_more_chars . “ < br / > ”; // Displays “” (or possibly a newline)
echo feof( $handle ) . “ < br / > ”; // Displays “1” (true)
fclose( $handle );

feof() is useful with fread() or fgetc() in a while loop when you don ’ t know how long the file is:
// hello_world.txt contains the characters “Hello, world!”
$handle = fopen( “hello_world.txt”, “r” );
$text = “”;

while ( !feof( $handle ) ) {
$text .= fread( $handle, 3 ); // Read 3 chars at a time
}

echo $text . “ < br / > ”; // Displays “Hello, world!”
fclose( $handle );

Reading One Line at a Time
Often it ’ s useful to read text from a file one line at a time. A line is a nice manageable chunk of text to
process or display. For example, data files and configuration files often contain one chunk of information
per line, such as a data record or a configuration setting.
To read a line of text from an open file, call the
fgets() function, passing in the file handle. The function
reads from the current file pointer to the end of the current line, and returns the read characters as a
string (or
false if there was a problem, such as the end of the file being reached). Note that any end - of -
line character (or characters) at the end of the line is also included in the string.
You can limit the number of characters read by passing in a second, integer argument, in which case

fgets() stops when it reaches that number of characters minus one (unless the end of the line is
reached first). It ’ s a good idea to include this argument when reading large files that might not contain
line breaks.
The following example uses
fgets() to read and display a three - line text file, one line at a time. The

while loop exits when fgets() returns false (which means it ’ s reached the end of the file):
/*
milton.txt contains:
The mind is its own place, and in it self
Can make a Heav’n of Hell, a Hell of Heav’n.
What matter where, if I be still the same,
*/

$handle = fopen( “milton.txt”, “r” );
$lineNumber = 1;

while ( $line = fgets( $handle ) ) {
echo $lineNumber++ . “: $line < br / > ”;
}

fclose( $handle );

c11.indd 307c11.indd 307 9/21/09 9:10:14 AM9/21/09 9:10:14 AM
308
Part III: Using PHP in Practice
The code produces the following output:
1: The mind is its own place, and in it self
2: Can make a Heav’n of Hell, a Hell of Heav’n.
3: What matter where, if I be still the same,

Reading CSV Files
If you ’ ve ever done any work with importing and exporting data, you probably know about the comma -
separated - value (CSV) data format. (CSV even has its own file extension:
.csv .) In CSV files, each data
record sits on its own line, and the fields within each record are separated by commas. String values are
often enclosed within double quotes:

“John”,”Smith”,45
“Anna”,”Clark”,37
“Bill”,”Murphy”,32

To read CSV files, you can use fgetcsv() . This function reads a line of CSV - formatted data from an
open file starting from the position of the file pointer, and puts the data it finds into an array, with one
field value per array element. Once you have an array of data you can easily manipulate it.
To call the
fgetcsv() function, pass it the file handle of an open file. You can also optionally specify:

The maximum number of characters to read. You can leave this value out, or use 0, in which case
PHP reads as many characters as necessary to read the whole line. However, specifying a value
makes the function slightly quicker
The delimiter that is used to separate each data value. The default is the comma (
, ). If you ’ re
reading a tab - separated - value (TSV) file, specify
“ \t ” (the tab character) for this argument
instead
The character that is used to enclose string values. The default is the double quote (
“ )
The character used to escape special characters. The default is the backslash (
\ )

fgetcsv() returns false if there was a problem reading the line, or if the end of the file has been
reached.
The following code snippet shows how you might retrieve three lines of data from a file in CSV format:

/*
people.csv contains:
“John”,”Smith”,45
“Anna”,”Clark”,37
“Bill”,”Murphy”,32
*/

$handle = fopen( “people.csv”, “r” );
while ( $record = fgetcsv( $handle, 1000 ) ) {
echo “Name: {$record[0]} {$record[1]}, Age: {$record[2]} < br / > ”;
}

fclose( $handle );

❑
❑
❑
❑
c11.indd 308c11.indd 308 9/21/09 9:10:14 AM9/21/09 9:10:14 AM
Chapter 11: Working with Files and Directories
309
This code displays:
Name: John Smith, Age: 45
Name: Anna Clark, Age: 37
Name: Bill Murphy, Age: 32

PHP 5.3 introduces a new function, str_getcsv(), that reads CSV data from a string instead of from
a file. This is handy if you already have your CSV data in memory. For details see

.net/manual/en/function.str-getcsv.php.
Reading and Writing Entire Files
Writing code to read a file line by line, or string by string, can be tedious. Fortunately, PHP provides you
with some functions that can access the complete contents of a file in one go. These include:

file() — For reading a whole file into an array, without needing to open it

file_get_contents() and file_put_contents() — For reading and writing the contents of
a file without needing to open it

fpassthru() — For displaying the contents of an open file

readfile() — For displaying the contents of a file without needing to open it
Because these functions read the entire file into memory in one go, they should really be used for

relatively small files (a few MB at most). If you ’ re working with a 100MB text file, it ’ s probably best to
use
fread() or fgets() to read and process the file in chunks.

file() reads the contents of a file into an array, with each element containing a line from the file. It
takes just one argument — a string containing the name of the file to read — and returns the array
containing the lines of the file:

$lines = file( “/home/chris/myfile.txt” );

The newline character remains attached at the end of each line stored in the array.
This function, like most of the others described in this section, doesn ’ t require you to specify a file
handle. All you need to do is pass in the filename of the file to read. The function automatically opens,
reads, and, once it ’ s done, closes the file.
You can optionally specify some useful flags as the second parameter to
file() :
Flag Description

FILE_USE_INCLUDE_PATH Look for the file in the include path (see Chapter 20 for more on
include paths)

FILE_IGNORE_NEW_LINES Remove newline characters from the end of each line in the array

FILE_SKIP_EMPTY_LINES Ignore empty lines in the file
❑
❑
❑
❑
c11.indd 309c11.indd 309 9/21/09 9:10:14 AM9/21/09 9:10:14 AM
310

Part III: Using PHP in Practice
As with other flags in PHP you can combine any of these flags with the bitwise OR operator (see Chapter 3
for details). For example, the following code looks for a file in the include path and, when found, reads
the file, ignoring any empty lines in the file:

$lines = file( “myfile.txt”, FILE_USE_INCLUDE_PATH | FILE_SKIP_EMPTY_LINES );

As with fopen() , you can also use file() to fetch files on a remote host:
$lines = file( “ );
foreach ( $lines as $line ) echo $line . “ < br / > ”;

A related function is file_get_contents() . This does a similar job to file() , but it returns the
file contents as a single string, rather than an array of lines. The end - of - line characters are included in
the string:

$fileContents = file_get_contents( “myfile.txt” );

If there was a problem reading the file, file_get_contents() returns false .
You can pass the
FILE_USE_INCLUDE_PATH flag (described earlier) as the second argument to
file_get_contents().
You can also optionally pass in an offset and/or a length parameter to determine where you want the file
reading to start, and how many characters you want to read. For example, the following code reads 23
characters from
myfile.txt , starting at character 17:
$fileContents = file_get_contents( “myfile.txt”, null, null, 17, 23 );

The first null argument avoids setting the FILE_USE_INCLUDE_PATH flag, and the second null
argument avoids setting a context. Contexts are out of the scope of this book, but you can find out more
about them in the online manual at

.

file_put_contents() is the complement to file_get_contents() . As you ’ d imagine, it takes a
string and writes it to a file:

$numChars = file_put_contents( “myfile.txt”, $myString );

The function returns the number of characters written, or false if there was a problem. You can affect the
behavior of the function by passing various flags as the third argument.
file_put_contents() supports
the same flags as
file_get_contents() , as well as two additional flags:
Flag Description

FILE_APPEND If the file already exists, append the string to the end of the file, rather than
overwriting the file.

LOCK_EX Lock the file before writing to it. This ensures that other processes can ’ t write to
the file at the same time.
c11.indd 310c11.indd 310 9/21/09 9:10:15 AM9/21/09 9:10:15 AM
Chapter 11: Working with Files and Directories
311
You can also lock files that are opened using fopen() . To do this, use flock() . See http://www
.php.net/manual/en/function.flock.php
for more details.

fpassthru() and readfile() both take a file and output its unmodified contents straight to the Web
browser.
fpassthru() requires the handle of an open file to work with:
$numChars = fpassthru( $handle );

readfile() instead works on an unopened file:
$numChars = readfile( “myfile.txt” );

As you can see, both functions return the number of characters read (or false if there was a problem).

fpassthru() reads from the current file pointer position, so if you ’ ve already read some of the file only
the remaining portion of the file will be sent.
You can make
readfile() search the include path for the file by passing true as the second argument.
Incidentally,
readfile() is handy for sending binary files — such as images and PDF documents — to
the Web browser for displaying or downloading. You see an example of this in Chapter 16.
Random Access to File Data
Using the functions you ’ ve met so far, you can only manipulate data sequentially, that is, in the same
order that it is arranged in the file. However, sometimes you need to skip around the contents of an open
file. For example, you might want to read a file once to search for a particular string, then return to the
start of the file in order to search for another string. Of course, this is easy if you ’ ve read the entire file
using, for example,
file_get_contents() . However, this isn ’ t practical for large files.
Fortunately, it ’ s possible to move the file pointer around within an open file, so that you can start
reading or writing at any point in the file. PHP gives you three functions that let you work with the file
pointer:

fseek() — Repositions the file pointer to a specified point in the file

rewind() — Moves the file pointer to the start of the file

ftell() — Returns the current position of the file pointer
❑

❑
❑
c11.indd 311c11.indd 311 9/21/09 9:10:15 AM9/21/09 9:10:15 AM
312
Part III: Using PHP in Practice
To use fseek() , pass the handle of the open file, and an integer offset. The file pointer moves to the
specified number of characters from the start of the file (use zero to move the pointer to the first
character). For example, the following code moves the pointer to the eighth character in the file (that is,
seven characters after the first character) and displays the next five characters from that point:

// hello_world.txt contains the characters “Hello, world!”
$handle = fopen( “hello_world.txt”, “r” );
fseek( $handle, 7 );
echo fread( $handle, 5 ); // Displays “world”
fclose( $handle );

To specify how the offset is calculated, you can add a third optional argument containing one of the
following constants:

SEEK_SET — Sets the pointer to the beginning of the file plus the specified offset (the default
setting)

SEEK_CUR — Sets the pointer to the current position plus the specified offset

SEEK_END — Sets the pointer to the end of the file plus the specified offset (use with a negative
offset)

fseek() returns 0 if the pointer was successfully positioned, or - 1 if there was a problem.
You can ’ t use this function with files on remote hosts opened via HTTP or FTP (for example,
fopen( “ ” )).

If you want to move the pointer back to the start of the file (a common occurrence), a handy shortcut is
the
rewind() function. The following two lines of code both do the same thing:
fseek( $handle, 0 );
rewind( $handle );

The ftell() function takes a file handle and returns the current offset (in characters) of the
corresponding file pointer from the start of the file. For example:

$offset = ftell( $handle );

As you saw earlier, the fpassthru() function outputs file data from the current file position onward. If you
have already read data from an open file but want to output the file ’ s entire contents, call
rewind() first.
Working with File Permissions
File system permissions determine what different users can do with each file and directory in the file
system. For example, whereas one user might have permission to read and write to a file, another user
may only be allowed to read the file. A third user might not even be allowed to do that.
❑
❑
❑
c11.indd 312c11.indd 312 9/21/09 9:10:16 AM9/21/09 9:10:16 AM
Chapter 11: Working with Files and Directories
313
Permissions generally won ’ t affect you much when writing PHP scripts, because PHP usually does the
right thing behind the scenes. For example, if you create a new file for writing, PHP automatically gives
that file read and write permission for the user that ’ s running your PHP script (usually the Web server
user). If you create a new directory, PHP gives the directory read, write, and execute permission for all
users by default, meaning that anyone can create and delete files within that directory.
In this section you explore PHP ’ s

chmod() function, which lets you change the mode (permissions) of a
file or directory. You also take a look at three PHP functions that let you determine if a file or directory is
readable, writable, or executable by the current user.
Changing Permissions
PHP ’ s chmod() function is used to change the mode, or permissions, of a file or directory. It functions
much like the UNIX
chmod command.
This section applies mainly to UNIX - based Web servers such as Linux and Mac OS X. Windows
servers do not have a concept of file and directory modes. Instead, you use Windows Explorer to set
access permissions on files and folders by right - clicking the item, choosing Properties, then clicking the
Security tab. You need to be an administrator to make these changes. If you ’ re running your PHP
scripts on a shared Windows server, and you need to set permissions on a certain file or folder, ask your
hosting company for help. Often they ’ ll do it for you, or point you to a Web - based control panel where
you can do it yourself.
To change a file ’ s permissions with
chmod() , pass it the filename and the new mode to use.
For example, to set a file ’ s mode to 644, use:
chmod( “myfile.txt”, 0644 );

The 0 (zero) before the 644 is important, because it tells PHP to interpret the digits as an octal number.

chmod() returns true if the permission change was successful, and false if it failed (for example,
you ’ re not the owner of the file).
So how do file modes work? Here ’ s a quick primer.
File modes are usually expressed as octal numbers containing three digits. The first digit determines
what the file ’ s owner – – usually the user that created the file — can do with the file. The second digit
determines what users in the file ’ s group — again, usually the group of the user that created the file —
can do with it. Finally, the last digit dictates what everyone else can do with the file.
The value of each digit represents the access permission for that particular class of user, as follows:
Digit Value Permission

0 Cannot read, write to, or execute the file
1 Can only execute the file
2 Can only write to the file
c11.indd 313c11.indd 313 9/21/09 9:10:16 AM9/21/09 9:10:16 AM
314
Part III: Using PHP in Practice
Digit Value Permission
3 Can write to and execute the file
4 Can only read the file
5 Can read and execute the file
6 Can read and write to the file
7 Can read, write to, and execute the file
Here are some commonly used examples to make the concept of file modes clearer:

// Owner can read and write the file; everyone else can just read it:
chmod( “myfile.txt”, 0644 );

// Everyone can read and write the file:
chmod( “myfile.txt”, 0666 );

// Everyone can read and execute the file, but only the owner can write to it:
chmod( “myfile.txt”, 0755 );

// Only the owner can access the file, and they can only read and write to it:
chmod( “myfile.txt”, 0600 );

Note that you can only change the permissions of a file or directory if you own it, or if you ’ re the
super - user (which is highly unlikely for PHP scripts running on a Web server).
So how do modes work with directories? Well, to read the files in a directory, you need to have both read
and execute permissions on that directory. Meanwhile, to create and delete files and subdirectories inside

the directory, you need to have write and execute permissions on the directory.
Checking File Permissions
Before you do something to a file in your script, it can be useful to know what kinds of things your script
can do with the file. PHP provides three handy functions to help you out.
To check if you ’ re allowed to read a file, use
is_readable() , passing in the filename of the file to check.
Similarly, you can check that you ’ re allowed to write to a file with
is_writable() , and see if you can
execute a file with
is_executable() . Each function returns true if the operation is allowed, or false
if it ’ s disallowed. For example:

if ( is_readable( “myfile.txt” ) {
echo “I can read myfile.txt”;
}

if ( is_writable( “myfile.txt” ) {
c11.indd 314c11.indd 314 9/21/09 9:10:16 AM9/21/09 9:10:16 AM
Chapter 11: Working with Files and Directories
315
echo “I can write to myfile.txt”;
}

if ( is_executable( “myfile.txt” ) {
echo “I can execute myfile.txt”;
}

You can also use the fileperms() function to return an integer representing the permissions that are set
on a file or directory. For example, to print the octal value of the permissions on a file you might use:

chmod( “myfile.txt”, 0644 );
echo substr( sprintf( “%o”, fileperms( “myfile.txt”) ), -4 ); // Displays
“0644”

(The call to substr() is used to return just the last four digits, because the other octal digits in the
returned value aren ’ t relevant.)
Copying, Renaming, and Deleting Files
PHP also lets you copy, rename, and delete files. The functions to perform these operations are copy() ,

rename() , and unlink() , respectively.
The
copy() function takes two string arguments: the first argument is the path to the file to copy,
and the second argument is the path to copy it to. It returns
true if the file was successfully copied, or

false if there was a problem copying the file. The following example copies the source file copyme.txt
to the destination file
copied.txt in the same folder:
copy( “./copyme.txt”, “./copied.txt” );

The rename() function is used to rename (or move) a file. It works in much the same way as copy() .
For example, to rename a file within a folder you could use:

rename( “./address.dat”, “./address.backup” );

To move a file to a different folder, you might use:
rename( “/home/joe/myfile.txt”, “/home/joe/archives/myfile.txt” );

The unlink() function lets you delete files from the server. To use it, pass the filename of the file you
want to delete. For example, if you wanted to say adi ó s to the file

trash.txt in the current directory,
you could write:

unlink( “./trash.txt” );

copy() , rename() , and unlink() raise warning - level errors if the file or directory in question can ’ t be
found. Make sure the file or directory exists first (for example, by using
file_exists() ) to avoid such
errors.
c11.indd 315c11.indd 315 9/21/09 9:10:16 AM9/21/09 9:10:16 AM
316
Part III: Using PHP in Practice
Working with Directories
PHP lets you work with directories in much the same way as files, using a variety of equivalent
functions. Some directory functions use a directory handle, whereas others use a string containing the
name of the directory with which you want to work. A directory handle is similar to a file handle; it ’ s a
special variable pointing to a directory, which you can obtain via the
opendir() function:
$handle = opendir( “/home/james” );

If there ’ s a problem opening the directory (for example, if the directory doesn ’ t exist), opendir()
returns
false instead of the directory handle. As you may have guessed, you can close a directory by
passing the directory handle to the function
closedir() :
closedir( $handle );

The readdir() function expects a directory handle for an opened directory, and returns the filename
of the next entry in the directory:

$filename = readdir( $handle );

Each directory contains a list of entries for each of the files and subdirectories inside it, as well as entries
for
. (representing the directory) and (the parent of the directory). PHP maintains an internal pointer
referring to the next entry in the list, just as a file pointer points to the position in a file where the next
file operation should occur.
Try It Out List Directory Entries
Here’s how to set up a loop to get all the files and folders inside a specified directory. Save the
following script as
dir_list.php in your document root folder. Now change the $dirPath variable
in the file so that it contains the path to a real directory on your Web server. Open the script’s URL in
your Web browser to test it.
<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Strict//EN”
“ /><html xmlns=” xml:lang=”en” lang=”en”>
<head>
<title>Listing the contents of a directory</title>
<link rel=”stylesheet” type=”text/css” href=”common.css” />
</head>
<body>
<h1>Listing the contents of a directory</h1>

<?php

$dirPath = “/home/matt/images”;
if ( !( $handle = opendir( $dirPath ) ) ) die( “Cannot open the directory.” );

?>
<p><?php echo $dirPath ?> contains the following files and folders:</p>
<ul>

c11.indd 316c11.indd 316 9/21/09 9:10:17 AM9/21/09 9:10:17 AM
Chapter 11: Working with Files and Directories
317
<?php

while ( $file = readdir( $handle ) ) {
if ( $file != “.” && $file != “ ” ) echo “<li>$file</li>”;
}

closedir( $handle );

?>
</ul>
</body>
</html>
Figure 11-2 shows an example result.
Figure 11-2
How It Works
After displaying the page header and storing the path to the directory to scan in the $dirPath
variable, the script gets a handle on the directory:
if ( !( $handle = opendir( $dirPath ) ) ) die( “Cannot open the directory.” );
If the directory was successfully opened, its name is displayed in the page and an unordered list (ul)
HTML element is started. Next the script uses
readdir() to loop through each entry in the directory
and, as long as the entry isn’t
“.” or “ ”, display it. The loop exits when readdir() returns false,
which occurs when the list of entries is exhausted:
while ( $file = readdir( $handle ) ) {
if ( $file != “.” && $file != “ ” ) echo “<li>$file</li>“;
}

Finally, the script calls closedir() to close the directory, then finishes off the markup for the list and
the page.
c11.indd 317c11.indd 317 9/21/09 9:10:17 AM9/21/09 9:10:17 AM
318
Part III: Using PHP in Practice
You can see that the returned filenames are not sorted in any way. To sort them, first read the entries
into an array:
$filenames = array();
while ( $file = readdir( $handle ) ) $filenames[] = $file;
closedir( $handle );
The $filenames array now contains every entry in the directory. Now you can call sort() to arrange
the array elements in ascending order, then loop through the array displaying all except the
“.” and
“ ” entries:
sort( $filenames );

foreach ( $filenames as $file ) {
if ( $file != “.” && $file != “ ” ) {
echo “<li>$file</li>“;
}
}

Other Directory Functions
Just as with files, PHP provides a range of ways to manipulate directories, including the following
functions:

rewinddir() — Moves the directory pointer back to the start of the list of entries

chdir() — Changes the current directory

mkdir() — Creates a directory

rmdir() — Deletes a directory

dirname() — Returns the directory portion of a path
Resetting the Directory Pointer
The rewinddir() function resets PHP ’ s internal pointer back to the first entry in a given directory. This
function is the directory counterpart to the
rewind() function for files. To use rewinddir() , pass an
open directory handle to it, as follows:

rewinddir( $handle );

Changing the Current Directory
The chdir() function call changes the current directory to a new directory:
chdir( “/home/matt/myfolder” );

❑
❑
❑
❑
❑
c11.indd 318c11.indd 318 9/21/09 9:10:18 AM9/21/09 9:10:18 AM
Chapter 11: Working with Files and Directories
319
chdir() returns true if PHP managed to change to the specified directory, or false if there was an
error (such as the directory not being found).
The current directory is the directory where PHP first looks for files. If you specify a path that isn ’ t an
absolute or relative path, PHP looks for the file inside the current directory. So the following code

chdir( “/home/matt/myfolder” );
$handle = fopen( “myfile.txt” );

opens the same myfile.txt file as:
$handle = fopen( “/home/matt/myfolder/myfile.txt” );

The current directory is also used as the base directory for relative file paths. For example:
chdir( “/home/joe/images” );
$handle = fopen( “ /myfile.txt” ); // Looks for myfile.txt in /home/joe

Usually the current directory defaults to the directory containing the running script. You can retrieve the
current directory by calling
getcwd() :
chdir( “/home/matt/newfolder” );
echo getcwd(); // Displays “/home/matt/newfolder”

Creating Directories
To create a new directory, call the mkdir() function, passing in the path of the directory you want to create:
mkdir( “/home/matt/newfolder” );

Note that the parent directory has to exist already ( “ /home/matt ” in the example just shown) for the
function to work.
mkdir() returns true if the directory was created, or false if there was a problem.
You can also set permissions for the directory at the time you create it by passing the mode as the second
argument. This works much like using
chmod() — see the “ Changing Permissions ” section earlier in the
chapter for details. For example, the following code creates a directory with read, write, and execute
permissions granted to all users:

mkdir( “/home/matt/newfolder”, 0777 );

File and directory modes only work on UNIX systems such as Linux and Mac OS; they have no effect
when used on Windows machines.
Deleting Directories
The rmdir() function removes a given directory. The directory must be empty, and you need
appropriate permissions to remove it. For example:

rmdir( “/home/matt/myfolder” );

If PHP can ’ t remove the directory — for example, because it ’ s not empty — rmdir() returns false ;
otherwise it returns
true .
c11.indd 319c11.indd 319 9/21/09 9:10:18 AM9/21/09 9:10:18 AM
320
Part III: Using PHP in Practice
Getting the Directory Path
The dirname() function returns the directory part of a given path. It complements the basename()
function, which returns the filename portion of a given path (see the section “ Retrieving a Filename from
a Path ” earlier in the chapter).
For example:

$path = “/home/james/docs/index.html”;
$directoryPath = dirname( $path );
$filename = basename( $path );

After running this code., $directoryPath contains “ /home/james/docs ” , and $filename holds

“ index.html ”.
Working with Directory Objects
PHP offers an alternative object - oriented mechanism for working with directories: the Directory class.
To use it, first create a

Directory object by calling the dir() function with the name of the directory
you want to work with, as follows:

$dir = dir( “/home/james/docs” );

The Directory object provides two properties: handle and path . These refer to the directory handle
and the path to the directory, respectively:

echo $dir- > handle . “ < br / > ”; // Displays the directory handle
echo $dir- > path . “ < br / > ”; // Displays “/home/james/docs”

You can use the handle property with other directory functions such as readdir() , rewinddir() ,
and
closedir() , just as if you were using a regular directory handle.
The
Directory object supports three methods — read() , rewind() , and close() — which are
functionally equivalent to
readdir() , rewinddir() , and closedir() , respectively. For example, you
can rewrite the
dir_list.php script from earlier in the chapter using a Directory object:
< !DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Strict//EN”
“ >
< html xmlns=” xml:lang=”en” lang=”en” >
< head >
< title > Listing the contents of a directory < /title >
< link rel=”stylesheet” type=”text/css” href=”common.css” / >
< /head >
< body >
< h1 > Listing the contents of a directory < /h1 >

< ?php

$dirPath = “/home/matt/images”;
$dir = dir( $dirPath );

? >
c11.indd 320c11.indd 320 9/21/09 9:10:19 AM9/21/09 9:10:19 AM
Chapter 11: Working with Files and Directories
321
< p > < ?php echo $dirPath ? > contains the following files and folders: < /p >
< ul >
< ?php

while ( $file = $dir- > read() ) {
if ( $file != “.” & & $file != “ ” ) echo “ < li > $file < /li > ”;
}

$dir- > close();

? >
< /ul >
< /body >
< /html >

Telling a File from a Directory
Often you need to know whether a particular file is a regular file or a directory. For example, suppose
you want to write some code that travels down through a tree of folders. You ’ d need to detect when a
file was actually a folder, so you could enter the folder and continue working through the tree. By the
same token, if you want to display the files in a folder, you ’ d need to detect when a file is in fact a
regular file.

Remember: both directories and regular files are all essentially files, but directories are a special kind
of file.
PHP has two functions to help you test for a file or a directory:

is_dir() — Returns true if the given filename refers to a directory

is_file() — Returns true if the given filename refers to a regular file
Here ’ s a simple example that determines if a file called
myfile is a file or a directory:
$filename = “myfile”;

if ( is_dir( $filename ) ) {
echo “$filename is a directory.”;
} elseif ( is_file( $filename ) ) {
echo “$filename is a file.”;
} else {
echo “$filename is neither a directory nor a file.”;
}

❑
❑
c11.indd 321c11.indd 321 9/21/09 9:10:19 AM9/21/09 9:10:19 AM
322
Part III: Using PHP in Practice
Try It Out Traversing a Directory Hierarchy
As you learned in Chapter 7, recursion is particularly useful when a script has to perform repetitive
operations over a set of data of unknown size, and traversing a directory hierarchy is a very good
example.
A directory may hold subdirectories as well as files. If you want to create a script that lists all the files
and subdirectories under a given directory — including subdirectories of subdirectories, and so on —

you need to write a recursive function, as follows:
1. Read the entries in the current directory.
2. If the next entry is a file, display its name.
3. If the next entry is a subdirectory, display its name, then call the function recursively to read the
entries inside it.
As you can see, the third step repeats the whole process by itself, when necessary. The recursion
continues until there are no more subdirectories left to traverse.
To try out this technique, first save the following script as
directory_tree.php. Now change the
$dirPath variable at the top of the script to point to a folder on your Web server’s hard drive, and
open the script’s URL in your Web browser. You should see a page similar to Figure 11-3.
<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Strict//EN”
“ /><html xmlns=” xml:lang=”en” lang=”en”>
<head>
<title>Listing the contents of a directory</title>
<link rel=”stylesheet” type=”text/css” href=”common.css” />
</head>
<body>
<h1>Listing the contents of a directory</h1>

<?php

$dirPath = “/home/matt/images”;

function traverseDir( $dir ) {
echo “<h2>Listing $dir </h2>”;
if ( !( $handle = opendir( $dir ) ) ) die( “Cannot open $dir.” );

$files = array();

while ( $file = readdir( $handle ) ) {
if ( $file != “.” && $file != “ ” ) {
if ( is_dir( $dir . “/” . $file ) ) $file .= “/”;
$files[] = $file;
}
}

sort( $files );
echo “<ul>”;
foreach ( $files as $file ) echo “<li>$file</li>”;
c11.indd 322c11.indd 322 9/21/09 9:10:19 AM9/21/09 9:10:19 AM
Chapter 11: Working with Files and Directories
323
echo “</ul>”;

foreach ( $files as $file ) {
if ( substr( $file, -1 ) == “/” ) traverseDir( “$dir/” . substr( $file,
0, -1 ) );
}

closedir( $handle );
}

traverseDir( $dirPath );

?>
</body>
</html>
Figure 11-3
c11.indd 323c11.indd 323 9/21/09 9:10:20 AM9/21/09 9:10:20 AM

324
Part III: Using PHP in Practice
How It Works
The traverseDir() recursive function traverses the whole directory hierarchy under a specified
directory. First, the function displays the path of the directory it is currently exploring. Then, it opens
the directory with
opendir():
if ( !( $handle = opendir( $dir ) ) ) die( “Cannot open $dir.” );
Next the function sets up a $files array to hold the list of filenames within the directory, then uses
readdir() with a while loop to move through each entry in the directory, adding each filename to
the array as it goes (
”.” and “ ” are skipped). If a particular filename is a directory, a slash (/) is
added to the end of the filename to indicate to the user (and the rest of the function) that the file is in
fact a directory:
$files = array();

while ( $file = readdir( $handle ) ) {
if ( $file != “.” && $file != “ ” ) {
if ( is_dir( $dir . “/” . $file ) ) $file .= “/“;
$files[] = $file;
}
}
Now the array of filenames is sorted alphabetically to aid readability, and the filenames are displayed
in an unordered list:
sort( $files );
echo “<ul>“;
foreach ( $files as $file ) echo “<li>$file</li>“;
echo “</ul>“;
The last part of the function loops through the array again, looking for any directories (where the
filename ends in a slash). If it finds a directory, the function calls itself with the directory path (minus

the trailing slash) to explore the contents of the directory:
foreach ( $files as $file ) {
if ( substr( $file, -1 ) == “/” ) traverseDir( “$dir/” . substr( $file,
0, -1 ) );
}
Finally, the directory handle is closed:
closedir( $handle );
The last line of code in the script kicks off the directory traversal, starting with the path to the initial,
topmost directory:
traverseDir( $dirPath );

c11.indd 324c11.indd 324 9/21/09 9:10:20 AM9/21/09 9:10:20 AM
Chapter 11: Working with Files and Directories
325
Building a Text Editor
With the basics of PHP ’ s file and directory handling capabilities under your belt, it ’ s time to create a
simple Web - based text file editor application. The editor will display a list of text files in a designated
folder, inviting the user to edit a file by clicking its name. The edit page will simply display the file ’ s
contents in an HTML text area field, with buttons for saving changes or canceling edits.
The user will also be able to create new text files to work with. For the sake of simplicity the editor will
only handle text files with the
.txt filename extension.
The Text Editor Script
Here ’ s the code for the text editor. Save it as text_editor.php in your document root folder:
< ?php

define( “PATH_TO_FILES”, “/home/matt/sandbox” );

if ( isset( $_POST[“saveFile”] ) ) {
saveFile();

} elseif ( isset( $_GET[“filename”] ) ) {
displayEditForm();
} elseif ( isset( $_POST[“createFile”] ) ) {
createFile();
} else {
displayFileList();
}

function displayFileList( $message=”” ) {
displayPageHeader();
if ( !file_exists( PATH_TO_FILES ) ) die( “Directory not found” );
if ( !( $dir = dir( PATH_TO_FILES ) ) ) die( “Can’t open directory” );

? >
< ?php if ( $message ) echo ‘ < p class=”error” > ’ . $message . ‘ < /p > ’ ? >
< h2 > Choose a file to edit: < /h2 >
< table cellspacing=”0” border=”0” style=”width: 40em; border: 1px solid
#666;” >
< tr >
< th > Filename < /th >
< th > Size (bytes) < /th >
< th > Last Modified < /th >
< /tr >
< ?php

while ( $filename = $dir- > read() ) {
$filepath = PATH_TO_FILES . “/$filename”;
if ( $filename != “.” & & $filename != “ ” & & !is_dir( $filepath ) & &
strrchr( $filename, “.” ) == “.txt” ) {
echo ‘ < tr > < td > < a href=”text_editor.php?filename=’ . urlencode(

$filename ) . ‘” > ’ . $filename . ‘ < /a
> < /td > ’;
echo ‘ < td > ’ . filesize( $filepath ) . ‘ < /td > ’;
c11.indd 325c11.indd 325 9/21/09 9:10:21 AM9/21/09 9:10:21 AM
326
Part III: Using PHP in Practice
echo ‘ < td > ’ . date( “M j, Y H:i:s”, filemtime( $filepath ) ) .
‘ < /td > < /tr > ’;
}
}

$dir- > close();
? >
< /table >
< h2 > or create a new file: < /h2 >
< form action=”text_editor.php” method=”post” >
< div style=”width: 20em;” >
< label for=”filename” > Filename < /label >
< div style=”float: right; width: 7%; margin-top: 0.7em;” > .txt < /div >
< input type=”text” name=”filename” id=”filename” style=”width: 50%;”
value=”” / >
< div style=”clear: both;” >
< input type=”submit” name=”createFile” value=”Create File” / >
< /div >
< /div >
< /form >
< /body >
< /html >
< ?php
}

function displayEditForm( $filename=”” ) {
if ( !$filename ) $filename = basename( $_GET[“filename”] );
if ( !$filename ) die( “Invalid filename” );
$filepath = PATH_TO_FILES . “/$filename”;
if ( !file_exists( $filepath ) ) die( “File not found” );
displayPageHeader();
? >
< h2 > Editing
< ?php echo $filename ? > < /h2 >
< form action=”text_editor.php” method=”post” >
< div style=”width: 40em;” >
< input type=”hidden” name=”filename” value=” < ?php echo $filename ? > ” / >
< textarea name=”fileContents” id=”fileContents” rows=”20” cols=”80”
style=”width: 100%;” > < ?php
echo htmlspecialchars( file_get_contents( $filepath ) )
? > < /textarea >
< div style=”clear: both;” >
< input type=”submit” name=”saveFile” value=”Save File” / >
< input type=”submit” name=”cancel” value=”Cancel” style=
”margin-right: 20px;” / >
< /div >
< /div >
< /form >
< /body >
< /html >
< ?php
}

file” );
chmod( $filepath, 0666 );
displayEditForm( “$filename” );
}
}

function displayPageHeader() {
? >
< !DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Strict//EN”
“ >
< html xmlns=” xml:lang=”en” lang=”en” >
< head >
< title > A simple text editor < /title >
< link rel=”stylesheet” type=”text/css” href=”common.css” / >
< style type=”text/css” >
.error { background: #d33; color: white; padding: 0.2em; }
th { text-align: left; background-color: #999; }
th, td { padding: 0.4em; }
< /style >
< /head >
< body >
< h1 > A simple text editor < /h1 >
< ?php
}
? >

c11.indd 327c11.indd 327 9/21/09 9:10:21 AM9/21/09 9:10:21 AM

Beginning PHP 5.3 phần 5 pot

Tài liệu liên quan

Tài liệu bạn tìm kiếm đã sẵn sàng tải về