Teoría PowerShell 1

PowerShell
Tutorial básico de
PowerShell
1 Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es)

PowerShell
Contenido
1. Introducción a PowerShell.................................................................................................... 3
2. Uso de PowerShell ................................................................................................................ 4
3. Consola ................................................................................................................................. 5
3.1. Formato de cmdlet ...................................................................................................... 5
3.2. Cmdlets disponibles ..................................................................................................... 9
4. Canalización de objetos ...................................................................................................... 13
5. Windows PowerShell ISE .................................................................................................... 16
6. Sintaxis de scripts ............................................................................................................... 17
6.1. Preparación para ejecutar scripts de PowerShell ...................................................... 17
6.2. Variables y parámetros .............................................................................................. 18
6.3. Uso de comillas .......................................................................................................... 19
6.4. Comentarios............................................................................................................... 19
6.5. Operadores ................................................................................................................ 20
6.6. Condiciones y ciclos ................................................................................................... 20
7. Funciones............................................................................................................................ 21
7.1. Parámetros ................................................................................................................ 21
7.2. Opciones de parámetros ........................................................................................... 22
7.3. Estructura de las funciones........................................................................................ 23
8. Uso de la Ayuda .................................................................................................................. 24
8.1. Manejo de Errores ..................................................................................................... 25
9. Cmdlets más usados ........................................................................................................... 28
9.1. Ejemplos..................................................................................................................... 30
10. Explorar Windows PowerShell ISE ................................................................................. 32
11. Alias de compatibilidad .................................................................................................. 34
11.1. Usar nombres de comando conocidos ...................................................................... 34
11.2. Interpretar los alias estándar ..................................................................................... 35
11.3. Crear nuevos alias ...................................................................................................... 36
Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es) 2

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

unión de comandos por medio de instrucciones (scripts). Es mucho más rica e interactiva
que sus predecesores, desde DOS hasta Windows 10. Esta interfaz de consola está
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 cambió al actual cuando fue lanzada al público
el 25 de abril del 2006.
PowerShell no solo 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, creació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.
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.

PowerShell
2. Uso de PowerShell
Para abrir la consola de PowerShell, ejecutamos PowerShell en el menú de inicio de

Windows 10. La ventana que se abrirá, tendrá la siguiente apariencia.

PowerShell
3. 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.
3.1. Formato de cmdlet

Un cmdlet siempre consta de un verbo (o una palabra que funciona como un verbo) y
un sustantivo, separados por un guión (la regla del "sustantivo del verbo"). Por ejemplo,
algunos de los verbos que podemos usar incluyen:
• Get - Para obtener algo
• Set - Para definir algo
• Start - Para ejecutar algo
• Stop: para detener algo que se está ejecutando
• Out - Para generar algo
• New: para crear algo ("nuevo" no es un verbo, por supuesto, pero funciona como
tal)

PowerShell
Para practicar, vamos a ejecutar los siguientes cmdlets:

• Get-Process: muestra los procesos que se están ejecutando actualmente en su
computadora:

PowerShell
• Get-Service: muestra la lista de servicios con su estado

PowerShell
• Get-Content: muestra el contenido del archivo que especifique (por ejemplo,

Get-Content C:\Windows\System32\drivers\etc\hosts)

PowerShell
3.2. Cmdlets disponibles

Buenas noticias: no necesita memorizar todos los cmdlets. Puede mostrar todos los
cmdlets ejecutando Get-Help -Category cmdlet, que devolverá un listado con todos los
cmdlets disponibles:
También puede crear sus propios cmdlets personalizados.

Cada cmdlet tiene varios parámetros que personalizan lo que hace. PowerShell ISE
sugerirá automáticamente todos los parámetros válidos y sus tipos después de escribir
un cmdlet y un guión (-):

PowerShell
Por ejemplo, el siguiente cmdlet muestra todos los servicios cuyos nombres comienzan
con "W":
Get-Service -Name W*
Si nos olvidamos los parámetros de un cmdlet, solo use un script como el siguiente, que
mostrará los parámetros para el cmdlet Get-Process:
Get-Process | Get-Member

PowerShell
Si aún no se encuentra el cmdlet que se necesita, podemos asegurarnos de que la ayuda

esté actualizada con Update-Help y luego obtener ejemplos para un cmdlet (como Get-
Process) usando un script como este:
Update-Help #to update the help data

Get-Help Get-Process -Examples
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: Muestra el contenido de un directorio.
Get-ChildItem | Get-Member
# En este caso mostrará información acerca de las clases

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

