Grössenangabe automatische Umwandlung

**GreenHorn3600**

Hallo Wissende,

ich bin auf der Suche nach einer Funktion, welcher man die Größe einer Datei in Byte übergibt und die dann die Bytegröße, Größe in KB, MB, GB oder TB ausgibt mit der entsprechenden Größenangabe. Kennt jemand von euch so eine Standardfunktion, oder muß ich mir das was selbst basteln?

Schöne Grüße
Euer GreenHorn

**khh**

na das sollte doch eine einfache rechnung bewerkstelligen, wenn man weiss wieviele bytes ein kbyte hat

**GreenHorn3600**

Ganz so einfach ist es halt nicht, da man noch entsprechende Regeln mit berücksichtigen muss, ab wann man z.B. zur anderen Größenordnung übergeht ohne daß man zu ungenau ist. Da dies aber sehr häufig in Windows zu sehen ist, wie sich die Einheiten ändern, sollte eigentlich eine Standardfunktion hierfür bestehen. Soll ja auch stimmig sein. Fängt ja alleine schon mal an, wieviel ist ein kB 1000 oder 1024 Byte?

Euer GreenHorn

**khh**

Zitat von GreenHorn3600:

Fängt ja alleine schon mal an, wieviel ist ein kB 1000 oder 1024 Byte?

Euer GreenHorn

ein KB war und ist schon immer 1024 byte.

**Bernhard Geyer**

Zitat von GreenHorn3600:

Ganz so einfach ist es halt nicht, da man noch entsprechende Regeln mit berücksichtigen muss, ab wann man z.B. zur anderen Größenordnung übergeht ohne daß man zu ungenau ist.

Das wird auch Anwendungsanfall-Abhängig sein

Zitat von GreenHorn3600:

Da dies aber sehr häufig in Windows zu sehen ist, wie sich die Einheiten ändern, sollte eigentlich eine Standardfunktion hierfür bestehen.

Kannst ja bei MS nachfragen ob sie dir den Quellcode des Windows Explorer geben.

Zitat von GreenHorn3600:

Soll ja auch stimmig sein. Fängt ja alleine schon mal an, wieviel ist ein kB 1000 oder 1024 Byte?

Wiki gibt doch hier

außreichend Info liefern

**himitsu**

zusammenfalten · markieren

Delphi-Quellcode:

			Function SizeToString(Const Size: Int64): String;

  Begin

    If Size < 1000 Then Result := Format('%d B', [Size])

    Else If Size < 10235 Then Result := Format('%.2n KB', [Size / 1024])

    Else If Size < 102349 Then Result := Format('%.1n KB', [Size / 1024])

    Else If Size < 1023488 Then Result := Format('%.0n KB', [Size / 1024])

    Else If Size < 10480518 Then Result := Format('%.2n MB', [Size / 1048576])

    Else If Size < 104805172 Then Result := Format('%.1n MB', [Size / 1048576])

    Else If Size < 1048051712 Then Result := Format('%.0n MB', [Size / 1048576])

    Else If Size < 10732049531 Then Result := Format('%.2n GB', [Size / 1073741824])

    Else If Size < 107320495309 Then Result := Format('%.1n GB', [Size / 1073741824])

    Else If Size < 1073204953088 Then Result := Format('%.0n GB', [Size / 1073741824])

    Else If Size < 10989618719622 Then Result := Format('%.2n TB', [Size / 1099511627776])

    Else If Size < 109896187196212 Then Result := Format('%.1n TB', [Size / 1099511627776])

    Else If Size < 1098961871962112 Then Result := Format('%.0n TB', [Size / 1099511627776])

    Else If Size < 11253369568892027 Then Result := Format('%.2n PB', [Size / 1125899906842624])

    Else If Size < 112533695688920269 Then Result := Format('%.1n PB', [Size / 1125899906842624])

    Else If Size < 1125336956889202688 Then Result := Format('%.0n PB', [Size / 1125899906842624])

    Else Result := Format('%.2n EB', [Size / 1152921504606846976]);

  End;

es ginge auch über eine Schleife zu berechnen, aber das ist so eine der schnellsten Möglichkeiten

