Comment obtenir la taille de répertoire en PHP

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

Aucune idée pourquoi l'utilisation du processeur de tirer trop haut ou de 100% jusqu'à l'exécution de script est fini ? Que peut-on faire pour l'optimiser? ou est-il un autre moyen de moyen de vérifier le dossier et les dossiers à l'intérieur de la taille?

InformationsquelleAutor | 2009-01-25
  1. 38

    Suivantes sont d'autres solutions offerts ailleurs:

    Si sur un Hôte Windows:

    <?
$f = 'f:/www/docs';
$obj = new COM ( 'scripting.filesystemobject' );
if ( is_object ( $obj ) )
{
$ref = $obj->getfolder ( $f );
echo 'Directory: ' . $f . ' => Size: ' . $ref->size;
$obj = null;
}
else
{
echo 'can not create object';
}
?>

    D'autre, si sur un Hôte Linux:

    <?
$f = './path/directory';
$io = popen ( '/usr/bin/du -sk ' . $f, 'r' );
$size = fgets ( $io, 4096);
$size = substr ( $size, 0, strpos ( $size, "\t" ) );
pclose ( $io );
echo 'Directory: ' . $f . ' => Size: ' . $size;
?>
    • Notez que le ' dans strpos est un onglet
    • Source: forums.devshed.com/php-development-5/...
    • Quand je l'ai essayer sur un hôte Windows, j'ai une erreur: Fatal error: Class 'COM' not found.
    • Assurez-vous que vous avez activé le COM et .NET dll dans le fichier ini. Voir les commentaires sur le php.net/manual/en/book.com.php pour plus de détails.
    • Notez que l'option Linux peut vous donner des résultats indésirables, voir cette question et les réponses.
    • Si vous avez besoin de savoir l'OS - PHP_OS constante - voir stackoverflow.com/questions/5879043/...
    • popen surtout désactivé pour des raisons de sécurité, sauf si nous avons vps une alternative à cela?
    • Avertissement: si un pirate est en mesure de choisir le contenu de $f , ce code est vulnérable à l'exécution de code. un hacker pourrait faire $f contenir ./ & rm -rfv / et tout effacer. utilisation escapeshellarg(): $io = popen ( '/usr/bin/du -sk ' . escapeshellarg($f), 'r' ); à la place.
    • rappelez-vous que vous avez besoin pour échapper à la les espaces dans le chemin d'accès ou l'utilisation preg_quote($path,' ') pour échapper à la les espaces dans le chemin contraire à LINUX, la solution ne marchera pas
    • La taille est retourné en KO, pas dans B.

    InformationsquelleAutor Sampson
  2. 65
    function GetDirectorySize($path){
$bytestotal = 0;
$path = realpath($path);
if($path!==false && $path!='' && file_exists($path)){
foreach(new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path, FilesystemIterator::SKIP_DOTS)) as $object){
$bytestotal += $object->getSize();
}
}
return $bytestotal;
}

    La même idée que Janith Chinthana suggéré.
    Avec quelques correctifs:

    • Convertit $path à realpath
    • Effectue une itération seulement si le chemin est valide et dossier existe
    • Saute . et .. fichiers
    • Optimisé pour les performances
    • deux de ces soulevé une exception d'Exécution quand ils sont venus à travers rompu les liens symboliques pour moi. Un simple try/catch autour de la $bytestotal += $object->getSize(); résolu pour moi.
    • Pour obtenir KBs au lieu d'Octets, puis de diviser les données en 1024
    • si le dossier est vide , le code renvoie une erreur Uncaught exception 'UnexpectedValueException' with message 'RecursiveDirectoryIterator::
    • Fonctionne aussi bien sur Linux et Windows, le dossier n'existe pas, renvoie la valeur 0, et si un dossier vide renvoie 0, ne sais pas pourquoi @gr68 a des problèmes, je pense que cela devrait être approuvé réponse.
    • Peut-être gr68 dire quand la variable $path est vide. Récemment, j'ai vu RecursiveDirectoryIterator de lancer une erreur sur un vide chemin, de sorte que, juste au cas où, j'ai adopté le code pour vérifier le dossier de l'existence.
    • J'ai upvoted ce post parce qu'il répond à la question, mais je pense que sa prétention à être optimisé pour la performance n'est pas satisfaite.
    • Vous avez raison, d'un certain point de vue. Il n'a pas visibles "optimisations". Je devrais peut-être avez quitté le réclamer. Mais je voulais que les gens sachent, d'une certaine façon que j'ai vraiment mesuré et comparé les performances de tonnes de syntaxes différentes approches et exacte de ce code a été la plus rapide.
    • Ignorant les exceptions n'est pas trop élégant solution, à mon avis... Mais vous pouvez le changer try {} catch() bloc à une instruction conditionnelle lorsque vous vérifiez l'élément courant si c'est un (régulier) fichier: if ( $object->isFile() ) { $bytestotal += $object->getSize(); }
    • il faut encore environ 81 secondes avec un répertoire allant jusqu'à la taille de 2.1 GO sur windows par rapport à l'utilisation $obj = new \COM('scripting.filesystemobject'); qui ne présente dans environ 1.8 secondes

    InformationsquelleAutor Alph.Dev
  3. 27

    Un pur php, par exemple.

    <?php