PowerShell
• 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 está 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
4. Canalización de objetos
Las canalizaciones actúan como una serie de segmentos de canalización conectados. Los
elementos que se mueven por la canalización pasan a través de cada segmento. Para
crear una canalización en Windows PowerShell, se conectan comandos con el operador
de canalización "|". La salida de cada comando se usa como entrada para el siguiente.
Las canalizaciones son sin duda el concepto más valioso usado en las interfaces de línea
de comandos. Si se usan correctamente, las canalizaciones no solo reducen el esfuerzo
que implica escribir comandos complejos, sino que también facilitan la visualización del
flujo de trabajo en los comandos. Una característica útil relacionada con las
canalizaciones es que, dado que operan en cada elemento por separado, no tienen que
modificarse según la ausencia de elementos o la presencia de uno o muchos elementos
en la canalización. Además, cada comando de una canalización (denominado un
elemento de canalización) suele pasar la salida al siguiente comando de la canalización
elemento por elemento. Normalmente, esto reduce la demanda de recursos de
comandos complejos y permite empezar a obtener la salida inmediatamente.
La canalización funciona prácticamente en cualquier lugar en Windows PowerShell.

Aunque se ve texto en la pantalla, Windows PowerShell no canaliza texto entre los
comandos. En su lugar, canaliza objetos.
La notación usada para las canalizaciones es similar a la que se usa en otros shells, por
lo que, a primera vista, puede que no sea evidente que Windows PowerShell presenta
algo nuevo. Por ejemplo, si usa el cmdlet Out-Host para forzar una presentación página
por página de la salida de otro comando, la salida tiene el aspecto del texto normal que
se muestra en la pantalla:
El comando Out-Host -Paging es un elemento de la canalización útil siempre que se tiene

una salida larga que le gustaría mostrar lentamente. Es especialmente útil si la operación

PowerShell
consume una gran cantidad de CPU. Dado que el procesamiento se transfiere al cmdlet
Out-Host cuando tiene una página completa lista para mostrar, los cmdlets que lo
preceden en la canalización detienen la operación hasta que la siguiente página de salida
esté disponible. Puede verlo si usa el Administrador de tareas de Windows para
supervisar el uso de la CPU y la memoria de Windows PowerShell.
Ejecute el siguiente comando: Get-ChildItem C:\Windows -Recurse. Compare el uso de

la CPU y la memoria con este comando: Get-ChildItem C:\Windows -Recurse | Out-Host
-Paging. Lo que ve en la pantalla es texto, lo que se debe a la necesidad de representar
objetos como texto en una ventana de la consola. Se trata simplemente de una
representación de lo que sucede realmente en Windows PowerShell. Por ejemplo,
considere el cmdlet Get-Location. Si escribe Get-Location mientras la ubicación actual
es la raíz de la unidad C, verá la siguiente salida:
Si Windows PowerShell canaliza texto, al emitir un comando como Get-Location | Out-

Host, pasará de Get-Location a Out-Host un conjunto de caracteres en el orden en que
se muestran en la pantalla. En otras palabras, si fuera a ignorar la información de
encabezado, Out-Host recibiría primero el carácter 'C', luego el carácter ':' y, finalmente,
el carácter '\'. El cmdlet Out-Host no pudo determinar el significado que debía asociarse
a los caracteres emitidos por el cmdlet Get-Location.
En lugar de utilizar texto para permitir que los comandos de una canalización se
comuniquen, Windows PowerShell usa objetos. Desde el punto de vista de un usuario,
los objetos empaquetan información relacionada en un formulario que facilita la
manipulación de la información como una unidad y la extracción de los elementos
específicos que necesita.
El comando Get-Location no devuelve el texto que contenga la ruta de acceso actual.

Devuelve un conjunto de información denominado objeto PathInfo que contiene la ruta
de acceso actual junto con otra información. El cmdlet Out-Host envía luego este objeto

PowerShell
PathInfo a la pantalla y Windows PowerShell decide qué información se mostrará y

cómo se mostrará en función de sus reglas de formato.
De hecho, la información de encabezado generada por el cmdlet Get-Location se agrega
solo al final del proceso, como parte del proceso de formato de los datos para su
presentación en pantalla. Lo que ve en la pantalla es un resumen de la información y no
una representación completa del objeto de salida.