falls sich wer über die "krummen" Zahlen wundert, diese sind so gewählt, daß der Wert immer mit maximal 3 Stellen (Vor- und Nachkomma) und in der optimalsten, dazupassenden Skalierung dargestellt wird.

gerechnet mit 1024, damit es zu den Werten im Explorer paßt (ja, ich kenn das 1000er-Besteben, aber ich halte mich ans gängige Verhalten des BS)

!!! Achtung: wenn am Rundungsverhalten der FPU rumgespielt wurde, muß/sollte es für diese Funktion wieder zurückgestellt werden, oder man muß dieses auch noch mit hier einbauen.

**sirius**

http://forum.delphi-treff.de/showthread.php?t=26330

**GreenHorn3600**

Dank Euch. Werde mal auf die Lib von himitsu zurückgreifen. Wenn jemand noch etwas mehr Standardkonformes hat, bin ich da nicht gegen abgeneigt.

Schöne Grüße
Euer GreenHorn

**himitsu**

Dieser Code ist theoretisch so optimiert, daß es maximal 3 Zahlen im Ergebnis gibt (abgesehn von stsFull)

zusammenfalten · markieren

Delphi-Quellcode:

			Type TSTSFormat = (sts2, sts10, sts2Long, sts10Long, stsFull);

Function SizeToString(Const Size: Int64; SFormat: TSizeFormat): String;

  Const D: Array[0..17] of Integer = (1000, 10235, 102349, 1023488, 10480518,

      104805172, 1048051712, 10732049531, 107320495309, 1073204953088,

      10989618719622, 109896187196212, 1098961871962112, 11253369568892027,

      112533695688920269, 1125336956889202688, 0);

    S: Array[sts2..sts10Long] of Array[0..7] of String = (('%.*n B', '%.*n KB',

      '%.*n MB', '%.*n GB', '%.*n TB', '%.*n PB', '%.*n EB'), ('%.*n B', '%.*n KiB',

      '%.*n MiB', '%.*n GiB', '%.*n TiB', '%.*n PiB', '%.*n EiB'), ('%.*n Byte',

      '%.*n Kilobyte', '%.*n Megabyte', '%.*n Gigabyte', '%.*n Terabyte',

      '%.*n Petabyte', '%.*n Exabyte'), ('%.*n Byte', '%.*n Kibibyte', '%.*n Mebibyte',

      '%.*n Gibibyte', '%.*n Tebibyte', '%.*n Pebibyte', '%.*n Exbibyte');

    X: Array[0..7] of Integer = (1, 1024, 1048576, 1073741824, 1099511627776,

      1125899906842624, 1152921504606846976);

  Var i: Integer;

  Begin

    If SFormat < stsFull Then Begin

      i := 0;

      While (i < 17) and (Size < D[i]) do Inc(i);

      Result := Format(S[SFormat, (i + 2) div 3],

        [2 - ((i + 2) mod 3), Size / X[(i + 2) div 3]]); 

    Else Result := Format(S[sts2Long, 0], [Size / 1]); 

  End;

Hab grad kein Delphi hier, also ist es noch komplett ungetestet.

**himitsu**

OK, abgesehn von ein paar Denkfehlern und dem Verzählen bei den Arraygrößen ...

sollte es jetzt gehn und es sollte für jeden was dabei sein

zusammenfalten · markieren

Delphi-Quellcode:

			Type TSTSFormat = (stsShort, stsLong, sts2, sts2Long, sts10, sts10Long, stsFull);

Function SizeToString(Const Size: Int64; SFormat: TSTSFormat; Const ErrorStr: String = ''): String;

  Const D: Array[Boolean, 0..16] of Int64 = ((1000, 10235, 102349, 1023488, 10480518, 104805172,

      1048051712, 10732049531, 107320495309, 1073204953088, 10989618719622, 109896187196212,

      1098961871962112, 11253369568892027, 112533695688920269, 1125336956889202688, 0), (1000,

      9995, 99950, 999500, 9995000, 99950000, 999500000, 9995000000, 99950000000, 999500000000,

      9995000000000, 99950000000000, 999500000000000, 9995000000000000, 99950000000000000,

      999500000000000000, 0));

    S: Array[sts2..sts10Long] of Array[0..6] of String = (('%.*n B', '%.*n KiB', '%.*n MiB',

      '%.*n GiB', '%.*n TiB', '%.*n PiB', '%.*n EiB'), ('%.*n Byte', '%.*n Kibibyte',

      '%.*n Mebibyte', '%.*n Gibibyte', '%.*n Tebibyte', '%.*n Pebibyte', '%.*n Exbibyte'), (

      '%.*n B', '%.*n KB', '%.*n MB', '%.*n GB', '%.*n TB', '%.*n PB', '%.*n EB'), ('%.*n Byte',

      '%.*n Kilobyte', '%.*n Megabyte', '%.*n Gigabyte', '%.*n Terabyte', '%.*n Petabyte',

      '%.*n Exabyte'));

    X: Array[Boolean, 0..6] of Int64 = ((1, 1024, 1048576, 1073741824, 1099511627776,

      1125899906842624, 1152921504606846976), (1, 1000, 1000000, 1000000000, 1000000000000,

      1000000000000000, 1000000000000000000));

  Var i: Integer;

    F:   TSTSFormat;

  Begin

    If Size >= 0 Then Begin

      If SFormat < stsFull Then Begin

        i := 0;

        While (i < High(D[False])) and (Size >= D[SFormat >= sts10, i]) do Inc(i);

        Inc(i, 2);

        F := SFormat;

        If F < sts2 Then Inc(F, 4);

        Result := Format(S[F, i div 3], [2 - (i mod 3), Size / X[SFormat >= sts10, i div 3]]);

      End Else Result := Format(S[sts2Long, 0], [0, Size / 1]);

    End Else Result := Format(ErrorStr, [Size, Size / 1]);

  End;

Wie gesagt, es wird immer auf maximal 3 Stellen gerundet angezeigt.
(dieses funktioniert aber nur richtig, wenn der Standardrundungsmodus verwendet wird und bei den 1000er-Schritten muß ich mal sehn, ob es so auch noch stimmt)

Für ErrorStr kann man sonstewas angeben, welches genutzt wird, wenn der Wert negativ ist.
z.B.: "Fehler", "%d" oder "%1:.0f Byte"

Grössenangabe automatische Umwandlung

Grössenangabe automatische Umwandlung

Re: Grössenangabe automatische Umwandlung

Re: Grössenangabe automatische Umwandlung

Re: Grössenangabe automatische Umwandlung

Re: Grössenangabe automatische Umwandlung

Re: Grössenangabe automatische Umwandlung

Re: Grössenangabe automatische Umwandlung

Re: Grössenangabe automatische Umwandlung

Re: Grössenangabe automatische Umwandlung

Re: Grössenangabe automatische Umwandlung

Forumregeln

khh Registriert seit: 18. Apr 2008 Ort: Südbaden 1.903 Beiträge FreePascal / Lazarus	#2 Re: Grössenangabe automatische Umwandlung 7. Aug 2009, 10:00 na das sollte doch eine einfache rechnung bewerkstelligen, wenn man weiss wieviele bytes ein kbyte hat Karl-Heinz
	Zitat

khh Registriert seit: 18. Apr 2008 Ort: Südbaden 1.903 Beiträge FreePascal / Lazarus	#4 Re: Grössenangabe automatische Umwandlung 7. Aug 2009, 10:12 Zitat von GreenHorn3600: Fängt ja alleine schon mal an, wieviel ist ein kB 1000 oder 1024 Byte? Euer GreenHorn ein KB war und ist schon immer 1024 byte. Karl-Heinz
	Zitat

sirius Registriert seit: 3. Jan 2007 Ort: Dresden 3.443 Beiträge Delphi 7 Enterprise	#7 Re: Grössenangabe automatische Umwandlung 7. Aug 2009, 10:26 http://forum.delphi-treff.de/showthread.php?t=26330 Dieser Beitrag ist für Jugendliche unter 18 Jahren nicht geeignet.
	Zitat

GreenHorn3600 Registriert seit: 24. Jun 2007 165 Beiträge	#8 Re: Grössenangabe automatische Umwandlung 7. Aug 2009, 10:42 Dank Euch. Werde mal auf die Lib von himitsu zurückgreifen. Wenn jemand noch etwas mehr Standardkonformes hat, bin ich da nicht gegen abgeneigt. Schöne Grüße Euer GreenHorn
	Zitat