จัดรูปแบบไบต์เป็นกิโลไบต์เมกะไบต์กิกะไบต์

สถานการณ์จำลอง: ขนาดของไฟล์ต่าง ๆ จะถูกเก็บไว้ในฐานข้อมูลเป็นไบต์ วิธีที่ดีที่สุดในการจัดรูปแบบข้อมูลขนาดนี้เป็นกิโลไบต์เมกะไบต์และกิกะไบต์คืออะไร เช่นฉันมี MP3 ที่ Ubuntu แสดงเป็น "5.2 MB (5445632 bytes)" ฉันจะแสดงสิ่งนี้บนหน้าเว็บเป็น "5.2 MB" และมีไฟล์แสดงน้อยกว่าหนึ่งเมกะไบต์เป็น KB และไฟล์หนึ่งกิกะไบต์ขึ้นไปแสดงเป็น GB ได้อย่างไร

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

pseudocode:

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

นี่คือการนำไปใช้ของ Kohanaคุณสามารถใช้:

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 ง่ายเหมือนที่

เพียงทางเลือกของฉันสั้นและสะอาด:

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

ใช้ฟังก์ชั่นนี้หากคุณต้องการรหัสย่อ

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

ฉันรู้ว่ามันอาจจะสายไปซักนิดที่จะตอบคำถามนี้ แต่ข้อมูลเพิ่มเติมจะไม่ฆ่าใครซักคน นี่เป็นฟังก์ชั่นที่รวดเร็วมาก:

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

แก้ไข: ฉันอัปเดตโพสต์ของฉันเพื่อรวมการแก้ไขที่เสนอโดย 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 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"

ฉันประสบความสำเร็จด้วยฟังก์ชั่นต่อไปนี้

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

ฉันไม่รู้ว่าทำไมคุณควรทำให้มันซับซ้อนเหมือนคนอื่น ๆ

รหัสต่อไปนี้เข้าใจได้ง่ายกว่ามากและเร็วกว่าโซลูชั่นอื่น ๆ ที่ใช้ฟังก์ชันบันทึกประมาณ 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];
}

ฉันทำสิ่งนี้เพื่อแปลงอินพุตทั้งหมดเป็นไบต์และแปลงเป็นเอาต์พุตใด ๆ ที่ต้องการ นอกจากนี้ฉันใช้ฟังก์ชั่นที่คุ้นเคยเพื่อรับฐาน 1,000 หรือ 1024 แต่ปล่อยให้มันโค้งงอเพื่อตัดสินใจใช้ 1024 กับประเภทที่นิยม (โดยไม่มี 'i' เช่น MB แทนที่จะเป็น MiB)

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

ลองนี้;)

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

เพียงแค่เรียกฟังก์ชั่น

echo convertToReadableSize(1024); // Outputs '1KB'
echo convertToReadableSize(1024 * 1024); // Outputs '1MB'

ใช้งานได้กับ PHP ล่าสุด

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

    $bytes /= pow(1024, $pow); 

    return round($bytes, $precision) . ' ' . $units[$pow]; 
} 

แม้ว่าจะเป็นบิตแล้วห้องสมุดนี้มีAPI การแปลงที่ได้รับการทดสอบและมีประสิทธิภาพ:

https://github.com/gabrielelana/byte-units

เมื่อติดตั้งแล้ว:

\ByteUnits\Binary::bytes(1024)->format();

// Output: "1.00KiB"

และการแปลงในทิศทางอื่น:

\ByteUnits\Binary::parse('1KiB')->numberOfBytes();

// Output: "1024"

นอกเหนือจากการแปลงพื้นฐานมันมีวิธีการบวกการลบการเปรียบเทียบและอื่น ๆ

ฉันไม่มีทางเข้าร่วมกับห้องสมุดนี้

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 (ไบนารี) หรือฐาน 1,000 (ฐานสิบ) และยังทำงานกับตัวเลขจำนวนมากอย่างไม่น่าเชื่อดังนั้นการใช้ไลบรารี 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';
}

ฉันคิดว่าฉันจะเพิ่มการเชื่อมโยงของรหัสผู้ส่งสองคน (โดยใช้รหัสของ John Himmelman ซึ่งอยู่ในหัวข้อนี้และใช้รหัสของEugene Kuzmenko ) ที่ฉันใช้

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

นี่ใช้โค้ดของ Eugene เพื่อจัดรูปแบบ$valueเป็นไบต์ (ฉันเก็บข้อมูลของฉันเป็น MB ดังนั้นจึงแปลงข้อมูลของฉัน: 10485760 MBเป็น10995116277760) - จากนั้นใช้รหัสของ John เพื่อแปลงเป็นค่าการแสดงผลที่เหมาะสม ( 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];
}
?>

ฉันพัฒนาฟังก์ชั่นของตัวเองที่แปลงขนาดหน่วยความจำที่มนุษย์อ่านได้ให้เป็นขนาดที่แตกต่างกัน

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

ฟังก์ชั่นนี้รองรับตัวย่อขนาดหน่วยความจำเช่น "Megabyte, MB, Mb, mb, m, กิโลไบต์, K, KB, b, Terabyte, T .... " จึงปลอดภัย

ฐานในคำตอบของลีโอเพิ่ม

• รองรับการลบ
• สนับสนุน 0 <value <1 (เช่น 0.2 จะทำให้ log (value) = จำนวนลบ)

หากคุณต้องการหน่วยสูงสุดเป็นเมกะเปลี่ยนเป็น $units = explode(' ', ' K M');

function formatUnit($value, $precision = 2) {
    $units = explode(' ', ' K M G T P E Z Y');

    if ($value < 0) {
        return '-' . formatUnit(abs($value));
    }

    if ($value < 1) {
        return $value . $units[0];
    }

    $power = min(
        floor(log($value, 1024)),
        count($units) - 1
    );

    return round($value / pow(1024, $power), $precision) . $units[$power];
}