blocks|key|1079531|text|只需将其除以1024表示kb，1024%5E2表示mb，1024%5E3表示GB。就这么简单。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1079532|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Just divide it by 1024 for kb, 1024^2 for mb and 1024^3 for GB. As simple as that.

blocks|key|1294513|text|这是Kohana's实现，您可以使用它：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1294514|public+static+function+bytes($bytes,+$force_unit+=+NULL,+$format+=+NULL,+$si+=+TRUE)
{
++++//+Format+string
++++$format+=+($format+===+NULL)+?+'%2501.2f+%25s'+:+(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]);
}|code-block|syntax|javascript|1294515|entityMap|0|LINK|mutability|MUTABLE|url|http://v3.kohanaphp.com/guide/api/Text#bytes^0|2|8|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

This is <a href="http://v3.kohanaphp.com/guide/api/Text#bytes" rel="noreferrer">Kohana's</a> implementation, you could use it:

<pre><code>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 &gt; 0) ? floor(log($bytes, $mod)) : 0;
 }

 return sprintf($format, $bytes / pow($mod, $power), $units[$power]);
}
</code></pre>

blocks|key|1079598|text|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];+
}+|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1079599|(取自php.net，还有许多其他示例，但我最喜欢这个:-)|unstyled|offset|length|1079600|entityMap|0|LINK|mutability|MUTABLE|url|http://php.net/manual/de/function.filesize.php^0|0|3|7|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@$G|S|H|T|1|U]]|A|$]]|$1|I|3|-4|5|F|7|V|8|@]|9|@]|A|$]]]|J|$K|$5|L|M|N|A|$O|P]]]]

<pre><code>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 &lt;&lt; (10 * $pow)); 

 return round($bytes, $precision) . ' ' . $units[$pow]; 
} 
</code></pre>

(Taken from <a href="http://php.net/manual/de/function.filesize.php" rel="noreferrer">php.net</a>, there are many other examples there, but I like this one best :-)

blocks|key|1294562|text|伪码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1294563|$base+=+log($size)+/+log(1024);
$suffix+=+array("",+"k",+"M",+"G",+"T")[floor($base)];
return+pow(1024,+$base+-+floor($base))+.+$suffix;|code-block|syntax|javascript|1294564|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Pseudocode:

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

blocks|key|1079641|text|这是Chris+Jester-Young的实现，我见过的最干净的，结合了php.net的和一个精确的参数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1079642|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|code-block|syntax|javascript|1079643|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is Chris Jester-Young's implementation, cleanest I've ever seen, combined with php.net's and a precision argument.

<pre><code>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
</code></pre>

blocks|key|1079674|text|如果您想要简短的代码，请使用此函数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1079675|bcdiv()|offset|length|1079676|$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|code-block|syntax|javascript|1079677|entityMap|0|LINK|mutability|MUTABLE|url|http://php.net/manual/en/function.bcdiv.php^0|0|0|7|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@$D|U|E|V|1|W]]|A|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

use this function if you want a short code

<a href="http://php.net/manual/en/function.bcdiv.php" rel="noreferrer">bcdiv()</a>

<pre><code>$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
</code></pre>

blocks|key|1294665|text|我知道现在回答这个问题可能有点晚了，但是，更多的数据不会杀死一个人。下面是一个非常快速的函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1294666|function+format_filesize($B,+$D=2){
++++$S+=+'BkMGTPEZY';
++++$F+=+floor((strlen($B)+-+1)+/+3);
++++return+sprintf("%25.{$D}f",+$B/pow(1024,+$F)).'+'.@$S[$F].'B';
}|code-block|syntax|javascript|1294667|编辑:我更新了我的帖子，包含了camomileCase提出的修复：|1294668|function+format_filesize($B,+$D=2){
++++$S+=+'kMGTPEZY';
++++$F+=+floor((strlen($B)+-+1)+/+3);
++++return+sprintf("%25.{$D}f",+$B/pow(1024,+$F)).'+'.@$S[$F-1].'B';
}|1294669|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I know it's maybe a little late to answer this question but, more data is not going to kill someone. Here's a very fast function :

<pre><code>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';
}
</code></pre>

EDIT: I updated my post to include the fix proposed by camomileCase:

<pre><code>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';
}
</code></pre>

