Как найти каталог php

<?php
$directory = '/path/to/my/directory';
$scanned_directory = array_diff(scandir($directory), array('..', '.'));
?>

<?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

   }

)

    foreach (

<?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 :)

<?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;

}

?>

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:Websitestemp');//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);
?>

<?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

$x = scandir__DIR__; //any directory
foreach ($x as $key => $value) {
        if ('.' !== $value && '..' !== $value){
               echo $value;
   }
}
Simple and working

<?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

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>";

<?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

*******************************/

?>

if( DIRECTORY_SEPARATOR != substr($path, -1) || (DIRECTORY_SEPARATOR.DIRECTORY_SEPARATOR) == substr($path, -2))
{
    throw new Error("A non-standard path is specified. `{$path}`");
}

$scandir_result = scandir( $path, SCANDIR_SORT_DESCENDING );

for( $n = 0, $e = count($scandir_result) - 2; $n < $e; $n++ )
{
    echo ($path  .  $scandir_result[$n])  .'<br/>';
}

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
)

$files = array_values(array_diff(scandir($directory), array('..', '.')));

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

<?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;
}
?>

<?php
$files = array_filter(scandir($directory), function($file) { return is_file($file); })
?>

<?phpfunction 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( '.' );?>

/* 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"
  }
}

<?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;

}

?>

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');

?>

<?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
)

<?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.

<?php
$itemnum = 1;
$dir = 'C:/Path/To/Directory';
foreach(scandir($dir) as $item){
    if (!($item == '.')) {
        if (!($item == '..')) {
              echo($itemnum." = ".$item."<br>");
             $itemnum = ($itemnum + 1);
}}}
?>

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);

}

?>

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.

<?php

$target = '/';

$weeds = array('.', '..');

$directories = array_diff(scandir($target), $weeds);

   
foreach(

$directories as $value)

{

   if(is_dir($target.$value))

   {

      echo $value.'<br />';

   }

}

?>

<?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);
?>

<?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

         }
return $files ;

}

<?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
)