PowerShell
5. Windows PowerShell ISE
Windows PowerShell ISE (Integrated Scripting Engine), es el IDE que nos provee
Windows donde podemos ejecutar comandos o cmdlets , escribir, probar, crear, guardar
o depurar scripts en un entorno con interfaz gráfica, con edición multimedia,
autocompletado con el tabulador, sintaxis coloreada, ejecución selectiva, ayuda
contextual y compatibilidad con idiomas que se escriben de derecha a izquierda, con
ella podemos tener una experiencia de usuario más enriquecida a la hora de automatizar
nuestras tares de administración con la creación de scripts y la fácil incorporación
cmdlets, gracias al panel de módulos que nos provee ayuda en la utilización y búsqueda
de los mismos.
Windows PowerShell ISE

PowerShell
6. Sintaxis de scripts
6.1. Preparación para ejecutar scripts de PowerShell
Los scripts de PowerShell se almacenan en archivos .ps1. Por diseño, no se puede
ejecutar una secuencia de comandos simplemente haciendo doble clic en un archivo;
esto ayuda a evitar daños accidentales al sistema. En su lugar, para ejecutar un script,
hacemos clic derecho y hacemos clic en "Ejecutar con PowerShell":
Además, hay una política que restringe la ejecución de scripts. Se puede verificar esta
política ejecutando el comando Get-ExecutionPolicy en PowerShell:
Obtendrá uno de los siguientes valores:
• Restricted: no se permiten scripts. Esta es la configuración predeterminada, por

lo que la verá la primera vez que ejecute el comando.
• AllSigned: puede ejecutar scripts firmados por un desarrollador de confianza.
Con esta configuración, antes de ejecutar un script, le pedirá que confirme que
desea ejecutarlo.
• RemoteSigned: puede ejecutar sus propios scripts o scripts firmados por un
desarrollador de confianza.
• Unrestricted: puede ejecutar cualquier script que desee.

PowerShell
Para comenzar a trabajar con PowerShell, se deberá cambiar la configuración de la

directiva de Restricted a RemoteSigned mediante el comando Set-ExecutionPolicy
RemoteSigned:
6.2. Variables y parámetros

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 especifico 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 será́ 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 Versión de PowerShell
$Pwd Path actual
$Errors Array con los últimos errores, siendo $Error[0] el más
reciente
Ejemplo:
Write-Output ('Primer parámetro: ' + $Args[0])
Write-Output ('Último parámetro: ' + $Args[-1])
Write-Output ('Cantidad de argumentos: ' + $Args.Count)
Salida:
Primer parámetro: param1
Último parámetro: param3
Cantidad de argumentos: 3

PowerShell
6.3. Uso de comillas

Es importante señalar que, al momento de trabajar con este 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 $.
•
Utilización de comillas
6.4. 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 #>

PowerShell
6.5. Operadores
• Aritméticos: +, -, *, /, %
• De asignación; =, +=, -=, *=, /=, %=
• De comparación: -eq, -ne, -gt, -lt, -le, -ge
• También coincidencia (-match, -nomatch), sustitución (-replace) y de patrones (-like, -
nolike)
• Lógicos: -and, -or, -xor, -not, !
• De redirección: >, >>
• De división y combinación: -split, -join
• De tipo: -is, -isnot, -as
Operador de comparación Significado Ejemplo (devuelve el valor True)

-eq Es igual a 1 -eq 1
-ne Es distinto de 1 -ne 2
-lt Es menor que 1 -lt 2
-le Es menor o igual que 1 -le 2
-gt Es mayor que 2 -gt 1
-ge Es mayor o igual que 2 -ge 1
-like Es como (comparación de "file.doc" -like "f*.do?"
caracteres comodín para texto)
-notlike No es como (comparación de "file.doc" -notlike "p*.doc"
caracteres comodín para texto)
-contains Contiene 1,2,3 -contains 1
-notcontains No contiene 1,2,3 -notcontains 4
6.6. 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)

PowerShell
7. Funciones
En los scripts de PowerShell se pueden definir funciones para facilitar el armado de
scripts.
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 nú
mero'
$result = Get-Factorial $value # $result = Get-Factorial -value $value
Write-Output "$value! = $result"
El uso de funciones, nos permite crear funcionalidades similares a los cmdlets y por tal
motivo, se brinda la directiva CmdLetBinding, que transforma nuestras funciones en una
especie de CmdLets proporcionando los parámetros comunes como –Verbose –Debug.
De la función anterior obtenemos el siguiente comportamiento:
Pero al aplicar la directiva [CmdLetBinding()] el comportamiento cambia a:
7.1. Pará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.

