scandir

(PHP 5, PHP 7, PHP 8)

scandir列出指定路径中的文件和目录

说明

scandir ( string $directory , int $sorting_order = ? , resource $context = ? ) : array

返回一个 array,包含有 directory 中的文件和目录。

参数

directory

要被浏览的目录

sorting_order

默认的排序顺序是按字母升序排列。如果使用了可选参数 sorting_order(设为 1),则排序顺序是按字母降序排列。

context

context 参数的说明见手册中的 Streams API 一章。

返回值

成功则返回包含有文件名的 array,如果失败则返回 false。如果 directory 不是个目录,则返回布尔值 false 并生成一条 E_WARNING 级的错误。

更新日志

版本 说明
5.4.0 sorting_order now accepts constants. Any nonzero value caused descending order in previous versions.

范例

Example #1 一个简单的 scandir() 例子

<?php
$dir    
'/tmp';
$files1 scandir($dir);
$files2 scandir($dir1);

print_r($files1);
print_r($files2);
?>

以上例程的输出类似于:

Array
(
    [0] => .
    [1] => ..
    [2] => bar.php
    [3] => foo.txt
    [4] => somedir
)
Array
(
    [0] => somedir
    [1] => foo.txt
    [2] => bar.php
    [3] => ..
    [4] => .
)

Example #2 scandir() 在 PHP 4 中的实现

<?php
$dir 
"/tmp";
$dh  opendir($dir);
while (
false !== ($filename readdir($dh))) {
    
$files[] = $filename;
}

sort($files);

print_r($files);

rsort($files);

print_r($files);

?>

以上例程的输出类似于:

Array
(
    [0] => .
    [1] => ..
    [2] => bar.php
    [3] => foo.txt
    [4] => somedir
)
Array
(
    [0] => somedir
    [1] => foo.txt
    [2] => bar.php
    [3] => ..
    [4] => .
)

注释

Tip

如已启用fopen 包装器,在此函数中, URL 可作为文件名。关于如何指定文件名详见 fopen()。各种 wapper 的不同功能请参见 支持的协议和封装协议,注意其用法及其可提供的预定义变量。

参见

  • opendir() - 打开目录句柄
  • readdir() - 从目录句柄中读取条目
  • glob() - 寻找与模式匹配的文件路径
  • is_dir() - 判断给定文件名是否是一个目录
  • sort() - 对数组升序排序

User Contributed Notes

djacobson at usa dot rugby 03-Feb-2020 09:39
<?php
/**
  * Get rid of the dots, the occasional `.DS_Store` file and reindex the
  * resulting array all at once.
  *
  * @param string $path_to_directory The relative path to your target directory.
  *
  * @return array The reindexed array of files.
  */
function get_the_files( $path_to_directory ) {
    return
array_slice( array_diff( scandir( $path_to_directory ), array( '..', '.', '.DS_Store' ) ), 0 );
}
?>
webmaster at gmail dot com 27-Oct-2019 08:17
easy way to list every item in a directory

<?php
$itemnum
= 1;
$dir = 'C:/Path/To/Directory';
foreach(
scandir($dir) as $item){
    if (!(
$item == '.')) {
        if (!(
$item == '..')) {
              echo(
$itemnum." = ".$item."<br>");
            
$itemnum = ($itemnum + 1);
}}}
?>
Nerbert 29-Jul-2019 12:58
If you use array_diff() to eliminate "." and ".." you must use array_values() on the result because array_diff() will return an associative array, which may cause problems for a for loop beginning at 0.

$files = array_values(array_diff(scandir($directory), array('..', '.')));
artmanniako at gmail dot com 02-Mar-2019 11:28
How i solved problem with '.' and '..'

$x = scandir__DIR__; //any directory
foreach ($x as $key => $value) {
        if ('.' !== $value && '..' !== $value){
               echo $value;
   }
}
Simple and working
admin at kmoz000 dot free 21-Aug-2018 01:49
function ScaniDir($path){
  $ptd= opendir($path);
  while (( $ptdf=readdir($ptd))){
      $srca = $path.'/'.$ptdf;
     if (is_file($srca) and pathinfo($srca, PATHINFO_EXTENSION)=='pdf') {$files['src'][]=$srca;$files['name'][]=explode('.',$ptdf)[0];}
    
    }
return $files ;

 }
info at remark dot no 25-Feb-2018 07:08
Someone wrote that array_slice could be used to quickly remove directory entries "." and "..". However, "-" is a valid entry that would come before those, so array_slice would remove the wrong entries.
SPekary 03-Jun-2017 06:30
Unless you specify no sorting, file names are sorted in ASCII alphabetic order, meaning numbers first, then uppercase, then lowercase letters, even on operating systems whose file system ignores the case of file names when it does its own sorting.

For example, on Mac OS, the following files will appear in this order in the Finder, when your disk is formated using the standard file system:
1file.php
a.inc
B.txt
c.txt

However, scandir will produce an array in the following order:
1file.php
B.txt
a.inc
c.txt
simon dot riget at gmail dot com 02-Jun-2016 07:28
This is a simple and versatile function that returns an array tree of files, matching wildcards:

<?php
// List files in tree, matching wildcards * and ?
function tree($path){
  static
$match;

 
// Find the real directory part of the path, and set the match parameter
 
$last=strrpos($path,"/");
  if(!
is_dir($path)){
   
$match=substr($path,$last);
    while(!
is_dir($path=substr($path,0,$last)) && $last!==false)
     
$last=strrpos($path,"/",-1);
  }
  if(empty(
$match)) $match="/*";
  if(!
$path=realpath($path)) return;

 
// List files
 
foreach(glob($path.$match) as $file){
   
$list[]=substr($file,strrpos($file,"/")+1);
  } 

 
// Process sub directories
 
foreach(glob("$path/*", GLOB_ONLYDIR) as $dir){
   
$list[substr($dir,strrpos($dir,"/",-1)+1)]=tree($dir);
  }
 
  return @
$list;
}
?>
telefoontoestel59 at hotmail dot com 01-Jul-2015 02:12
I was looking for an easy way to get only files from a certain directory. I came up with the following line of code that will result in an array listing only files. the samen can be done for directories ofcourse.

<?php
$files
= array_filter(scandir($directory), function($file) { return is_file($file); })
?>
Tom 24-Jan-2015 04:01
Just was curious to count files and lines in a project

<?php

 
function DirLineCounter( $dir , $result = array('lines_html' => false, 'files_count' => false, 'lines_count' => false ), $complete_table = true )
  {

     
$file_read = array( 'php', 'html', 'js', 'css' );
     
$dir_ignore = array();
     
     
$scan_result = scandir( $dir );
     
      foreach (
$scan_result as $key => $value ) {
       
          if ( !
in_array( $value, array( '.', '..' ) ) ) {
           
              if (
is_dir( $dir . DIRECTORY_SEPARATOR . $value ) ) {
               
                  if (
in_array( $value, $dir_ignore ) ) {
                    continue;
                  }
               
                 
$result = DirLineCounter( $dir . DIRECTORY_SEPARATOR . $value, $result, false );
                 
              }
              else {
               
             
$type = explode( '.', $value );
             
$type = array_reverse( $type );
              if( !
in_array( $type[0], $file_read ) ) {
                continue;
              }
             
             
$lines = 0;
             
$handle = fopen( $dir . DIRECTORY_SEPARATOR . $value, 'r' );

              while ( !
feof( $handle ) ) {

                  if (
is_bool( $handle ) ) {
                      break;
                  }

                 
$line = fgets( $handle );
                 
$lines++;
              }

             
fclose( $handle );

             
$result['lines_html'][] = '<tr><td>' . $dir . '</td><td>' . $value . '</td><td>' . $lines . '</td></tr>';
             
$result['lines_count'] = $result['lines_count'] + $lines;
             
$result['files_count'] = $result['files_count'] + 1;
                            
              }
          }
      }
     
      if (
$complete_table ) {
       
       
$lines_html = implode('', $result['lines_html']) . '<tr><td></td><td style="border: 1px solid #222">Files Total: ' . $result['files_count'] . '</td><td style="border: 1px solid #222">Lines Total: ' . $result['lines_count'] . '</td></tr>';
        return
'<table><tr><td style="width: 60%; background-color:#ddd;">Dir</td><td style="width: 30%; background-color:#ddd;">File</td><td style="width: 10%; background-color:#ddd;">Lines</td></tr>' . $lines_html . '</table>';
       
      }
      else {
        return
$result;
      }
     
  }

  echo
DirLineCounter( '.' );

?>
eep2004 at ukr dot net 07-Oct-2014 09:28
Fastest way to get a list of files without dots.
<?php
$files
= array_slice(scandir('/path/to/directory/'), 2);
gambit_642 AT hotmailDOTcom 22-Jan-2014 02:04
Needed something that could return the contents of single or multiple directories, recursively or non-recursively,
for all files or specified file extensions that would be
accessible easily from any scope or script.

And I wanted to allow overloading cause sometimes I'm too lazy to pass all params.
<?php
class scanDir {
    static private
$directories, $files, $ext_filter, $recursive;

// ----------------------------------------------------------------------------------------------
    // scan(dirpath::string|array, extensions::string|array, recursive::true|false)
   
static public function scan(){
       
// Initialize defaults
       
self::$recursive = false;
       
self::$directories = array();
       
self::$files = array();
       
self::$ext_filter = false;

       
// Check we have minimum parameters
       
if(!$args = func_get_args()){
            die(
"Must provide a path string or array of path strings");
        }
        if(
gettype($args[0]) != "string" && gettype($args[0]) != "array"){
            die(
"Must provide a path string or array of path strings");
        }

       
// Check if recursive scan | default action: no sub-directories
       
if(isset($args[2]) && $args[2] == true){self::$recursive = true;}

       
// Was a filter on file extensions included? | default action: return all file types
       
if(isset($args[1])){
            if(
gettype($args[1]) == "array"){self::$ext_filter = array_map('strtolower', $args[1]);}
            else
            if(
gettype($args[1]) == "string"){self::$ext_filter[] = strtolower($args[1]);}
        }

       
// Grab path(s)
       
self::verifyPaths($args[0]);
        return
self::$files;
    }

