PowerShell: Obtener tamaños de carpetas 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 usar herramientas de terceros como TreeSize 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, será mejor que use 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.

Puede utilizar Get-ChildItem (

gci

alias) y Measure-Object (

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 según 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 el campo Sum y es de aproximadamente 2,1 GB (el tamaño se indica 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, use el

-Recurse

parámetro. Obtengamos el tamaño total de los archivos en la carpeta C:\Windows:

"{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, también he usado el argumento -force.

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

 -ErrorAction SilentlyContinue

Este script calcula incorrectamente el tamaño de un directorio si contiene enlaces simbólicos o duros. por ejemplo, el

C:\Windows

La carpeta contiene muchos enlaces duros a archivos en la carpeta WinSxS (Almacén de componentes de Windows). Como resultado, dichos archivos se pueden contar varias veces. Para ignorar los enlaces físicos en los resultados, use el siguiente comando (lleva mucho tiempo completarlo):

"{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

bucle.

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 forma de tabla conveniente para el análisis y que pueda ordenarse 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, debería aparecer la vista gráfica de la tabla 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 a un archivo de Excel.

Si está utilizando 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 PowerShell local para verificar el tamaño de la carpeta en computadoras remotas a través del

Invoke-Command

(Comunicación remota de PowerShell).

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