blocks|key|1294696|text|我成功地实现了以下功能，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1294697|++++function+format_size($size)+{
++++++++$mod+=+1024;
++++++++$units+=+explode('+','B+KB+MB+GB+TB+PB');
++++++++for+($i+=+0;+$size+>+$mod;+$i%2B%2B)+{
++++++++++++$size+/=+$mod;
++++++++}
++++++++return+round($size,+2)+.+'+'+.+$units[$i];
++++}|code-block|syntax|javascript|1294698|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I succeeded with following function,

<pre><code> function format_size($size) {
 $mod = 1024;
 $units = explode(' ','B KB MB GB TB PB');
 for ($i = 0; $size &gt; $mod; $i++) {
 $size /= $mod;
 }
 return round($size, 2) . ' ' . $units[$i];
 }
</code></pre>

blocks|key|1294736|text|试试这个;)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1294737|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);|code-block|syntax|javascript|1294738|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

try this ;)

<pre><code>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);
</code></pre>

blocks|key|1294758|text|这是我的另一种选择，简明扼要：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1294759|/**
+*+@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))+%7C+0;
++++return+round($bytes+/+(pow(1024,+$exp)),+$precision).$unit[$exp];
}|code-block|syntax|javascript|1294760|或者，更愚蠢和更有效的方法：|1294761|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";
}|1294762|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Just my alternative, short and clean:

<pre><code>/**
 * @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];
}
</code></pre>

or, more stupid and efficent:

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

blocks|key|1294772|text|我的方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1294773|++++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];
++}
}|code-block|syntax|javascript|1294774|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

My approach

<pre><code> 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 &gt;= 0; $i--) {
 $power = $i * 10;
 if (($bytes &gt;&gt; $power) &gt;= 1)
 return round($bytes / (1 &lt;&lt; $power), $decimals) . ' ' . $unit_list[$i];
 }
}
</code></pre>

blocks|key|1079854|text|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;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1079855|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

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

blocks|key|1294792|text|简单函数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1294793|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%2B%2B){
++++++++$size+/=+1024;
++++}

++++return+round($size,+$precision).'+'.$unit[$i];
}

echo+formatBytes('1876144',+2);
//returns+1.79+MiB|code-block|syntax|javascript|1294794|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Simple function

<pre><code>function formatBytes($size, $precision = 0){
 $unit = ['Byte','KiB','MiB','GiB','TiB','PiB','EiB','ZiB','YiB'];

 for($i = 0; $size &gt;= 1024 &amp;&amp; $i &lt; count($unit)-1; $i++){
 $size /= 1024;
 }

 return round($size, $precision).' '.$unit[$i];
}

echo formatBytes('1876144', 2);
//returns 1.79 MiB
</code></pre>

blocks|key|1294820|text|下面是Drupal+format_size函数的简化实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1294821|/**
+*+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;
++}
}|code-block|syntax|javascript|1294822|entityMap|0|LINK|mutability|MUTABLE|url|http://api.drupal.org/api/function/format_size/7^0|A|B|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Here is simplified implementation of the Drupal <a href="http://api.drupal.org/api/function/format_size/7" rel="nofollow">format_size</a> function:

<pre><code>/**
 * 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 &lt; 1024) {
 return $size . ' B';
 }
 else {
 $size = $size / 1024;
 $units = ['KB', 'MB', 'GB', 'TB'];
 foreach ($units as $unit) {
 if (round($size, 2) &gt;= 1024) {
 $size = $size / 1024;
 }
 else {
 break;
 }
 }
 return round($size, 2) . ' ' . $unit;
 }
}
</code></pre>

blocks|key|1079891|text|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');|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1079892|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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');
</code></pre>

blocks|key|1079914|text|虽然有点晚了，但以下是公认答案的一个稍快的版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1079915|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];
}|code-block|syntax|javascript|1079916|由于执行一次log-2操作而不是两次log-e操作，因此效率更高。|1079917|然而，它实际上比下面更明显的解决方案更快：|1079918|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%2B%2B)
++++{
++++++++$bytes+/=+1024;
++++}

++++return+round($bytes,+$precision)+.+'+'+.+$unit_list[$index];
}|1079919|这是因为索引是与相应单元中的字节数的值同时计算的。这减少了大约35%25的执行时间(提高了55%25的速度)。|1079920|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

It's a little late but a slightly faster version of the accepted answer is below:

<pre><code>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];
}
</code></pre>

It's more efficient, due to performing a single log-2 operation instead of two log-e operations.

It's actually faster to do the more obvious solution below, however:

<pre><code>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 &gt;= 1024 &amp;&amp; $index &lt; $index_max; $index++)
 {
 $bytes /= 1024;
 }

 return round($bytes, $precision) . ' ' . $unit_list[$index];
}
</code></pre>

This is because as the index is calculated at the same time as the value of the number of bytes in the appropriate unit. This cut the execution time by about 35% (a 55% speed increase).

blocks|key|1079945|text|另一个精简的实现可以转换为基数1024+(二进制)或基数1000+(十进制)，也可以处理非常大的数字，因此使用了bc库：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1079946|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';
}|code-block|syntax|javascript|1079947|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another condensed implementation which can translate to the base 1024 (binary) or base 1000 (decimal) and also works with incredibly large numbers hence of the use of the bc library:

<pre><code>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&gt;=1;$i--)
 if(bccomp($byte,bcpow($base, $i))&gt;=0)
 return bcdiv($byte,bcpow($base, $i), $precision).' '.$labels[$i-1].($mibi?'iB':'B');
 return $byte.' Byte';
}
</code></pre>

blocks|key|1294961|text|我不明白你为什么要把事情搞得和其他人一样复杂。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1294962|下面的代码更易于理解，并且比使用log函数的其他解决方案(称为函数20Mio)快25%25。使用不同参数的时间)|1294963|function+formatBytes($bytes,+$precision+=+2)+{
++++$units+=+['Byte',+'Kilobyte',+'Megabyte',+'Gigabyte',+'Terabyte'];
++++$i+=+0;

++++while($bytes+>+1024)+{
++++++++$bytes+/=+1024;
++++++++$i%2B%2B;
++++}
++++return+round($bytes,+$precision)+.+'+'+.+$units[$i];
}|code-block|syntax|javascript|1294964|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I don't know why you should make it so complicated as the others.

The following code is much simpler to understand and about 25% faster than the other solutions who uses the log function (called the function 20 Mio. times with different parameters)

<pre><code>function formatBytes($bytes, $precision = 2) {
 $units = ['Byte', 'Kilobyte', 'Megabyte', 'Gigabyte', 'Terabyte'];
 $i = 0;

 while($bytes &gt; 1024) {
 $bytes /= 1024;
 $i++;
 }
 return round($bytes, $precision) . ' ' . $units[$i];
}
</code></pre>

blocks|key|1295029|text|我想我应该添加一个我正在使用的两个提交者代码的网格(使用John+Himmelman的代码，在这个线程中，并使用Eugene+Kuzmenko的代码)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1295030|function+swissConverter($value,+$format+=+true,+$precision+=+2)+{
++++//Below+converts+value+into+bytes+depending+on+input+(specify+mb,+for+
++++//example)
++++$bytes+=+preg_replace_callback('/%5E\s*(\d%2B)\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
++++}
}|code-block|syntax|javascript|1295031|它使用Eugene的代码将$value格式化为字节(我将数据保存在MB中，因此它将我的数据：10485760+MB转换为10995116277760)+-然后使用John的代码将其转换为正确的显示值(10995116277760转换为10+TB)。|style|CODE|1295032|我发现这真的很有帮助-所以我要感谢两个提交者！|1295033|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/11807115/php-convert-kb-mb-gb-tb-etc-to-bytes/24676538#24676538^0|1K|F|0|0|0|D|6|1A|B|1O|E|2S|E|39|5|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@$A|12|B|13|K|L]|$A|14|B|15|K|L]|$A|16|B|17|K|L]|$A|18|B|19|K|L]|$A|1A|B|1B|K|L]]|9|@]|C|$]]|$1|M|3|N|5|6|7|1C|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|1D|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

I figured I would add a meshing of two submitters code (Using John Himmelman's code, which is in this thread, and using <a href="https://stackoverflow.com/questions/11807115/php-convert-kb-mb-gb-tb-etc-to-bytes/24676538#24676538">Eugene Kuzmenko</a>'s code) that I'm using. 

<pre><code>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
 }
}
</code></pre>

This uses Eugene's code to format the <code>$value</code> into bytes (I keep my data in MB, so it converts my data: <code>10485760 MB</code> into <code>10995116277760</code>) - it then uses John's code to convert it into the proper display value (<code>10995116277760</code> into <code>10 TB</code>). 

I've found this really helpful - so my thanks to the two submitters!

blocks|key|1295049|text|获取人类文件大小的极其简单的函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1295050|原文来源：http://php.net/manual/de/function.filesize.php#106569|offset|length|1295051|复制/粘贴代码：|1295052|<?php
function+human_filesize($bytes,+$decimals+=+2)+{
++$sz+=+'BKMGTP';
++$factor+=+floor((strlen($bytes)+-+1)+/+3);
++return+sprintf("%25.{$decimals}f",+$bytes+/+pow(1024,+$factor))+.+@$sz[$factor];
}
?>|code-block|syntax|javascript|1295053|entityMap|0|LINK|mutability|MUTABLE|url|http://php.net/manual/de/function.filesize.php#106569^0|0|5|1H|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@$D|W|E|X|1|Y]]|A|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

Extremely simple function to get human file size.

Original source: <a href="http://php.net/manual/de/function.filesize.php#106569" rel="nofollow noreferrer">http://php.net/manual/de/function.filesize.php#106569</a>

Copy/paste code:

<pre><code>&lt;?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];
}
?&gt;
</code></pre>

blocks|key|1295114|text|我开发了自己的函数，将人类可读的内存大小转换为不同的大小。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1295115|function+convertMemorySize($strval,+string+$to_unit+=+'b')
{
++++$strval++++=+strtolower(str_replace('+',+'',+$strval));
++++$val+++++++=+floatval($strval);
++++$to_unit+++=+strtolower(trim($to_unit))[0];
++++$from_unit+=+str_replace($val,+'',+$strval);
++++$from_unit+=+empty($from_unit)+?+'b'+:+trim($from_unit)[0];
++++$units+++++=+'kmgtph';++//+(k)ilobyte,+(m)egabyte,+(g)igabyte+and+so+on...


++++//+Convert+to+bytes
++++if+($from_unit+!==+'b')
++++++++$val+*=+1024+**+(strpos($units,+$from_unit)+%2B+1);


++++//+Convert+to+unit
++++if+($to_unit+!==+'b')
++++++++$val+/=+1024+**+(strpos($units,+$to_unit)+%2B+1);


++++return+$val;
}


convertMemorySize('1024Kb',+'Mb');++//+1
convertMemorySize('1024',+'k')++++++//+1
convertMemorySize('5.2Mb',+'b')+++++//+5452595.2
convertMemorySize('10+kilobytes',+'bytes')+//+10240
convertMemorySize(2048,+'k')++++++++//+By+default+convert+from+bytes,+result+is+2|code-block|syntax|javascript|1295116|此函数接受任何内存大小的缩写，如"Megabyte，MB，Mb，mb，m，kilobyte，K，KB，b，Terabyte，T....“所以它是打字安全的。|1295117|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I developed my own function that convert human readable memory size to different sizes.

<pre class="lang-php prettyprint-override"><code>function convertMemorySize($strval, string $to_unit = 'b')
{
 $strval = strtolower(str_replace(' ', '', $strval));
 $val = floatval($strval);
 $to_unit = strtolower(trim($to_unit))[0];
 $from_unit = str_replace($val, '', $strval);
 $from_unit = empty($from_unit) ? 'b' : trim($from_unit)[0];
 $units = 'kmgtph'; // (k)ilobyte, (m)egabyte, (g)igabyte and so on...


 // Convert to bytes
 if ($from_unit !== 'b')
 $val *= 1024 ** (strpos($units, $from_unit) + 1);


 // Convert to unit
 if ($to_unit !== 'b')
 $val /= 1024 ** (strpos($units, $to_unit) + 1);


 return $val;
}


convertMemorySize('1024Kb', 'Mb'); // 1
convertMemorySize('1024', 'k') // 1
convertMemorySize('5.2Mb', 'b') // 5452595.2
convertMemorySize('10 kilobytes', 'bytes') // 10240
convertMemorySize(2048, 'k') // By default convert from bytes, result is 2
</code></pre>

This function accepts any memory size abbreviation like "Megabyte, MB, Mb, mb, m, kilobyte, K, KB, b, Terabyte, T...." so it is typo safe.

blocks|key|1080116|text|function+convertToReadableSize($size)
{
++$base+=+log($size)+/+log(1024);
++$suffix+=+array("B",+"KB",+"MB",+"GB",+"TB");
++$f_base+=+floor($base);
++return+round(pow(1024,+$base+-+floor($base)),+1)+.+$suffix[$f_base];
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1080117|只需调用该函数|unstyled|1080118|echo+convertToReadableSize(1024);+//+Outputs+'1KB'
echo+convertToReadableSize(1024+*+1024);+//+Outputs+'1MB'|1080119|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>function convertToReadableSize($size)
{
 $base = log($size) / log(1024);
 $suffix = array("B", "KB", "MB", "GB", "TB");
 $f_base = floor($base);
 return round(pow(1024, $base - floor($base)), 1) . $suffix[$f_base];
}
</code></pre>

Just call the function

<pre><code>echo convertToReadableSize(1024); // Outputs '1KB'
echo convertToReadableSize(1024 * 1024); // Outputs '1MB'
</code></pre>

blocks|key|1080138|text|灵活的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1080139|function+size($size,+array+$options=null)+{

++++$o+=+[
++++++++'binary'+=>+false,
++++++++'decimalPlaces'+=>+2,
++++++++'decimalSeparator'+=>+'.',
++++++++'thausandsSeparator'+=>+'',
++++++++'maxThreshold'+=>+false,+//+or+thresholds+key
++++++++'suffix'+=>+[
++++++++++++'thresholds'+=>+['',+'K',+'M',+'G',+'T',+'P',+'E',+'Z',+'Y'],
++++++++++++'decimal'+=>+'+{threshold}B',
++++++++++++'binary'+=>+'+{threshold}iB',
++++++++++++'bytes'+=>+'+B'
++++++++]
++++];

++++if+($options+!==+null)
++++++++$o+=+array_replace_recursive($o,+$options);

++++$base+=+$o['binary']+?+1024+:+1000;
++++$exp+=+$size+?+floor(log($size)+/+log($base))+:+0;

++++if+(($o['maxThreshold']+!==+false)+&&
++++++++($o['maxThreshold']+<+$exp)
++++)
++++++++$exp+=+$o['maxThreshold'];

++++return+!$exp
++++++++?+(round($size)+.+$o['suffix']['bytes'])
++++++++:+(
++++++++++++number_format(
++++++++++++++++$size+/+pow($base,+$exp),
++++++++++++++++$o['decimalPlaces'],
++++++++++++++++$o['decimalSeparator'],
++++++++++++++++$o['thausandsSeparator']
++++++++++++)+.
++++++++++++str_replace(
++++++++++++++++'{threshold}',
++++++++++++++++$o['suffix']['thresholds'][$exp],
++++++++++++++++$o['suffix'][$o['binary']+?+'binary'+:+'decimal']
++++++++++++)
++++++++);
}

var_dump(size(disk_free_space('/')));
//+string(8)+"14.63+GB"
var_dump(size(disk_free_space('/'),+['binary'+=>+true]));
//+string(9)+"13.63+GiB"
var_dump(size(disk_free_space('/'),+['maxThreshold'+=>+2]));
//+string(11)+"14631.90+MB"
var_dump(size(disk_free_space('/'),+['binary'+=>+true,+'maxThreshold'+=>+2]));
//+string(12)+"13954.07+MiB"|code-block|syntax|javascript|1080140|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Flexible solution:
<pre class="lang-php prettyprint-override"><code>function size($size, array $options=null) {

 $o = [
 'binary' =&gt; false,
 'decimalPlaces' =&gt; 2,
 'decimalSeparator' =&gt; '.',
 'thausandsSeparator' =&gt; '',
 'maxThreshold' =&gt; false, // or thresholds key
 'suffix' =&gt; [
 'thresholds' =&gt; ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'],
 'decimal' =&gt; ' {threshold}B',
 'binary' =&gt; ' {threshold}iB',
 'bytes' =&gt; ' B'
 ]
 ];

 if ($options !== null)
 $o = array_replace_recursive($o, $options);

 $base = $o['binary'] ? 1024 : 1000;
 $exp = $size ? floor(log($size) / log($base)) : 0;

 if (($o['maxThreshold'] !== false) &amp;&amp;
 ($o['maxThreshold'] &lt; $exp)
 )
 $exp = $o['maxThreshold'];

 return !$exp
 ? (round($size) . $o['suffix']['bytes'])
 : (
 number_format(
 $size / pow($base, $exp),
 $o['decimalPlaces'],
 $o['decimalSeparator'],
 $o['thausandsSeparator']
 ) .
 str_replace(
 '{threshold}',
 $o['suffix']['thresholds'][$exp],
 $o['suffix'][$o['binary'] ? 'binary' : 'decimal']
 )
 );
}

var_dump(size(disk_free_space('/')));
// string(8) &quot;14.63 GB&quot;
var_dump(size(disk_free_space('/'), ['binary' =&gt; true]));
// string(9) &quot;13.63 GiB&quot;
var_dump(size(disk_free_space('/'), ['maxThreshold' =&gt; 2]));
// string(11) &quot;14631.90 MB&quot;
var_dump(size(disk_free_space('/'), ['binary' =&gt; true, 'maxThreshold' =&gt; 2]));
// string(12) &quot;13954.07 MiB&quot;
</code></pre>

blocks|key|1080182|text|我这样做了，将所有输入转换为字节，因此转换为任何需要的输出。此外，我使用了一个辅助函数来获得基数1000或1024，但让它灵活地决定在流行类型上使用1024+(没有'i'，比如MB而不是MiB)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1080183|++++public+function+converte_binario($size=0,$format_in='B',$format_out='MB',$force_in_1024=false,$force_out_1024=false,$precisao=5,$return_format=true,$decimal=',',$centena=''){
++++$out+=+false;

++++if(+(is_numeric($size))+&&+($size>0)){
++++++++$in_data+=+$this->converte_binario_aux($format_in,$force_in_1024);
++++++++$out_data+=+$this->converte_binario_aux($format_out,$force_out_1024);

++++++++//+se+formato+de+entrada+e+saída+foram+encontrados
++++++++if(+((isset($in_data['sucesso']))+&&+($in_data['sucesso']==true))+&&+((isset($out_data['sucesso']))+&&+($out_data['sucesso']==true))){
++++++++++++//+converte+formato+de+entrada+para+bytes.
++++++++++++$size_bytes_in+=+$size+*+(pow($in_data['base'],+$in_data['pot']));
++++++++++++$size_byte_out+=+(pow($out_data['base'],+$out_data['pot']));
++++++++++++//+transforma+bytes+na+unidade+de+destino
++++++++++++$out+=+number_format($size_bytes_in+/+$size_byte_out,$precisao,$decimal,$centena);
++++++++++++if($return_format){
++++++++++++++++$out+.=+$format_out;
++++++++++++}
++++++++}
++++}
++++return+$out;
}

public+function+converte_binario_aux($format=false,$force_1024=false){
++++$out+=+[];
++++$out['sucesso']+=+false;
++++$out['base']+=+0;
++++$out['pot']+=+0;
++++if((is_string($format)+&&+(strlen($format)>0))){
++++++++$format+=+trim(strtolower($format));
++++++++$units_1000+=+['b','kb'+,'mb'+,'gb'+,'tb'+,'pb'+,'eb'+,'zb'+,'yb'+];
++++++++$units_1024+=+['b','kib','mib','gib','tib','pib','eib','zib','yib'];
++++++++$pot+=+array_search($format,$units_1000);
++++++++if(+(is_numeric($pot))+&&+($pot>=0)){
++++++++++++$out['pot']+=+$pot;
++++++++++++$out['base']+=+1000;
++++++++++++$out['sucesso']+=+true;
++++++++}
++++++++else{
++++++++++++$pot+=+array_search($format,$units_1024);
++++++++++++if(+(is_numeric($pot))+&&+($pot>=0)){
++++++++++++++++$out['pot']+=+$pot;
++++++++++++++++$out['base']+=+1024;
++++++++++++++++$out['sucesso']+=+true;
++++++++++++}
++++++++}
++++++++if($force_1024){
++++++++++++$out['base']+=+1024;
++++++++}
++++}
++++return+$out;
}|code-block|syntax|javascript|1080184|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I did this converting all input to byte and so converting to any output needed. Also, I used a auxiliar function to get base 1000 or 1024, but left it flex to decide use 1024 on popular type (without 'i', like MB instead of MiB). 

<pre><code> public function converte_binario($size=0,$format_in='B',$format_out='MB',$force_in_1024=false,$force_out_1024=false,$precisao=5,$return_format=true,$decimal=',',$centena=''){
 $out = false;

 if( (is_numeric($size)) &amp;&amp; ($size&gt;0)){
 $in_data = $this-&gt;converte_binario_aux($format_in,$force_in_1024);
 $out_data = $this-&gt;converte_binario_aux($format_out,$force_out_1024);

 // se formato de entrada e saída foram encontrados
 if( ((isset($in_data['sucesso'])) &amp;&amp; ($in_data['sucesso']==true)) &amp;&amp; ((isset($out_data['sucesso'])) &amp;&amp; ($out_data['sucesso']==true))){
 // converte formato de entrada para bytes.
 $size_bytes_in = $size * (pow($in_data['base'], $in_data['pot']));
 $size_byte_out = (pow($out_data['base'], $out_data['pot']));
 // transforma bytes na unidade de destino
 $out = number_format($size_bytes_in / $size_byte_out,$precisao,$decimal,$centena);
 if($return_format){
 $out .= $format_out;
 }
 }
 }
 return $out;
}

public function converte_binario_aux($format=false,$force_1024=false){
 $out = [];
 $out['sucesso'] = false;
 $out['base'] = 0;
 $out['pot'] = 0;
 if((is_string($format) &amp;&amp; (strlen($format)&gt;0))){
 $format = trim(strtolower($format));
 $units_1000 = ['b','kb' ,'mb' ,'gb' ,'tb' ,'pb' ,'eb' ,'zb' ,'yb' ];
 $units_1024 = ['b','kib','mib','gib','tib','pib','eib','zib','yib'];
 $pot = array_search($format,$units_1000);
 if( (is_numeric($pot)) &amp;&amp; ($pot&gt;=0)){
 $out['pot'] = $pot;
 $out['base'] = 1000;
 $out['sucesso'] = true;
 }
 else{
 $pot = array_search($format,$units_1024);
 if( (is_numeric($pot)) &amp;&amp; ($pot&gt;=0)){
 $out['pot'] = $pot;
 $out['base'] = 1024;
 $out['sucesso'] = true;
 }
 }
 if($force_1024){
 $out['base'] = 1024;
 }
 }
 return $out;
}
</code></pre>

blocks|key|1295219|text|下面是一个使用log10的选项|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1295220|<?php

function+format_number(float+$d):+string+{
+++$e+=+(int)(log10($d)+/+3);
+++return+sprintf('%25.3f',+$d+/+1e3+**+$e)+.+['',+'+k',+'+M',+'+G'][$e];
}

$s+=+format_number(9012345678);
var_dump($s+==+'9.012+G');|code-block|syntax|javascript|1295221|https://php.net/function.log10|1295222|entityMap|0|LINK|mutability|MUTABLE|url^0|7|5|0|0|0|U|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|W|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|X|8|@]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|M|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|L]]]]

Here is an option using <code>log10</code>:
<pre><code>&lt;?php

function format_number(float $d): string {
 $e = (int)(log10($d) / 3);
 return sprintf('%.3f', $d / 1e3 ** $e) . ['', ' k', ' M', ' G'][$e];
}

$s = format_number(9012345678);
var_dump($s == '9.012 G');
</code></pre>
<a href="https://php.net/function.log10" rel="nofollow noreferrer">https://php.net/function.log10</a>

Scenario: the size of various files are stored in a database as bytes. What's the best way to format this size info to kilobytes, megabytes and gigabytes? For instance I have an MP3 that Ubuntu displays as "5.2 MB (5445632 bytes)". How would I display this on a web page as "5.2 MB" AND have files less than one megabyte display as KB and files one gigabyte and above display as GB?

Format bytes to kilobytes, megabytes, gigabytes

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

场景:各种文件的大小以字节为单位存储在数据库中。将此大小信息格式化为千字节、兆字节和千兆字节的最佳方式是什么？例如，我有一个Ubuntu显示为“5.2MB (5445632字节)”的MP3。我如何在网页上将其显示为“5.2MB”，并使小于1MB的文件显示为KB，而1G以上的文件显示为GB？

问将字节格式化为千字节、兆字节、千兆字节
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将字节格式化为千字节、兆字节、千兆字节EN