    static private function
verifyPaths($paths){
       
$path_errors = array();
        if(
gettype($paths) == "string"){$paths = array($paths);}

        foreach(
$paths as $path){
            if(
is_dir($path)){
               
self::$directories[] = $path;
               
$dirContents = self::find_contents($path);
            } else {
               
$path_errors[] = $path;
            }
        }

        if(
$path_errors){echo "The following directories do not exists<br />";die(var_dump($path_errors));}
    }

   
// This is how we scan directories
   
static private function find_contents($dir){
       
$result = array();
       
$root = scandir($dir);
        foreach(
$root as $value){
            if(
$value === '.' || $value === '..') {continue;}
            if(
is_file($dir.DIRECTORY_SEPARATOR.$value)){
                if(!
self::$ext_filter || in_array(strtolower(pathinfo($dir.DIRECTORY_SEPARATOR.$value, PATHINFO_EXTENSION)), self::$ext_filter)){
                   
self::$files[] = $result[] = $dir.DIRECTORY_SEPARATOR.$value;
                }
                continue;
            }
            if(
self::$recursive){
                foreach(
self::find_contents($dir.DIRECTORY_SEPARATOR.$value) as $value) {
                   
self::$files[] = $result[] = $value;
                }
            }
        }
       
// Return required for recursive search
       
return $result;
    }
}
?>

Usage:
scanDir::scan(path(s):string|array, [file_extensions:string|array], [subfolders?:true|false]);
<?php
//Scan a single directory for all files, no sub-directories
$files = scanDir::scan('D:\Websites\temp');

//Scan multiple directories for all files, no sub-dirs
$dirs = array(
   
'D:\folder';
   
'D:\folder2';
   
'C:\Other';
);
$files = scanDir::scan($dirs);

// Scan multiple directories for files with provided file extension,
// no sub-dirs
$files = scanDir::scan($dirs, "jpg");
//or with an array of extensions
$file_ext = array(
   
"jpg",
   
"bmp",
   
"png"
);
$files = scanDir::scan($dirs, $file_ext);

// Scan multiple directories for files with any extension,
// include files in recursive sub-folders
$files = scanDir::scan($dirs, false, true);

// Multiple dirs, with specified extensions, include sub-dir files
$files = scanDir::scan($dirs, $file_ext, true);
?>
Patrick 12-Jan-2014 09:10
Here is my recursive function, placing directories into new array keys and its contents within.

/* find_files( string, &array )
** Recursive function to return a multidimensional array of folders and files
** that are contained within the directory given
*/
function find_files($dir, &$dir_array)
{
    // Create array of current directory
    $files = scandir($dir);
   
    if(is_array($files))
    {
        foreach($files as $val)
        {
            // Skip home and previous listings
            if($val == '.' || $val == '..')
                continue;
           
            // If directory then dive deeper, else add file to directory key
            if(is_dir($dir.'/'.$val))
            {
                // Add value to current array, dir or file
                $dir_array[$dir][] = $val;
               
                find_files($dir.'/'.$val, $dir_array);
            }
            else
            {
                $dir_array[$dir][] = $val;
            }
        }
    }
    ksort($dir_array);
}

// Example
$folder_list = array();
find_files('/path', $folder_list)

var_dump($folder_list);

array(3) {
  ["directory_01"]=>
  array(4) {
    [0]=>
    string(12) "directory_02"
    [1]=>
    string(12) "directory_03"
    [2]=>
    string(11) "file_01.txt"
    [3]=>
    string(11) "file_02.txt"
  }
  ["directory_01/directory_02"]=>
  array(2) {
    [0]=>
    string(11) "file_03.txt"
    [1]=>
    string(11) "file_04.txt"
  }
  ["directory_01/directory_03"]=>
  array(2) {
    [0]=>
    string(11) "file_05.txt"
    [1]=>
    string(11) "file_06.txt"
  }
}
hex at mail dot nnov dot ru 07-Sep-2013 07:38
// Extreme minimal version recursive scan:
function rscandir($dir){
  $dirs = array_fill_keys( array_diff( scandir( $dir ), array( '.', '..' ) ), array());
  foreach( $dirs as $d => $v )
    if( is_dir($dir."/".$d) )
      $dirs[$d] = rscandir($dir."/".$d);
  return $dirs;
}
mmda dot nl at gmail dot com 08-Nov-2012 12:43
Here is my 2 cents. I wanted to create an array of my directory structure recursively. I wanted to easely access data in a certain directory using foreach. I came up with the following:

<?php
function dirToArray($dir) {
  
  
$result = array();

  
$cdir = scandir($dir);
   foreach (
$cdir as $key => $value)
   {
      if (!
in_array($value,array(".","..")))
      {
         if (
is_dir($dir . DIRECTORY_SEPARATOR . $value))
         {
           
$result[$value] = dirToArray($dir . DIRECTORY_SEPARATOR . $value);
         }
         else
         {
           
$result[] = $value;
         }
      }
   }
  
   return
$result;
}
?>

Output
Array
(
   [subdir1] => Array
   (
      [0] => file1.txt
      [subsubdir] => Array
      (
         [0] => file2.txt
         [1] => file3.txt
      )
   )
   [subdir2] => Array
   (
    [0] => file4.txt
   }
)
carneiro at isharelife dot com dot br 22-Jun-2012 06:47
<?php
/**
     * Get an array that represents directory tree
     * @param string $directory     Directory path
     * @param bool $recursive         Include sub directories
     * @param bool $listDirs         Include directories on listing
     * @param bool $listFiles         Include files on listing
     * @param regex $exclude         Exclude paths that matches this regex
     */
   
