php - mejor - que es mas un gb o un mb en internet

Formato de bytes a kilobytes, megabytes, gigabytes

Question

Escenario: el tamaño de varios archivos se almacena en una base de datos como bytes. ¿Cuál es la mejor forma de formatear esta información de tamaño a kilobytes, megabytes y gigabytes? Por ejemplo, tengo un MP3 que Ubuntu muestra como "5.2 MB (5445632 bytes)". ¿Cómo podría mostrar esto en una página web como "5.2 MB" Y tener archivos de menos de un megabyte como KB y archivos de un gigabyte y más como GB?

Answer 1

Aquí hay una implementación simplificada de la función 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;
  }
}

Answer 2

Desarrollé mi propia función que convierte el tamaño de la memoria humana legible a diferentes tamaños.

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

Esta función acepta cualquier abreviatura de tamaño de memoria como "Megabyte, MB, Mb, mb, m, kilobyte, K, KB, b, Terabyte, T ...." por lo que es seguro contra errores tipográficos.

Answer 3

Es un poco tarde, pero a continuación se incluye una versión ligeramente más rápida de la respuesta aceptada:

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

Es más eficiente, debido a la realización de una única operación de log-2 en lugar de dos operaciones de log-e.

Sin embargo, en realidad es más rápido hacer la solución más obvia a continuación:

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

Esto se debe a que el índice se calcula al mismo tiempo que el valor del número de bytes en la unidad apropiada. Esto redujo el tiempo de ejecución en aproximadamente un 35% (un aumento de velocidad del 55%).

Answer 4

Esta es Kohana''s implementación Kohana''s , podrías usarla:

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

Answer 5

Esta es la implementación de Chris Jester-Young, la más limpia que he visto, combinada con php.net y un argumento de precisión.

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

Answer 6

Función extremadamente simple para obtener el tamaño de archivo humano.

Fuente original: http://php.net/manual/de/function.filesize.php#106569

Copiar / pegar código:

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

Answer 7

Función simple

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

Answer 8

Logré con la siguiente función

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

Answer 9

Mi acercamiento

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

Answer 10

No sé por qué deberías hacerlo tan complicado como los demás.

El siguiente código es mucho más fácil de entender y aproximadamente un 25% más rápido que las otras soluciones que usan la función de registro (llamada función 20 Mio. veces con diferentes parámetros)

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

Answer 11

Otra implementación condensada que puede traducirse a la base 1024 (binario) o base 1000 (decimal) y también funciona con números increíblemente grandes, por lo tanto, del uso de la biblioteca 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'';
}

Answer 12

Pensé que agregaría un mallado de dos códigos de remitentes (usando el código de John Himmelman, que está en este hilo y usando el código de Eugene Kuzmenko ) que estoy usando.

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

Esto usa el código de Eugene para formatear el $value en bytes (guardo mis datos en MB, entonces convierte mis datos: 10485760 MB en 10995116277760 ) - luego usa el código de John para convertirlo en el valor de visualización adecuado ( 10995116277760 en 10 TB ) .

Esto me ha resultado muy útil, ¡así que gracias a los dos remitentes!

Answer 13

Pseudocódigo:

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

Answer 14

Sé que tal vez sea un poco tarde para responder esta pregunta, pero más datos no matarán a nadie. Aquí hay una función muy rápida:

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

EDITAR: Actualicé mi publicación para incluir la solución propuesta por 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'';
}

Answer 15

Simplemente divídalo por 1024 para kb, 1024 ^ 2 para mb y 1024 ^ 3 para GB. Tan sencillo como eso.

Answer 16

Solo mi alternativa, corta y limpia:

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

o, más estúpido y eficiente:

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

Answer 17

prueba esto ;)

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

Answer 18

usa esta función si quieres un código corto

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

Answer 19

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

Answer 20

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

Answer 21

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

Solo llame a la función

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

Answer 22

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

(Tomado de php.net , hay muchos otros ejemplos allí, pero este me gusta más :-)