PowerShell: obtener tamaños de carpeta en disco en Windows

La mayoría de los usuarios de Windows saben que la forma más sencilla de comprobar el tamaño de una carpeta es abrir las propiedades de la carpeta en el Explorador de archivos. Los usuarios más experimentados prefieren utilizar herramientas de terceros como Tamaño del árbol o WinDirStat. Sin embargo, si desea obtener estadísticas más detalladas sobre el tamaño de las carpetas en el directorio específico o excluir ciertos tipos de archivos, es mejor que utilice las funciones de PowerShell. En este artículo, le mostraremos cómo obtener rápidamente el tamaño de la carpeta específica en el disco (y todas las subcarpetas) usando PowerShell.

Puedes usar el Get-ChildItem (gci alias) y Objeto de medida (measure alias) cmdlets para obtener los tamaños de archivos y carpetas (incluidas las subcarpetas) en PowerShell. El primer cmdlet le permite obtener la lista de archivos (con tamaños) en el directorio especificado de acuerdo con los criterios especificados, y el segundo realiza operaciones aritméticas.

Por ejemplo, para obtener el tamaño de la carpeta C: ISO, ejecute el siguiente comando:

Get-ChildItem C:ISO | Measure-Object -Property Length -sum

Como puede ver, el tamaño total de los archivos en este directorio se muestra en la Suma campo y es de aproximadamente 2,1 GB (el tamaño se da en bytes).

Para convertir el tamaño en un MB o GB más conveniente, use este comando:

(gci c:iso | measure Length -s).sum / 1Gb

O:

(gci c:iso | measure Length -s).sum / 1Mb

Para redondear el resultado a dos decimales, ejecute el siguiente comando:

"{0:N2} GB" -f ((gci c:iso | measure Length -s).sum / 1Gb)

Puede usar PowerShell para calcular el tamaño total de todos los archivos de un determinado tipo en un directorio. Por ejemplo, desea obtener el tamaño total de todos los archivos ISO en una carpeta:

(gci c:iso *.iso | measure Length -s).sum / 1Mb

Los comandos que se muestran arriba le permiten obtener solo el tamaño total de los archivos en el directorio especificado. Si hay subcarpetas en el directorio, no se calculará el tamaño de los archivos en las subcarpetas. Para obtener el tamaño total de los archivos en el directorio, incluidos los subdirectorios, utilice la –Recurse parámetro. Obtengamos el tamaño total de los archivos en el C: Windows carpeta:

"{0:N2} GB" -f ((gci –force c:Windows –Recurse -ErrorAction SilentlyContinue| measure Length -s).sum / 1Gb)

Para tener en cuenta el tamaño de los archivos ocultos y del sistema, he utilizado el -fuerza argumento también.

Entonces, el tamaño de C: Windows en mi disco local es de aproximadamente 40 GB (el script ignora la compresión NTFS).

Consejo. Para evitar errores de acceso al directorio (PermissionDenied -> DirUnauthorizedAccessError), use el -ErrorAction SilentlyContinue parámetro.

Este script calcula incorrectamente el tamaño de un directorio si contiene enlaces físicos o simbólicos. Por ejemplo, el C:Windows La carpeta contiene muchos vínculos físicos a los archivos de la carpeta WinSxS (Tienda de componentes de Windows). Como resultado, estos archivos se pueden contar varias veces. Para ignorar los enlaces físicos en los resultados, use el siguiente comando (tarda mucho en completarse):

"{0:N2} GB" -f ((gci –force C:windows –Recurse -ErrorAction SilentlyContinue | Where-Object { $_.LinkType -notmatch "HardLink" }| measure Length -s).sum / 1Gb)

Como puede ver, el tamaño real de la carpeta de Windows es un poco más pequeño.

Puede usar filtros para seleccionar los archivos a considerar al calcular el tamaño final. Por ejemplo, puede obtener el tamaño de los archivos creados en 2020:

(gci -force c:ps –Recurse -ErrorAction SilentlyContinue | ? {$_.CreationTime -gt ‘1/1/20’ -AND $_.CreationTime -lt ‘12/31/20’}| measure Length -s).sum / 1Gb

Puede obtener el tamaño de todas las subcarpetas de primer nivel en el directorio especificado. Por ejemplo, desea obtener el tamaño de todos los perfiles de usuario en la carpeta C: Usuarios.

gci -force 'C:Users'-ErrorAction SilentlyContinue | ? { $_ -is [io.directoryinfo] } | % {
$len = 0
gci -recurse -force $_.fullname -ErrorAction SilentlyContinue | % { $len += $_.length }
$_.fullname, '{0:N2} GB' -f ($len / 1Gb)
}

% es un alias para el foreach-object círculo.

Continúemos. Supongamos que su tarea es encontrar el tamaño de cada directorio en la raíz del disco duro del sistema y presentar la información en la forma de tabla conveniente para su análisis y poder ser ordenada por el tamaño de la carpeta.

Para obtener información sobre el tamaño de los directorios en la unidad C: del sistema, ejecute el siguiente script de PowerShell:

$targetfolder="C:"
$dataColl = @()
gci -force $targetfolder -ErrorAction SilentlyContinue | ? { $_ -is [io.directoryinfo] } | % {
$len = 0
gci -recurse -force $_.fullname -ErrorAction SilentlyContinue | % { $len += $_.length }
$foldername = $_.fullname
$foldersize="{0:N2}" -f ($len / 1Gb)
$dataObject = New-Object PSObject
Add-Member -inputObject $dataObject -memberType NoteProperty -name “foldername” -value $foldername
Add-Member -inputObject $dataObject -memberType NoteProperty -name “foldersizeGb” -value $foldersize
$dataColl += $dataObject
}
$dataColl | Out-GridView -Title “Size of subdirectories”

Como puede ver, la vista gráfica de la tabla debería aparecer donde se muestran todas las carpetas en la raíz de la unidad del sistema C: y su tamaño (la tabla es generada por el Out-GridView cmdlet). Al hacer clic en el encabezado de la columna, puede ordenar las carpetas por tamaño. También puede exportar los resultados a CSV (| Export-Csv folder_size.csv) o en un archivo de Excel.

Si está usando la verificación del tamaño del directorio en sus scripts de PowerShell, puede crear una función separada:

function Get-FolderSize {
[CmdletBinding()]
Param (
[Parameter(Mandatory=$true,ValueFromPipeline=$true)]
$Path
)
if ( (Test-Path $Path) -and (Get-Item $Path).PSIsContainer ) {
$Measure = Get-ChildItem $Path -Recurse -Force -ErrorAction SilentlyContinue | Measure-Object -Property Length -Sum
$Sum = '{0:N2}' -f ($Measure.Sum / 1Gb)
[PSCustomObject]@{
"Path" = $Path
"Size($Gb)" = $Sum
}
}
}

Para usar la función, simplemente ejecute el comando con la ruta de la carpeta como argumento:

Get-FolderSize ('C:PS')

Puede usar su función local de PowerShell para verificar el tamaño de la carpeta en computadoras remotas a través de la Invoke-Command (PowerShell Remoting) cmdlet.

Invoke-Command -ComputerName hq-srv01 -ScriptBlock ${Function:Get-FolderSize} –ArgumentList 'C:PS'