function directoryToArray($directory, $recursive = true, $listDirs = false, $listFiles = true, $exclude = '') {
       
$arrayItems = array();
       
$skipByExclude = false;
       
$handle = opendir($directory);
        if (
$handle) {
            while (
false !== ($file = readdir($handle))) {
           
preg_match("/(^(([\.]){1,2})$|(\.(svn|git|md))|(Thumbs\.db|\.DS_STORE))$/iu", $file, $skip);
            if(
$exclude){
               
preg_match($exclude, $file, $skipByExclude);
            }
            if (!
$skip && !$skipByExclude) {
                if (
is_dir($directory. DIRECTORY_SEPARATOR . $file)) {
                    if(
$recursive) {
                       
$arrayItems = array_merge($arrayItems, directoryToArray($directory. DIRECTORY_SEPARATOR . $file, $recursive, $listDirs, $listFiles, $exclude));
                    }
                    if(
$listDirs){
                       
$file = $directory . DIRECTORY_SEPARATOR . $file;
                       
$arrayItems[] = $file;
                    }
                } else {
                    if(
$listFiles){
                       
$file = $directory . DIRECTORY_SEPARATOR . $file;
                       
$arrayItems[] = $file;
                    }
                }
            }
        }
       
closedir($handle);
        }
        return
$arrayItems;
    }
?>
2bbasic at gmail dot com 21-Jun-2012 11:35
<?php
//-- Directory Navigation with SCANDIR
//--
//-- optional placemenet
$exclude_list = array(".", "..", "example.txt");
if (isset(
$_GET["dir"])) {
 
$dir_path = $_SERVER["DOCUMENT_ROOT"]."/".$_GET["dir"];
}
else {
 
$dir_path = $_SERVER["DOCUMENT_ROOT"]."/";
}
//-- until here
function dir_nav() {
  global
$exclude_list, $dir_path;
 
$directories = array_diff(scandir($dir_path), $exclude_list);
  echo
"<ul style='list-style:none;padding:0'>";
  foreach(
$directories as $entry) {
    if(
is_dir($dir_path.$entry)) {
      echo
"<li style='margin-left:1em;'>[`] <a href='?dir=".$_GET["dir"].$entry."/"."'>".$entry."</a></li>";
    }
  }
  echo
"</ul>";
 
//-- separator
 
echo "<ul style='list-style:none;padding:0'>";
  foreach(
$directories as $entry) {
    if(
is_file($dir_path.$entry)) {
      echo
"<li style='margin-left:1em;'>[ ] <a href='?file=".$_GET["dir"].$entry."'>".$entry."</a></li>";
    }
  }
  echo
"</ul>";
}
dir_nav();
//-- optional placement
if (isset($_GET["file"])) {
  echo
"<div style='margin:1em;border:1px solid Silver;'>";
 
highlight_file($dir_path.$_GET['file']);
  echo
"</div>";
}
//-- until here
//--
//-- Because I love php.net
?>
fazle dot elahee at gmail dot com 09-Apr-2012 06:52
/**
 * This function will scan all files recursively in the sub-folder and folder.
 *
 * @author Fazle Elahee
 *
 */

function scanFileNameRecursivly($path = '', &$name = array() )
{
  $path = $path == ''? dirname(__FILE__) : $path;
  $lists = @scandir($path);
 
  if(!empty($lists))
  {
      foreach($lists as $f)
      {
   
      if(is_dir($path.DIRECTORY_SEPARATOR.$f) && $f != ".." && $f != ".")
      {
          scanFileNameRecursivly($path.DIRECTORY_SEPARATOR.$f, &$name);
      }
      else
      {
          $name[] = $path.DIRECTORY_SEPARATOR.$f;
      }
      }
  }
  return $name;
}

$path = "/var/www/SimplejQueryDropdowns";
$file_names = scanFileNameRecursivly($path);

echo "<pre>";
var_dump($file_names);
echo "</pre>";
dwieeb at gmail dot com 22-Jan-2012 08:06
Easy way to get rid of the dots that scandir() picks up in Linux environments:

<?php
$directory
= '/path/to/my/directory';
$scanned_directory = array_diff(scandir($directory), array('..', '.'));
?>
kodlee at kodleeshare dot net 08-Jan-2012 03:51
I needed to find a way to get the full path of all files in the directory and all subdirectories of a directory.
Here's my solution: Recursive functions!

<?php
function find_all_files($dir)
{
   
$root = scandir($dir);
    foreach(
$root as $value)
    {
        if(
$value === '.' || $value === '..') {continue;}
        if(
is_file("$dir/$value")) {$result[]="$dir/$value";continue;}
        foreach(
find_all_files("$dir/$value") as $value)
        {
           
$result[]=$value;
        }
    }
    return
$result;
}
?>
boen dot robot at gmail dot com 20-Feb-2010 10:10
If you have a folder with many files and/or subfolders, doing a recursive scandir will likely either slow down your application, or cause a high rise in RAM consumption due to the large size of the generated array.

To help with this, as well as to make processing of files in a folder easier, I wrote a function that reads a folder and its subfolders recursively, and calls a function upon each match.

