it-swarm.com.de

Größe der PowerShell-Anzeigedatei in KB, MB oder GB

Ich habe einen Abschnitt eines PowerShell-Skripts, das die Dateigröße eines angegebenen Verzeichnisses abruft.

Ich bin in der Lage, die Werte für verschiedene Maßeinheiten in Variablen zu erfassen, aber ich kenne keinen guten Weg, um die entsprechenden Maßeinheiten anzuzeigen.

$DirSize = "{0:N2}" -f (($DirArray | Measure-Object -property length -sum).sum)
$DirSizeKB = "{0:N2}" -f (($DirArray | Measure-Object -property length -sum).sum / 1KB)
$DirSizeMB = "{0:N2}" -f (($DirArray | Measure-Object -property length -sum).sum / 1MB)
$DirSizeGB = "{0:N2}" -f (($DirArray | Measure-Object -property length -sum).sum / 1GB)

Wenn die Anzahl der Bytes mindestens 1 KB beträgt, möchte ich, dass der KB-Wert angezeigt wird. Wenn die Anzahl der KB mindestens 1 MB beträgt, möchte ich, dass MB angezeigt werden und so weiter.

Gibt es einen guten Weg, dies zu erreichen?

8
Beninja2

Verwenden Sie einen Schalter oder eine Reihe von "if" -Anweisungen. Ihre Logik (Pseudocode) sollte so aussehen:

  1. Ist die Größe mindestens 1 GB? Ja, Anzeige in GB (sonst ...)
  2. Ist die Größe mindestens 1 MB? Ja, Anzeige in MB (sonst ...)
  3. Anzeige in KB.

Beachten Sie, dass Sie in umgekehrter Reihenfolge von der größten zur kleinsten Größe testen sollten. Ja, ich hätte den Code für Sie schreiben können, aber ich vermute, dass Sie genug wissen, um aus dem oben genannten ein Skript zu machen. Es ist nur die Herangehensweise, die dich überwältigt hat.

3
x0n

Es gibt viele Möglichkeiten, dies zu tun. Hier ist eins:

switch -Regex ([math]::truncate([math]::log($bytecount,1024))) {

    '^0' {"$bytecount Bytes"}

    '^1' {"{0:n2} KB" -f ($bytecount / 1KB)}

    '^2' {"{0:n2} MB" -f ($bytecount / 1MB)}

    '^3' {"{0:n2} GB" -f ($bytecount / 1GB)}

    '^4' {"{0:n2} TB" -f ($bytecount / 1TB)}

     Default {"{0:n2} PB" -f ($bytecount / 1pb)}
}
10
mjolinor

Meines ähnelt dem von @zdan, wird aber als Skriptfunktion geschrieben:

function DisplayInBytes($num) 
{
    $suffix = "B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"
    $index = 0
    while ($num -gt 1kb) 
    {
        $num = $num / 1kb
        $index++
    } 

    "{0:N1} {1}" -f $num, $suffix[$index]
}
7

Hier eine Funktion, die ich vor einiger Zeit geschrieben habe und die Win32-API verwendet, um das zu erreichen, wonach Sie suchen.

Function Convert-Size {
    <#
        .SYSNOPSIS
            Converts a size in bytes to its upper most value.

        .DESCRIPTION
            Converts a size in bytes to its upper most value.

        .PARAMETER Size
            The size in bytes to convert

        .NOTES
            Author: Boe Prox
            Date Created: 22AUG2012

        .EXAMPLE
        Convert-Size -Size 568956
        555 KB

        Description
        -----------
        Converts the byte value 568956 to upper most value of 555 KB

        .EXAMPLE
        Get-ChildItem  | ? {! $_.PSIsContainer} | Select -First 5 | Select Name, @{L='Size';E={$_ | Convert-Size}}
        Name                                                           Size                                                          
        ----                                                           ----                                                          
        Data1.cap                                                      14.4 MB                                                       
        Data2.cap                                                      12.5 MB                                                       
        Image.iso                                                      5.72 GB                                                       
        Index.txt                                                      23.9 KB                                                       
        SomeSite.lnk                                                   1.52 KB     
        SomeFile.ini                                                   152 bytes   

        Description
        -----------
        Used with Get-ChildItem and custom formatting with Select-Object to list the uppermost size.          
    #>
    [cmdletbinding()]
    Param (
        [parameter(ValueFromPipeline=$True,ValueFromPipelineByPropertyName=$True)]
        [Alias("Length")]
        [int64]$Size
    )
    Begin {
        If (-Not $ConvertSize) {
            Write-Verbose ("Creating signature from Win32API")
            $Signature =  @"
                 [DllImport("Shlwapi.dll", CharSet = CharSet.Auto)]
                 public static extern long StrFormatByteSize( long fileSize, System.Text.StringBuilder buffer, int bufferSize );
"@
            $Global:ConvertSize = Add-Type -Name SizeConverter -MemberDefinition $Signature -PassThru
        }
        Write-Verbose ("Building buffer for string")
        $stringBuilder = New-Object Text.StringBuilder 1024
    }
    Process {
        Write-Verbose ("Converting {0} to upper most size" -f $Size)
        $ConvertSize::StrFormatByteSize( $Size, $stringBuilder, $stringBuilder.Capacity ) | Out-Null
        $stringBuilder.ToString()
    }
}
4
boeprox

Ich hoffe der folgende Code wird Ihnen helfen ...

$file = 'C:\file.txt'
Write-Host((Get-Item $file).length/1KB) // returns file length in KB
Write-Host((Get-Item $file).length/1MB) // returns file length in MB
Write-Host((Get-Item $file).length/1GB) // returns file length in GB
4
Nandha kumar

Ich habe die Funktion DisplayInBytes ($ num) im Bill Stewart "d.ps1" Skript hinzugefügt

function DisplayInBytes($num)
{
    $suffix = "oct", "Kib", "Mib", "Gib", "Tib", "Pib", "Eib", "Zib", "Yib"
    $index = 0
    while ($num -gt 1kb) 
    {
        $num = $num / 1kb
        $index++
    }

    $sFmt="{0:N"
    if ($index -eq 0) {$sFmt += "0"} else {$sFmt += "1"}
    $sFmt += "} {1}"
    $sFmt -f $num, $suffix[$index]
}

Ersetzen Sie den Block

  # Create the formatted string expression.
   $formatStr = "`"{0,5} {1,10} {2,5} {3,15:N0} ({4,11})"   $formatStr += iif { -not $Q } { " {5}" } { " {5,-22} {6}" }   $formatStr += "`" -f `$_.Mode," +
        "`$_.$TimeField.ToString('d')," +
        "`$_.$TimeField.ToString('t')," +
        "`$_.Length,`$sfSize"

Und

  if (-not $Bare) {
    $sfSize=DisplayInBytes $_.Length
    invoke-expression $formatStr

Und am Ende

  # Output footer information when not using -bare.
  if (-not $Bare) {
    if (($fileCount -gt 0) -or ($dirCount -gt 0)) {
      $sfSize = DisplayInBytes $sizeTotal
      "{0,14:N0} file(s) {1,15:N0} ({3,11})`n{2,15:N0} dir(s)" -f
        $fileCount,$sizeTotal,$dirCount,$sfSize
    }
  }
0
PcSi-L

Eine Alternative zu einer Reihe von if-Optionen ist die Verwendung einer while-Schleife, bis der Wert die richtige Größe hat. Es skaliert!

[double] $val = ($DirArray | Measure-Object -property length -sum).sum
while($val -gt 1kb){$val /= 1kb;}
"{0:N2}" -f $val
0
zdan