PowerShell
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,
será́ el primer parámetro sin nombre (Position=1). El segundo parámetro, firstName, no
es obligatorio y al no tener especificada una posición, si no se lo pasa por nombre no
tendrá́ valor.
Código:
Param(
[Parameter(Mandatory=$True, Position=1)] [string]$name,
[Parameter(Mandatory=$False)] $firstName
Write-Output "Hola $name $firstName"
Se ejecuta de la siguiente manera:

# Los dos parámetros se pasan por nombre.
.\script.ps1 -name ‘Nombre’ -firstName ‘Apellido’
# Un parámetro es pasado por nombre y el otro por posición.
.\script.ps1 -firstName ‘Apellido’ ‘Nombre’
# No se puede ejecutar de esta manera, ya que dará error porque no se especificó el

parámetro “name” que era obligatorio.
.\script.ps1 -firstName ‘Apellido’
Salida:
Hola Nombre Apellido
7.2. 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 encargará 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
)

PowerShell
7.3. 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 ejecutará
por única vez al comienzo de la invocación y el bloque End que se ejecutará 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 ejecució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:

PowerShell
8. Uso de la Ayuda
Para obtener ayuda sobre los cmdlet existe el Get-Help, que nos brindará 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 identificará como parte de
la ayuda sino como un comentario del script.
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 má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
#>

PowerShell
function Verb-Noun
{
<# CODE #>
}
Agregando la sección de ayuda a la función Get-Factorial obtenemos el siguiente
resultado:
<#
.Synopsis
Esta funció
n calcula el factorial de un nú
mero de manera recursiva
.Description
Esta funció
n calcula el factorial de un nú
mero de manera recursiva
.Parameter value
Este parámetro indicaráa que número vamos a calcular el factorial
.Example
Get-Factorial -value 5
120
#>
function Get-Factorial()
{
Note que para obtener diferentes grados de información podemos utilizar los
parámetros – Example, –Detailed o –Full, los cuales irán mostrando un mayor detalle de
la ayuda informada en la metadata de la función.
8.1. 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 {
<#Có
digo con posibilidad de error#>
}
catch {
<#Acciones a tomar ante la excepció
n#>
}
finally {
<#Acciones que siempre se ejecutaran#>
}

PowerShell
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 establecer 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 establecer
el argumento con “Stop”.
• ErrorVariable (EV), nos permite crear una variable donde se almacenarán 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 establecida 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"
}
}#fin forech
}
}
Ejemplos de uso:
1- Ejecutar la función con Ids inexistentes:
PS> Detener-Proceso -Id 3324, 3325 -ErrorVariable errorKill -ErrorAction Stop
El resultado será́ el siguiente:

ADVERTENCIA: El proceso 3324 no existe en el sistema

PowerShell
2- Uso del Pipeline:

Verificamos que existan procesos:
PS> get-process -Name notepad*
Handles NPM(K) PM(K)
------- ------ -----
61 3 1212
121 9 10592
WS(K) VM(M) CPU(s)
----- ----- ------
4904 64 0,06
16760 100 0,42
Id ProcessName
-- -----------
5344 notepad
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
3- 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 ejecución porque la variable de preferencia

"ErrorActionPreference" o un parámetro común se han establecido en Stop: No se
encuentra ningún proceso con el identificador 4364.
kill : No se encuentra ningún proceso con el identificador 4364.
En C:\Users\Public\Documents\Manuales\PowerShell\Scripts\pruebas.ps1: 15
Carácter: 17
++
kill -Id $proc

~~~~~~~~~~~~~~
+ CategoryInfo
ProcessCommandException
: ObjectNotFound: (4364:Int32) [Stop-Process],
+ FullyQualifiedErrorId :
NoProcessFoundForGivenId,Microsoft.PowerShell.Commands.StopProcessCommand

PowerShell
9. Cmdlets más usados
A continuación, una lista de los cmdlets más comunes y equivalentes de Linux:

• Archivos:
Los proveedores de PowerShell son programas que nos permiten trabajar con
almacenes de datos como si fueran unidades montadas, por ejemplo, con el sistema de
archivos, registro, certificados…. Utilizan los siguiente cmdlets:
Cmdlet Alias Cmd Commands Descritption
Get-Location gl Pwd Directorio actual
Set-Location sl cd, chdir Cambiar el directorio actual
Copy-Item cpi Copy Copiar archivos
Remove-Item ri Del Elimina un archivo o directorio
Move-Item mi Move Mueve (o cambia el nombre) de un arch. o dir.
Rename-Item rni Rn Cambia el nombre de un archivo
New-Item ni n/a Crea un nuevo archivo o una carpeta vacía
Clear-Item cli n/a Borra el contenido de un archivo
Set-Item si n/a Establece el contenido de un archivo
Mkdir n/a Md Crea un nuevo directorio
Get-Content gc Type Envía el contenido de un archivo a la salida
Set-Content sc n/a Establece el contenido de un archivo
o Obtiene una lista de los proveedores