<?php
/**
 * Calls a function for every file in a folder.
 *
 * @author Vasil Rangelov a.k.a. boen_robot
 *
 * @param string $callback The function to call. It must accept one argument that is a relative filepath of the file.
 * @param string $dir The directory to traverse.
 * @param array $types The file types to call the function for. Leave as NULL to match all types.
 * @param bool $recursive Whether to list subfolders as well.
 * @param string $baseDir String to append at the beginning of every filepath that the callback will receive.
 */
function dir_walk($callback, $dir, $types = null, $recursive = false, $baseDir = '') {
    if (
$dh = opendir($dir)) {
        while ((
$file = readdir($dh)) !== false) {
            if (
$file === '.' || $file === '..') {
                continue;
            }
            if (
is_file($dir . $file)) {
                if (
is_array($types)) {
                    if (!
in_array(strtolower(pathinfo($dir . $file, PATHINFO_EXTENSION)), $types, true)) {
                        continue;
                    }
                }
               
$callback($baseDir . $file);
            }elseif(
$recursive && is_dir($dir . $file)) {
               
dir_walk($callback, $dir . $file . DIRECTORY_SEPARATOR, $types, $recursive, $baseDir . $file . DIRECTORY_SEPARATOR);
            }
        }
       
closedir($dh);
    }
}
?>

Of course, because it is recursive, a folder with many levels of folders could potentially consume lots of memory, but then again, so can every other recursive scandir implementation here.

BTW, there's also the RecursiveDirectoryIterator SPL class:
http://bg.php.net/manual/en/class.recursivedirectoryiterator.php
which, even if using the same approach, will most likely be faster and hold down deeper levels (because it works on the C level), but this one will always work, regardless of settings... even on PHP4.

Point is, avoid recursive scandir implementations.
moik78 at gmail dot com 28-Jan-2010 05:43
This is a function to count the number of files of a directory

<?php
function countFiles($dir){
   
$files = array();
   
$directory = opendir($dir);
    while(
$item = readdir($directory)){
   
// We filter the elements that we don't want to appear ".", ".." and ".svn"
        
if(($item != ".") && ($item != "..") && ($item != ".svn") ){
             
$files[] = $item;
         }
    }
   
$numFiles = count($files);
    return
$numFiles;
}
?>
phpnet at novaclic dot com 11-Jan-2010 02:36
Was looking for a simple way to search for a file/directory using a mask. Here is such a function.

By default, this function will keep in memory the scandir() result, to avoid scaning multiple time for the same directory.

Requires at least PHP5.

<?php
function sdir( $path='.', $mask='*', $nocache=0 ){
    static
$dir = array(); // cache result in memory
   
if ( !isset($dir[$path]) || $nocache) {
       
$dir[$path] = scandir($path);
    }
    foreach (
$dir[$path] as $i=>$entry) {
        if (
$entry!='.' && $entry!='..' && fnmatch($mask, $entry) ) {
           
$sdir[] = $entry;
        }
    }
    return (
$sdir);
}
?>
magicmind at netcabo dot pt 09-Jun-2009 05:20
Hello all,

I just added a extension filter to the getDirectoryTree function, so it can filter an extension for files in the folders/subfolders:

<?php
function getDirectoryTree( $outerDir , $x){
   
$dirs = array_diff( scandir( $outerDir ), Array( ".", ".." ) );
   
$dir_array = Array();
    foreach(
$dirs as $d ){
        if(
is_dir($outerDir."/".$d)  ){
           
$dir_array[ $d ] = getDirectoryTree( $outerDir."/".$d , $x);
        }else{
         if ((
$x)?ereg($x.'$',$d):1)
           
$dir_array[ $d ] = $d;
            }
    }
    return
$dir_array;
}

$dirlist = getDirectoryTree('filmes','flv');
?>
phpdotnet at lavavortex dot com 01-May-2009 05:05
How a ninja may retrieve a list of files, files filtered by extension, or directories:

<?php
//NNNIIIinnnjaaa::
//array of files without directories... optionally filtered by extension
function file_list($d,$x){
       foreach(
array_diff(scandir($d),array('.','..')) as $f)if(is_file($d.'/'.$f)&&(($x)?ereg($x.'$',$f):1))$l[]=$f;
       return
$l;
}

//NNNIIIinnnjaaa::
//array of directories
function dir_list($d){
       foreach(
array_diff(scandir($d),array('.','..')) as $f)if(is_dir($d.'/'.$f))$l[]=$f;
       return
$l;
}

/********************************************************************\
                    PRETTY PRETTY LIGHTS (DOCUMENTATION)
\********************************************************************/

/********************************************************************
Overloaded PHP file listing function:
array file_list ( string $directory [, string $file_extension] )

$directory
  path without backslash, e.g. "/home/public_html/blarg"

$file_extention
  optionally filter specific filename extentions, e.g. ".jpg"

>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TRANSLATION <<<<<<<<<<<<<<<<<<<<<<<<<<<<
file_list("/home");          //return list of files (no directories)
file_list("/home", ".jpg");  //return only .jpg file list
\********************************************************************/

