Cátedra de Sistemas Operativos · 2019-09-24 · PowerShell - Guía teórica Sistemas Operativos 4/26 Instalar PowerShell Core en Linux Para la creación y prueba de los scripts

Universidad Nacional de la Matanza Ingeniería en Informática Cátedra de Sistemas Operativos Año 2019

Departamento de Ingeniería e

Investigaciones Tecnológicas

Jefe de Cátedra: Fabio Rivalta

Autor: Fernando Piubel

Año: 2015

Ultima revisión: Alejandro Rodriguez

Año de revisión: 2019

Guía sobre PowerShell

Cátedra de Sistemas

Operativos

PowerShell - Guía teórica

Sistemas Operativos 2/26

Contenido Introducción ..................................................................................................................................... 3

Instalar PowerShell Core en Linux ............................................................................................ 4

Ubuntu 18.04 ................................................................................................................................. 4

Visual Studio Code con PowerShell .......................................................................................... 5

Consola ............................................................................................................................................. 6

PowerShell pipeline ....................................................................................................................... 8

Filtrado de resultados ................................................................................................................... 9

Por registros .................................................................................................................................. 9

Por columnas ................................................................................................................................ 9

Sintaxis de scripts ....................................................................................................................... 10

Variables ...................................................................................................................................... 10

Uso de comillas ........................................................................................................................... 10

Comentarios ................................................................................................................................ 11

Condiciones y ciclos ................................................................................................................... 11

Funciones .................................................................................................................................... 12

Parámetros .................................................................................................................................. 13

Opciones de parámetros ........................................................................................................... 14

Estructura de las funciones ....................................................................................................... 14

Colecciones ................................................................................................................................. 16

Listas ........................................................................................................................................ 16

Hast Tables ............................................................................................................................. 16

Manejo de eventos ..................................................................................................................... 17

Scopes ......................................................................................................................................... 19

Uso de la Ayuda ......................................................................................................................... 19



Introducción "Windows PowerShell es una interfaz de consola (CLI) con posibilidad de escritura y unión de

comandos por medio de instrucciones (scripts en inglés). Es mucho más rica e interactiva que sus

predecesores, desde DOS hasta Windows 7. Esta interfaz de consola está diseñada para su uso por

parte de administradores de sistemas, con el propósito de automatizar tareas o realizarlas de

forma más controlada. Originalmente denominada como MONAD en 2003, su nombre oficial

cambió al actual cuando fue lanzada al público el 25 de abril del 2006.

PowerShell no sólo permite interactuar con el sistema operativo, sino también con programas de

Microsoft como SQL Server, Exchange o IIS. La principal utilidad de PowerShell es permitir

automatizar tareas administrativas al usuario.

El lenguaje de la consola incluye declaración de variables, variables especiales predefinidas,

operadores matemáticos, incluyendo igualdades y desigualdades numéricas, manejo de vectores,

comparación entre estos, operadores de asignación, vectores asociativos (hashtables), valores

booleanos, ciclos y ruptura de los mismos, operadores de expansión para simplificación de

ejecuciones complejas (creación de vectores por medio de llamados a procedimientos, creación

dinámica de vectores, etc.); comentarios, operadores de comparación binaria, caracteres de

escape, orden de ejecución, ciclos del tipo "foreach", creación de procedimientos y funciones,

creación de filtros, estructuras condicionales complejas (if/then/else/elseif/switch), operador de

invocación dinámica del contenido de variables ($p = "MiProceso" --> &$p ejecuta MiProceso),

llamado a métodos de tipo "$p.ToUpper()", acceso a propiedades de instancias de objetos,

redirección de salida normal de consola a archivos, retorno de valores, manejo de cadenas de

caracteres por medio de operadores, manejo de excepciones y conversión explícita de tipos.

Una de las principales funciones de PowerShell es tratar de igualar al famoso lenguaje Perl de

UNIX. El cual está considerado versátil, potente y con facilidad para interactuar con el sistema

operativo. Exchange server 2007 utiliza PowerShell internamente. La tendencia es que todas las

aplicaciones tengan su sección visual y una opción para ver el código generado en PowerShell.

La característica distintiva de PowerShell, es que es un intérprete de comandos orientado a

objetos. La información de entrada y de salida en cada etapa del proceso es un conjunto de

instancias de objeto, a diferencia de lo que ocurre con los intérpretes de comandos tradicionales,