Get-PSProvider
o Muestra las unidades disponibles para unidades de disco
Get-PSDrive –Provider FileSystem
o Variables de entorno (Proveedor env)
o Accede a las variables de entorno del sistema (propiedades de Mi PC) Ejemplo:
Set-Location Env:
Get-ChildItem
o Obtener una variable:
Get-ChildItem OS
o Crear una variable:
New-Item -Path . –Name Variable1 – Value “Texto de la variable”
o Sistema de Archivos
De forma predeterminada Get-ChildItem permite trabajar con el sistema de
archivos (crear, modificar, eliminar archivos y carpetas). La primera columna del
resultado tiene los siguientes significados:
d = directorio
a = archivo

PowerShell
r = sólo lectura
h = oculto
s = de sistema
Get-ChildItem
Para mostrar los archivos ocultos también
Get-ChildItem –force
o Para crear directorios:
New-Item –Path C:\Nuevo – Type Directory
o Para crear un archivo, si no indicas el tipo te lo pregunta:
New-Item –Path C:\Nuevo\Archivo.txt –Type File
o Para mover archivos o directorios:
Move-Item –Path C:\Nuevo\Archivo.txt C:\
Move-Item –Path C:\Nuevo C:\NuevoDir
o Para renombrar archivos (también con Move)
Rename-Item –Path C:\Archivo.txt C:\NuevoFile.txt
Rename-Item –Path C:\NuevoDir C:\Direc
o Para borrar archivos y directorios
Remove-Item –Path C:\NuevoFile.txt –Confirm
Remove-Item –Path C:\Direc
o Contenido de un archivo
Obtener el contenido:
Get-content C:\Windows\System32\drivers\etc\services
Obtener el contenido línea a línea:
Get-content C:\Windows\System32\drivers\etc\services |
ForEach-Object {write-host $i "" $_; $i++}
o Escribir en un archivo:
Set-Content –Path C:\Archivo.txt –Value “Hola, caracola”
o Añadir a un archivo:
Add-Content –Path C:\Archivo.txt –Value “Adios”
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)

PowerShell
9.1. Ejemplos
Get-ChildItem
El cmdlet Get-ChildItem obtiene elementos y elementos secundarios de una ubicación
determinada. Es similar en concepto a un comando DIR para listar archivos en un
directorio.
Get-ChildItem -Path 'C:\' # List all files in the root directory.
Get-ChildItem -Path 'C:\' -Recurse # List all files on the C drive.
New-Item
El cmdlet New-Item crea un nuevo elemento del tipo dado en la ubicación de ruta
determinada.
New-Item -Path 'C:\' -Name 'PSTest' -ItemType Directory
New-Item -Path 'C:\PSTest' -Name 'Test.txt' -ItemType File -Value 'This is a
test.'
Move-Item
El cmdlet Move-Item mueve un elemento de la ubicación de ruta determinada al destino
especificado.
Move-Item -Path 'C:\PSTest\Test.txt' -Destination 'C:\PSTest\Test2.txt'
Copy-Item
El cmdlet Copy-Item copia un elemento de la ubicación de ruta determinada al destino
especificado.
Copy-Item -Path 'C:\PSTest\Test2.txt' -Destination 'C:\PSTest\Test.txt'
Remove-Item
El cmdlet Remove-Item elimina un elemento de la ubicación de ruta determinada.
Remove-Item -Path 'C:\PSTest\Test.txt'
Remove-Item -Path 'C:\PSTest' -Recurse
Test-Path
El cmdlet Test-Path determina si existe una ruta.
$filename = 'example.txt'
if((Test-Path $filename) -ne $true)
{
Write-Output "$filename not found!"
}
Set-Content
El cmdlet Set-Content es un cmdlet de procesamiento de cadenas que escribe o
reemplaza el contenido en el elemento especificado, como un archivo.
$path = $HOME + '\My PowerShell Content.txt'
$value = @('Colors', 'Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo',
'Violet')
Set-Content -Path $path -Value $value
Add-Content
El cmdlet Add-Content agrega contenido a un elemento o archivo especificado.
Add-Content -Path $path -Value 'Brown'
Add-Content -Path $path -Value 'Black'

PowerShell
Get-Content
El cmdlet Get-Content obtiene el contenido de un elemento determinado.

$content = Get-Content -Path $path
foreach ($line in $content)
{
Write-Output $line
}
Clear-Content
El cmdlet Clear-Content elimina el contenido de un elemento, como eliminar el texto de
un archivo, pero no elimina el elemento.
Clear-Content -Path $path