//(note: one slash (/) below and you enable all your test functions, guess where ;-))
/********************************************************************\
// TEST FUNCTIONS... IF THESE WORK, THIS FUNCTION WORKS ON THIS PLATFORM
echo "<hr><b>File List:</b><br>";
$n = file_list(getcwd());
if($n) foreach($n as $f) echo "$f<br>";             //current files

echo "<hr><b>Files with extension .php:</b><br>";
$n = file_list(getcwd(),".php");
if($n) foreach($n as $f) echo "$f<br>";             //files with .php extensions

echo "<hr><b>Directories:</b><br>";
$d = dir_list(getcwd());
if($d) foreach($d as $f) echo "$f<br>";             //directories
/********************************************************************/

/************\
RUNTIME NOTES:
file_list($arg1); // php issues a warning that there is no second parameter, but we know that, izz ok
\************/

/*******************************\
TESTED AND WORKING ON 2009.04.30:
OS:     Linux 2.6.9-78.0.17.ELsmp
APACHE: 2.2.9
PHP:    5.2.5
\*******************************/
?>
dsiembab at fullchannel dot net 08-Dec-2008 11:29
Back in the saddle of scandir I wrote this function for a function that I needed to seperate directories from files. Since I am still learning from my last example way below I would figure I would add it so it can be criticized.
<?php
function dirlist($dir, $bool = "dirs"){
  
$truedir = $dir;
  
$dir = scandir($dir);
   if(
$bool == "files"){ // dynamic function based on second pram
     
$direct = 'is_dir';
   }elseif(
$bool == "dirs"){
     
$direct = 'is_file';
   }
   foreach(
$dir as $k => $v){
      if((
$direct($truedir.$dir[$k])) || $dir[$k] == '.' || $dir[$k] == '..' ){
         unset(
$dir[$k]);
      }
   }
  
$dir = array_values($dir);
   return
$dir;
}
?>
<?php
print_r
(dirlist("../"));  //confirm array of subdirectories

print_r(dirlist("../", "files") // confirm list on files in the directory
?>
asamir at asamir dot net 05-Mar-2008 04:21
This is a modification of scanDirectories function that generates a list of all files in the chosen directory and all subdirectories of specific extentions $allowext

<?php
function scanDirectories($rootDir, $allowext, $allData=array()) {
   
$dirContent = scandir($rootDir);
    foreach(
$dirContent as $key => $content) {
       
$path = $rootDir.'/'.$content;
       
$ext = substr($content, strrpos($content, '.') + 1);
       
        if(
in_array($ext, $allowext)) {
            if(
is_file($path) && is_readable($path)) {
               
$allData[] = $path;
            }elseif(
is_dir($path) && is_readable($path)) {
               
// recursive callback to open new directory
               
$allData = scanDirectories($path, $allData);
            }
        }
    }
    return
$allData;
}

$rootDir = "www";
$allowext = array("zip","rar","html");
$files_array = scanDirectories($rootDir,$allowext);
print_r($files_array);
?>
fatpratmatt dot at dot gmail dot com 27-Dec-2007 04:28
This function generates a list of all files in the chosen directory and all subdirectories, throws them into a NON-multidimentional array and returns them.

Most of the recursive functions on this page only return a multi-dimensional array.

This is actually a modification of some one else's function (thanks mail at bartrail dot de ;])

<?php
function scanDirectories($rootDir, $allData=array()) {
   
// set filenames invisible if you want
   
$invisibleFileNames = array(".", "..", ".htaccess", ".htpasswd");
   
// run through content of root directory
   
$dirContent = scandir($rootDir);
    foreach(
$dirContent as $key => $content) {
       
// filter all files not accessible
       
$path = $rootDir.'/'.$content;
        if(!
in_array($content, $invisibleFileNames)) {
           
// if content is file & readable, add to array
           
if(is_file($path) && is_readable($path)) {
               
// save file name with path
               
$allData[] = $path;
           
// if content is a directory and readable, add path and name
           
}elseif(is_dir($path) && is_readable($path)) {
               
// recursive callback to open new directory
               
$allData = scanDirectories($path, $allData);
            }
        }
    }
    return
$allData;
}
?>

Example output:

print_r(scanDirectories("www"));
---
Array
(
    [0] => www/index.php
    [1] => www/admin.php
    [3] => www/css/css.css
    [4] => www/articles/2007/article1.txt
    [4] => www/articles/2006/article1.txt
    [8] => www/img/img1.png
)
cHH 05-Nov-2007 09:46
Since scandir() returns and array, here is a more concise method of dealing with the '.' and '..' problem when listing directories:

<?php
$target
= '/';
$weeds = array('.', '..');
$directories = array_diff(scandir($target), $weeds);
   
foreach(
$directories as $value)
{
   if(
is_dir($target.$value))
   {
      echo
$value.'<br />';
   }
}
?>
beingmrkenny at gmail dot com 13-Aug-2006 11:41
I wrote this function to read a folder and place all the folders and sub folders it contains into an array.

<?php

// Initialise empty array, otherwise an error occurs
$folders = array();

function
recursive_subfolders($folders) {

   
// Set path here
   
$path = '/path/to/folder';
   
   
// Create initial "Folders" array
   
if ($dir = opendir($path)) {
       
$j = 0;
        while ((
$file = readdir($dir)) !== false) {
            if (
$file != '.' && $file != '..' && is_dir($path.$file)) {
               
$j++;
               
$folders[$j] = $path . $file;
            }
        }
    }
   
   
closedir($dir);
   
   
// Then check each folder in that array for subfolders and add the subfolders to the "Folders" array.
   
$j = count($folders);
    foreach (
$folders as $folder) {
        if (
$dir = opendir($folder)) {
            while ((
$file = readdir($dir)) !== false) {
               
$pathto = $folder. '/' . $file;
                if (
$file != '.' && $file != '..' && is_dir($pathto) && !in_array($pathto, $folders)) {
                   
$j++;
                   
$folders[$j] = $pathto;
                   
$folders = recursive_subfolders($folders);
                }
            }
        }
       
closedir($dir);
    }
   
   
sort($folders);
    return
$folders;
}

$folders = recursive_subfolders($folders);

?>

$folders now contains an array with the full paths to each subfolder. E.g.:

Array
(
    [0] => /path/to/folder/dir1
    [1] => /path/to/folder/dir1/subdir
    [2] => /path/to/folder/dir1/subdir/subsubdir
    [3] => /path/to/dolfer/dir2
)

This function has only been tested on Linux.
progrium+php at gmail dot com 30-Jun-2005 04:54
I made this to represent a directory tree in an array that uses the file or directory names as keys and full paths as the value for files. Directories are nested arrays.

<?php
function generatePathTree($rootPath) {
   
$pathStack = array($rootPath);
   
$contentsRoot = array();
   
$contents = &$contentsRoot;
    while (
$path = array_pop($pathStack)) {
      
$contents[basename($path)] = array();
      
$contents = &$contents[basename($path)];
       foreach (
scandir($path) as $filename) {
           if (
'.' != substr($filename, 0, 1)) {
              
$newPath = $path.'/'.$filename;
               if (
is_dir($newPath)) {
                  
array_push($pathStack, $newPath);
                  
$contents[basename($newPath)] = array();
               } else {
                  
$contents[basename($filename)] = $newPath;
               }
           }
       }
    }
    return
$contentsRoot[basename($rootPath)];
}
?>

The function will return something like this:

Array
(
    [index.php] => /usr/local/www/index.php
    [js] => Array
        (
            [async.js] => /usr/local/www/js/async.js
            [dom.js] => /usr/local/www/js/dom.js
            [effects.js] => /usr/local/www/js/effects.js
            [prototype.js] => /usr/local/www/js/prototype.js
        )

    [logo.png] => /usr/local/www/logo.png
    [server.php] => /usr/local/www/server.php
    [test.js] => /usr/local/www/test.js
)
Pawel Dlugosz 11-May-2005 11:18
For directory containing files like (for example) -.jpg the results of scandir are a little "weird" ;)

