Jolie taille de fichier dans Ruby?

Je suis en train de faire une méthode qui convertit un entier qui représente octets d'une chaîne avec un " prettied jusqu'format.

Voici mon demi-travail tentative:

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

Ce que je fais mal?

source d'informationauteur TeamBlast

22

Comment au sujet de la Taille de gemme ? Il semble être en mesure de convertir des octets (et autres formats) dans de jolis imprimés valeurs:

exemple:
```
Filesize.from("12502343 B").pretty      # => "11.92 MiB"
```
http://rubygems.org/gems/filesize
24

Si vous l'utilisez avec Rails - ce que sur les Rails numéro de l'aide?

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

number_to_human_size(number, options = {})

?
13

Je suis d'accord avec @David, il est probablement préférable d'utiliser une solution existante, mais pour répondre à votre question au sujet de ce que vous faites mal:
1. La principale erreur est de diviser s par self plutôt que l'inverse.
2. Vous voulez vraiment diviser par le précédent sdonc le diviser s par 1024.
3. Faire de l'arithmétique des nombres entiers vous donnera des résultats confus, afin de convertir à flotteur.
4. Peut-être le tour de la réponse.
Donc:
```
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
```
vous permet de:
```
1.to_filesize 
# => "1.0 B" 
1020.to_filesize 
# => "1020.0 B" 
1024.to_filesize 
# => "1.0 KB" 
1048576.to_filesize 
# => "1.0 MB" 
```
Encore une fois, je ne recommande pas réellement le faire, mais il semble en vaut la correction de bugs.

Vous obtenez des points pour l'ajout d'une méthode à l'Entier, mais cela semble de plus en plus de Fichiers spécifiques, je vous suggère monkeying autour de Fichier, par exemple par l'ajout d'une méthode pour Fichier appelé .prettysize().

Mais ici, c'est une solution alternative qui utilise itération, et évite l'impression de les octets en tant que float 🙂

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

C'est ma solution:

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

Par rapport à d'autres solutions, c'est plus simple, plus efficace, et génère une plus bonne sortie.

Format

Les deux to_filesize et to_human ont des problèmes avec de grands nombres. format_mb a un drôle de cas où, par exemple, '1 MiB" est considéré comme "1024 Ko" qui est quelque chose que l'on pourrait vouloir, mais certainement pas moi.

    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

Performance

Aussi, il a le meilleur rendement.

                      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)

J'ai testé chaque mise en œuvre réaliste le générateur de nombre aléatoire:

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

@Darshan de Calcul de la solution n'est que partielle ici. Depuis les clés de hachage ne sont pas garantis pour être commandé cette approche ne fonctionnera pas de manière fiable. Vous pouvez résoudre ce problème en faisant quelque chose comme cela à l'intérieur de la to_filesize méthode,

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

C'est ce que j'ai fait pour une méthode similaire à l'intérieur du Flotteur,

 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

Vous devez vous connecter pour publier un commentaire.