Cmdlet

Un cmdlet, que se pronuncia command-let, es un comando pequeño y liviano que se usa en el entorno de Windows PowerShell. Un cmdlet normalmente existe como un pequeño script que está diseñado para realizar una única función específica, como copiar archivos y cambiar directorios. Se puede ingresar un cmdlet y sus parámetros relevantes en una línea de comandos de PowerShell para su ejecución inmediata o se pueden incluir como parte de un script de PowerShell más largo que se puede ejecutar como se desee.

¿Cómo funcionan los cmdlets?

Los cmdlets emplean un patrón de denominación de verbo / sustantivo diseñado para que cada cmdlet sea más fácil de recordar y leer. Como ejemplo, un comando típico Get-ChildItem usa el verbo Get seguido del sustantivo ChildItem. Cuando se ejecuta a través del entorno de ejecución de PowerShell, el comando enumera o devuelve los elementos en una o más ubicaciones especificadas. Si los elementos están en un contenedor, el comando obtiene los elementos dentro del contenedor: elementos secundarios.

Los cmdlets se basan en clases .NET y dependen del uso de objetos .NET. Por lo tanto, los cmdlets pueden recibir objetos como entrada y entregar objetos como salida, que luego pueden alimentar la entrada de los objetos posteriores, lo que permite que los cmdlets formen una canalización de comandos.

La mayoría de los cmdlets admiten el uso de parámetros como parte del mecanismo de entrada. Los parámetros se pueden agregar al cmdlet en la línea de comandos o pasar a los cmdlets a través de la canalización como resultado de un cmdlet anterior. Los argumentos o valores de cada parámetro detallan la entrada real que aceptará el cmdlet, cómo debería funcionar el cmdlet y qué datos, si los hubiera, genera el cmdlet. Los interruptores son argumentos especializados que ofrecen opciones o selecciones preestablecidas.

Este artículo es parte de

Guía completa de PowerShell para administradores nuevos y experimentados

  • Que también incluye:
  • Mejores prácticas para usar PowerShell ISE para scripting
  • Siga esta guía paso a paso para usar AWS Lambda con PowerShell
  • Sube de nivel con estos comandos avanzados de PowerShell para copiar archivos

Descargar1

¡Descarga esta guía completa GRATIS ahora!

Considere un cmdlet simple como Get-Help; la sintaxis del cmdlet para obtener ayuda para los cmdlets deseados de una biblioteca en línea es:

consigue ayuda -en línea

Get-Help es el cmdlet. El argumento del parámetro es el nombre del cmdlet que necesita más información. En el uso real, los usuarios sustituirían el nombre del cmdlet deseado. Puede ser cualquier cmdlet. El conmutador es -online, lo que le indica a PowerShell que haga referencia y devuelva la ayuda para el cmdlet deseado de la biblioteca en línea de Microsoft. Por ejemplo, para obtener más ayuda sobre el cmdlet Add-AppxPackage, el comando de PowerShell se vería así:

get-help add-appxpackage -online

Para usar la ayuda local para el mismo cmdlet, elimine el modificador:

get-help add-appxpackage

get-help add-appxpackage

Obtenga más información sobre el cmdlet Add-AppxPackage.

Cmdlets frente a funciones

Aunque PowerShell se basa en el procesamiento de cmdlets, existe un segundo tipo de comando denominado funciones. Las funciones también se interpretan a través de PowerShell y se utilizan habitualmente en scripts. Es común confundir cmdlets y funciones. Sin embargo, los cmdlets y las funciones difieren en varios aspectos importantes.

Los cmdlets son clases .NET escritas en lenguajes de programación superiores como C # y compiladas en archivos .dll para que PowerShell pueda acceder a ellos. Por lo tanto, los conjuntos de cmdlets se pueden agregar fácilmente y se pueden crear nuevos cmdlets y ponerlos a disposición de PowerShell. En comparación, las funciones tienden a integrarse en PowerShell y no se compilan, sino que se escriben en el lenguaje de PowerShell. Las funciones tienden a ser entidades más largas y complejas que normalmente pueden manejar el análisis, la presentación de errores y el formato de salida, donde los cmdlets son a menudo demasiado pequeños y simples para manejar tales detalles.

Aún así, la diferencia esencial entre los cmdlets y las funciones radica en los problemas de empaquetado, incluida la configuración, la instalación y las características. En la práctica, hay poca diferencia notable entre cmdlets y funciones. Al igual que los cmdlets, las funciones pueden tener parámetros y valores de retorno que se pueden mostrar o asignar a variables. Tanto los cmdlets como las funciones se usan fácilmente en los scripts de PowerShell.

Cmdlets populares

