|
Systemvoraussetzung
- Linux
- Windows
- PHP 3
- PHP 4
- PHP 5
Datei(en)
size_format.php
Problem
Täglich sehen wir auf Webseiten Dateien zum Download, bei denen die Dateigröße
nicht angegeben wird. Gerade diese Information ist für sehr viele
Besucher wichtig und sollte auch neben jeder Datei stehen. Wie Sie die Größe
einer Datei erhalten, sollte kein Problem darstellen – Sie nutzen ja dafür die
Funktion filesize().
Diese Größe erhalten Sie aber in Byte zurück. Für Sie ist das vielleicht eine Zahl,
mit der Sie umgehen können, für viele Besucher ist sie aber nicht aussagekräftig
genug. Sie sollten also die Größe jeweils in die entsprechende Darstellung
formatieren.
Aber gerade hier entstehen schon die ersten Probleme. Nehme ich für meine
Darstellung Kilobyte und Megabyte oder Kibibyte und Mebibyte, und wie ist
eigentlich der Umrechnungsfaktor? Waren das jetzt 1000 oder 1024, und was
gehört zu wem? 1000 zu Kibi oder 1000 zu Kilo?
Wie Sie sehen, gibt es einiges zu berücksichtigen. Es ist aber sehr wichtig
welches Präfix (z. B. Kibi oder Kilo) Sie für Ihre Darstellung der Dateigröße
nehmen. Je nachdem kommen unterschiedliche Größen heraus, und durch
eine falsche Bezeichnung kann es passieren, dass es bei einer Rückrechnung
mit einem korrekten Wert zu einer fehlerhaften Ausgabe kommt! Wir werden
uns im Anschluss um dieses Problem kümmern. In Zukunft lassen Sie die
Formatierung einfach durch die nachfolgende Funktion erledigen, da diese
Ihnen die komplette Arbeit abnimmt.
Lösung
Zuerst sollten wir uns kurz die Begriffserklärung anschauen. Wir werden in
diesem Buch nicht die komplette Bedeutung aufzeigen, sondern sie nur an
einem Beispiel kurz erläutern.
Wir sprechen in der Informatik sehr oft von Bit und Byte, wenn es um Daten
geht, also Speicherverbrauch, Übertragungsgeschwindigkeit oder z. B. Festplattengröße.
Wenn die Werte größer werden, rechnen wir sie um und fügen die Präfixe Kilo
(kBit/kByte), Mega (MBit/MByte), Giga (GBit/GByte), Tera (TBit/TByte) etc. vor
die Maßeinheit. Verwirrung entsteht, wenn man einen Wert angibt, dabei aber
die falsche Maßeinheit benutzt.
Von Kilobyte bis Yottabyte
- 1 Kilobyte (kB) sind 1000 Byte (10^3 Byte)
- 1 Megabyte (MB) sind 1.000.000 Byte (10^6 Byte)
- 1 Gigabyte (GB) sind 1.000.000.000 Byte (10^9 Byte)
- 1 Terabyte (TB) sind 1.000.000.000.000 Byte (10^12 Byte)
- 1 Petabyte (PB) sind 1.000.000.000.000.000 Byte (10^15 Byte)
- 1 Exabyte (EB) sind 1.000.000.000.000.000.000 Byte (10^18 Byte)
- 1 Zettabyte (ZB) sind 1.000.000.000.000.000.000.000 Byte (10^21 Byte)
- 1 Yottabyte (YB) sind 1.000.000.000.000.000.000.000.000 Byte (10^24 Byte)
Von Kibibyte bis Yobibyte
- 1 Kibibyte (KiB) sind 1024 Byte (2^10 Byte)
- 1 Mebibyte (MiB) sind 1.048.576 Byte (2^20 Byte)
- 1 Gibibyte (GiB) sind 1.073.741.824 Byte (2^30 Byte)
- 1 Tebibyte (TiB) sind 1.099511628E+12 Byte (2^40 Byte)
- 1 Pebibyte (PiB) sind 1.125899907 E+15 Byte (2^50 Byte)
- 1 Exbibyte (EiB) sind 1.152921505 E+18 Byte (2^60 Byte)
- 1 Zebibyte (ZiB) sind 1.180591621 E+21 Byte (2^70 Byte)
- 1 Yobibyte (YiB) sind 1.20892582 E+24 Byte (2^80 Byte)
Achtung: KB ist nicht gleich kB. Häufig wird zur Unterscheidung von Kilobyte
und Kibibyte jeweils der erste Buchstabe anders geschrieben.
- kB = Kilobyte
- KB = Kibibyte
Wir wollen aber an dieser Stelle nicht weiter auf dieses Thema eingehen. Achten
Sie jedenfalls darauf, dass Sie bei Berechnungen die richtige Einheit angeben.
Gerade Festplattenhersteller nutzen sehr gerne den Umrechnungsfaktor 1000,
da dadurch die gewonnene Zahl wesentlich größer wird und somit der Eindruck
entsteht, dass es sich um eine Festplatte mit größerer Kapazität handelt. Diese
Vorgehensweise ist nicht unüblich, man nutzt hier die Unwissenheit der Käufer
aus!
function binary_multiples($size, $praefix=true, $short= true)
@param integer $size
@param bool $praefix
@param bool $short
@return float $size
Die Funktion binary_multiples() erwartet als Parameter die umzurechnende
Größe in Byte, den auszugebenden Präfix als booleschen Wert (TRUE
berechnet durch den Faktor 1000 [für z. B. kB], FALSE berechnet durch den
Faktor 1024 [für z. B. KiB]) und als letzten Parameter die Schreibweise (TRUE =
Kurzschreibweise und FALSE = Langschreibweise).
Je nachdem, welches Format Sie für die Ausgabe haben möchten, wird in den
jeweiligen Zweigen verleitet. Wollen Sie z. B. Byte in Megabyte umrechnen,
wird der erste Zweig (39) und danach der nächste Zweig (45) abgearbeitet. Als
Umrechnungsfaktor dient dann die Zahl 1000.
Wollen Sie hingegen Byte in Mebibyte umrechnen, wird der äußere else-Zweig
(61) abgearbeitet und anschließend der innere else-Zweig
(67). Als Umrechnungsfaktor
wird dann die Zahl 1024 herangezogen.
Das eigentliche Kernstück dieser Funktion ist allerdings die Berechnung. Da wir
Byte in eine größere Maßeinheit umrechnen wollen, müssen wir den Bytewert
so lange durch den Umrechnungsfaktor dividieren (90), bis letztendlich die
richtige Maßeinheit gefunden wird. Wir sehen uns das anhand eines Beispiels
genauer an.
Die Ausgangslage sind 1099511627776 Byte, und wir nehmen für die Berechnung
den Umrechnungsfaktor 1024.
1099511627776 Bytes
1099511627776 / 1024 = 1073741823 Kibibyte
1073741823 / 1024 = 1048575.999 Mebibyte
1048575.999 / 1024 = 1023. 999999 Gibibyte
1023. 999999 / 1024 = 0.99 Tebibyte |
Als Ergebnis haben wir also 0.99 Tebibyte. Da allerdings in unserem Beispiel
Rundungsfehler enthalten sind, ist der tatsächliche Wert genau 1 Tebibyte.
Unsere WHILE-Schleife
(88) läuft also so lange, bis der umgerechnete Wert
kleiner als der Umrechnungsfaktor ist. Zusätzlich darf die Variable $x nicht
größer sein als die Menge der Arrayinhalte von den jeweiligen Namen ($norm).
Bei jedem Schleifendurchlauf erhöhen (91) wir $x, sodass wir nachher direkt
mit diesem Wert den jeweiligen Namen aus dem Array (94) nehmen können.
Zusätzlich formatieren wir zum Schluss unseren gefundenen Wert (94) und
kürzen ihn auf zwei Stellen. Wir müssen danach lediglich den formatierten
Wert an die aufrufende Stelle zurückgeben (96). 036:
037:
038:
039:
040:
041:
042:
043:
044:
045:
046:
047:
048:
049:
050:
051:
052:
053:
054:
055:
056:
057:
058:
059:
060:
061:
062:
063:
064:
065:
066:
067:
068:
069:
070:
071:
072:
073:
074:
075:
076:
077:
078:
079:
080:
081:
082:
083:
084:
085:
086:
087:
088:
089:
090:
091:
092:
093:
094:
095:
096:
097:
098: | function binary_multiples($size, $praefix=true, $short= true)
{
if($praefix === true)
{
if($short === true)
{
$norm = array('B', 'kB', 'MB', 'GB', 'TB', 'PB',
'EB', 'ZB', 'YB');
}
else
{
$norm = array('Byte',
'Kilobyte',
'Megabyte',
'Gigabyte',
'Terabyte',
'Petabyte',
'Exabyte',
'Zettabyte',
'Yottabyte'
);
}
$factor = 1000;
}
else
{
if($short === true)
{
$norm = array('B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB',
'EiB', 'ZiB', 'YiB');
}
else
{
$norm = array('Byte',
'Kibibyte',
'Mebibyte',
'Gibibyte',
'Tebibyte',
'Pebibyte',
'Exbibyte',
'Zebibyte',
'Yobibyte'
);
}
$factor = 1024;
}
$count = count($norm) -1;
$x = 0;
while ($size >= $factor && $x < $count)
{
$size /= $factor;
$x++;
}
$size = sprintf("%01.2f", $size) . ' ' . $norm[$x];
return $size;
} |
Beispiel 9.1: size_format.php
Der folgende Programmcode muss nicht erklärt werden, sondern dient hier
lediglich als Beispiel für unsere Ausgabe. Wir durchlaufen einfach ein Array
mit einer Vielzahl von Byte-Werten
und lassen uns diese formatiert ausgeben. 102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148: | <pre>
<?php
$test = array(1024,
1048576,
1073741824,
1099511627776,
1125899906842624,
1152921504606846976,
1180591620717411303424,
1208925819614629174706176
);
echo "Kurzform\n";
echo "--------\n";
for($x=0;$x<count($test);$x++)
{
echo binary_multiples($test[$x]) . "\n";
}
echo "\n";
echo "Langform\n";
echo "--------\n";
for($x=0;$x<count($test);$x++)
{
echo binary_multiples($test[$x],true,false) . "\n";
}
echo "\n";
echo "Kurzform\n";
echo "--------\n";
for($x=0;$x<count($test);$x++)
{
echo binary_multiples($test[$x],false) . "\n";
}
echo "\n";
echo "Langform\n";
echo "--------\n";
for($x=0;$x<count($test);$x++)
{
echo binary_multiples($test[$x],false,false) . "\n";
}
echo "\n";
?>
</pre>
|
Beispiel 9.2: size_format.php
Ausgabe im Browser
Kurzform
----------
1.02
kB
1.05 MB
1.07 GB
1.10 TB
1.13 PB
1.15 EB
1.18 ZB
1.21 YB
Langform
----------
1.02
Kilobyte
1.05 Megabyte
1.07 Gigabyte
1.10 Terabyte
1.13 Petabyte
1.15 Exabyte
1.18 Zettabyte
1.21 Yottabyte
Kurzform
----------
1.00
KiB
1.00 MiB
1.00 GiB
1.00 TiB
1.00 PiB
1.00 EiB
1.00 ZiB
1.00 YiB
Langform
----------
1.00
Kibibyte
1.00 Mebibyte
1.00 Gibibyte
1.00 Tebibyte
1.00 Pebibyte
1.00 Exbibyte
1.00 Zebibyte
1.00 Yobibyte |
Wie Sie sehen, haben Sie jetzt eine sehr schöne Funktion, um in Zukunft jeden
Bytewert in einer anderen Darstellung zu präsentieren.
Dieses Skript aus dem SELFPHP KOCHBUCH wurde von SELFPHP unter dem "Tarif Mc500" von McAc.net-Webhosting erfolgreich ausgeführt und getestet!
Auf der Übersichtseite unter "McAc.net – Webhosting zu diesem Buch" finden Sie weitere Informationen zu dem Webhostingpaket, dass durch SELFPHP getestet wurde.
|
SELFPHP
SELFPHP OHG, info@selfphp.de, Impressum, Kontakt