Procedure.s byterechner(byte.f, nachkommastellen.l)

[AND51]

Procedure.s byterechner(byte.f, nachkommastellen.l) (einen passenderen Titel gibt's gar nicht)

... und wieder ein kleiner Codeschnipsel.
Diese Prozedur wandelt eine Byteangabe in die sinnvoll größte Einheit um und hängt diese dann auch dahinter. Angaben kleiner als 0, wie sie zum Beispiel von FileSize() wiedergegeben werden, werden von der Prozedur ignoriert. Macht manuelle If-Abfragen unnötig.
Die Rückgabe erfolgt (natürlich) als String.

Code: Alles auswählen

Procedure.s byterechner(byte.f, nachkommastellen.l)
	;	© AND-Software, 2006
	Protected temp$
	If byte < 0
		ProcedureReturn ""
	EndIf
	If byte < 1024
		byte=byte
		temp$="Byte"
		nachkommastellen=0
	EndIf
	If byte >= 1024
		byte=byte/1024
		temp$="KB"
	EndIf
	If byte >= 1024
		byte=byte/1024
		temp$="MB"
	EndIf
	If byte >= 1024
		byte=byte/1024
		temp$="GB"
	EndIf
	If byte >= 1024
		byte=byte/1024
		temp$="TB"
	EndIf
	ProcedureReturn StrF(byte, Abs(nachkommastellen))+" "+temp$
EndProcedure

Debug byterechner(FileSize("about:blank"), 2) ; nichts, da nicht existent/keine Größe
Debug byterechner(75991, 1)                   ; ca. 75 KB
Debug byterechner(12*1024*1024+339, 0)        ; ca. 12 MB

Wenn ihr Lust habt, könnt ihr ja mal eure Meinung posten, bin gespannt. Auch wenn es eine einfache Prozedur ist, dann braucht ihr sie wenigstens nicht mehr zu tippen.

[MVXA]

Code: Alles auswählen

Procedure.s ByteRechner(fSize.f)
    Protected lLevel.l, sName.s
    
    Restore pNamen
    If fSize > 0.0
        Read sName
        
        While fSize > 1024
            fSize / 1024
            Read sName
        Wend
    
        ProcedureReturn StrF(fSize, 2) + sName
        
    Else 
        ProcedureReturn ""
    EndIf
    
EndProcedure

Debug ByteRechner(1024*1024*10)

DataSection
    pNamen:
        Data.s " Byte", " KByte", " MByte", " GByte", " TByte"
EndDataSection

Das ist meine Meinung

[AND51]

Tja, deine Prozedur ist kürzer. Man sagt ja auch immer, auf die Länge kommt es ja sowieso nicht an
Bei deiner Prozedur muss man aber immer außerhalb der eigentlichen Prozedur die DataSection mitschleifen.

Naja, ist ja auch egal, welche Prozedur eher genutzt wird. Trotzdem danke für deine Meinung...

[HeX0R]

Bei deiner Prozedur muss man aber immer außerhalb der eigentlichen Prozedur die DataSection mitschleifen.

Das geht auch ohne (und natürlich noch kürzer):

Code: Alles auswählen

Procedure.s ByteRechner(fSize.d)
	Protected Result.s, Namen.q, i.l

	Namen = 'KMGTPEZY'
	If fSize > 0.0
		i = 56
		While fSize > 1024
			fSize / 1024
			Result = Chr((Namen >> i) & $FF) + "i"
			i - 8
		Wend
		ProcedureReturn StrD(fSize, 2) + " " + Result + "Byte"
	EndIf

EndProcedure

Debug ByteRechner(25465215)

(das i wegen der eigentlich richtigen Angabe KiB, TiB ...)

[NicTheQuick]

Gute Idee.

Aber so finde ich es besser:

Code: Alles auswählen

Procedure.s ByteRechner(fSize.f) 
  Protected lLevel.l, sName.s, Letters.l
  
  Letters = 'TGMK'
  
  If fSize > 0.0 
    sName = " Byte"
    lLevel = 0
    
    While fSize > 1024 And lLevel < 4
      fSize / 1024 
      sName = " " + Chr(PeekB(@Letters + lLevel)) + "Byte"
      lLevel + 1
    Wend 
    
    ProcedureReturn StrF(fSize, 2) + sName 
  EndIf 
  
  ProcedureReturn "" 
EndProcedure 

Debug ByteRechner(10)
Debug ByteRechner(1024 * 10)
Debug ByteRechner(1024 * 1024 * 10)
Debug ByteRechner(1024 * 1024 * 1024 * 10)
Debug ByteRechner(1024 * 1024 * 1024 * 1024 * 10)
Debug ByteRechner(1024 * 1024 * 1024 * 1024 * 1024 * 10)

///EDIT:
@HeX0R:
Da fehlt noch was als Bedingung in der While-Schleife.

Code: Alles auswählen

Procedure.s ByteRechner(dSize.d) 
   Protected Result.s, Namen.q, i.l 

   Namen = 'KMGTPEZY' 
   If dSize > 0.0 
      i = 56 
      While dSize > 1024 And i >= 0
         dSize / 1024 
         Result = Chr((Namen >> i) & $FF) + "i" 
         i - 8 
      Wend 
      ProcedureReturn StrD(dSize, 2) + " " + Result + "Byte" 
   EndIf 

EndProcedure 

Debug ByteRechner(10) 
Debug ByteRechner(1024 * 10) 
Debug ByteRechner(1024 * 1024 * 10) 
Debug ByteRechner(1024 * 1024 * 1024 * 10) 
Debug ByteRechner(1024 * 1024 * 1024 * 1024 * 10) 
Debug ByteRechner(1024 * 1024 * 1024 * 1024 * 1024 * 10)
Debug ByteRechner(1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 10)
Debug ByteRechner(1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 10)
Debug ByteRechner(1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 10)
Debug ByteRechner(1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 10)

[HeX0R]

@HeX0R:
Da fehlt noch was als Bedingung in der While-Schleife.

Ja o.k. , wusste nicht, dass du so grosse Festplatten hast

[NicTheQuick]

Achso, dieses "i" finde ich schwachsinnig. Wenn von Bytes die Rede ist,
dann ist für mich der Multiplikator immer 1024. "Kibi" klingt irgendwie
"schwul".

[AND51]

Ach ja, wie ist denn das? Ich habe gehört, dass es keine Kilobytes etc. mehr geben soll, stattdessen gibt es jetzt nur noch Kibibyte und Mebibyte oder so ähnlich. Stimmt das? Ich meine, so eine große Veränderung kann doch an mir nicht spurlos vorübergehen...

[helpy]

News von 1999 bei heise.de: http://www.heise.de/newsticker/meldung/4987

Und hier noch bei wikipedia: http://en.wikipedia.org/wiki/Kibibyte