Comment obtenir la taille d'un fichier en mégaoctets en utilisant Perl?

Je veux obtenir la taille d'un fichier sur le disque en méga-octets. À l'aide de la -s opérateur me donne la taille en octets, mais je vais supposer que puis en divisant ce chiffre par un nombre magique est une mauvaise idée:

my $size_in_mb = (-s $fh) / (1024 * 1024);

Devrais-je utiliser un en lecture seule variable pour définir 1024 ou est-il un moyen via un programme pour obtenir le nombre d'octets dans un kilo-octet?

EDIT: mis à Jour le calcul incorrect.

source d'informationauteur cowgod

29

Si vous voulez éviter des numéros de magie, essayez le module CPAN Numéro: Octets::Homme.
```
use Number::Bytes::Human qw(format_bytes);
my $size = format_bytes(-s $file); # 4.5M
```
6

Vous pouvez bien sûr créer une fonction pour le calcul de cette. C'est une meilleure solution que de créer des constantes dans cette instance.
```
sub size_in_mb {
    my $size_in_bytes = shift;
    return $size_in_bytes / (1024 * 1024);
}
```
Pas nécessaire pour les constantes. La modification de la 1024 à une sorte de variable/constant de ne pas rendre ce code plus lisible.
4

Bien, il n'y a pas de 1024 octets dans un meg, il y a 1024 octets dans un K, et 1024 K dans un meg...

Cela dit, 1024 est un coffre-fort "de la magie" nombre qui ne changera jamais dans tout système, vous pouvez vous attendre de votre programme de travail.
4

Je lisais ça dans une variable plutôt que d'utiliser un nombre magique. Même si des numéros de magie ne vont pas changer, comme le nombre d'octets dans un mégaoctet, à l'aide d'un bien nommée constante est une bonne pratique car il rend votre code plus lisible. Il rend immédiatement évident pour tout le monde ce que votre intention est.

C'est une vieille question et a déjà été répondu correctement, mais juste au cas où votre programme est limitée pour les modules de base et vous ne pouvez pas utiliser Numéro: Octets::Homme ici vous avez plusieurs autres options que j'ai été collectées au fil du temps. J'ai gardé aussi parce que chacun d'utiliser un autre Perl et est un bel exemple de l' TIMTOWTDI:

exemple 1: utilise l'état pour éviter de réinitialiser la variable à chaque fois (avant de perl 5.16 vous devez utiliser la fonctionnalité de l'état ou perl -E)

http://kba49.wordpress.com/2013/02/17/format-file-sizes-human-readable-in-perl/

    sub formatSize {
        my $size = shift;
        my $exp = 0;

        state $units = [qw(B KB MB GB TB PB)];

        for (@$units) {
            last if $size < 1024;
            $size /= 1024;
            $exp++;
        }

        return wantarray ? ($size, $units->[$exp]) : sprintf("%.2f %s", $size, $units->[$exp]);
    }

exemple 2: utilisation de trier les carte

sub scaledbytes {

    # http://www.perlmonks.org/?node_id=378580
    (sort { length $a <=> length $b 
          } map { sprintf '%.3g%s', $_[0]/1024**$_->[1], $_->[0]
                }[" bytes"=>0]
                ,[KB=>1]
                ,[MB=>2]
                ,[GB=>3]
                ,[TB=>4]
                ,[PB=>5]
                ,[EB=>6]
    )[0]
  }

exemple 3: profiter du fait que 1 Go = 1024 Mo, 1 Mo = 1024 Ko et 1024 = 2 ** 10:

# http://www.perlmonks.org/?node_id=378544
my $kb = 1024 * 1024; # set to 1 Gb

my $mb = $kb >> 10;
my $gb = $mb >> 10;

print "$kb kb = $mb mb = $gb gb\n";
__END__
1048576 kb = 1024 mb = 1 gb

exemple 4: utilisation de ++$n and ... until .. pour obtenir un indice de la matrice

# http://www.perlmonks.org/?node_id=378542
#! perl -slw
use strict;

sub scaleIt {
    my( $size, $n ) =( shift, 0 );
    ++$n and $size /= 1024 until $size < 1024;
    return sprintf "%.2f %s",
           $size, ( qw[ bytes KB MB GB ] )[ $n ];
}

my $size = -s $ARGV[ 0 ];

print "$ARGV[ 0 ]: ", scaleIt $size;

Même si vous ne pouvez pas utiliser ce Numéro::Octets::Humain, prendre un coup d'oeil au code source pour voir toutes les choses que vous devez être conscient de.

1

1) Vous ne voulez pas 1024. Qui vous donne kilo-octets. Vous souhaitez 1024*1024, ou 1048576.

2) Pourquoi les divisant par un nombre magique est une mauvaise idée? Ce n'est pas comme le nombre d'octets dans un mégaoctet ne changera jamais. Ne pas overthink trop de choses.
1

Ne m'obtenez pas le mal, mais: je pense que la déclaration de 1024 comme une Magie Variable va un peu trop loin, c'est un peu comme "$UN = 1; $DEUX = 2;" etc.

Un kilo-Octet a été faussement déclaré que 1024 Octets depuis plus de 20 ans, et je doute sérieusement que le système d'exploitation, les fabricants auront jamais de corriger ce bug et de le modifier pour 1000.

Ce qui pourrait faire sens, cependant, est de déclarer la non-évident trucs comme "$méga-octet = 1024 * 1024", car c'est plus lisible que 1048576.
1

Depuis le-s de l'opérateur retourne la taille du fichier en octets, vous devriez probablement faire quelque chose comme
```
my $size_in_mb = (-s $fh) / (1024 * 1024);
```
et utiliser int() si vous avez besoin d'un chiffre rond. Ce n'est pas comme les dimensions de KO ou MO va changer à tout moment dans le futur proche 🙂

Vous devez vous connecter pour publier un commentaire.