Teil von  SELFPHP
Professional CronJob-Service

Suche

:: Anbieterverzeichnis ::

Globale Branchen

Informieren Sie sich über ausgewählte Unternehmen im Anbieterverzeichnis von SELFPHP  

 

:: SELFPHP Forum ::

Fragen rund um die Themen PHP?
In über 130.000 Beiträgen finden Sie sicher die passende Antwort!  

 

:: Newsletter ::

Abonnieren Sie hier den kostenlosen SELFPHP Newsletter!

Vorname: 
Name:
E-Mail:
 
 

:: Qozido ::

Die Bilderverwaltung mit Logbuch für Taucher und Schnorchler.   

 
 
Umrechnung Byte/Kilobyte/Megabyte – Byte/Kibibyte/Mebibyte

Am Ende der Seite finden Sie das komplette Beispiel als Download.

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$shorttrue)
{

    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.




 

Download

Info   ZIP BZIP2 TARGZ
Größe   1.23 Kilobyte 1.36 Kilobyte 1.29 Kilobyte

Alle Beispiele als PHP-Datei(en)

Hier haben Sie die Möglichkeit, sich sämtliche auf dieser Seite gezeigten Beispiele als PHP-Dateien direkt downzuloaden.

Umständliches Copy & Paste ist daher nicht mehr notwendig, da alle Beispiele sofort ausprobiert werden können.

Sie haben bei der Auswahl der bereitgestellten Downloads mehrere Möglichkeiten, je nachdem welches Komprimierungsverfahren Sie bevorzugen.

Zurück zur Übersichtsseite


 




:: Premium-Partner ::

Webhosting/Serverlösungen

MECO Systemhaus GmbH & Co. KG weitere Premium-Partner
 

:: SELFPHP Sponsor ::

ionCube Ltd. weitere Sponsoren
 


:: Buchempfehlung ::

Webseiten professionell erstellen

Webseiten professionell erstellen zur Buchempfehlung
 

:: Anbieterverzeichnis ::

Webhosting/Serverlösungen

Suchen Sie den für Sie passenden IT-Dienstleister für Ihr Webhosting-Paket oder Ihre Serverlösung?

Sie sind nur ein paar Klicks davon entfernt!


 

Ausgewählter Tipp im Bereich PHP-Skripte


Dateidownload realisieren

Weitere interessante Beispiele aus dem SELFPHP Kochbuch finden Sie im Bereich PHP-Skripte
 

SELFPHP Code Snippet


2 Versionsnummern (z.B. 2.12.23 mit 2.12.3) vergleichen

Weitere interessante Code Snippets finden Sie auf SELFPHP im Bereich PHP Code Snippets
 
© 2001-2016 E-Mail SELFPHP OHG, info@selfphp.deImpressumKontakt
© 2005-2016 E-Mail PHP5 Praxisbuch - Matthias Kannengiesser, m.kannengiesser@selfphp.de