PowerShell
10. Explorar Windows PowerShell ISE
Puede usar el Entorno de scripting integrado (ISE) de Windows PowerShell® para crear,
ejecutar y depurar scripts y comandos. Windows PowerShell ISE consta de la barra de
menús, las pestañas de Windows PowerShell, la barra de herramientas, las pestañas de
script, un panel de scripts, un panel de consola, una barra de estado, un control
deslizante de tamaño de texto y la ayuda contextual.
Barra de menús
La barra de menús contiene los menús Archivo, Edición, Ver, Herramientas, Depurar,
Complementos y Ayuda. Los botones de los menús permiten realizar tareas
relacionadas con la escritura y ejecución de scripts y la ejecución de comandos en
Windows PowerShell ISE.
Pestañas de Windows PowerShell

Una pestaña de Windows PowerShell es el entorno en el que se ejecuta un script de
Windows PowerShell. Puede abrir nuevas pestañas de Windows PowerShell en
Windows PowerShell ISE para crear entornos independientes en el equipo local o en
equipos remotos. Puede tener un máximo de ocho pestañas de PowerShell abiertas de
forma simultánea.
Barra de herramientas
Los botones siguientes están ubicados en la barra de herramientas.
Botón Función
Nuevo Abre un nuevo script.
Abrir Abre un script o un archivo existente.
Guardar Guarda un script o un archivo.
Cortar Corta el texto seleccionado y lo copia en el Portapapeles.
Copiar Copia el texto seleccionado en el portapapeles.
Pegar Pega el contenido del Portapapeles en la ubicación del
cursor.
Borrar panel de Borra todo el contenido del panel de salida.
salida
Deshacer Invierte la acción que se acaba de realizar.
Rehacer Realiza la acción que se acaba de deshacer.
Ejecutar script Ejecuta un script.
Ejecutar selección Ejecuta una parte seleccionada de un script.
Detener la ejecución Detiene un script que se está ejecutando.
Nueva pestaña de Crea una nueva pestaña de PowerShell que establece una
PowerShell en sesión en un equipo remoto. Aparece un cuadro de diálogo
remoto que le pide que escriba los detalles necesarios para
establecer la conexión remota.
Iniciar Abre una consola de PowerShell.
PowerShell.exe

PowerShell
Mostrar panel de Mueve el panel de scripts a la parte superior de la pantalla.

scripts arriba
Mover panel de Mueve el panel de scripts a la derecha de la pantalla.
scripts a la derecha
Mostrar panel de Maximiza el panel de scripts.
scripts maximizado
Pestaña Script
Muestra el nombre del script que se está editando. Puede hacer clic en una pestaña de
script para seleccionar el script que desea editar.
Cuando apunte a la pestaña de script, la ruta de acceso completa al archivo de script se
mostrará en una información sobre herramientas.
Panel de scripts
Permite crear y ejecutar scripts. Puede abrir, editar y ejecutar scripts existentes en el
panel de scripts.
Panel de salida
Muestra los resultados de los comandos y scripts que ha ejecutado. También puede
copiar y borrar el contenido en el panel de salida.
Panel de comandos
Permite escribir comandos. Puede ejecutar un comando de una línea o un comando de
varias líneas en el panel de comandos. Presione MAYÚS+ENTRAR para introducir cada
línea de un comando de varias líneas y presione ENTRAR después de la última línea para
ejecutarlo. El mensaje que aparece en la parte superior del panel de comandos muestra
la ruta de acceso al directorio de trabajo actual.
Barra de estado
Permite ver si los comandos y scripts que ejecuta se han completado. La barra de estado
se encuentra en la parte inferior de la pantalla. Las partes seleccionadas de los mensajes
de error se muestran en la barra de estado.
Control deslizante Tamaño del texto

Aumenta o disminuye el tamaño del texto en la pantalla.
Ayuda
La ayuda de Windows PowerShell ISE está disponible en la biblioteca de TechNet en
Internet. Para abrir la Ayuda, haga clic en Ayuda de Windows PowerShell ISE en el menú
Ayuda o presione la tecla F1 en cualquier lugar excepto cuando el cursor esté en el
nombre de un cmdlet en el panel de scripts o en panel de consola. Desde el menú Ayuda
también puede ejecutar el cmdlet Update-Help y mostrar la ventana Comandos, que le
muestra todos los parámetros de un cmdlet para ayudarle a construir comandos, lo que
permite rellenar los parámetros en un formulario fácil de usar.

