Búsqueda de sitios web

Comprensión de los tipos de datos y aceleradores de PowerShell

Como muchos otros lenguajes, PowerShell usa objetos para casi todo. PowerShell tiene tipos de datos para "categorizar" tipos de objetos con diferentes esquemas de propiedades y métodos.

Una vez que comprenda los tipos de datos de PowerShell, pronto verá la capacidad de ahorrar tiempo de un concepto llamado aceleradores de tipo PowerShell. Los aceleradores son métodos para acelerar la asignación de tipos de datos en PowerShell.

En este artículo, aprenderá sobre varios tipos de datos de objetos y también cómo utilizar aceleradores para que sea más fácil trabajar con ellos.

Ejemplos de aceleradores de tipo

Incluso si no ha oído hablar de los aceleradores antes, lo más probable es que los haya usado mientras codificaba. Al utilizar PowerShell para obtener tipos, encontrará que [Array], [Bool] o [String] son todos aceleradores de tipos. Lo que ofrecen estos aceleradores de clases es un acceso rápido a las definiciones .NET más largas.

  • [Matriz] → [System.Array]
  • [CmdletBinding] → [System.Management.Automation.CmdletBindingAttribute]

¿Cómo averiguamos cuáles son nuestras opciones para usar aceleradores dentro de PowerShell? ¡Siga leyendo para aprender todo sobre los aceleradores de tipos!

Descubra los tipos de datos de PowerShell obteniendo aceleradores de tipos

PowerShell ofrece un comando de una línea que devolverá todos los tipos de aceleradores conocidos por PowerShell. Por ejemplo, a continuación se muestran los aceleradores de tipos disponibles en un entorno PowerShell 7.

[PSObject].Assembly.GetType("System.Management.Automation.TypeAccelerators")::Get

Key                          Value
---                          -----
Alias                        System.Management.Automation.AliasAttribute
AllowEmptyCollection         System.Management.Automation.AllowEmptyCollectionAttribute
AllowEmptyString             System.Management.Automation.AllowEmptyStringAttribute
AllowNull                    System.Management.Automation.AllowNullAttribute
ArgumentCompleter            System.Management.Automation.ArgumentCompleterAttribute
ArgumentCompletions          System.Management.Automation.ArgumentCompletionsAttribute
<SNIP>

Comprender cómo utilizar cada acelerador es una tarea completamente diferente. Para ello, es necesario comprender los constructores de un acelerador determinado. Usando el método GetConstructors, podemos descubrir los parámetros necesarios para un constructor.

Primero, recuperamos el acelerador URI para saber que hay seis tipos diferentes. Es posible que el resultado no siempre sea claro sobre qué valor usar; si es así, leer los documentos de referencia de Microsoft a menudo aclara cómo usar la clase.

( [Type]"URI" ).GetConstructors() | ForEach-Object {
	( $_.GetParameters() | ForEach-Object { $_.ToString() } ) -Join ", "
}

Aceleradores de tipos de datos de PowerShell

Armado con la capacidad de encontrar aceleradores de tipos de datos de PowerShell y qué constructores pueden usar, ¡profundicemos en el uso de los más comunes!

URI

Las URL (localizadores uniformes de recursos) y las URI (identificadores uniformes de recursos) pueden ser difíciles de manipular. Muchas veces, el único recurso es utilizar la manipulación de cadenas para extraer los valores que necesita. .NET ofrece el acelerador de tipo URI para estas ocasiones.

El siguiente ejemplo demuestra cómo pasar una URL simple al acelerador URI. El resultado son los segmentos componentes del URI y hace que la manipulación sea mucho más rápida.

[URI]"https://google.com/"

Una vez que tenga un objeto URI, hay métodos simples disponibles para su uso posterior, como se ve en el resultado Get-Member a continuación.

$URI = [URI]"https://google.com/"
$URI | Get-Member -Type Method

WMI, WMISearcher, WMIClass

