Windows PowerShell es un entorno de comandos que admite scripts orientados a objetos basados en Microsoft .NET Framework. Su corazón es el cmdlet de PowerShell, un comando ligero que realiza una acción específica y, en el proceso, devuelve un objeto .NET. PowerShell le permite utilizar cmdlets para acceder a una variedad de sistemas y realizar numerosas tareas contra esos sistemas. Sin embargo, los cmdlets por sí solos no siempre son suficientes para llevar a cabo ciertas acciones. Para esas acciones, a menudo debes crear tus propios objetos basados en las clases .NET. Un tipo de objeto .NET que puede construir es el objeto personalizado. Un objeto personalizado le permite definir los tipos de datos asignados a ese objeto y las acciones que puede llevar a cabo. Después de entender cómo construir un objeto personalizado, tendrá una poderosa herramienta para construir scripts que pueden ampliar el alcance ya significativo de PowerShell.
Tenga en cuenta que el .NET Framework y la programación orientada a objetos son temas complejos, mucho más allá del alcance aquí. Para apreciar plenamente la naturaleza orientada a objetos de PowerShell, puede ser útil tener al menos una comprensión básica de estos conceptos. Para obtener más información sobre .NET Framework, consulte el artículo de MSDN «Overview of the .NET Framework». Para obtener una introducción a la programación orientada a objetos, consulte el artículo de MSDN «Programación orientada a objetos (C# y Visual Basic)».
Creación de un objeto personalizado
Para crear un objeto personalizado en PowerShell, primero debe utilizar el cmdlet New-Object para crear el objeto inicial. Este cmdlet le permite crear objetos .NET o COM a partir de un surtido de clases. Un objeto personalizado es un tipo especial de objeto .NET basado en la clase Object o PSObject .NET. No hay ninguna diferencia entre ambas a la hora de crear el objeto inicial. Sin embargo, generalmente se prefiere la clase PSObject debido a los problemas que pueden surgir al añadir propiedades a un objeto basado en la clase Object, por lo que utilizaremos PSObject.
Para crear un objeto basado en la clase PSObject, es necesario utilizar el cmdlet New-Object con el parámetro -TypeName y especificar la clase PSObject como valor del parámetro, así:
$system = New-Object -TypeName PSObject
Cuando ejecute este comando, generará un objeto PSCustomObject y lo asignará a la variable $system. La mayoría de las veces, querrá asignar el objeto a una variable para poder trabajar fácilmente con los miembros de ese objeto. Los miembros son los componentes que conforman un objeto, como las propiedades, los métodos, las propiedades de alias y los conjuntos de miembros.
Cuando se trabaja con objetos en PowerShell, los dos tipos de miembros que probablemente utilizará son las propiedades y los métodos. Una propiedad describe un aspecto específico del objeto. Por ejemplo, uno de los miembros de la clase FileInfo .NET es la propiedad Length, que proporciona el tamaño de un archivo en bytes. Si se crea un objeto FileInfo basado en esa clase, se puede utilizar la propiedad Length para acceder al tamaño del archivo asociado a ese objeto. Un método realiza una acción relacionada con el objeto. Por ejemplo, la clase FileInfo también incluye el método Delete, que puede utilizar para eliminar el archivo representado por el objeto.
Poder identificar fácilmente los miembros de un objeto facilita el trabajo con dicho objeto. Para obtener una lista de los miembros que componen un objeto, puede utilizar el cmdlet Get-Member. Por ejemplo, para ver los miembros del nuevo objeto que se asignó a la variable $system, puede canalizar la variable $system al cmdlet Get-Member:
$system | Get-Member
Como muestra la Figura 1, el objeto que ha creado se basa en la clase System.Management.Automation.PSCustomObject, que incluye sólo un pequeño número de miembros, todos los cuales son métodos. Pero es por eso que se llama un objeto personalizado: puedes personalizarlo añadiendo tus propios miembros.
Antes de mostrarte cómo añadir miembros, permíteme añadir que, como muchas clases .NET, la clase PSCustomObject también incluye un número de miembros ocultos de varios tipos, como memberset y codeproperty. Puede ver esos miembros incluyendo el parámetro -Force al llamar al cmdlet Get-Member. Aunque una discusión de los miembros ocultos está más allá del alcance aquí, usted puede encontrar útil en algún momento para explorar los miembros ocultos disponibles para la clase PSCustomObject y otras clases .NET para aprovechar al máximo sus objetos de PowerShell.
Añadir propiedades a un objeto personalizado
Un objeto personalizado es sólo tan útil como los miembros asociados con el objeto. Usted puede agregar varios tipos diferentes de miembros a un objeto personalizado. Para este ejemplo, añadirá los miembros NoteProperty y ScriptMethod. Un miembro NoteProperty es similar a una propiedad normal, y un miembro ScriptMethod es muy parecido a un método normal. No puedes añadir una propiedad o método normal a un objeto personalizado, por lo que vas a utilizar NoteProperty y ScriptMethod. (Para obtener información sobre los miembros admitidos en un objeto personalizado, consulte el tema de PowerShell TechNet «Add-Member»)
Empecemos por añadir un par de miembros NoteProperty al objeto $system. Para añadir los miembros, puede utilizar el cmdlet Add-Member para definir los nombres y valores de las propiedades. Por ejemplo, supongamos que queremos añadir propiedades de nota basadas en datos recuperados a través de las capacidades de Windows Management Instrumentation (WMI) integradas en PowerShell. (WMI proporciona una infraestructura para gestionar datos y operaciones en los sistemas operativos Windows). El modelo de objetos WMI incluye numerosas clases que soportan una amplia gama de operaciones de gestión. Por ejemplo, la clase Win32_OperatingSystem proporciona acceso a información como el nombre del SO instalado en un equipo y el último paquete de servicios aplicado a ese SO.
Para crear un objeto WMI, se utiliza el cmdlet Get-WmiObject y se especifica la clase deseada. Por ejemplo, para crear un objeto WMI Win32_OperatingSystem y asignarlo a la variable $os, utilizaría el código:
$os = Get-WmiObject Win32_OperatingSystem
En este caso, está recuperando información del sistema del equipo local, pero la belleza de WMI es su capacidad para acceder y gestionar también equipos Windows remotos.
A continuación, puede utilizar la variable $os para acceder a la información devuelta por ese objeto. La asignación de un objeto a una variable de esta manera bloquea los datos en ese momento. Por ejemplo, si se aplica un nuevo paquete de servicios al sistema operativo después de crear la variable $os, la propiedad CSDVersion del objeto no reflejará el cambio porque el objeto se había creado basándose en los datos originales.
Después de definir la variable $os, es necesario especificar dos comandos Add-Member. Cada comando tomará cuatro parámetros:
- InputObject. El parámetro -InputObject se utiliza para identificar el objeto que recibe las nuevas propiedades de la nota. En este caso, es necesario especificar el objeto $system.
- -MemberType. El parámetro -MemberType indica el tipo de miembro a crear, por lo que es necesario especificar NoteProperty.
- -Name. El parámetro -Name se utiliza para especificar el nombre del nuevo miembro. Para este ejemplo, vamos a nombrar el primer miembro OperatingSystem y el segundo miembro ServicePack.
- -Value. Este parámetro especifica el valor del miembro. Para la primera propiedad de la nota, necesita especificar $os.Caption para devolver el nombre del sistema operativo. Para la segunda propiedad de la nota, necesitas especificar $os.CSDVersion para devolver el último service pack aplicado al SO.
Aquí está el aspecto de los dos comandos Add-Member:
Add-Member -InputObject $system -MemberType NoteProperty ` -Name OperatingSystem -Value $os.CaptionAdd-Member -InputObject $system -MemberType NoteProperty ` -Name ServicePack -Value $os.CSDVersion
Nota que he dividido cada comando Add-Member en dos líneas. Al final de cada primera línea, he incluido una marca de retroceso (`) para que el procesador de PowerShell sepa que debe continuar con la siguiente línea para el comando completo.
Después de ejecutar los comandos Add-Member, puede llamar a la variable $system para ver su contenido:
$system
La figura 2 muestra resultados de ejemplo.
También puede utilizar la variable $system para llamar a miembros individuales. Simplemente especifique el nombre de la variable, seguido de un punto, y luego el nombre del miembro. Por ejemplo, el siguiente comando devuelve el valor actual de la propiedad de nota OperatingSystem:
$system.OperatingSystem
Una ventaja de crear un objeto personalizado es que permite crear propiedades de nota basadas en datos que provienen de diferentes fuentes, así como una propiedad de nota cuyo valor es una cadena específica. Por ejemplo, eche un vistazo al código del Listado 1, que añade tres nuevas propiedades de nota al objeto $system.
$mem = Get-WmiObject Win32_PhysicalMemory$disk = Get-WmiObject Win32_DiskDriveAdd-Member -InputObject $system -MemberType NoteProperty ` -Name PhysicalMemory ` -Value (("{0:N2}" -f ($mem.Capacity/1GB)) + ' GB')Add-Member -InputObject $system -MemberType NoteProperty ` -Name DiskSize ` -Value (("{0:N2}" -f ($disk.Size/1GB)) + ' GB')Add-Member -InputObject $system -MemberType NoteProperty ` -Name Owner -Value "janetp"
La mayoría de los elementos del Listado 1 los ha visto en el ejemplo anterior. Sin embargo, observe que el código está creando una instancia de la clase Win32_PhysicalMemory, que se asigna a la variable $mem, y una instancia de la clase Win32_DiskDrive, que se asigna a la variable $disk. Dos de las propiedades de la nota añadida utilizan estos nuevos objetos WMI como fuentes de datos.
El primer comando Add-Member recupera datos de la propiedad $mem.Capacity, que proporciona la capacidad de la memoria en el sistema de destino. En este caso, sin embargo, el parámetro -Value es un poco más complejo que el visto en el ejemplo anterior. En primer lugar, el comando especifica «{0:N2}» seguido de -f, que es una construcción .NET para formatear el número de salida. Básicamente, esto especifica que se devuelva un número con dos decimales. Las instrucciones de formato van seguidas de una expresión corta ($mem.Capacity/1GB) que divide el valor de Capacity entre 1GB. El valor de Capacidad proporciona el tamaño de la memoria en bytes. PowerShell facilita la conversión de bytes a gigabytes simplemente dividiendo por 1GB. Finalmente, el comando etiqueta la cadena ‘ GB’ (incluyendo el espacio) en la salida y encierra todo entre paréntesis.
El segundo comando Add-Member sigue la misma lógica para devolver el tamaño del disco duro del ordenador. Utiliza la propiedad $disk.Size para devolver el tamaño en bytes, y luego lo convierte a gigabytes.
El tercer comando Add-Member añade una propiedad de nota llamada Owner y le asigna el valor de cadena janetp. En este caso, «owner» puede significar cualquier cosa-el usuario principal, el último usuario, el administrador, o cualquier significado que quieras imponer a la propiedad. Lo he incluido aquí sólo para demostrar que se puede añadir una propiedad de nota cuyo valor es una simple cadena.
Después de haber añadido los tres miembros al objeto personalizado, puedes volver a llamar a la variable $system. Devolverá resultados como los mostrados en la Figura 3.
Ahora tiene un único objeto que contiene datos derivados de tres objetos WMI diferentes. El objeto también contiene la propiedad Owner, que se basa en un valor de cadena. Puede llamar a esa propiedad note como lo haría con cualquier otro miembro:
$system.Owner
Como era de esperar, el comando devuelve el valor janetp. Sin embargo, puedes cambiar ese valor por otro diferente asignando un nuevo valor a la propiedad, así:
$system.Owner = "rogert"
En este caso, el valor rogert ha sido asignado a la propiedad Owner note. Si ahora llama a esa propiedad de nota, devolverá el nuevo valor.
Al igual que con muchas de las tareas que puede realizar en PowerShell, hay varias formas diferentes de añadir un miembro a un objeto personalizado. Por ejemplo, PowerShell 3.0 permite crear una tabla hash y pasar el hash al comando New-Object. El código del Listado 2 crea las mismas cinco propiedades de nota pero utiliza una tabla hash para pasar los nombres y valores de los miembros.
$info = @{ "OperatingSystem" = $os.Caption; "ServicePack" = $os.CSDVersion; "PhysicalMemory" = (("{0:N2}" -f ($mem.Capacity/1GB)) + ' GB'); "DiskSize" = (("{0:N2}" -f ($disk.Size/1GB)) + ' GB'); "Owner" = 'janetp'}$system = New-Object -TypeName PSObject -Property $info$system
Este código crea primero una tabla hash que define cinco pares propiedad/valor, cada uno correspondiente a las propiedades de nota. Como muestra el código, hay que separar los pares propiedad/valor con punto y coma. También hay que encerrar el conjunto de cinco pares propiedad/valor entre corchetes y preceder el corchete de apertura con el símbolo at (@). Por último, es necesario asignar la tabla hash a la variable $info.
Después de definir la tabla hash, el código utiliza el cmdlet New-Object para crear un objeto basado en la clase PSObject y lo asigna a la variable $system. Sólo que esta vez, el comando incluye el parámetro -Property, que toma como valor la variable $info.
Finalmente, el código llama a la variable $system, que devuelve resultados como los de la Figura 4. Fíjate en el orden en que se han añadido las propiedades al objeto. Uno de los problemas de utilizar una tabla hash para añadir las propiedades de las notas es que no puedes controlar su orden. Para controlar el orden, debe utilizar el cmdlet Add-Member para añadir cada miembro.
Añadir métodos a un objeto personalizado
Ahora que ha visto lo fácil que es añadir propiedades, acceder a sus valores y cambiar esos valores, pasemos a los métodos. Estos se vuelven un poco más complicados porque los métodos tienen que hacer algo, y necesitas definir ese algo como parte del valor del método.
Por ejemplo, el código del Listado 3 crea un método que recupera la fecha y la hora actuales y las devuelve tanto en su formato original como en valores de Tiempo Universal Coordinado (UTC).
$method ={ $a = Get-Date -Format F; "Local: " + $a; $b = Get-Date; "UTC: " + $b.ToUniversalTime().DateTime}Add-Member -InputObject $system -MemberType ScriptMethod ` -Name GetUTC -Value $method
Para mantener el código legible, puedes asignar el valor del método a una variable (por ejemplo, $method). Ese valor incluye las expresiones necesarias para devolver la información de fecha y hora. Sin embargo, debe definir el valor como un bloque de script para pasarlo al comando Add-Member. Para ello, debe encerrar el contenido del valor entre llaves. PowerShell asignará entonces el valor en su forma actual a la variable como un objeto ScriptBlock.
En el Listado 3, el valor del método incluye dos expresiones. La primera expresión devuelve la fecha y hora actuales, y la segunda expresión devuelve la versión UTC. La primera expresión se inicia utilizando el cmdlet Get-Date para recuperar la fecha y hora actuales, que se asigna a la variable $a. Tenga en cuenta que cuando llame al cmdlet Get-Date, debe incluir el parámetro -Format, junto con el valor F. Esto indica a PowerShell que muestre la marca de tiempo en un formato completo de fecha y hora, como en Monday, August 19, 2013 12:28:25 PM. A continuación, se añade la cadena «Local: » (incluyendo el espacio) al valor de la variable para devolver la fecha y hora actuales junto con esa etiqueta.
En la segunda expresión, de nuevo empiezas con el cmdlet Get-Date para devolver la fecha y hora actuales, que asignas a la variable $b. A continuación, se utiliza el método ToUniversalTime de la variable para devolver la fecha y la hora como un valor UTC, y luego se especifica la propiedad DateTime para devolver el formato correcto.
Si se llamara a la variable $method en este punto, devolvería las dos expresiones como cadenas, tal y como se han escrito. Como has definido el valor de la variable como un bloque de script, los comandos no se procesan cuando se asignan a la variable $method. En su lugar, la variable $method se crea como un objeto ScriptBlock, lo que puedes confirmar utilizando el método GetType para ver el tipo de la variable:
$method.GetType()
Para trabajar con el bloque de script, necesitas añadir el método como miembro del objeto $system después de definir la variable $method. Para ello, se crea un comando Add-Member que especifica ScriptMethod como el tipo, GetUTC como el nombre, y la variable $method como el valor.
Después de ejecutar el código del Listado 3, puedes utilizar la variable $system para llamar al método GetUTC de la misma manera que llamaste a las propiedades:
$system.GetUTC()
Nota, sin embargo, que cuando llames al método script, debes incluir los paréntesis, igual que haces con cualquier otro método, incluso si no estás pasando argumentos. El método debería devolver resultados similares a los de la Figura 5, pero con la fecha y la hora en que se llamó al método.
En la vida real, probablemente querrá crear métodos que tengan más fuerza. Por ejemplo, el objeto $system podría incorporar tareas de gestión de WMI en sus métodos de script. Si lo hace, necesita probar completamente el método para asegurarse de que sus comandos están haciendo exactamente lo que se supone que deben hacer. PowerShell y WMI son herramientas poderosas, por lo que deben ser utilizados con cuidado al administrar equipos de Windows.
Agregar objetos personalizados a una matriz
Los objetos personalizados no se limitan a objetos independientes que se utilizan una vez y se tiran a un lado. Puedes añadir esos objetos a un array de objetos, y luego acceder a los objetos a través de ese array. Por ejemplo, suponga que quiere manipular la información que recupera de varios ordenadores. Esa información puede incluir detalles sobre la memoria y las unidades lógicas disponibles en esos sistemas. Usted quiere ser capaz de trabajar con esos detalles de una manera significativa en PowerShell. Debido a la naturaleza orientada a objetos de PowerShell, poner esa información en objetos es a menudo la forma más sencilla de trabajar con esos datos.
Veamos un ejemplo de cómo podría hacer esto. Para esta discusión, el enfoque utilizado para recoger la información sobre los distintos ordenadores no es importante. Usted podría, por ejemplo, configurar un bucle foreach en PowerShell que utiliza WMI para recuperar la información de las diferentes estaciones de trabajo. Independientemente del método utilizado, en aras de la brevedad, suponga que ha recopilado la información en un archivo de texto separado por comas que contiene los datos mostrados en la Figura 6.
El archivo de texto incluye una fila de encabezado y una fila para las unidades lógicas de cada sistema. Por ejemplo, la primera fila de datos proporciona detalles sobre la unidad lógica C del ordenador ws01. La unidad lógica tiene una capacidad de 500 GB, con 225 GB de espacio libre. El sistema también tiene 4 GB de memoria. La segunda fila indica que el mismo ordenador también contiene la unidad lógica D, que tiene la misma capacidad que la unidad C pero con 320GB de espacio libre.
El objetivo es convertir cada fila de datos en su propio objeto personalizado, y luego añadir esos objetos a un array. A continuación, puede realizar acciones en los objetos dentro de la matriz mediante la canalización de los datos a otros comandos de PowerShell. El código del Listado 4 define una matriz vacía, importa los datos del archivo de texto y luego utiliza un bucle foreach para crear los objetos y añadirlos a la matriz.
$SystemInfo = @()$SourceData = Import-CSV C:\DataFiles\SourceData.txtforeach ($source in $SourceData){ $system = New-Object -TypeName PSObject $system | Add-Member -Type NoteProperty ` -Name Computer -Value $source.Computer $system | Add-Member -Type NoteProperty ` -Name DeviceID -Value $source.DeviceID $system | Add-Member -Type NoteProperty ` -Name DriveSize -Value ($source.DriveSize) $system | Add-Member -Type NoteProperty ` -Name UsedSpace ` -Value ($source.DriveSize - $Source.FreeSpace) $system | Add-Member -Type NoteProperty ` -Name FreeSpace -Value ($source.FreeSpace) $SystemInfo += $system}
Como puede ver, el primer paso es crear la matriz vacía (@()) y asignarla a la variable $SystemInfo. Eventualmente, se añadirán los objetos personalizados a este array.
A continuación, se utiliza el cmdlet Import-CSV para importar los datos a la variable $SourceData. Para este ejercicio, el archivo de texto se llama SourceData.txt y se guarda en la carpeta C:\NDataFiles. El cmdlet Import-CSV recupera cada fila como su propio objeto, guardándolo en $SourceData. En este punto, podría utilizar esa variable para acceder a los datos, pero no tendría control sobre los miembros incluidos en el objeto, ni podría añadir miembros.
El siguiente paso, entonces, es crear un bucle foreach que le permita crear un objeto personalizado para cada fila del archivo de texto. La condición foreach ($fuente en $DatosFuente) especifica que cada fila en $DatosFuente debe ser asignada a la variable $fuente mientras el código itera a través del bucle foreach. La lógica definida dentro del bloque de script foreach (encerrado entre llaves) se ejecutará entonces una vez para cada fila, con un objeto $fuente diferente aplicado durante cada iteración. (Para obtener más información sobre la creación de un bucle foreach, consulte el tema de PowerShell TechNet about_ForEach.)
Veamos con más detalle el bloque de script foreach. El primer comando crea el objeto inicial y lo guarda en la variable $system, como ha visto en los ejemplos anteriores. A continuación, la variable $system se canaliza a un comando Add-Member para crear la primera propiedad de la nota. Este es un formato ligeramente diferente al utilizado anteriormente. En lugar de incluir el parámetro -InputObject en el comando Add-Member, simplemente se canaliza $system al comando. Esto logra los mismos resultados que vio en los ejemplos anteriores de comandos Add-Member. He tomado este enfoque aquí simplemente para demostrar una manera más que PowerShell le permite agregar miembros.
Para el valor del comando Add-Member, se utiliza la variable $source para llamar a la propiedad Computer, que corresponde al campo Computer en los datos de origen. El segundo comando Add-Member funciona de la misma manera, excepto que recupera los datos de la propiedad DeviceID. Observe que la propiedad Memory no está incluida. Cuando se crea un objeto personalizado, se pueden omitir propiedades específicas o ponerlas en un orden diferente.
El tercer comando Add-Member funciona de forma muy parecida a los dos primeros, excepto que accede a la propiedad DriveSize. Como es posible que desee trabajar con estos datos como un valor numérico en lugar de una cadena, el comando convierte explícitamente los datos en un número. Esto se consigue precediendo el nombre de la propiedad con para indicar que se quiere el tipo de datosint, y luego encerrando toda la expresión de la propiedad entre paréntesis.
El cuarto comando Add-Member hace algo un poco diferente. Crea un miembro calculado que resta el valor FreeSpace del valor DriveSize para determinar la cantidad de espacio utilizado. De nuevo, el nombre de la propiedad va precedido de y toda la expresión va encerrada entre paréntesis. La posibilidad de crear una propiedad calculada es una de las principales razones por las que podría querer crear objetos personalizados.
El último comando Add-Member funciona igual que el tercero, excepto que recupera los datos de la propiedad FreeSpace.
El último comando del bloque de script foreach añade el objeto $system actual a la matriz $SystemInfo. Observe que el operador += se utiliza para asegurar que el nuevo objeto $system se añade con cada iteración del bucle, sin que se sobrescriba nada.
Después de ejecutar el código del Listado 4, puede llamar a la variable para ver su contenido. La figura 7 muestra una lista parcial de los datos almacenados ahora en la matriz $SystemInfo.
Específicamente, muestra los datos de los siete primeros objetos de la matriz, que corresponden a las siete primeras filas de datos del archivo de texto original. Cada agrupación representa uno de los objetos añadidos al array $SystemInfo. Puede verificar que ha creado una matriz de objetos utilizando el método GetType para recuperar el tipo de la variable:
$SystemInfo.GetType()
Si este comando devuelve un BaseType de System.Array, la variable $SystemInfo es efectivamente una matriz de objetos capaz de contener objetos personalizados. Puede entonces utilizar esa variable para manipular los datos como mejor le parezca. Por ejemplo, puede canalizar la variable a un comando Sort-Object para ordenar los datos en orden descendente, basándose en los valores de FreeSpace:
$SystemInfo | Sort FreeSpace -Descending
En este caso, el comando utiliza el alias Sort para hacer referencia al cmdlet Sort-Object e incluye la propiedad FreeSpace y el parámetro -Descending. Como puede ver en la Figura 8, los objetos se enumeran ahora según los valores de FreeSpace, con la mayor cantidad de espacio libre en primer lugar. Una vez más, ésta es sólo una lista parcial.
También puede ordenar los datos basándose en varias columnas. Por ejemplo, puede ordenar los datos primero por la propiedad Ordenador y luego por la propiedad Espacio libre, en orden descendente:
$SystemInfo | Sort Computer, FreeSpace -Descending
Como era de esperar, los resultados son ahora muy diferentes, como muestra la figura 9.
Una de las consecuencias de ordenar las columnas de esta manera es que los valores de Equipo, así como los de Espacio libre, se ordenan en orden descendente. El cmdlet Sort-Object no permite ordenar fácilmente una columna en orden ascendente y otra en orden descendente. Si especifica el parámetro -Descending, todos los datos se clasifican en ese orden. Sin embargo, puede evitar esta limitación creando expresiones para cada propiedad que especifiquen cómo ordenar esos valores. Por ejemplo, el siguiente comando ordena primero por la propiedad Computer en orden ascendente, y luego por la propiedad FreeSpace en orden descendente:
$SystemInfo | Sort ` @{Expression="Computer"; Descending=$false}, @{Expression="FreeSpace"; Descending=$true}
La primera expresión Sort-Object establece la propiedad Expression en Computer y la propiedad Descending en $false. La segunda expresión establece la propiedad Expression a FreeSpace y la propiedad Descending a $true. (Las variables $true y $false son variables del sistema incorporadas que proporcionan los valores booleanos verdadero y falso de 1 y 0, respectivamente). A continuación, debe encerrar cada expresión entre corchetes y preceder cada corchete de apertura con el símbolo at (@). Ahora los datos se ordenarán en el orden deseado, como se muestra en la Figura 10.
Esto puede parecer exagerado en el tema de la ordenación, pero señala la flexibilidad de trabajar con objetos en un array. Y ciertamente no está limitado al cmdlet Sort-Object. Por ejemplo, el siguiente comando envía la variable $SystemInfo al cmdlet Where-Object:
$SystemInfo | Where DriveSize -gt 250 | Sort FreeSpace -Descending
En este caso, el comando utiliza el alias Where para hacer referencia al cmdlet Where-Object. Además, está especificando que el valor de DriveSize debe ser mayor que 250 para ser incluido en los resultados. (En PowerShell, se utiliza -gt para el operador mayor que.) Los resultados que cumplen estos criterios se canalizan al cmdlet Sort-Object para que los datos se muestren en el orden adecuado.
Incluso puede canalizar los datos ordenados a un comando Select-Object, como este:
$SystemInfo | Where DriveSize -gt 250 | Sort FreeSpace -Descending | Select -First 5
Este comando utiliza el cmdlet Select-Object (al que hace referencia el alias Select) para devolver sólo las cinco primeras filas del conjunto de resultados. Como puede ver, una vez que agrega objetos personalizados a la matriz $SystemInfo, tiene una variedad de opciones para trabajar con esos objetos.
Aprovechar al máximo sus objetos personalizados
En su mayor parte, la creación de objetos personalizados en PowerShell es un proceso bastante sencillo. Si hay alguna complejidad involucrada, por lo general proviene de las expresiones de valor que usted define para sus propiedades de nota o métodos de script. Las expresiones de estos ejemplos son relativamente sencillas en comparación con los tipos de expresiones que se pueden crear en PowerShell. Aun así, lo que has visto aquí debería proporcionarte la base que necesitas para crear objetos personalizados. Cuando se utilizan de forma eficaz, pueden ser un poderoso componente de sus scripts de PowerShell, ya sea que cree objetos individuales, los agregue a una matriz o los utilice de alguna otra forma. Por ejemplo, puede crear objetos personalizados dentro de su perfil de PowerShell para que estén disponibles cada vez que inicie una nueva sesión. La forma de utilizar los objetos personalizados en tus scripts depende de ti. Sólo tiene que saber que el objeto personalizado es una herramienta eficaz y flexible que puede servir para muchas de sus necesidades de secuencias de comandos.
Para obtener información adicional sobre la creación de objetos personalizados en Windows PowerShell, consulte «Creación de objetos personalizados en Windows PowerShell» de Bill Stewart.