PowerShell
11. Alias de compatibilidad
Windows PowerShell tiene varios alias de transición que permiten a los usuarios de UNIX
y Cmd usar nombres de comando conocidos en Windows PowerShell. Los alias más
comunes se muestran en la tabla siguiente, junto con el comando de Windows
PowerShell detrás del alias y el alias de Windows PowerShell estándar si existe uno.
Puede encontrar el comando de Windows PowerShell al que cualquier alias señala desde
Windows PowerShell mediante el cmdlet Get-Alias. Por ejemplo, escriba get-alias cls.
Comando de CMD Comando de UNIX Comando de PS Alias de PS

dir Ls Get-ChildItem gci
cls Clear Clear-Host (función) cls
del, erase, rmdir Rm Remove-Item ri
copy Cp Copy-Item ci
move Mv Move-Item mi
rename Mv Rename-Item rni
type Cat Get-Content gc
cd Cd Set-Location sl
md Mkdir New-Item ni
pushd Pushd Push-Location pushd
popd Popd Pop-Location popd
11.1. Usar nombres de comando conocidos

Mediante un mecanismo denominado alias, Windows PowerShell permite a los usuarios
hacer referencia a los comandos con nombres alternativos. El aliasing permite a los
usuarios con experiencia en otros shells reutilizar los nombres de comandos comunes
que ya conocen para realizar operaciones similares en Windows PowerShell. Aunque no
trataremos en detalle los alias de Windows PowerShell, puede usarlos para empezar a
trabajar con Windows PowerShell.
El aliasing asocia un nombre de comando que escribe a otro comando. Por ejemplo,
Windows PowerShell tiene una función interna denominada Clear-Host que borra la
ventana de salida. Si escribe el comando cls o clear en un símbolo del sistema, Windows
PowerShell interpreta que se trata de un alias de la función Clear-Host y ejecuta la
función Clear-Host.

PowerShell
Esta característica ayuda a los usuarios a aprender a usar Windows PowerShell. En

primer lugar, la mayoría de los usuarios de Cmd.exe y UNIX tienen un gran repertorio de
comandos que los usuarios que ya conocen por su nombre y, aunque los equivalentes
de Windows PowerShell podrían no producir resultados idénticos, son lo
suficientemente parecidos para que los usuarios pueden usarlos en su trabajo sin tener
que memorizar primero los nombres de Windows PowerShell. En segundo lugar, la
principal fuente de frustración a la hora de aprender un nuevo shell cuando el usuario
ya está familiarizado con otro, son los errores provocados por la "memoria digital". Si
hace años que usa Cmd.exe y tiene una pantalla repleta de salida que quiere limpiar,
escribiría de manera reflexiva el comando cls y presionaría la tecla ENTRAR. Sin el alias
de la función Clear-Host de Windows PowerShell, obtendría un mensaje de error similar
a "'cls' no se reconoce como cmdlet, función, programa ejecutable o archivo de script"
y se quedaría sin saber qué debe hacer para borrar la salida.
La siguiente es una lista breve de comandos de Cmd.exe y UNIX comunes que puede
usar en Windows PowerShell:
cat Dir monunt Rm

cd Echo move Rmdir
chdir Erase popd Sleep
clear H ps sort
cls History pushd tee
copy Kill pwd tipe
del Lp r write
diff Ls ren
Si usa uno de estos comandos de forma reflexiva y desea obtener el nombre real del
comando nativo de Windows PowerShell, puede usar el comando Get-Alias:
Para que los ejemplos sean más legibles, la Guía de usuario de Windows PowerShell
suele evitar el uso de alias. Sin embargo, saber más sobre los alias con antelación puede
resultarle útil si trabaja con fragmentos de código arbitrarios de código de Windows
PowerShell de otro origen o desea definir sus propios alias. En el resto de esta sección
se tratarán los alias estándar y cómo definir sus propios alias.
11.2. Interpretar los alias estándar

A diferencia de los alias descritos anteriormente, que se diseñaron para ofrecer
compatibilidad con los nombres de otras interfaces, los alias integrados en Windows

PowerShell
PowerShell están diseñados generalmente para ofrecer brevedad. Estos nombres más
cortos pueden escribirse rápidamente, pero son imposibles de leer si no sabe a qué
hacen referencia.
Windows PowerShell intenta compensar la claridad y la brevedad proporcionando un