Muchos administradores veteranos de PowerShell conocen WMI o el Instrumental de administración de Windows. Muchas configuraciones de Windows existen dentro del marco WMI. Entonces, ¿qué podemos hacer con los aceleradores WMI, WMISearcher y WMIClass?

  • WMIClass: acceda a las propiedades y métodos estáticos de una clase.
  • WMISearcher: crea una búsqueda de objetos WMI.
  • WMI: recupera una única instancia de una clase.

A continuación se muestra el código que utiliza los tres métodos para crear el proceso notepad.exe, localizar ese proceso y luego recuperar más detalles del proceso.

# Create notepad.exe Process
$ProcessManager = [WMICLASS]"root\cimv2:WIn32_Process"
$ProcessManager.Create("notepad.exe")

# Locate the notepad.exe process
$Search = [WmiSearcher]'SELECT * FROM Win32_Process'
$Processes = $Search.Get()
$Process = $Processes | Where-Object Name -Match "Notepad"

# Use WMI accelerator to retrieve the notepad.exe process
$WMIProcess = [WMI]("\.\root\cimv2:Win32_Process.Handle='{0}'" -F $Process.ProcessId)

XML

Trabajar con documentos XML es un desafío. XML ofrece un formato flexible pero detallado. Intentar analizar un documento largo y complejo es difícil en cualquier idioma. PowerShell hace que esto sea mucho más fácil utilizando el acelerador de tipos de datos de PowerShell XML. Consuma un documento XML, ya sea desde una cadena o desde un archivo usando Get-Content.

$XML = [XML]"<note>
	<to>Joe</to>
	<from>Ashley</from>
	<heading>Reminder</heading>
	<body>Don't forget Bob's birthday this weekend!</body>
</note>"

$XML.Note.Body

Puede ver lo fácil que es navegar por los nodos para encontrar un valor específico. Por ejemplo, digamos que no queremos el nodo secundario heading. Las búsquedas XPath son fáciles de realizar utilizando el método SelectNodes. Usando SelectSingleNode para apuntar a un solo nodo, elimine el nodo usando el método RemoveChild.

$XPath = '/note'
$Nodes = $XML.SelectNodes($XPath )
$Nodes | ForEach-Object {
  $Node = $_.SelectSingleNode('heading')
  $_.RemoveChild($Node) | Out-Null
}

expresión regular

Las expresiones regulares facilitan las búsquedas complejas dentro del contenido de texto. Construir estas consultas es un desafío en sí mismo. Una vez que haya creado la consulta perfecta, puede utilizar el acelerador RegEx de PowerShell para realizar una coincidencia rápida en el contenido de texto.

Aunque técnicamente no es un tipo de datos de PowerShell, el acelerador de tipos regex aún puede reducir enormemente la realización de coincidencias de expresiones regulares.

A continuación se muestra un método de coincidencia RegEx simple. Cree una expresión regular simple y llame al método Match en una cadena de texto para realizar una búsqueda.

([RegEx]'\d{8}').Match('This will find the first 8 values, like 12345678').Value

Fecha y hora

Lo común en PowerShell es la necesidad de trabajar con fechas en scripts. Hay muchas formas de manipular la fecha y la hora. Una forma sencilla, con muchos métodos útiles, es utilizar el acelerador del tipo de datos [DateTime] de PowerShell. Algunas de las técnicas más útiles son:

  • Analizar una cadena de fecha y hora
  • Formatear una fecha y hora
  • Operaciones aritméticas de fecha y hora

Analizar una cadena de fecha y hora

Dado un formato de fecha conocido (es decir, no es un formato personalizado), el acelerador DateTime devolverá un objeto System.DateTime válido, que es el mismo tipo de objeto cuando se usa la función Get-Date.

[DateTime]::Parse('2020-08-10')

Formatear una fecha y hora

Los archivos de datos suelen necesitar una cadena de fecha y hora en un formato único. Por ejemplo, tomemos la misma fecha que creamos anteriormente y llamemos al método ToString. A este método, le pasaremos el formato de fecha personalizado, MM_dd_yyyy-hh:mm:ss. Tenga en cuenta que este no es un formato típico, pero utilizando el método ToString, generaremos correctamente la fecha en este formato.

