Формат байтов в килобайтах, мегабайт, гигабайт

function formatBytes($bytes, $precision = 2) { $units = array('B', 'KB', 'MB', 'GB', 'TB'); $bytes = max($bytes, 0); $pow = floor(($bytes ? log($bytes) : 0) / log(1024)); $pow = min($pow, count($units) - 1); // Uncomment one of the following alternatives // $bytes /= pow(1024, $pow); // $bytes /= (1 << (10 * $pow)); return round($bytes, $precision) . ' ' . $units[$pow]; } 

(Взято с php.net , есть много других примеров, но мне нравится этот лучший 🙂

Это реализация Chris Jester-Young, чистая, которую я когда-либо видел, в сочетании с аргументами php.net и точностью.

 function formatBytes($size, $precision = 2) { $base = log($size, 1024); $suffixes = array('', 'K', 'M', 'G', 'T'); return round(pow(1024, $base - floor($base)), $precision) .' '. $suffixes[floor($base)]; } echo formatBytes(24962496); // 23.81M echo formatBytes(24962496, 0); // 24M echo formatBytes(24962496, 4); // 23.8061M 

псевдокод:

 $base = log($size) / log(1024); $suffix = array("", "k", "M", "G", "T")[floor($base)]; return pow(1024, $base - floor($base)) . $suffix; 

Это реализация Коханы , вы можете использовать ее:

 public static function bytes($bytes, $force_unit = NULL, $format = NULL, $si = TRUE) { // Format string $format = ($format === NULL) ? '%01.2f %s' : (string) $format; // IEC prefixes (binary) if ($si == FALSE OR strpos($force_unit, 'i') !== FALSE) { $units = array('B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB'); $mod = 1024; } // SI prefixes (decimal) else { $units = array('B', 'kB', 'MB', 'GB', 'TB', 'PB'); $mod = 1000; } // Determine unit to use if (($power = array_search((string) $force_unit, $units)) === FALSE) { $power = ($bytes > 0) ? floor(log($bytes, $mod)) : 0; } return sprintf($format, $bytes / pow($mod, $power), $units[$power]); } 

Просто разделите его на 1024 для kb, 1024 ^ 2 для mb и 1024 ^ 3 для GB. Так просто.

используйте эту функцию, если вам нужен короткий код

bcdiv ()

 $size = 11485760; echo bcdiv($size, 1048576, 0); // return: 10 echo bcdiv($size, 1048576, 2); // return: 10,9 echo bcdiv($size, 1048576, 2); // return: 10,95 echo bcdiv($size, 1048576, 3); // return: 10,953 

Просто моя альтернатива, короткая и чистая:

 /** * @param int $bytes Number of bytes (eg. 25907) * @param int $precision [optional] Number of digits after the decimal point (eg. 1) * @return string Value converted with unit (eg. 25.3KB) */ function formatBytes($bytes, $precision = 2) { $unit = ["B", "KB", "MB", "GB"]; $exp = floor(log($bytes, 1024)) | 0; return round($bytes / (pow(1024, $exp)), $precision).$unit[$exp]; } 

или, более глупые и эффективные:

 function formatBytes($bytes, $precision = 2) { if ($bytes > pow(1024,3)) return round($bytes / pow(1024,3), $precision)."GB"; else if ($bytes > pow(1024,2)) return round($bytes / pow(1024,2), $precision)."MB"; else if ($bytes > 1024) return round($bytes / 1024, $precision)."KB"; else return ($bytes)."B"; } 

Я знаю, что, может быть, немного поздно ответить на этот вопрос, но больше данных не собирается убивать кого-то. Вот очень быстрая функция:

 function format_filesize($B, $D=2){ $S = 'BkMGTPEZY'; $F = floor((strlen($B) - 1) / 3); return sprintf("%.{$D}f", $B/pow(1024, $F)).' '.@$S[$F].'B'; } 

EDIT: я обновил сообщение, чтобы включить исправление, предлагаемое camomileCase:

 function format_filesize($B, $D=2){ $S = 'kMGTPEZY'; $F = floor((strlen($B) - 1) / 3); return sprintf("%.{$D}f", $B/pow(1024, $F)).' '.@$S[$F-1].'B'; } 

Простая функция

 function formatBytes($size, $precision = 0){ $unit = ['Byte','KiB','MiB','GiB','TiB','PiB','EiB','ZiB','YiB']; for($i = 0; $size >= 1024 && $i < count($unit)-1; $i++){ $size /= 1024; } return round($size, $precision).' '.$unit[$i]; } echo formatBytes('1876144', 2); //returns 1.79 MiB 

Мне удалось выполнить следующую функцию,

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

Мой подход

  function file_format_size($bytes, $decimals = 2) { $unit_list = array('B', 'KB', 'MB', 'GB', 'PB'); if ($bytes == 0) { return $bytes . ' ' . $unit_list[0]; } $unit_count = count($unit_list); for ($i = $unit_count - 1; $i >= 0; $i--) { $power = $i * 10; if (($bytes >> $power) >= 1) return round($bytes / (1 << $power), $decimals) . ' ' . $unit_list[$i]; } } 

 function changeType($size, $type, $end){ $arr = ['B', 'KB', 'MB', 'GB', 'TB']; $tSayi = array_search($type, $arr); $eSayi = array_search($end, $arr); $pow = $eSayi - $tSayi; return $size * pow(1024 * $pow) . ' ' . $end; } echo changeType(500, 'B', 'KB'); 

попробуй это 😉

 function bytesToSize($bytes) { $sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB']; if ($bytes == 0) return 'n/a'; $i = intval(floor(log($bytes) / log(1024))); if ($i == 0) return $bytes . ' ' . $sizes[$i]; return round(($bytes / pow(1024, $i)),1,PHP_ROUND_HALF_UP). ' ' . $sizes[$i]; } echo bytesToSize(10000050300); 

 function byte_format($size) { $bytes = array( ' KB', ' MB', ' GB', ' TB' ); foreach ($bytes as $val) { if (1024 <= $size) { $size = $size / 1024; continue; } break; } return round( $size, 1 ) . $val; } 

Вот упрощенная реализация функции drupal format_size :

 /** * Generates a string representation for the given byte count. * * @param $size * A size in bytes. * * @return * A string representation of the size. */ function format_size($size) { if ($size < 1024) { return $size . ' B'; } else { $size = $size / 1024; $units = ['KB', 'MB', 'GB', 'TB']; foreach ($units as $unit) { if (round($size, 2) >= 1024) { $size = $size / 1024; } else { break; } } return round($size, 2) . ' ' . $unit; } } 

Это немного поздно, но немного более быстрая версия принятого ответа ниже:

 function formatBytes($bytes, $precision) { $unit_list = array ( 'B', 'KB', 'MB', 'GB', 'TB', ); $bytes = max($bytes, 0); $index = floor(log($bytes, 2) / 10); $index = min($index, count($unit_list) - 1); $bytes /= pow(1024, $index); return round($bytes, $precision) . ' ' . $unit_list[$index]; } 

Это более эффективно из-за выполнения одной операции log-2 вместо двух операций log-e.

Однако на самом деле быстрее сделать более очевидное решение ниже:

 function formatBytes($bytes, $precision) { $unit_list = array ( 'B', 'KB', 'MB', 'GB', 'TB', ); $index_max = count($unit_list) - 1; $bytes = max($bytes, 0); for ($index = 0; $bytes >= 1024 && $index < $index_max; $index++) { $bytes /= 1024; } return round($bytes, $precision) . ' ' . $unit_list[$index]; } 

Это связано с тем, что, поскольку индекс рассчитывается одновременно с значением количества байтов в соответствующем модуле. Это сократило время выполнения примерно на 35% (увеличение скорости на 55%).

Другая сжатая реализация, которая может перевести на базу 1024 (двоичная) или базовая 1000 (десятичная), а также работает с невероятно большими числами, следовательно, от использования библиотеки bc:

 function renderSize($byte,$precision=2,$mibi=true) { $base = (string)($mibi?1024:1000); $labels = array('K','M','G','T','P','E','Z','Y'); for($i=8;$i>=1;$i--) if(bccomp($byte,bcpow($base, $i))>=0) return bcdiv($byte,bcpow($base, $i), $precision).' '.$labels[$i-1].($mibi?'iB':'B'); return $byte.' Byte'; } 

Я не знаю, почему вы должны сделать это настолько сложным, как другие.

Следующий код намного проще понять и примерно на 25% быстрее, чем другие решения, которые используют функцию журнала (называемую функцией 20 Mio. раз с разными параметрами)

 function formatBytes($bytes, $precision = 2) { $units = ['Byte', 'Kilobyte', 'Megabyte', 'Gigabyte', 'Terabyte']; $i = 0; while($bytes > 1024) { $bytes /= 1024; $i++; } return round($bytes, $precision) . ' ' . $units[$i]; } 

Я предположил, что добавлю два элемента кода отправителя (используя код Джона Химмельмана, который находится в этой теме, и используя код Юджина Кузьменко ), который я использую.

 function swissConverter($value, $format = true, $precision = 2) { //Below converts value into bytes depending on input (specify mb, for //example) $bytes = preg_replace_callback('/^\s*(\d+)\s*(?:([kmgt]?)b?)?\s*$/i', function ($m) { switch (strtolower($m[2])) { case 't': $m[1] *= 1024; case 'g': $m[1] *= 1024; case 'm': $m[1] *= 1024; case 'k': $m[1] *= 1024; } return $m[1]; }, $value); if(is_numeric($bytes)) { if($format === true) { //Below converts bytes into proper formatting (human readable //basically) $base = log($bytes, 1024); $suffixes = array('', 'KB', 'MB', 'GB', 'TB'); return round(pow(1024, $base - floor($base)), $precision) .' '. $suffixes[floor($base)]; } else { return $bytes; } } else { return NULL; //Change to prefered response } } 

Это использует код Юджина для форматирования $value в байтах (я сохраняю свои данные в МБ, поэтому он преобразует мои данные: 10485760 MB в 10995116277760 ) – тогда он использует код Джона для преобразования его в правильное отображаемое значение ( 10995116277760 на 10 TB ) ,

Я нашел это очень полезным – так что спасибо двум подателям!

Чрезвычайно простая функция для получения человеческого размера файла.

Оригинальный источник: http://php.net/manual/de/function.filesize.php#106569

Копировать / вставить код:

 <?php function human_filesize($bytes, $decimals = 2) { $sz = 'BKMGTP'; $factor = floor((strlen($bytes) - 1) / 3); return sprintf("%.{$decimals}f", $bytes / pow(1024, $factor)) . @$sz[$factor]; } ?>