sintax - ruby on rails haml

¿Tamaño de archivo bonito en Ruby?

Question

Estoy tratando de hacer un método que convierta un entero que represente los bytes a una cadena con un formato "preparado".

Aquí está mi intento medio de trabajo:

class Integer
def to_filesize
{
''B'' => 1024,
''KB'' => 1024 * 1024,
''MB'' => 1024 * 1024 * 1024,
''GB'' => 1024 * 1024 * 1024 * 1024,
''TB'' => 1024 * 1024 * 1024 * 1024 * 1024
}.each_pair { |e, s| return "#{s / self}#{e}" if self < s }
end
end

¿Qué estoy haciendo mal?

Answer 1

¿Qué tal la gema del tamaño de archivo? Parece poder convertir de bytes (y otros formatos) a valores impresos bonitos:

ejemplo:

Filesize.from("12502343 B").pretty # => "11.92 MiB"

http://rubygems.org/gems/filesize

Answer 2

Esta es mi solución:

def filesize(size)
units = [''B'', ''KiB'', ''MiB'', ''GiB'', ''TiB'', ''Pib'', ''EiB'']
return ''0.0 B'' if size == 0
exp = (Math.log(size) / Math.log(1024)).to_i
exp = 6 if exp > 6
''%.1f %s'' % [size.to_f / 1024 ** exp, units[exp]]
end

Comparado con otras soluciones, es más simple, más eficiente y genera un resultado más adecuado.

Formato

Tanto to_filesize como to_human tienen problemas con grandes números. format_mb tiene un caso extraño en el que, por ejemplo, ''1 MiB'' se considera ''1024 KiB'', que es algo que algunas personas pueden desear, pero ciertamente no yo.

 origin: filesize to_filesize format_mb to_human
0 B: 0.0 B 0.0B 0 b 0.00 B
1 B: 1.0 B 1.0B 1 b 1.00 B
10 B: 10.0 B 10.0B 10 b 10.00 B
1000 B: 1000.0 B 1000.0B 1000 b 1000.00 B
1 KiB: 1.0 KiB 1.0KB 1024 b 1.00 KB
1.5 KiB: 1.5 KiB 1.5KB 1536.0 b 1.50 KB
10 KiB: 10.0 KiB 10.0KB 10.000 kb 10.00 KB
100 KiB: 100.0 KiB 100.0KB 100.000 kb 100.00 KB
1000 KiB: 1000.0 KiB 1000.0KB 1000.000 kb 1000.00 KB
1 MiB: 1.0 MiB 1.0MB 1024.000 kb 1.00 MB
1 Gib: 1.0 GiB 1.0GB 1024.000 mb 1.00 GB
1 TiB: 1.0 TiB 1.0TB 1024.000 gb 1.00 TB
1 PiB: 1.0 Pib ERROR 1024.000 tb 1.00 PB
1 EiB: 1.0 EiB ERROR 1024.000 pb 1.00 EB
1 ZiB: 1024.0 EiB ERROR 1024.000 eb ERROR
1 YiB: 1048576.0 EiB ERROR 1048576.000 eb ERROR

Actuación

Además, tiene el mejor rendimiento.

 user system total real
filesize: 2.740000 0.000000 2.740000 ( 2.747873)
to_filesize: 3.560000 0.000000 3.560000 ( 3.557808)
format_mb: 2.950000 0.000000 2.950000 ( 2.949930)
to_human: 5.770000 0.000000 5.770000 ( 5.783925)

Probé cada implementación con un generador de números aleatorios realista:

def numbers
Enumerator.new do |enum|
1000000.times do
exp = rand(5)
num = rand(1024 ** exp)
enum.yield num
end
end
end

Answer 3

Estoy de acuerdo con @David en que probablemente sea mejor utilizar una solución existente, pero para responder a su pregunta sobre lo que está haciendo mal:

1. El error primario es dividir s por self lugar de al revés.
2. Realmente quieres dividir por la s anterior, entonces divide s por 1024.
3. Hacer aritmética de enteros le dará resultados confusos, así que conviértalos a flotar.
4. Quizás redondear la respuesta.

Asi que:

class Integer
def to_filesize
{
''B'' => 1024,
''KB'' => 1024 * 1024,
''MB'' => 1024 * 1024 * 1024,
''GB'' => 1024 * 1024 * 1024 * 1024,
''TB'' => 1024 * 1024 * 1024 * 1024 * 1024
}.each_pair { |e, s| return "#{(self.to_f / (s / 1024)).round(2)}#{e}" if self < s }
end
end

te deja:

1.to_filesize # => "1.0B" 1020.to_filesize # => "1020.0B" 1024.to_filesize # => "1.0KB" 1048576.to_filesize # => "1.0MB"

Nuevamente, no recomiendo hacerlo, pero vale la pena corregir los errores.

Answer 4

La solución de @Darshan Computing es solo parcial aquí. Dado que no se garantiza que se ordenen las claves hash, este enfoque no funcionará de manera confiable. Podría arreglar esto haciendo algo como esto dentro del método to_filesize,

 conv={
1024=>''B'',
1024*1024=>''KB'',
...
}
conv.keys.sort.each { |s|
next if self >= s
e=conv[s]
return "#{(self.to_f / (s / 1024)).round(2)}#{e}" if self < s }
}

Esto es lo que terminé haciendo para un método similar dentro de Float,

 class Float
def to_human
conv={
1024=>''B'',
1024*1024=>''KB'',
1024*1024*1024=>''MB'',
1024*1024*1024*1024=>''GB'',
1024*1024*1024*1024*1024=>''TB'',
1024*1024*1024*1024*1024*1024=>''PB'',
1024*1024*1024*1024*1024*1024*1024=>''EB''
}
conv.keys.sort.each { |mult|
next if self >= mult
suffix=conv[mult]
return "%.2f %s" % [ self / (mult / 1024), suffix ]
}
end
end

Answer 5

Obtiene puntos por agregar un método a Integer, pero esto parece ser más específico del archivo, por lo que sugeriría que haga monos con File, por ejemplo, agregando un método al archivo llamado .prettysize ().

Pero aquí hay una solución alternativa que utiliza la iteración y evita la impresión de bytes individuales como flotante :-)

def format_mb(size)
conv = [ ''b'', ''kb'', ''mb'', ''gb'', ''tb'', ''pb'', ''eb'' ];
scale = 1024;
ndx=1
if( size < 2*(scale**ndx) ) then
return "#{(size)} #{conv[ndx-1]}"
end
size=size.to_f
[2,3,4,5,6,7].each do |ndx|
if( size < 2*(scale**ndx) ) then
return "#{''%.3f'' % (size/(scale**(ndx-1)))} #{conv[ndx-1]}"
end
end
ndx=7
return "#{''%.3f'' % (size/(scale**(ndx-1)))} #{conv[ndx-1]}"
end

Answer 6

Si lo usa con Rails, ¿qué pasa con el asistente de números de Rails estándar?

http://api.rubyonrails.org/classes/ActionView/Helpers/NumberHelper.html#method-i-number_to_human_size

number_to_human_size(number, options = {})

?