que sólo devuelven y reciben texto."

Fuente: Windows PowerShell - https://es.wikipedia.org

https://es.wikipedia.org/wiki/special:search/Windows%20PowerShell



Instalar PowerShell Core en Linux Para la creación y prueba de los scripts utilizaremos la versión 6.0 de PowerShell, debido a que es

compatible con Net Core.

Ubuntu 18.04

Instalar via Package Repository - Ubuntu 18.04

https://docs.microsoft.com/en-us/powershell/scripting/install/installing-powershell-core-on-

linux?view=powershell-6

# Download the Microsoft repository GPG keys wget -q https://packages.microsoft.com/config/ubuntu/18.04/packages-microsoft-prod.deb # Register the Microsoft repository GPG keys sudo dpkg -i packages-microsoft-prod.deb # Update the list of products sudo apt-get update # Enable the "universe" repositories sudo add-apt-repository universe # Install PowerShell sudo apt-get install -y powershell # Start PowerShell pwsh

https://docs.microsoft.com/en-us/powershell/scripting/install/installing-powershell-core-on-linux?view=powershell-6

https://docs.microsoft.com/en-us/powershell/scripting/install/installing-powershell-core-on-linux?view=powershell-6



Visual Studio Code con PowerShell

El IDE de desarrollo definido por Microsoft para trabajar con PS Core es VisualStudio Code, el cual

funciona en todas las plataformas donde funciona PS Core (Windows, macOS, and Linux)

Una forma sencilla de instalar VS Code es a través de snap:

$ sudo snap install --classic code

Si no tienen instalado en la distribución de Linux snap, pueden hacerlo de la siguiente manera:

$ sudo apt update

$ sudo apt install snapd

Una vez instalado el VS Code, es necesario instalar la extensión de PowerShell, para ello se debe

realizar lo siguiente:

Abrir la vista Extensions, clickeando el icono Extensions en la Activity Bar o con la combinación

(Ctrl+Shift+X). Escribir PowerShell en el buscador e instalar la extensión.

También se puede realizar desde la línea de comandos:

code --install-extension ms-vscode.powershell



Consola Desde PowerShell se pueden ejecutar tres tipos de comandos: cmdlets, scripts y programas

ejecutables (binarios).

Los cmdlets son comandos de PowerShell que realizan una acción y como resultado devuelven un

objeto basado en el framework .NET de Microsoft. Sus nombres están formados por un verbo y un

sustantivo, separados por un guion, como por ejemplo, Get-Help, Select-String, Format-Table, Set-

Variable, Start-Process, Stop-Process, Update-Help, Write-Output.

A diferencia de los comandos de otros shells, los cmdlets tienen las siguientes características:

Son instancias de clases de .NET.

Generalmente no manejan su propia salida de datos, ya sea la salida por pantalla o la salida de

error. Estas tareas las maneja el mismo PowerShell.

Procesan objetos como entrada en vez de texto, y normalmente también devuelven objetos.

Normalmente, la salida de un cmdlet, es la entrada de otro.

Para pasar la salida de un cmdlet como entrada de otro se usa el símbolo “|”.

A continuación, se mencionan y explican algunos de los cmdlets más comunes.

Get-Command: Muestra un listado de todos los cmdlets que se encuentran disponibles

para usar.

Get-Help: Muestra la ayuda de un cmdlet. Ejemplo:

Get-Help Get-Command # Muestra la ayuda de Get-Command

Get-Help Get-ChildItem -detailed # Muestra la ayuda detallada de Get-ChildItem

Get-Help Select-String -online # Muestra la ayuda de Select-String en Internet

Update-Help: Actualiza la ayuda.

Get-Member: Muestra las propiedades, métodos y eventos de un tipo de objeto. Ejemplo

de uso:

Get-ChildItem | Get-Member

# En este caso mostrará información acerca de las clases System.IO.DirectoryInfo y

System.IO.FileInfo, que son los tipos de objetos que devuelve Get-ChildItem.

Get-ChildItem: Muestra el contenido de un directorio.

Get-Process: Muestra los procesos que están corriendo actualmente en el sistema.

Get-Counter: Muestra contadores de performance (uso de la red, uso del procesador, uso

de memoria, etc.) del equipo local o de un equipo remoto.



Start-Sleep -Seconds 10: Hace una pausa de 10 segundos.

Write-Output: Muestra un mensaje por pantalla.