<?php
  
   $dir
= '/somedir';
  
$files = scandir($dir);
  
print_r($files);
?>

Array
(
    [0] => -.jpg
    [1] => .
    [2] => ..
    [3] => foo.txt
    [4] => somedir
)

Beware - sorting is in ASCII order :)
wwwebdesigner at web doott de 12-Apr-2005 12:20
using sort of scandir() that returns the content sorted by Filemodificationtime.

<?php
function scandir_by_mtime($folder) {
 
$dircontent = scandir($folder);
 
$arr = array();
  foreach(
$dircontent as $filename) {
    if (
$filename != '.' && $filename != '..') {
      if (
filemtime($folder.$filename) === false) return false;
     
$dat = date("YmdHis", filemtime($folder.$filename));
     
$arr[$dat] = $filename;
    }
  }
  if (!
ksort($arr)) return false;
  return
$arr;
}
?>

returns false if an error occured
otherwise it returns an array like this.
Array
(
    [20040813231320] => DSC00023.JPG
    [20040813231456] => DSC00024.JPG
    [20040814003728] => MOV00055.MPG
    [20040814003804] => DSC00056.JPG
    [20040814003946] => DSC00057.JPG
    [20040814004030] => DSC00058.JPG
    [20040814014516] => DSC00083.JPG
    [20050401161718] => album.txt
)
csaba at alum dot mit dot edu 04-Mar-2005 03:19
Scandir on steroids:
For when you want to filter your file list, or only want to list so many levels of subdirectories...