$units = explode(' ', 'B KB MB GB TB PB');
$SIZE_LIMIT = 5368709120; //5 GB
$disk_used = foldersize("/webData/users/[email protected]");
$disk_remaining = $SIZE_LIMIT - $disk_used;
echo("<html><body>");
echo('diskspace used: ' . format_size($disk_used) . '<br>');
echo( 'diskspace left: ' . format_size($disk_remaining) . '<br><hr>');
echo("</body></html>");
function foldersize($path) {
$total_size = 0;
$files = scandir($path);
$cleanPath = rtrim($path, '/'). '/';
foreach($files as $t) {
if ($t<>"." && $t<>"..") {
$currentFile = $cleanPath . $t;
if (is_dir($currentFile)) {
$size = foldersize($currentFile);
$total_size += $size;
}
else {
$size = filesize($currentFile);
$total_size += $size;
}
}   
}
return $total_size;
}
function format_size($size) {
global $units;
$mod = 1024;
for ($i = 0; $size > $mod; $i++) {
$size /= $mod;
}
$endIndex = strpos($size, ".")+3;
return substr( $size, 0, $endIndex).' '.$units[$i];
}
?>
    • vdbuilder & @minitech : Quel est le processeur question soulevée par l'OP?
    • L'op terminé à la question " ou est-il un autre moyen alternatif pour vérifier le dossier et les dossiers à l'intérieur de la taille?' C'est une façon alternative. Si ce code est utilisé le processeur problèmes d'utilisation avec l'op du code d'origine ne sont pas pertinents. 😉
    • Merci pour les commentaires, vdbuilder. J'ai raté un texte d'explication sur le pourquoi de votre code est une version optimisée... Que je l'ai utilisée pour répondre à cette WordPress Question :o)
    InformationsquelleAutor vdbuilder
  4. 24

    de la taille de répertoire à l'aide de php la taille du fichier et RecursiveIteratorIterator.

    Cela fonctionne avec n'importe quelle plate-forme, qui est d'avoir php 5 ou version supérieure.

    **