Read-Host: Lee una línea de entrada de la consola.

Exit: Termina el script actual o la sesión de PowerShell.

Get-host: obtiene un objeto con la información del host. Con este objeto se puede

verificar la versión de PowerShell.

Teniendo en cuenta que PowerShell está pensado como una herramienta de administración de

sistemas, muchos de los comandos pueden ser ejecutados de manera remota en otra

computadora, normalmente con el parámetro -ComputerName.



PowerShell pipeline El pipeline actúa como una serie de segmentos de canalización conectados. Los elementos que se

mueven por el pipeline pasan a través de cada segmento. Para crear una canalización en

PowerShell, se conectan comandos con el operador "|". La salida de cada comando se usa como

entrada para el siguiente.

La notación utilizada es similar a la notación utilizada en otros shells. A primera vista, puede que

no sea evidente en qué se diferencia de otros shells, pero el pipeline en PowerShell, aunque

muestre texto, en realidad está enviando objetos por el pipeline entre los comandos.

Para evidenciar esto utilizaremos el cmdlet Get-Member, el cual muestra la estructura de la salida

del comando:

Get-Location | Get-Member

TypeName: System.Management.Automation.PathInfo

Name MemberType Definition Equals Method bool Equals(System.Object obj) GetHashCode Method int GetHashCode() GetType Method type GetType() ToString Method string ToString() Drive Property System.Management.Automation.PSDriveInfo Drive {get;} Path Property string Path {get;} Provider Property System.Management.Automation.ProviderInfo Provider {get;} ProviderPath Property string ProviderPath {get;}



Filtrado de resultados Si bien existen muchos cmdlets que definen la opción de filtrado por alguna condición, utilizando

el pipeline podemos realizar filtros sobre los resultados obtenidos, tanto en cantidad de registros,

como en campos/columnas obtenidos.

Get-ChildItem -Filter "*pdf" -Recurse

El cmdlet Get-ChildItem define el parámetro -Filter el cual filtrará los archivos que cumplan con la

condición de finalizar el pdf.

Por registros

Para realizar el filtro de los resultados por registros o filas, utilizaremos el cmdlet Where-Object, al

cual le indicaremos una condición por la cual realizar el filtrado. Esta condición se evaluará registro

a registro y producirá un resultado acorde.

1) Get-Process | Where-Object ProcessName -Match “^p.*”

2) Get-Process | Where-Object {$_.WorkingSet -gt 25000}

El cmdlet Get-Process devuelve la información de los procesos que están en ejecución, en una lista

de objetos de tipo System.Diagnostics.Process. El cmdlet, recibe por el pipeline esta lista de

objetos y realiza lo siguiente:

1) Define una expresión regular que se debe cumplir a través de -Match. En este caso

devolverá todos los objetos cuyo Property ProcessName empiece con la letra p y luego lo

siga cualquier carácter

2) En este caso es filtrarán los procesos donde su Property WorkingSet (Memoria física) sea

mayor a (gt) 25000 bytes.

Por columnas

Para realizar el filtro de los resultados por registros o filas, utilizaremos el cmdlet Select-Object, al

cual le indicaremos una condición por la cual realizar el filtrado. Esta condición se evaluará registro

a registro y producirá un resultado acorde.

(WS = working set = memoria) Get-Process | Select-Object -Property ProcessName, Id, WS

En este caso se seleccionan las Propiedades ProcessName, Id y WS. Los valores a utilizar se

pueden obtener como ya vimos previamente con el cmdlet Get-Member



Sintaxis de scripts

Variables

PowerShell soporta el uso de variables en scripts. Todos los nombres de variables empiezan con el

signo $, pueden ser dinámicas o de un tipo específico y no son case sensitive (al igual que todos los

comandos).

Las variables pertenecen al ámbito en donde fueron declaradas. Esto quiere decir que si se declara

una variable dentro de una función, sólo será accesible dentro de ella.

Las siguientes son variables propias de PowerShell:

Variable Contiene $_ Objeto proveniente del pipeline $Args Array que contiene cada uno de los parámetros pasados $? Estado del último comando ejecutado. True si fue exitoso, False en caso de error $False Constante False $True Constante True $Null Constante Null $PSVersionTable Versión de PowerShell $Pwd Path actual $Errors Array con los últimos errores, siendo $Error[0] el más reciente

Ejemplo:

Write-Output ('Primer parámetro: ' + $Args[0]) Write-Output ('Último parámetro: ' + $Args[-1]) Write-Output ('Cantidad de argumentos: ' + $Args.Count)

Salida:

Primer parámetro: param1 Último parámetro: param3 Cantidad de argumentos: 3

Uso de comillas

Es importante señalar que, al momento de trabajar con texto, el uso de las comillas varía

dependiendo del comportamiento que se espera. Existen 3 tipos de comillas a utilizar: las comillas

dobles (“), comillas simples (‘) y acento grave (`).

Las comillas dobles, también denominadas comillas débiles, permiten utilizar texto e interpretar

variables al mismo tiempo.

Las comillas simples, también denominadas comillas fuertes, generan que el texto delimitado

entre ellas se utilice de forma literal, lo que evita que se interpreten las variables.



El acento grave, es el carácter de escape para evitar la interpretación de los caracteres especiales,

como por ejemplo el símbolo $.

Ejemplo:

PS > $version = Get-Host | Select version

PS > Write-Output "la versión de PS es: $version" la versión de PS es: @{Version=6.2.0}

PS > Write-Output 'la versión de PS es: $version' la versión de PS es: $version

PS > Write-Output "la versión de PS es: `$version" la versión de PS es: $version

Comentarios

Para la utilización de comentarios dentro del código tenemos 2 opciones, los comentarios de línea

o los de múltiples líneas:

Ejemplo:

# Comentario Simple

<# Comentario

Multi

Línea

#>

Condiciones y ciclos

El siguiente ejemplo muestra la sintaxis de las condiciones y ciclos de PowerShell:

# Condiciones

if ($variable -eq 'valor')

{

...

}

elseif ($variable -lt 'valor')

{

...

}

else

{

...

}

# Ciclo for

for ($i = 0; $i -lt 10; $i++)

{

...

}

# Ciclo foreach

foreach ($item in $array)

{

...

}

# Ciclo while

while ($variable -lt 5)

{

...

}

# Ciclo do while

do

{

...

} while ($variable -lt 10)



Funciones

En los scripts de PowerShell se pueden definir funciones para facilitar el armado de scripts.

Estas funciones estarán definidas por los siguientes atributos:

• Por la palabra reservada Function • Un scope o ámbito (opcional) • El nombre con el cual se identificará a la función • Parámetros (opcional) • Secuencia de comandos definidos entre las llaves { }

El siguiente es un script que utiliza una función de manera recursiva para calcular el factorial de un

número.

function Get-Factorial()

{

Param (

[int]$value

)

if($value -lt 0)

{

$result = 0

}

elseif($value -le 1)

{

$result = 1

}

else

{

$result = $value * (Get-Factorial($value - 1))

}

return $result

}

$value = Read-Host 'Ingrese un número'

$result = Get-Factorial $value # $result = Get-Factorial -value $value

Write-Output "$value! = $result"



Parámetros

A pesar de que se puede acceder a los parámetros del script con la variable $Args, también es

posible accederlos al igual que hacemos en Shell scripting $1, $2, etc. y adicionalmente, podemos

declarar parámetros con nombre y asignarle un tipo de datos y validaciones.

En el siguiente ejemplo se declaran dos parámetros con nombre. El primero, llamado name, es

obligatorio (Mandatory=$True), de tipo String y si no se lo pasa por nombre, será el primer

parámetro sin nombre (Position=1). El segundo parámetro, firstName, no es obligatorio y al no

tener especificada una posición, si no se lo pasa por nombre no tendrá valor.

Código:

Param( [Parameter(Mandatory=$True, Position=1)] [string]$name, [Parameter(Mandatory=$False)] $lastName ) Write-Output "Hola $name $lastName "

Se ejecuta de la siguiente manera:

# Los dos parámetros se pasan por nombre. .\script.ps1 -name ‘Nombre’ -lastName ‘Apellido’ # Un parámetro es pasado por nombre y el otro por posición. .\script.ps1 -lastName ‘Apellido’ ‘Nombre’ # No se puede ejecutar de esta manera, ya que dará error porque no se especificó el parámetro “name” que era obligatorio. .\script.ps1 -lastName ‘Apellido’

Salida:

Hola Nombre Apellido



Opciones de parámetros

La definición de parámetros en PowerShell, nos permite especificar una gran variedad de opciones

y validaciones, que el Engine se encargará de resolver automáticamente al recibir los valores en los

parámetros.

Además de las opciones ya vistas, se pueden añadir validaciones a los parámetros, ya sea de tipo,

rango, largo, vacío o null, patrones (con expresiones regulares), entre otras.

Param ( [parameter(Mandatory=$true)] [ValidateNotNullOrEmpty()] [ValidateLength(5,8)] # De 5 a 8 caracteres de largo [ValidatePattern('^.*@.*\.[a-z]{3}$')] [string]$cadena, [parameter(Mandatory=$true)] [ValidateNotNullOrEmpty()] [ValidateRange(1,10)] [int]$entero )

Estructura de las funciones

Ya hemos visto la definición de los parámetros y ahora veremos las secciones que se pueden

definir dentro de las funciones:

Begin {

<#

Code

#>

}

Process {

<#

Code

#>

}

End {

<#

Code

#>

}



Esta estructura es similar a la de AWK, donde tenemos el bloque Begin, que se ejecutará por única

vez al comienzo de la invocación y el bloque End que se ejecutará por única vez, al finalizar la

ejecución. En cambio, el bloque Process veremos que se puede ejecutar más de una vez si

utilizamos la función en un pipeline de ejecución.

En el siguiente ejemplo veremos la iteración del bloque Process:

function Get-Multiplicacion() { [CmdletBinding()] param( [Parameter(ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true)] [int]$value ) Begin{ $result = 0 } Process { Write-Output "Resultado parcial: $result" if($value -lt 0) { $result = 0 } elseif($value -le 1) { $result = 1 } else { $result = $value * $result } } End{ Write-Output "Resultado Final: $result" } }

Resultado de la ejecución:

PS > 1 .. 8 | Get-Multiplicacion

Resultado parcial: 0 Resultado parcial: 1 Resultado parcial: 2 Resultado parcial: 6 Resultado parcial: 24 Resultado parcial: 120 Resultado parcial: 720 Resultado parcial: 50040 Resultado Final: 40320



Colecciones

Veremos como utilizar algunas de las collections más utilizadas: Listas y Hash Tables

Listas

Defino una nueva lista con la sentencia @() y luego le agrego elementos:

$array = @() $array += 1 $array += 2 $array += (3..9) $array

$datos = Import-CSV -Delimiter ',' -Path ./delimitados.txt $datos | Sort-Object -Property Patente $datos | Get-Member

$patente = 0 $datos | ForEach-Object { if ($patente -eq $_.patente) { # mientras sean iguales acumulo } else { # imprimo } }

También puedo definir a la lista como un nuevo objeto y definir el tipo de dato.

$paises = New-Object System.Collections.ArrayList $paises.Add('Argentina') $paises.Add('Brasil') > $null $paises.Add(22) $paises

Hast Tables

Defino un nuevo Hash Table vacío con la sentencia @{}

$materias = @{ }

Hash Table inicializado con valores:

$materias = @{SO= "Sistemas Operativos"; CP = "Compiladores"; BD = "Base de Datos" }



Agregar y quitar valores:

$materias.add("PR1", "Programación 1") $materias["PR1"] $materias.Remove("PR1") $materias["PR1"] $materias["PR1"] = "Programación 1" $materias["PR1"]

Accedo a los valores haciendo referencia por medio del subíndice, que puede ser un número o un string.

Manejo de eventos

PowerShell nos permite definir acciones a realizar sobre diversos eventos controlados sobre los

objetos. Para ello haremos uso de los siguientes cmdlet para registrar, validar y eliminar los

eventos.

• Register-ObjectEvent Registra el evento en el sistema

• Get-EventSubscriber Obtiene los eventos registrados

• Unregister-Event Elimina el evento registrado

Para registrar un evento en el sistema debemos definir los siguientes atributos:

• InputObject: objeto que utilizaremos para registrar el evento

• EventName: evento a registrar del objeto

• SourceIdentifier: identificador que utilizaremos definir al evento

• Action: serie de comandos a ejecutar cuando se invoque el evento



Para conocer los eventos que podemos registrar de un objeto utilizaremos el cmdlet Get-Member

# Obtención de los eventos que puede registrar un objeto New-Object Timers.Timer | Get-Member -Type Event | Select Name Name ---- Disposed Elapsed

# Ejemplo de uso: $timer = New-Object Timers.Timer $timer2 = New-Object Timers.Timer $timer3 = New-Object Timers.Timer # Tener en cuenta es es posible que sea necesario utilizar el scope Global si se controlará por fuera del script. $repeticiones = 1 $action = { write-host "$repeticiones, Timer Elapse Event: $(get-date -Format ‘HH:mm:ss’)" $repeticiones++ }

$timer.Interval = 1000 #1 seconds $timer2.Interval = 2000 #2 seconds $timer3.Interval = 3000 #3 seconds Register-ObjectEvent -InputObject $timer -EventName elapsed –SourceIdentifier timer1seg -Action $action Register-ObjectEvent -InputObject $timer2 -EventName elapsed –SourceIdentifier timer2seg -Action $action Register-ObjectEvent -InputObject $timer3 -EventName elapsed –SourceIdentifier timer3seg -Action $action # Para iniciar el timer $timer.start() $timer2.start() $timer3.start() # Para detenerlo $timer.stop() # Borro el registro del evento Unregister-Event timer1seg # Obtengo los eventos registrados Get-EventSubscriber | Unregister-Event



Scopes

PowerShell maneja el concepto de scope o ámbito, el cual se aplica en 3 niveles y puede ser utilizado para modificar variables, alias y funciones.

• Global: El scope que está vigente cuando se inicia PowerShell. Las variables y funciones que

están presentes cuando se inicia PowerShell se han creado en el ámbito global, como las

variables automáticas y las variables de preferencia. Las variables, los alias y las funciones

en sus perfiles de PowerShell también se crean en el ámbito global.

• Local: El scope actual. El ámbito local puede ser el ámbito global o cualquier otro ámbito.

• Script: El scope que se crea mientras se ejecuta un archivo de script. Solo los comandos en

el script se ejecutan en el alcance del script. Para los comandos en un script, el alcance del

script es el alcance local.

La sintaxis es la siguiente:

$[<scope-modifier>:]<name> = <value>

function [<scope-modifier>:]<name> {<function-body>}

Para más información: https://docs.microsoft.com/en-

us/powershell/module/microsoft.powershell.core/about/about_scopes?view=powershell-6

Uso de la Ayuda

Para obtener ayuda sobre los cmdlet existe el Get-Help, que nos brindará la información funcional,

sobre los parámetros, el modo de uso, entre otros temas.

PowerShell genera de forma automática, una hoja de ayuda con las funciones que creamos, con la

información básica. Por ejemplo, de la función anterior Get-Factorial, obtenemos lo siguiente:

Esto nos brinda una ayuda estándar para todos los cmdlet y funciones de usuario que se

desarrollan. A continuación, veremos cómo explotar un poco más la utilización de la ayuda.

La recopilación de la información de ayuda de la función se realiza mediante metadata que se

debe especificar inmediatamente antes de la palabra reservada function, sin dejar espacios ni

saltos de línea, ya que de lo contrario no se identificará como parte de la ayuda sino como un

comentario del script.

https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_scopes?view=powershell-6

https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_scopes?view=powershell-6



Dentro de la especificación existen varias secciones que son las que luego se mostraran con el

Get-Help. Las mismas son:

.Synopsis

.Description

.Example (puede ser más de 1)

.Inputs

.Outputs

A continuación se muestra un ejemplo básico de estas secciones:

<# .Synopsis Short description .DESCRIPTION Long description .EXAMPLE Example of how to use this cmdlet .EXAMPLE Another example of how to use this cmdlet .INPUTS Inputs to this cmdlet (if any) .OUTPUTS Output from this cmdlet (if any) .NOTES General notes .COMPONENT The component this cmdlet belongs to .ROLE The role this cmdlet belongs to .FUNCTIONALITY The functionality that best describes this cmdlet #> function Verb-Noun { <# CODE #> }

Agregando la sección de ayuda a la función Get-Factorial obtenemos el siguiente resultado:

<# .Synopsis Esta función calcula el factorial de un número de manera recursiva .Description Esta función calcula el factorial de un número de manera recursiva .Parameter value



Este parámetro indicará cuál el número al cuál calcular el factorial .Example Get-Factorial -value 5 120 #> function Get-Factorial() {

Note que para obtener diferentes grados de información podemos utilizar los parámetros –

Example, –Detailed o –Full, los cuales irán mostrando un mayor detalle de la ayuda informada en

la metadata de la función.



Manejo de Errores

Para el manejo de errores, tendremos la opción de capturarlos y darles un tratamiento adecuado,

al igual que podemos hacer en lenguajes como .NET o Java, entre otros, y adicionalmente, definir

un comportamiento por defecto ante la aparición de alguna excepción.

La sintaxis es la siguiente:

try { <# Código con posibilidad de error #> } catch { <# Acciones a tomar ante la excepción #> } finally { <# Acciones que siempre se ejecutaran #> }

Al incorporar la directiva CmdLetBinding, que ya hemos mencionado anteriormente, se nos

habilitan los siguientes argumentos a las funciones: ErrorAction y ErrorVarible.

ErrorAction (EA), es una enumeración que nos permite setear el comportamiento ante una

excepción en la ejecución del CmdLet o la función. Si queremos que el error encontrado sea

capturado, entonces se debe setear el argumento con “Stop”.

ErrorVariable (EV), nos permite crear una variable donde se almacenaran los errores obtenidos

para inspeccionarlos y poder analizar las causas y determinar las acciones a tomar.

Adicionalmente, a estos argumentos, es importante resaltar la existencia y diferencia en el uso de

los cmdLets para la escritura de información:

Write-Error: Muestra el mensaje especificado y finaliza la ejecución de la función.

Write-Warning: Muestra el mensaje en un color diferente al normal a la consola, con la leyenda

“WARNING” o “ADVERTENCIA”, dependiendo del lenguaje.

Write-Output: Muestra el mensaje especificado en el estándar output.

Write-Debug: Muestra el mensaje en un color diferente al normal con la leyenda “Debug”,

solamente si la variable –Debug ha sido seteada en la ejecución del CmdLet.



function Detener-Proceso() { [CmdLetBinding()] Param( [Parameter(Mandatory=$True, ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true)] [Int[]]$Id ) Process{ foreach ($proc in $Id) { try{ kill -Id $proc Write-Output "El proceso $proc fue detenido exitosamente" } catch{ Write-Warning "El proceso $proc no existe en el sistema" } } } }

Ejemplos de uso:

Ejecutar la función con Ids inexistentes:

PS> Detener-Proceso -Id 3324, 3325 -ErrorVariable errorKill -ErrorAction Stop

El resultado será el siguiente:

ADVERTENCIA: El proceso 3324 no existe en el sistema


Uso del Pipeline:

Verificamos que existan procesos:

PS> get-process -Name notepad*

Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName

------- ------ ----- ----- ----- ------ -- -----------

61 3 1212 4904 64 0,06 5344 notepad

121 9 10592 16760 100 0,42 4124 notepad++

Ejecución de la instrucción:



PS> get-process -Name notepad* | Detener-Proceso -EA Stop -EV errorKill

El proceso 5344 fue detenido exitosamente


Ejecución de la función para Ids existentes e inexistentes:

PS> Detener-Proceso -Id 4364, 3984 -EV errorKill -EA Stop



PS> $errorKill

Se detuvo el comando en ejecución porque la variable de preferencia "ErrorActionPreference" o un parámetro común se han establecido en Stop: No se encuentra ningún proceso con el

identificador 4364.

kill : No se encuentra ningún proceso con el identificador 4364.

En C:\Users\Public\Documents\Manuales\PowerShell\Scripts\pruebas.ps1: 15 Carácter: 17

+ kill -Id $proc

+ ~~~~~~~~~~~~~~

+ CategoryInfo : ObjectNotFound: (4364:Int32) [Stop-Process], ProcessCommandException

+ FullyQualifiedErrorId : NoProcessFoundForGivenId,Microsoft.PowerShell.Commands.StopProcessCommand



Cmdlets más usados

A continuación una lista de los cmdlets más usados:

Archivos:

Get-ChildItem

Copy-Item

Move-Item

Get-Content

Set-Content

Out-File

Out-Null

Export-Csv

Cadenas:

Select-String

Manejo de colecciones de objetos:

Select-Object

Where-Object

ForEach-Object

Sort-Object

Procesos y datos del sistema:

Get-Process

Get-WmiObject

Get-Counter

Test-Connection (ping)

Add-Type (agrega bibliotecas de .Net)



Bibliografía

http://en.wikiversity.org/wiki/Windows_PowerShell

http://powershell.org/wp/

https://docs.microsoft.com/en-us/powershell/

http://en.wikiversity.org/wiki/Windows_PowerShell

http://powershell.org/wp/

https://docs.microsoft.com/en-us/powershell/