Hay cientos de cmdlets disponibles de forma predeterminada en PowerShell actual, y se pueden agregar cientos de cmdlets más a PowerShell para admitir aplicaciones avanzadas como plataformas de virtualización y herramientas de administración de sistemas. Para encontrar un índice completo de todos los cmdlets que están disponibles actualmente en PowerShell en una computadora, escriba:

cmdlet get-command -commandtype

Esto devuelve una lista completa de cmdlets actualmente en PowerShell. Sin embargo, esto no proporciona detalles específicos sobre el propósito o la sintaxis de cada cmdlet. Para recopilar más detalles sobre los cmdlets deseados, use el cmdlet Get-Help como se describe anteriormente. Por ejemplo, para aprender el nombre, la sintaxis, los alias y las notas sobre el cmdlet Unblock-File, use:

obtener ayuda para desbloquear el archivo

y PowerShell devuelve ejemplos completos de sintaxis y parámetros adecuados. Los usuarios de PowerShell a menudo se benefician al familiarizarse con una selección de cmdlets de PowerShell de uso común, que incluyen:

cmdlet Función
Obtener ubicación obtener el directorio actual
Get-ChildItem enumerar elementos en un directorio
Consigue ayuda obtener más información sobre un cmdlet deseado
Proceso de parada terminar un proceso de PowerShell
Escoger localización cambiar el directorio actual
Copiar artículo copiar archivos
Remover el artículo eliminar un archivo o directorio
Mover elemento mover un archivo
Cambiar nombre de elemento cambiar el nombre de un archivo
Nuevo artículo crear un nuevo archivo o directorio vacío
Invoke-GPUpdate forzar una actualización de la política de grupo
Stop-Computer apagar una computadora local o remota
Reiniciar-Computadora reiniciar una computadora local o remota
Add-Computer unir una computadora a un dominio

Cómo escribir un cmdlet simple

Los cmdlets suelen ser entidades simples y se pueden escribir en solo varias docenas de líneas de C # u otros lenguajes que admitan código de objeto .NET. Aunque el trabajo real y la complejidad de un cmdlet pueden variar drásticamente, el proceso real involucrado en delinear un nuevo cmdlet generalmente se puede dividir en varios pasos comunes que implican definir el cmdlet, aceptar parámetros y luego procesar los parámetros para entregar un resultado. Un ejemplo simple podría ser crear un cmdlet que tome el nombre de una persona y genere un mensaje de prueba.

1. Debido a que se trata de un cmdlet, el desarrollador básicamente está creando un objeto, por lo que primero especifique la clase principal del cmdlet. Un cmdlet se deriva de las clases System.Management.Automation.Cmdlet o System.Management.Automation.PSCmdlet. Un cmdlet en C # puede usar el comando using, como:

utilizando System.Management.Automation;

2. A continuación, especifique el nombre de la clase de objeto. Por ejemplo, si se supone que el nuevo cmdlet simplemente envía un mensaje de prueba, C # podría usar el comando de espacio de nombres como:

espacio de nombres SendTestMessage

3. Declare la clase del objeto como cmdlet. El atributo cmdlet permite a los desarrolladores estipular los elementos de verbo y sustantivo del nombre del cmdlet. Por ejemplo, un comando de C # que define un cmdlet y lo nombra "Send-Test" puede aparecer como:

[Cmdlet (VerbsCommunications.Send, "TestMessage")]

4. Especifique los parámetros del cmdlet mediante el atributo de parámetro. La longitud y la complejidad de esta sección de código dependen de la cantidad y los tipos de parámetros que el cmdlet debe manejar. Por ejemplo, si el cmdlet simplemente está destinado a aceptar el nombre de una persona para recibir un mensaje de prueba, un parámetro podría ser ingresar el nombre de esa persona y crear la cadena variable "nombre". En C #, la secuencia de código puede aparecer como:

[Parámetro (obligatorio = verdadero)]
    Nombre de cadena pública
    {
      obtener {nombre de retorno; }
      establecer {nombre = valor; }
    }
    nombre de cadena privada;

5. Ahora que se ha definido el cmdlet y se han aceptado los parámetros, el código del cmdlet puede centrarse en la tarea real en cuestión. En este caso, la tarea es tomar el parámetro de nombre y enviar ese nombre a un mensaje de prueba simple. Como ejemplo, el comando WriteObject puede producir una salida simple como:

     {
      WriteObject ("Es un gusto conocerte" + nombre + "!");
     }

Recuerde que este es solo un ejemplo simple y no detalla todos los comandos, la puntuación (sangría y corchetes) y el código de soporte que podría ser necesario para completar un cmdlet de este tipo con éxito. Los desarrolladores pueden consultar la documentación de C # y PowerShell, textos detallados sobre la creación de cmdlets e innumerables ejemplos de cmdlets para obtener más instrucciones de programación.