conjunto de alias estándar que se basan en nombres abreviados para nombres y verbos
comunes. Esto permite un conjunto principal de alias para cmdlets comunes que son
legibles si se conocen los nombres abreviados. Por ejemplo, en los alias estándar, el
verbo Get se abrevia a g, el verbo Set se abrevia a s, el nombre Item se abrevia a i, el
nombre Location se abrevia a l y el nombre Command se abrevia a cm.
Este es un breve ejemplo para ilustrar cómo funciona. El alias estándar de Get-Item
procede de la combinación de g de Get e i de Item: gi. El alias estándar de Set-Item
procede de la combinación de s de Set e i de Item: si. El alias estándar de Get-Location
procede de la combinación de g de Get y l de Location: gl. El alias estándar de Set-
Location procede de la combinación de s de Set y l de Location: sl. El alias estándar de
Get-Command procede de la combinación de g de Get y cm de Command: gcm. No
existe un cmdlet Set-Command, pero si lo hubiera, podríamos adivinar que el alias
estándar proviene de s de Set y cm de Command: scm. Además, las personas que
conozcan los alias de Windows PowerShell que se encuentren scm podrán adivinar que
el alias hace referencia a Set-Command.
11.3. Crear nuevos alias

Puede crear sus propios alias mediante el cmdlet Set-Alias. Por ejemplo, las siguientes
instrucciones crean los alias de cmdlet estándar que se describen en Interpretar los alias
estándar:
Set-Alias -Name gi -Value Get-Item
Set-Alias -Name si -Value Set-Item
Set-Alias -Name gl -Value Get-Location
Set-Alias -Name sl -Value Set-Location
Set-Alias -Name gcm -Value Get-Command
Internamente, Windows PowerShell usa estos comandos durante el inicio, pero estos
alias no se pueden cambiar. Si intenta ejecutar realmente uno de estos comandos,
obtendrá un error que indicará que no se puede modificar el alias. Por ejemplo:
PS> Set-Alias -Name gi -Value Get-Item
Set-Alias : Alias is not writeable because alias gi is read-only or constant and cannot be
written to.
At line:1 char:10
+ Set-Alias <<<< -Name gi -Value Get-Item

Teoría PowerShell 1

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Teoría PowerShell 1

Cargado por

Copyright:

Formatos disponibles

PowerShell

1 Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es)

Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es) 2

"Windows PowerShell es una interfaz de consola (CLI) con posibilidad de escritura y

3 Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es)

Para abrir la consola de PowerShell, ejecutamos PowerShell en el menú de inicio de

Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es) 4

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

3.1. Formato de cmdlet

5 Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es)

Para practicar, vamos a ejecutar los siguientes cmdlets:

Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es) 6

• Get-Service: muestra la lista de servicios con su estado

7 Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es)

• Get-Content: muestra el contenido del archivo que especifique (por ejemplo,

Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es) 8

3.2. Cmdlets disponibles

También puede crear sus propios cmdlets personalizados.

9 Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es)

Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es) 10

Si aún no se encuentra el cmdlet que se necesita, podemos asegurarnos de que la ayuda

Update-Help #to update the help data

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

# En este caso mostrará información acerca de las clases

11 Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es)

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

Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es) 12

La canalización funciona prácticamente en cualquier lugar en Windows PowerShell.

El comando Out-Host -Paging es un elemento de la canalización útil siempre que se tiene

13 Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es)

Ejecute el siguiente comando: Get-ChildItem C:\Windows -Recurse. Compare el uso de

Si Windows PowerShell canaliza texto, al emitir un comando como Get-Location | Out-

El comando Get-Location no devuelve el texto que contenga la ruta de acceso actual.

Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es) 14

PathInfo a la pantalla y Windows PowerShell decide qué información se mostrará y

15 Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es)

5. Windows PowerShell ISE

Windows PowerShell ISE

Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es) 16

Obtendrá uno de los siguientes valores:

• Restricted: no se permiten scripts. Esta es la configuración predeterminada, por

17 Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es)

Para comenzar a trabajar con PowerShell, se deberá cambiar la configuración de la

6.2. Variables y parámetros

Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es) 18

6.3. Uso de comillas

19 Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es)

Operador de comparación Significado Ejemplo (devuelve el valor True)

6.6. Condiciones y ciclos

Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es) 20

Pero al aplicar la directiva [CmdLetBinding()] el comportamiento cambia a:

21 Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es)

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

Write-Output "Hola $name $firstName"

Se ejecuta de la siguiente manera:

# No se puede ejecutar de esta manera, ya que dará error porque no se especificó el

7.2. Opciones de parámetros

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

Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es) 22

7.3. Estructura de las funciones

23 Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es)

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

Francisco Javier Cabrerizo Membrilla (fjavier.cabrerizo@outlook.es) 24

8.1. Manejo de Errores