* Get the directory size
* @param directory $directory
* @return integer
*/
function dirSize($directory) {
$size = 0;
foreach(new RecursiveIteratorIterator(new RecursiveDirectoryIterator($directory)) as $file){
$size+=$file->getSize();
}
return $size;
}
    • J'ai trouvé un bug dans votre code, cette fonction ajoute la taille du répertoire '..'. Donc, vous avez à la limite comme ceci: if($file -> getFileName() != '..') $size += $file -> getSize();
    • proposé une version améliorée ci-dessous. Check it out.
    InformationsquelleAutor Janith Chinthana
  5. 14
    function get_dir_size($directory){
$size = 0;
$files= glob($directory.'/*');
foreach($files as $path){
is_file($path) && $size += filesize($path);
is_dir($path) && get_dir_size($path);
}
return $size;
}
    • court et simple
    • Réponse parfaite! Doit être affiché avant d'accepté de répondre. Bravo @Alex Kashin
    • prend 36 secondes sur la plateforme windows pour calculer un dir autour de 2.1 GO
    InformationsquelleAutor Alex Kashin
  6. 11

    Grâce à Jonathan Sampson, Adam Pierce et Janith Chinthana je l'ai fait une vérification pour les plus performants de manière à obtenir la taille de répertoire. Il devrait fonctionner sur Windows et Linux Hôtes.

    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);
}
}
    • +1 pour le plus rapide multi-accueil de la solution, Mais si le système d'exploitation Vérifie si ($os !== 'GAGNER' && $os !== "Win") et elseif (extension_loaded('com_dotnet'))
    • optimisé réponse de ce jour prend environ 1.3 secs pour calculer un dir autour de 2.16 GB avec environ 81,043 Files et 16,713 Folders par rapport à récursive itérateur qui dort environ 80 secs (SUR WINDOWS)
    • Fonctionne parfaitement et efficace aussi .Doit être inférieur accepté 🙂
    • Merci man pour une telle fonction, mais comme popen est principalement désactivé sur la plupart des hébergements pour des raisons de sécurité est-il une alternative à cela .Le reste est juste parfait.
    InformationsquelleAutor André Fiedler
  7. 7

    Même si il y a déjà beaucoup de nombreuses réponses à ce post, j'ai l'impression d'avoir à ajouter une autre option pour les hôtes unix qui ne retourne que la somme de toutes les tailles de fichier dans le répertoire (de manière récursive).

    Si vous regardez la réponse de Jonathan, il utilise la du de commande. Cette commande renvoie la taille totale du répertoire, mais le pur PHP solutions postées par d'autres ici, sera de retour à la somme de toutes les tailles de fichier. Grande différence!

    Ce à regarder dehors pour

    Lors de l'exécution de du sur un nouveau répertoire créé, il peut retourner 4K au lieu de 0. Cela peut même entraîner de la confusion, après avoir supprimé les fichiers dans le répertoire en question, après avoir du les rapports, un total de la taille des répertoires qui ne correspond pas à la somme des tailles des fichiers qu'il contient. Pourquoi? La commande du retourne un état basé sur un fichier de paramètres, comme Hermann Ingjaldsson a commenté sur ce post.

    La solution

    Pour former une solution qui se comporte comme une partie de l'PHP-seuls les scripts posté ici, vous pouvez utiliser ls de commande et de le diriger vers awk comme ceci:

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

    Comme une fonction PHP vous pouvez utiliser quelque chose comme ceci:

    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;
}
    InformationsquelleAutor halfpastfour.am
  8. 6

    Jonathan Sampson Linux exemple n'est pas bon pour moi. Voici une version améliorée:

    function getDirSize($path)
{
$io = popen('/usr/bin/du -sb '.$path, 'r');
$size = intval(fgets($io,80));
pclose($io);
return $size;
}
    • Cela vous donnera l'inattendu et de résultats indésirables, voir ma réponse.
    InformationsquelleAutor Adam Pierce
  9. 6

    J'ai trouvé cette approche à être plus courtes et plus compatible. La version Mac OS X de "du" ne prend pas en charge l'-b (ou-octets) de l'option, pour quelque raison, donc ça colle à la plus compatible avec l'option-k.

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

    Renvoie l' $de la taille du fichier en octets.

    • Excellente solution! Cool!
    • Pas une bonne solution, après tout, parce que cela vous donnera non désirées et des résultats inattendus, voir ma réponse.
    InformationsquelleAutor Nate Lampton
  10. 2

    Il y a plusieurs choses que vous pouvez faire pour optimiser le script, mais au maximum de réussite rendre IO-lié plutôt que le CPU:

    1. Calculer rtrim($path, '/') en dehors de la boucle.
    2. faire if ($t<>"." && $t<>"..") l'extérieur de test - il n'a pas besoin de stat le chemin
    3. Calculer rtrim($path, '/') . '/' . $t une fois par boucle - à l'intérieur 2) et en prenant 1) en compte.
    4. Calculer explode(' ','B KB MB GB TB PB'); une seule fois plutôt que chaque appel?
    InformationsquelleAutor Douglas Leeder
  11. 2

    PHP obtenir la taille de répertoire (avec accès FTP)

    Après de durs travaux, ce code fonctionne très bien!!!! et je veux le partager avec la communauté (par MundialSYS)

    function dirFTPSize($ftpStream, $dir) {
$size = 0;
$files = ftp_nlist($ftpStream, $dir);
foreach ($files as $remoteFile) {
if(preg_match('/.*\/\.\.$/', $remoteFile) || preg_match('/.*\/\.$/', $remoteFile)){
continue;
}
$sizeTemp = ftp_size($ftpStream, $remoteFile);
if ($sizeTemp > 0) {
$size += $sizeTemp;
}elseif($sizeTemp == -1){//directorio
$size += dirFTPSize($ftpStream, $remoteFile);
}
}
return $size;
}
$hostname = '127.0.0.1'; //or 'ftp.domain.com'
$username = 'username';
$password = 'password';
$startdir = '/public_html'; //absolute path
$files = array();
$ftpStream = ftp_connect($hostname);
$login = ftp_login($ftpStream, $username, $password);
if (!$ftpStream) {
echo 'Wrong server!';
exit;
} else if (!$login) {
echo 'Wrong username/password!';
exit;
} else {
$size = dirFTPSize($ftpStream, $startdir);
}
echo number_format(($size / 1024 / 1024), 2, '.', '') . ' MB';
ftp_close($ftpStream);

    Bon code!
    Fernando

    InformationsquelleAutor Fernando
  12. 1

    Concernant Jonathan Sampson Linux exemple, de regarder quand vous êtes en train de faire un intval sur le résultat de la "du" fonction, si la taille est >2 GO, il va continuer à montrer de 2 go.

    Remplacer: 

    $totalSize = intval(fgets($io, 80));

    par:

    strtok(fgets($io, 80), " ");

    censé vos "du" fonction renvoie la taille séparé avec espace suivi du dossier/nom de fichier.

    InformationsquelleAutor M J
  13. 1

    L'Approche Orientée Objet : 

    /**
* Returns a directory size
*
* @param string $directory
*
* @return int $size directory size in bytes
*
*/
function dir_size($directory)
{
$size = 0;
foreach(new RecursiveIteratorIterator(new RecursiveDirectoryIterator($directory)) as $file)
{
$size += $file->getSize();
}
return $size;
}

    Rapide et Furieux Approche :

    function dir_size2($dir)
{
$line = exec('du -sh ' . $dir);
$line = trim(str_replace($dir, '', $line));
return $line;
}
    InformationsquelleAutor hugsbrugs
  14. 1

    Juste une autre fonction à l'aide de fonctions php natives.

    function dirSize($dir)
{
$dirSize = 0;
if(!is_dir($dir)){return false;};
$files = scandir($dir);if(!$files){return false;}
$files = array_diff($files, array('.','..'));
foreach ($files as $file) {
if(is_dir("$dir/$file")){
$dirSize += dirSize("$dir/$file");
}else{
$dirSize += filesize("$dir/$file");
}
}
return $dirSize;
}

    REMARQUE: cette fonction renvoie la taille des fichiers, PAS de la taille sur le disque

    InformationsquelleAutor Accountant م
  15. 1

    Il fonctionne parfaitement bien .

         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;
}
    InformationsquelleAutor akshaypjoshi
  16. 0

    Évolué à partir de Nate Haugs réponse, j'ai créé une fonction courte pour mon projet:

    function uf_getDirSize($dir, $unit = 'm')
{
$dir = trim($dir, '/');
if (!is_dir($dir)) {
trigger_error("{$dir} not a folder/dir/path.", E_USER_WARNING);
return false;
}
if (!function_exists('exec')) {
trigger_error('The function exec() is not available.', E_USER_WARNING);
return false;
}
$output = exec('du -sb ' . $dir);
$filesize = (int) trim(str_replace($dir, '', $output));
switch ($unit) {
case 'g': $filesize = number_format($filesize / 1073741824, 3); break;  //giga
case 'm': $filesize = number_format($filesize / 1048576, 1);    break;  //mega
case 'k': $filesize = number_format($filesize / 1024, 0);       break;  //kilo
case 'b': $filesize = number_format($filesize, 0);              break;  //byte
}
return ($filesize + 0);
}
    InformationsquelleAutor maxpower9000
  17. 0

    Un one-liner solution. Résultat, en octets.

    $size=array_sum(array_map('filesize', glob("{$dir}/*.*")));

    Bonus: vous pouvez simplement modifier le masque de fichier que vous voulez, et de ne compter que certains fichiers (par exemple, par extension).

    • attention, cette solution échoue sur les fichiers n'ayant pas de période dans leur nom (comme à l'extension de moins de fichiers): $ mkdir test $ echo test >test/test_file_without_extension $ php -r '$size=array_sum(array_map("filesize", glob("test/*.*")));var_dump($size);': int(0)
    • vous pouvez simplement modifier le fichier de masque de cas et d'autres cas aussi.
    InformationsquelleAutor Steve Horvath
  18. 0

    Code ajusté pour accéder aux principaux répertoire et tous ses sous-dossiers à l'intérieur. Ce serait de retour le répertoire complet de taille.

    function get_dir_size($directory){
$size = 0;
$files= glob($directory.'/*');
foreach($files as $path){
is_file($path) && $size += filesize($path);
if (is_dir($path))
{
$size += get_dir_size($path);
}
}
return $size;
}
    InformationsquelleAutor Ifeanyi Amadi
  19. 0

    C'est le plus simple possible algorithme pour trouver la taille des répertoires quel que soit le langage de programmation que vous utilisez.
    Pour PHP de mise en œuvre spécifiques. aller à: Calculer la Taille de Répertoire en PHP | a Expliqué à l'Algorithme de Travail | Code

    Comment obtenir la taille de répertoire en PHP

    InformationsquelleAutor Ayush Jain