([DateTime]::Parse('2020-08-10')).ToString('MM_dd_yyyy-hh:mm:ss')

Operaciones aritméticas de fecha y hora

Sumar y restar tiempo de un objeto datetime existente es crucial. En lugar de utilizar soluciones complicadas, aproveche la clase DateTime para realizar estas operaciones.

([DateTime]::Parse('2020-08-10')).AddDays(5)
(([DateTime]::Parse('2020-08-10')).AddDays(5)).AddMonths(-2)

Con 5 días agregados, también debemos eliminar dos meses. A pesar de utilizar el método AddMonths, pasar un valor negativo resta el tiempo. Encadenando operaciones, usando paréntesis, llegamos al resultado deseado.

Espacio de tiempo

Al igual que la clase DateTime, la clase TimeSpan facilita el trabajo con rangos de tiempo. A diferencia de DateTime, se encuentran disponibles operaciones matemáticas adicionales, como división y multiplicación.

Crear un objeto de intervalo de tiempo

Hay varias formas de construir un valor de período de tiempo. En nuestro ejemplo, utilizamos el constructor Horas, Minutos, Segundos. Otros posibles constructores se muestran a continuación.

  • Garrapatas
  • Horas, Minutos, Segundos
  • Días, Horas, Minutos, Segundos
  • Días, Horas, Minutos, Segundos, Milisegundos
$TimeSpan = [TimeSpan]::New(1,0,0)
$TimeSpan

Multiplicación y división en un lapso de tiempo

Digamos que ha definido un período de tiempo determinado, pero desea saber cuánto sería tres veces ese rango. Es sencillo de hacer usando el método Multiplicar.

$TimeSpan.Multiply(3)

¿Pero qué pasa con la división? ¿Cómo dividiríamos un intervalo de tiempo determinado en cuartos? Podemos utilizar el método Dividir para encontrar los valores de los cuartos del lapso de tiempo.

$TimeSpan.Divide(4)

Dirección IP

Navegar por la gestión de direcciones IP es una tarea ardua, al igual que la validación. El acelerador IPAddress ofrece la capacidad de validar direcciones IPv4 e IPv6.

[IPAddress]"10.0.0.1"

Como puede ver, esta es una dirección IP válida, pero ¿qué pasaría si tuviéramos un valor que no estuviéramos seguros de que fuera una dirección correcta? Pasar una dirección con formato incorrecto o fuera de rango generará un error al informar del valor incorrecto.

[IPAddress]"258.0.0.1"

PSCredencial

Proteger las credenciales es fundamental para interactuar con servicios web, sistemas remotos o aplicaciones de terceros. La clase PSCredential cifra una contraseña en un objeto. Pasar este objeto a funciones y cmdlets facilita la autenticación.

En el siguiente ejemplo, estamos creando un objeto PSCredential utilizado para almacenar nuestros valores seguros. Tenga en cuenta que el valor de la contraseña requiere una cadena segura.

[PSCredential]::New("username", ("password" | ConvertTo-SecureString -AsPlainText -Force))

Aunque vemos el valor del nombre de usuario generado aquí, no vemos el valor de la contraseña. ¿Cómo recuperamos eso?

$Credential = [PSCredential]::New("username", ("password" | ConvertTo-SecureString -AsPlainText -Force))
$Credential | Format-List

La forma más sencilla de recuperar la contraseña de este objeto es utilizar el método GetNetworkCredential. A continuación devolveremos la propiedad contraseña.

$credential.GetNetworkCredential().Password

Conclusión

Los aceleradores de tipos de datos de PowerShell facilitan las operaciones complejas en PowerShell. Hay muchos aceleradores, pero con estos consejos, deberías poder usar Powershell para obtener muchos tipos y descubrir nuevos usos. A menudo existen formas únicas de utilizar los aceleradores. ¡Aprender estas diferencias aumentará drásticamente tu productividad!

Artículos relacionados