<?php
function dirList($path="", $types=2, $levels=1, $aFilter=array()) {
//  returns an array of the specified files/directories
//  start search in $path (defaults to current working directory)
//  return $types:  2 => files; 1 => directories; 3 => both;
//  $levels: 1 => look in the $path only; 2 => $path and all children;
//          3 => $path, children, grandchildren; 0 => $path and all subdirectories;
//          less than 0 => complement of -$levels, OR everything starting -$levels down
//                e.g. -1 => everthing except $path; -2 => all descendants except $path + children
//  Remaining argument(s) is(are) a filter array(list) of regular expressions which operate on the full path.
//    First character (before the '/' of the regExp) '-' => NOT.
//    First character (after a possible '-') 'd' => apply to directory name
//    The filters may be passed in as an array of strings or as a list of strings
//  Note that output directories are prefixed with a '*' (done in the line above the return)
  
$dS = DIRECTORY_SEPARATOR;
   if (!(
$path = realpath($path?$path:getcwd()))) return array();    // bad path
   // next line rids terminating \ on drives (works since c: == c:\ on PHP).  OK in *nix?
  
if (substr($path,-1)==$dS) $path = substr($path,0,-1);
   if (
is_null($types)) $types = 2;
   if (
is_null($levels)) $levels = 1;
   if (
is_null($aFilter)) $aFilter=array();

  
// last argument may be passed as a list or as an array
  
$aFilter = array_slice(func_get_args(),3);
   if (
$aFilter && gettype($aFilter[0])=="array") $aFilter=$aFilter[0];
  
$adFilter = array();
  
// now move directory filters to separate array:
  
foreach ($aFilter as $i=>$filter)                  // for each directory filter...
    
if (($pos=stripos(" $filter","d")) && $pos<3) {  // next line eliminates the 'd'
        
$adFilter[] = substr($filter,0,$pos-1) . substr($filter,$pos);
         unset(
$aFilter[$i]); }
  
$aFilter = array_merge($aFilter);    // reset indeces

  
$aRes = array();                    // results, $aAcc is an Accumulator
  
$aDir = array($path);    // dirs to check
  
for ($i=$levels>0?$levels++:-1;($aAcc=array())||$i--&&$aDir;$aDir=$aAcc)
     while (
$dir = array_shift($aDir))
         foreach (
scandir ($dir) as $fileOrDir)
           if (
$fileOrDir!="." && $fileOrDir!="..") {
               if (
$dirP = is_dir ($rp="$dir$dS$fileOrDir"))
                 if (
pathFilter("$rp$dS", $adFilter))
                    
$aAcc[] = $rp;
               if (
$i<$levels-1 && ($types & (2-$dirP)))
                 if (
pathFilter($rp, $aFilter))
                    
$aRes[] = ($dirP?"*":"") . $rp; }
   return
$aRes;
}
?>

example usage:
<?php
define
("_", NULL);
// this will find all non .jpg, non .Thumbs.db files under c:\Photo
$aFiles = dirList('c:\Photo', _, 0, '-/\.jpg$/i', '-/\\\\Thumbs.db$/');
$aFiles = dirList();    // find the files in the current directory
// next lines will find .jpg files in non Photo(s) subdirectories, excluding Temporary Internet Files
set_time_limit(60);        // iterating from the top level can take a while
$aFiles = dirList("c:\\", _, 0, '/\.jpg$/i', '-d/\\\\Photos?$/i', '-d/Temporary Internet/i');
?>

Note that this function will consume a lot of time if scanning large
directory structures (which is the reason for the '[-]d/.../' filters).

Csaba Gabor from Vienna
csaba at alum dot mit dot edu 04-Mar-2005 04:52
A nice way to filter the files/directories you get back from scandir:

<?php
function pathFilter ($path, $aFilter) {
  
// returns true iff $path survives the tests from $aFilter
   // $aFilter is an array of regular expressions: [-]/regExp/modifiers
   // if there is a leading '-' it means exclude $path upon a match (a NOT test)
   // If the first expression has a leading '-', $path is in, unless it gets excluded.
   // Otherwise, $path is out, unless it gets included via the filter tests.
   // The tests are applied in succession.
   // A NOT test is applied only if $path is currently (within the tests) included
   // Other tests are applied only if $path is currently excluded.  Thus,
   // array("/a/", "-/b/", "/c/") => passes if $path has a c or if $path has an a but no b
   // array("/a/", "/c/", "-/b/") => passes if $path has an a or c, but no b
   // array("-/b/", "/a/", "/c/") => passes if $path has no b, or if $path has an a or c
  
if (!$aFilter) return true;           // automatic inclusion (pass) if no filters
  
foreach ($aFilter as $filter) break;  // we don't know how it's indexed
  
$in = $filter[0]=="-";                // initial in/exclusion based on first filter
  
foreach ($aFilter as $filter)         // walk the filters
     
if ($in==$not=($filter[0]=="-"))   //     testing only when necessary
        
$in ^= preg_match(substr($filter,$not),$path);    // flip in/exclusion upon a match
  
return $in;
}
?>

Csaba Gabor from Vienna
Stan P. van de Burgt 26-Oct-2004 09:05
scandir() with regexp matching on file name and sorting options based on stat().

<?php
function myscandir($dir, $exp, $how='name', $desc=0)
{
   
$r = array();
   
$dh = @opendir($dir);
    if (
$dh) {
        while ((
$fname = readdir($dh)) !== false) {
            if (
preg_match($exp, $fname)) {
               
$stat = stat("$dir/$fname");
               
$r[$fname] = ($how == 'name')? $fname: $stat[$how];
            }
        }
       
closedir($dh);
        if (
$desc) {
           
arsort($r);
        }
        else {
           
asort($r);
        }
    }
    return(
array_keys($r));
}

$r = myscandir('./book/', '/^article[0-9]{4}\.txt$/i', 'ctime', 1);
print_r($r);
?>

files can be sorted on name and stat() attributes, ascending and descending:

name    file name
dev     device number
ino     inode number
mode    inode protection mode
nlink   number of links
uid     userid of owner
gid     groupid of owner
rdev    device type, if inode device *
size    size in bytes
atime   time of last access (Unix timestamp)
mtime   time of last modification (Unix timestamp)
ctime   time of last inode change (Unix timestamp)
blksize blocksize of filesystem IO *
blocks  number of blocks allocated
PHP8中文手册 站长在线 整理 版权归PHP文档组所有