Wie man die Verzeichnisgröße in PHP ermittelt

Question

function foldersize($path) {
  $total_size = 0;
  $files = scandir($path);

  foreach($files as $t) {
    if (is_dir(rtrim($path, '/') . '/' . $t)) {
      if ($t<>"." && $t<>"..") {
          $size = foldersize(rtrim($path, '/') . '/' . $t);

          $total_size += $size;
      }
    } else {
      $size = filesize(rtrim($path, '/') . '/' . $t);
      $total_size += $size;
    }
  }
  return $total_size;
}

function format_size($size) {
  $mod = 1024;
  $units = explode(' ','B KB MB GB TB PB');
  for ($i = 0; $size > $mod; $i++) {
    $size /= $mod;
  }

  return round($size, 2) . ' ' . $units[$i];
}

$SIZE_LIMIT = 5368709120; // 5 GB

$sql="select * from users order by id";
$result=mysql_query($sql);

while($row=mysql_fetch_array($result)) {
  $disk_used = foldersize("C:/xampp/htdocs/freehosting/".$row['name']);

  $disk_remaining = $SIZE_LIMIT - $disk_used;
  print 'Name: ' . $row['name'] . '<br>';

  print 'diskspace used: ' . format_size($disk_used) . '<br>';
  print 'diskspace left: ' . format_size($disk_remaining) . '<br><hr>';
}

php disk_total_space

Haben Sie eine Idee, warum die Prozessorauslastung zu hoch oder auf 100% ansteigt, bis die Skriptausführung beendet ist? Kann man irgendetwas tun, um es zu optimieren? Oder gibt es eine andere Möglichkeit, die Größe von Ordnern und darin enthaltenen Verzeichnissen zu überprüfen?

Answer 1

Dank Jonathan Sampson, Adam Pierce und Janith Chinthana habe ich dies getan, indem ich nach dem performantesten Weg gesucht habe, um die Verzeichnisgröße zu ermitteln. Sollte auf Windows und Linux Hosts funktionieren.

static function getTotalSize($dir)
{
    $dir = rtrim(str_replace('\\', '/', $dir), '/');

    if (is_dir($dir) === true) {
        $totalSize = 0;
        $os        = strtoupper(substr(PHP_OS, 0, 3));
        // If on a Unix Host (Linux, Mac OS)
        if ($os !== 'WIN') {
            $io = popen('/usr/bin/du -sb ' . $dir, 'r');
            if ($io !== false) {
                $totalSize = intval(fgets($io, 80));
                pclose($io);
                return $totalSize;
            }
        }
        // If on a Windows Host (WIN32, WINNT, Windows)
        if ($os === 'WIN' && extension_loaded('com_dotnet')) {
            $obj = new \COM('scripting.filesystemobject');
            if (is_object($obj)) {
                $ref       = $obj->getfolder($dir);
                $totalSize = $ref->size;
                $obj       = null;
                return $totalSize;
            }
        }
        // If System calls did't work, use slower PHP 5
        $files = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($dir));
        foreach ($files as $file) {
            $totalSize += $file->getSize();
        }
        return $totalSize;
    } else if (is_file($dir) === true) {
        return filesize($dir);
    }
}

Answer 2

Auch wenn es bereits viele Antworten auf diesen Beitrag gibt, fühle ich mich verpflichtet, eine weitere Option für Unix-Hosts hinzuzufügen, die nur die Summe aller Dateigrößen im Verzeichnis (rekursiv) zurückgibt.

Wenn Sie sich Jonathans Antwort ansehen, verwendet er die du Befehl. Dieser Befehl gibt die Gesamtgröße des Verzeichnisses zurück, aber die reinen PHP-Lösungen, die hier von anderen gepostet wurden, geben die Summe aller Dateigrößen zurück. Ein großer Unterschied!

Worauf ist zu achten?

Bei der Ausführung du auf ein neu erstelltes Verzeichnis, kann es Folgendes zurückgeben 4K anstelle von 0 . Dies kann sogar noch verwirrender werden, nachdem Sie Dateien aus dem fraglichen Verzeichnis gelöscht haben, nachdem du die Meldung einer Gesamtgröße des Verzeichnisses, die nicht der Summe der Größen der darin enthaltenen Dateien entspricht. Warum ist das so? Der Befehl du gibt einen Bericht zurück, der auf einigen Dateieinstellungen basiert, wie Hermann Ingjaldsson kommentierte 本論文 .

Die Lösung

Um eine Lösung zu erstellen, die sich wie einige der hier veröffentlichten reinen PHP-Skripte verhält, können Sie ls Befehl und leiten ihn an awk wie diese:

ls -ltrR /path/to/dir |awk '{print \$5}'|awk 'BEGIN{sum=0} {sum=sum+\$1} END {print sum}'

Als PHP-Funktion könnten Sie etwas wie dieses verwenden:

function getDirectorySize( $path )
{
    if( !is_dir( $path ) ) {
        return 0;
    }

    $path   = strval( $path );
    $io     = popen( "ls -ltrR {$path} |awk '{print \$5}'|awk 'BEGIN{sum=0} {sum=sum+\$1} END {print sum}'", 'r' );
    $size   = intval( fgets( $io, 80 ) );
    pclose( $io );

    return $size;
}

Answer 3

Ich fand diesen Ansatz kürzer und besser kompatibel. Die Mac OS X-Version von "du" unterstützt aus irgendeinem Grund nicht die Option -b (oder --bytes), daher bleibt es bei der kompatibleren Option -k.

$file_directory = './directory/path';
$output = exec('du -sk ' . $file_directory);
$filesize = trim(str_replace($file_directory, '', $output)) * 1024;

Gibt die $filesize in Bytes zurück.

Answer 4

Das Linux-Beispiel von Johnathan Sampson hat bei mir nicht so gut funktioniert. Hier ist eine verbesserte Version:

function getDirSize($path)
{
    $io = popen('/usr/bin/du -sb '.$path, 'r');
    $size = intval(fgets($io,80));
    pclose($io);
    return $size;
}

Answer 5

Es funktioniert einwandfrei.

     public static function folderSize($dir)
     {
        $size = 0;

        foreach (glob(rtrim($dir, '/') . '/*', GLOB_NOSORT) as $each) {
            $func_name = __FUNCTION__;
            $size += is_file($each) ? filesize($each) : static::$func_name($each);
        }

        return $size;
      }