U.T.5. BLOQUE II – WINDOWS
POWERSHELL
2013/2014 CFGS Desarrollo de Aplicaciones Multiplataforma
Eugenia Pérez Martínez · ITC Cuatrovientos
http://eugeniaperez.es
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 1
TABLA DE CONTENIDO
TABLA DE CONTENIDO ........................................................................... 1
1 U.T. 5-B. WINDOWS POWERSHELL ...................................................... 4
1.1 INTRODUCCIÓN ............................................................................... 4
1.2 ESCOGIENDO EL ENTORNO ............................................................... 4
1.2.1 La consola interactiva .................................................................. 5
1.2.2 ISE (Integrated Scripting Environment) ......................................... 6
1.2.3 Otros editores ............................................................................. 8
1.3 LA AYUDA ........................................................................................ 8
1.3.1 Usando la ayuda para obtener comandos ................................... 10
1.4 COMANDOS Y CMDLETS ................................................................. 12
1.4.1 Autocompletado ........................................................................ 13
1.5 CATEGORÍAS DE COMANDOS .......................................................... 14
1.6 CONVENCIONES DEL LENGUAJE ...................................................... 15
1.7 ENTRADA/SALIDA .......................................................................... 15
1.7.1 Salida básica .............................................................................. 15
1.7.2 Entrada básica ........................................................................... 16
1.7.3 Uso de comentarios ................................................................... 16
1.8 EJECUCIÓN DE SCRIPTS ................................................................... 16
1.9 SINTAXIS DEL LENGUAJE ................................................................. 17
1.9.1 Tipos básicos ............................................................................ 17
1.9.2 Casting ...................................................................................... 18
1.9.3 Variables ................................................................................... 19
1.9.4 Arrays ....................................................................................... 20
1.9.5 Hashtables ................................................................................ 22
1.9.6 XML ........................................................................................... 23
1.10 OPERADORES Y EXPRESIONES ........................................................ 25
1.10.1 Operador de concatenación ..................................................... 25
1.10.2 Operadores aritméticos ............................................................ 26
1.10.3 Operadores de asignación ........................................................ 26
1.10.4 Operadores de comparación .................................................... 26
1.10.5 Operadores lógicos .................................................................. 27
1.11 ARGUMENTOS POR LÍNEA DE COMANDOS ..................................... 27
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 2
1.12 ESTRUCTURAS DE CONTROL ......................................................... 28
1.12.1 La estructura condicional ......................................................... 28
1.12.2 Estructura de Switch ................................................................ 29
1.12.3 La estructura While y do-While ................................................. 32
1.12.4 El bucle for .............................................................................. 33
1.12.5 El bucle foreach ....................................................................... 34
1.12.6 Sentencias de control de bucle: break y continue ..................... 36
1.13 EXPRESIONES REGULARES .............................................................. 37
1.14 FICHEROS ..................................................................................... 41
1.14.1 Leyendo y escribiendo ficheros ................................................ 41
1.14.2 Procesando texto no estructurado ............................................ 43
1.14.3 Realizando búsquedas ............................................................. 44
1.14.4 Ejemplo de procesamiento de un fichero CSV ........................... 45
1.14.5 Exportando e importando ficheros CSV .................................... 46
1.14.6 Convirtiendo a HTML ............................................................... 47
1.15 FUNCIONES ................................................................................... 47
1.16 MÓDULOS..................................................................................... 51
2 EJERCICIOS: SINTAXIS DEL LENGUAJE ............................................... 55
2.1 EJERCICIO 1 .................................................................................... 55
2.2 EJERCICIO 2 .................................................................................... 55
2.3 EJERCICIO 3 .................................................................................... 55
2.4 EJERCICIO 4 .................................................................................... 55
2.5 EJERCICIO 5 .................................................................................... 55
2.6 EJERCICIO 6 .................................................................................... 56
2.7 EJERCICIO 7 .................................................................................... 56
2.8 EJERCICIO 8 .................................................................................... 56
2.9 EJERCICIO 9 .................................................................................... 56
2.10 EJERCICIO 10 ................................................................................ 56
2.11 EJERCICIO 11 ................................................................................ 57
2.12 EJERCICIO 12 ................................................................................ 57
2.13 EJERCICIO 13 ................................................................................ 57
2.14 EJERCICIO 14 ................................................................................ 58
2.15 EJERCICIO 15 ................................................................................ 58
2.16 EJERCICIO 16 ................................................................................ 58
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 3
2.17 EJERCICIO 17 ................................................................................ 59
2.18 EJERCICIO 18 ................................................................................ 59
2.19 EJERCICIO 19 ................................................................................ 59
2.20 EJERCICIO 20 ................................................................................ 60
2.21 EJERCICIO 21 ................................................................................ 61
2.22 EJERCICIO 22 ................................................................................ 61
2.23 EJERCICIO 23 ................................................................................ 61
3 UTILIZAR POWERSHELL PARA TAREAS DE ADMINISTRACIÓN .............. 62
4 BIBLIOGRAFÍA Y REFERENCIAS ......................................................... 63
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 4
1 U.T. 5-B. WINDOWS POWERSHELL
1.1 INTRODUCCIÓN
Windows PowerShell es un shell de línea de comandos y un lenguaje de
scripting basado en tareas especialmente diseñado para la administración del
sistema. Basado en .NET Framework, Windows PowerShell ayuda a los
profesionales de TI y a los usuarios avanzados a controlar y automatizar la
administración del sistema operativo Windows y las aplicaciones que se
ejecutan en Windows.
Características y justificación de su estudio:
Utiliza Cmdlets para realizar tareas comunes de administración del sistema,
como administrar el Registro, servicios, procesos y registros de eventos, y
usar Instrumental de administración de Windows.
Es un lenguaje de scripting que posee una interfaz interactiva mucho más
rica que su predecesora para MSDOS. Disponiendo incluso de una
herramienta que ofrece todas las características representativas (incluida
depuración paso a paso) de los Entornos de desarrollo (o scripting)
integrados.
Es un lenguaje muy potente, con muchas características expandidas y
heredadas de la interfaz de .NET, en cuanto a sintaxis del lenguaje, así
como basado en un modelo orientado a objetos, pudiendo explotar las
características de este paradigma.
Interfaz extensible. Los proveedores de software independientes y los
programadores empresariales pueden crear herramientas y utilidades
personalizadas para administrar su software.
Ofrece todas las comodidades que tiene cualquier shell de unix: historial de
comandos con las flechas, un fuerte soporte al autocompletado de rutas y
comandos, e incluso la posibilidad de crear alias. En PowerShell por fin
podrás no equivocarte al escribir ls ya que los comandos más míticos de
Unix tienen su alias ya metido (Get-Alias).
A estas alturas, para determinadas tareas administrativas de Windows 2012
es mucho más rápido usar la consola que andar moviendo el ratón entre
asistentes.
1.2 ESCOGIENDO EL ENTORNO
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 5
Dependiendo de la versión de tu sistema operativo puedes acceder a
PowerShell de varias maneras. Si estás utilizando Windows 7, Windows Server
2008 R2 o bien versiones posteriores, no deberás hacer nada, ya lo incluyen
como parte del sistema. Para versiones anteriores, tendrás que descargar e
instalar el paquete en tu ordenador: http://microsoft.como/powershell
PowerShell se compone de dos partes principales:
El motor de PowerShell, que es el intérprete de comandos.
Una aplicación host que se encarga de pasar los comandos del
usuario al motor anterior. La versión de PowerShell 2 ya incluye un
entorno de desarrollo integrado más moderno, parecido a los que
podrías utilizar normalmente en otros lenguajes de programación:
PowerShell ISE.
1.2.1 La consola interactiva
Para lanzar la consola interactiva de PowerShell dirígete a Inicio -> Todos
los programas -> Accesorios -> Windows PowerShell.
O bien, en Inicio -> Ejecutar, teclea directamente Windows PowerShell.
Recuerda que en Windows 8 debes mantener la tecla Inicio más la R
presionadas para obtener el cuadro de diálogo de Ejecutar.
Si ahora tecleas el comando $PSVersionTable, comprobarás la versión que
estás utilizando.
Algunos contras de utilizarla:
Muchos idiomas no ingleses no se muestran correctamente.
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 6
Te ofrece escasa asistencia cuando tecleas en la misma.
Algunos pros:
Como la consola es pequeña, no consume tanta memoria y carga
relativamente rápido.
No requiere muchos de los componentes del framework de .NET
(WPF, Windows Presentation Foundation) que son necesarios en el
ISE.
Sencillamente, la balanza se decanta hacia el lado del ISE (o entorno de
desarrollo integrado) que será el que nosotros utilicemos. No obstante, debes
saber que al igual que ocurre con el símbolo del sistema en MSDOS, éste
también permite varias algunas opciones de configuración, pulsando en la
esquina superior izquierda.
Puedes probar a ejecutar algún comando conocido, del estilo dir, el
resultado te resultará familiar:
1.2.2 ISE (Integrated Scripting Environment)
De la mima forma que has obtenido la consola anteriormente, puedes
llegar al ISE o Entorno de desarrollo de scripts integrado.
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 7
Otra opción es que desde la consola teclees ISE, así obtendrás el editor
oficial de cmdlets.
Puedes observar como, por defecto, la ventana se divide en tres partes
principalmente:
El área de ejecución de comandos, abajo del todo.
La ventana de salida, en el centro.
Un editor, en la parte superior.
Ejecución de comandos: vamos a realizar la prueba de introducir el
comando dir en el panel inferior.
Nota: como no deja de ser una aplicación típica de un entorno en
Windows, sigue todas sus convenciones. No obstante, ten en cuenta que el
shortcut aplicado para copiar texto (Ctrl-C) aquí pasa a tener el significado de
detención del comando. Parece evidente que esta operación también pueda
realizarse desde el botón rojo en la barra de herramientas.
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 8
Panel de edición: aunque si bien es verdad que podrías utilizar cualquier
editor en texto plano conocido (del tipo del Notepad++) este entorno añade
características especiales a los anteriores.
Como todo entorno integrado, te colorea la sintaxis, puedes disponer de
varios ficheros simultáneamente, te permite seleccionar una región de código
y ejecutarla, presionando el botón del play o bien F8, te permite la depuración
de código, dispone de IntelliSense, etc. Si no has seleccionado ninguna porción
en la pantalla, entonces se ejecutará todo el código del script.
Para evitarnos problemas futuros, dado que no siempre es posible
corregirlos en un entorno de producción, nos aseguraremos que el ISE lo
ejecutamos como Administrador.
1.2.3 Otros editores
Puedes encontrar otros editores libres y comerciales específicamente
diseñados para PowerShell, como:
PowerGUI: puedes encontrar una versión libre http://powergui.org y
otra con licencia: http://quest.com/powershell
SAPIEN PrimalScript and PrimalForms: http://primaltools.com
PowerSE and PowerWF: http://powerwf.com
Idera PowerShell Plus: http://idera.com
1.3 LA AYUDA
Desde luego que no podrás encontrar cada detalle en la ayuda que te
proporciona PowerShell, pero un manejo exhaustivo de la misma te acercará a
dominar el sistema.
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 9
Lo primero que debes hacer es actualizarla, para ello PowerShell sale a
internet, permitiendo actualizarla, corregirla o extenderla. Por lo tanto, es
recomendable que actualices la ayuda con cierta perioricidad, por ejemplo, de
forma mensual.
PS C:\> update-help
El comando Get-help o help (que es un wrapper del cmdlet Get-help) a
secas nos permite obtener la ayuda de cualquier comando:
PS C:\Windows\system32> help Get-Service
NOMBRE
Get-Service
SINOPSIS
Obtiene los servicios en el equipo local o en un equipo remoto.
SINTAXIS
Get-Service [[-Name] <string[]>] [-ComputerName <string[]>] [-
DependentServices] [-Exclude <string[]>] [-Include <string[]>] [-
RequiredServices] [<CommonParameters>]
…
DESCRIPCIÓN
El cmdlet Get-Service obtiene objetos que representan los servicios en un
equipo local o en un equipo remoto, incluidos los servicios en ejecución y los
detenidos.
Puede dirigir Get-Service para que se obtengan solamente servicios
concretos especificando el nombre de servicio o el nombre para mostrar de los
servicios, o puede canalizar objetos de servicio a Get-Service.
VÍNCULOS RELACIONADOS
Online version: http://go.microsoft.com/fwlink/?LinkID=113332
Start-Service
Stop-Service
Restart-Service
Resume-Service
Suspend-Service
Set-Service
New-Service
NOTAS
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 10
Para ver los ejemplos, escriba: "get-help Get-Service -examples".
Para obtener más información, escriba: "get-help Get-Service -detailed".
Para obtener información técnica, escriba: "get-help Get-Service -full".
Por lo general en este tipo de notaciones, los parámetros entre corchetes
son opcionales y si algún nombre de parámetro aparece entre corchetes extra
significa que es posicional, es decir no necesitamos indicar el nombre de
parámetro y basta con indicar el valor.
Tal y como te indican en el ejemplo anterior:
se puede utilizar el flag -full para mostrar más información
técnica.
Podemos usar el flag -example para que nos muestre ejemplos de
uso de ese comando,
y -online para obtener ayuda.
Prueba a utilizar los tres flags sobre el comando dir:
PS C:\> help dir –full
PS C:\> help dir –example
PS C:\> help dir -online
1.3.1 Usando la ayuda para obtener comandos
Uno de los parámetros más útiles de Get-Help es –Name, nos ofrece ayuda
sobre comandos que no conocemos pero cuyo nombre puede ser evidente.
Imagínate que quisieras disponer de un listado de comandos que te
permitan conocer eventos registrados en logs. Podrías hacer algo así,
mediante el uso de wildcards:
Help *log*
Como resultado:
PS C:\Windows\system32> help *log*
Name Category Synopsis
---- -------- --------
Get-EventLog Cmdlet Obtiene los eventos de un registro
de eventos, o una lista de los...
Clear-EventLog Cmdlet Elimina todas las entradas de los
registros de eventos especifica...
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 11
Write-EventLog Cmdlet Escribe un evento en un registro
de eventos.
…
También podrías probar a escribir la parte conocida del comando y dar al
tabulador.
Adicionalmente podrías utilizar los wildcard con Gcm (que es una alias o
shortcut de Get –Command). Por ejemplo:
Gcm *event*
PowerShell contiene diferentes comandos ejecutables,
algunos son llamados cmdlets, otros funciones, otros son
conocidos como workflows, etc. Colectivamente son todos
comandos, y el sistema de ayuda trabaja con ellos. Un cmdlet es
algo único para PowerShell, siendo muchos de los comandos que
utilices considerados cmdlets.
Es posible obtener una ayuda más visual, para comprender la sintaxis de
un comando, es la utilidad de PowerShell v3 llamada Show-Command:
PS C:\> Show-Command dir
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 12
1.4 COMANDOS Y CMDLETS
Los comandos y su interpretación, son una parte fundamental en
PowerShell. Un comando podría tener la siguiente estructura:
El primer elemento es el nombre del comando a ejecutar.
A continuación se pueden especificar 0 o varios parámetros y
argumentos. Cada parámetro empieza con un guión y el argumento es el valor
que será asociado a dicho parámetro.
Por ejemplo, vamos a analizar el comando de salida Write-Output.
Recuerda que puedes consultar la ayuda:
get-help Write-Output
Y ejemplos:
get-help Write-Output –examples
PS C:\Users\PORTATIL> Write-Output -InputObject Hello
Hello
En este ejemplo, el comando Write-Output admite el parámetro –
InputObject con el argumento de valor Hello.
El concepto de argumento posicional implica que gracias al binder de
parámetros de PowerShell, éstos, en algunos casos, no necesariamente tienen
que ser indicados. En este caso se podría escribir:
PS (2) > Write-Output Hello
Hello
También permitirá entradas que especificaran de forma única lo que
quieres expresar. Por ejemplo:
PS (3) > Write-Output -input Hello
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 13
Hello
PS (4) > Write-Output -IN Hello
Hello
PS (5) > Write-Output -i Hello
Hello
Cabe destacar que los nombres de los cmdlets se componen siempre de
Verbo-Nombre, como por ejemplo Get-Content, Get-Service, etc.
1.4.1 Autocompletado
Una de las características de PowerShell es el autocompletado, mediante
la tecla Tab. Por ejemplo, si tecleamos:
PS (1) > cd c:\pro*files<tab>
El comando se expanderá a:
PS (2) > cd 'C:\Program Files'
Como se ha comentado anteriormente también se hace autocompletado
de cmdlets parciales. Adicionalmente, y en contraposición a cmd.exe, éste
permite autocompletado de parámetros, así como de variables parciales y sus
propiedades. Por ejemplo, definiendo una variable:
PS (1) > $a="abcde"
PS (2) > $a.len<tab>
PS (3) > $a.sub<tab>
Lo cual produce:
PS C:\Users\PORTATIL> $a="abcde"
______________________________________________________________________________
PS C:\Users\PORTATIL> $a.Length
5
______________________________________________________________________________
PS C:\Users\PORTATIL> $a.Substring(
PowerShell recuerda cada comando, es decir, tiene un histórico que
podrás obtener de la misma manera que en cmd. Éste se corresponde con el
comando Get-History.
PS C:\Users\PORTATIL> Get-History
Id CommandLine
-- -----------
1 $a="abcde"
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 14
2 $a.Length
Sin embargo, una característica importante ha sido añadida para
expandirlo. Si tecleas el carácter #, seguido del patrón del comando que
deseas obtener también funcionará. Por ejemplo:
PS (4) > #abc<tab>
Será capaz de encontrar:
PS (4) > $a="abcde"
Si lo utilizo seguido del número, también será capaz de recordar el
número del comando:
PS (5) > #2<tab>
1.5 CATEGORÍAS DE COMANDOS
En PowerShell existen 4 categorías de comandos:
Cmdlets
Es la categoría de comando más eficiente para ser ejecutado. Es un
término especificado en el entorno de PowerShell, implementado por
una clase derivada de la Cmdlet class de .NET, incluida en la SDK; y que
se compila en una DLL.
Son expresados en la forma comentada anteriormente, Verbo-
Nombre.
Funciones
Es un fragmento de sentencias de código agrupadas bajo un
nombre, que reside en memoria mientras el intérprete esté
ejecutándose y desaparece cuando se cierra.
Scripts
Son fragmentos de código escritos en texto plano y con extensión
.ps1, que podrán ser guardados, cargados y ejecutados en el ISE.
Comandos nativos
Son programas externos que pueden ser ejecutados por el sistema
operativo. Implican la creación de un nuevo proceso para el
comando, por lo tanto, son más lentos.
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 15
PS (2) > notepad foo.txt
1.6 CONVENCIONES DEL LENGUAJE
Siempre que se comienza con el aprendizaje de un lenguaje de
programación, resulta conveniente seguir las convenciones y estilos de
nombrado del fabricante. En este caso podremos consultar los siguientes
enlaces:
MSDN:
http://msdn.microsoft.com/enus/library/windows/desktop/ms714657(v=v
s.85).aspx
PowerShell best practices:
http://windowsitpro.com/blog/my12powershellbestpractices
1.7 ENTRADA/SALIDA
Vamos a ejecutar el primer programa de ejemplo:
# :: example1.ps1 ::
# Eugenia Pérez Martínez - [email protected]
Write-Output "Hello 1DAM"
1.7.1 Salida básica
Para realizar una impresión por pantalla se utiliza el comando Write-
Output, que necesita de un argumento (como recordarás era posible omitir el
parámetro –InputObject.
Segundo ejemplo:
<#:: example2.ps1 ::
Eugenia Pérez Martínez – [email protected]
Basic I/O, simple example of reading from console.
When you read from console the type of data is string
so you need to cast to int if you need to make any 15arithmetic op.
#>
$name = Read-Host “Write your name”
Write-Output “Hi $name!”
# Now we try to read two numbers
$op1 = Read-Host “Write the first number: “
$op2 = Read-Host “Write the second number: “
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 16
# Before adding them, we have to cast them to int
$result = ([int]$op1 + [int]$op2)
Write-Output “The result of adding is: $result”
# Adding the secure string mode
$pwd_secure_string = Read-Host "Enter a Password:" -assecurestring
Write-Output "Your password is: $pwd_secure_string"
1.7.2 Entrada básica
El comando utilizado para leer información desde la consola es el Read-
Host. Todo lo que se lee se guarda en una variable, que implícitamente será de
tipo string. Este cmdlet se puede usar para solicitar al usuario que proporcione
datos. Dado que la entrada se puede guardar como una cadena segura, puede
usarse para solicitar a los usuarios que proporcionen datos seguros, como
contraseñas, así como datos compartidos. De esta forma, deberemos añadirle
el parámetro –assecurestring, ocultando la entrada de datos en el cuadro de
diálogo. La salida se almacenará en un objeto SecureString.
1.7.3 Uso de comentarios
Como puedes observar los comentarios de una línea van precedidos del
símbolo #. También podrías realizar comentarios multilínea de la siguiente
forma:
<# :: Example1 ::
Eugenia Pérez Martínez - [email protected]
Este es un comentario
que ocupa varias
líneas #>
Write-Output "Hello 1DAM"
1.8 EJECUCIÓN DE SCRIPTS
Como ya habrás comprobado, un script en PowerShell tiene como
extensión .ps1. Tras haberlo guardado, tendremos varias posibilidades de
ejecución:
1. Al estilo bash, poniendo punto barra delante
PS C:\Cuatrovientos\DAM\SI\U.T.5\powershell\examples> .\example1.ps1
2. Poniendo la ruta completa
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 17
PS C:\> C:\Cuatrovientos\DAM\SI\U.T.5\powershell\examples\example1.ps1
3. Poniendo la ruta completa y sin extensión
PS C:\> C:\Cuatrovientos\DAM\SI\U.T.5\powershell\examples\example1
4. Usando el cmdlet Invoke-Expression (con comillas si existen espacios
en blanco)
C:\> Invoke-Expression "C:\Cuatrovientos\DAM\SI\U.T.
5\powershell\examples\example 1.ps1"
Utilizando el ISE o el entorno de desarrollo de scripts integrado, mediante
el triángulo verde de la barra de menú, o bien F5.
Nota: Cómo habilitar la ejecución de scripts para PowerShell
Al utilizar la herramienta Powershell nos puede llegar a dar un error de
seguridad indicando:
“en el sistema está deshabilitada la ejecución de scripts”
Para solucionar esto debemos ejecutar la consola Powershell en modo
administrador y comprobar el estado de la directiva ExecutionPolicy y
cambiarla en caso de ser necesario.
Para ello ejecutaremos los siguientes comandos:
Get-ExecutionPolicy
Restricted
En el caso de que el valor sea Restricted deberemos cambiar el estado de
ExecutionPolicy a Unrestricted:
Set-ExecutionPolicy Unrestricted
Consultamos de nuevo el estado de ExecutionPolicy y debería haber
cambiado a Unrestricted, de forma que ya podríamos ejecutar comandos en
Powershell sin problemas.
1.9 SINTAXIS DEL LENGUAJE
1.9.1 Tipos básicos
Nombre tipo corto Nombre largo .NET Descripción
[int] System.Int32 Entero con signo 32 bits
[long] System.Int64 Entero con signo 64 bits
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 18
[string] System.String Cadena unicode
[char] System.Char Un carácter unicode de 16
bits
[byte] System.Byte Un carácter de 8 bits sin signo
[bool] System.Boolean Booleano, True/False
[decimal] System.Decimal Número con decimales de
128bits
[single] System.Single Número de coma flotante de
32bits
[double] System.Double Número de coma flotante de
64bits
[xml] System.Xml.XmlDocument Objeto Xml
[array] System.Array Un array de valores
[hashtable] System.Collections.Hashtable Un Hashtable
Para obtener el tipo de una variable basta con teclear:
$name.GetType()
Y obtendremos las siguientes características:
IsPublic IsSerial Name BaseType
-------- -------- ---- --------
True True String System.Object
Como todo objeto de .NET heredan del tipo base Object.
Si queremos obtener el nombre completo:
PS C:\> $name.GetType().FullName
System.String
1.9.2 Casting
Para realizar el casting, bastará con indicar el valor el tipo al que se desea
convertir, y si es posible, se realizará la conversión. Ejemplo de error:
PS C:\> $test = [int]$name
No se puede convertir el valor "Eugenia" al tipo "System.Int32". Error: "La
cadena de entrada no tiene el formato correcto."
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 19
Cuando existe conversión de tipos, en contraposición a otros lenguajes,
PowerShell redondea, en lugar de truncar:
PS > (3/2)
1.5
PS > [int] (3/2)
2
1.9.3 Variables
Aunque existe casos en los que, opcionalmente, se podría especificar el
tipo de las variables, PowerShell es un lenguaje débilmente tipado, por lo que
no es necesario especificar el tipo de la variable en su declaración, aunque sí
que implícitamente se utilizan los tipos de variables y objetos, heredados de
.NET.
Definiremos variables de la siguiente manera:
$simpleVariable ="Value"
También se admite asignación múltiple (separando los valores por
comas):
$variable1, $variable2 = "Value1",“Value2”
Adicionalmente se puede declarar una variable mediante el cmdlet:
PS C:\> New-Variable variable "Eugenia"
PS C:\> Get-Variable variable
Name Value
---- -----
variable Eugenia
Ejemplo3:
<#:: example3.ps1 ::
Eugenia Pérez Martínez - [email protected]
Shows the use of the definition of basic types in PowerShell
#>
#strings
$string1 = "This is a string in double quotes"
Write-Output "$string1 - The type of this
variable:"$string1.getType().FullName
$string2 = 'This is a string in single quotes'
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 20
Write-Output "$string2 - The type of this
variable:"$string2.getType().FullName
# Numbers
$num1 = 3
Write-Output "$num1 - The type of this variable:"$num1.getType().FullName
$num2 = 4d
Write-Output "$num2 - The type of this variable:"$num2.getType().FullName
$num3 = 4.2
Write-Output "$num3 - The type of this variable:"$num3.getType().FullName
$num4 = 4.2d
Write-Output "$num4 - The type of this variable:"$num4.getType().FullName
#Expression
Write-Output "The result of adding:" $($num1 + $num2 + $num3 + $num4)
# A very long string
$LongMessage = @"
PowerShell is a shell
that both grows with you
and grows on you.
"@
Write-Output "$LongMessage - The type of this
variable:"$LongMessage.getType().FullName
#Date
$date = $(Get-Date)
Write-Output "$date - The type of this variable:"$date.getType().FullName
1.9.4 Arrays
PowerShell soporta las estructuras de arrays de una forma sencilla. La
sintaxis del array @( ) indica a PowerShell que todo lo que vaya contenido entre
() es un array.
Un array en lugar de ser una variable que contiene un único valor puede
contener varios indexados numéricamente (0,1,2,..). Es una estructura simple
pero muy útil que con un único nombre guarda más de un dato. Para acceder a
cada dato nos basta con conocer su índice.
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 21
Hay varias formas de definir, no es rígido con los tipos pero sí un poco
con los índices. No puedes crear un elemento donde quieras aunque sí los
puedes añadir posteriormente.
Los elementos de un array no necesitan ser todos del mismo tipo, a no
ser que lo declares de esa forma.
Vamos a ver de forma práctica ejemplos de uso:
<#
:: example4.ps1 ::
Eugenia Pérez Martínez - [email protected]
Shows the use of the arrays
#>
# To create an empty array
$emptyArray = @()
Write-Output "Array length is: " $emptyArray.Length
#To define a nonempty array, use a comma to separate its elements:
$myNumbers = 1, 2, 3, 4, 5
#Elements of an array do not need to be all of the same data type
$mySimpleArray = 1,"Two",3.14
Write-Output "Array length is: " $myNumbers.Length
Write-Output "Array length is: " $mySimpleArray.Length
#To access or show any number inside the array
Write-Output $myNumbers[0]
Write-Output "All the array: $myNumbers"
#To access to the second element
$second = $myNumbers[1]
Write-Output "Second element: $second"
#To access to the last element of the array
$last = $myNumbers[-1]
Write-Output "Last element: $last"
#To access to the second to last element of the array
$second_to_last = $myNumbers[-2]
Write-Output "The second to last element: $second_to_last"
#To access ranges of elements in your array
Write-Output "The ranges of elements: "$myNumbers[0..2]
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 22
#It's the same that writing to be shown in the same line:
Write-Output "The ranges of elements: $($myNumbers[0..2])"
#More examples to access ranges of elements in your array
Write-Output "The ranges of elements [-1..2]: "$myNumbers[-1..2]
Write-Output "The ranges of elements [-1..-3]: "$myNumbers[-1..-3]
#You can also slice the array
Write-Output "Slicing the array [0,2,4]: "$myNumbers[0,2,4]
#To modify any value inside it
$myNumbers[2] = 1024
#Arrays may optionally be only a single element long:
$myList = ,"Hello"
#Or, alternatively (using the array cast syntax):
$myList = @("Hello")
$programLanguages = @("Ruby", "PHP","C#","VB .NET","Java")
$programLanguages = $programLanguages + "Python"
Write-Output "My favourite programming languages: " $programLanguages
# Now we can create an array with only one item
$emptyArray = ,4
# to add elements to the array:
$emptyArray = $emptyArray + 50
Write-Output "The array now: $emptyArray"
#You can also declare it as a strongly typed array
[int[]] $myArray = 1,2,3.14
<# So generates an error if it cannot convert
any of the elements in your list to the required data type.
#>
Write-Output "It rounds 3.14 to the integer value of 3: $myArray[2]"
1.9.5 Hashtables
Un hashtable (también conocidos como arrays relacionales) permite crear
arrays pero almacenan una serie de claves, y cada una de estas claves tendrá
un valor asignado. Es decir, es como un array en el que el índice no es
numérico, puede ser una cadena. De esa manera el índice se convierte en una
clave de ese valor.
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 23
Veamos un simple ejemplo en el que se definen, se muestran y se
cambian valores de un par de hashtables:
<# example5.ps1
# Shows the use of hashtables in PowerShell scripts
# Eugenia Pérez Martínez - [email protected]
#>
#Defines an empty hashtable
$user = @Name='1DAM'; Login='1dam_4vientos'
$computer = @OS='Windows'; version='2012 R2 Server'; price=666.66
#To access a hashtable
Write-Output "Username is " $user["Name"]
# Using another notation:
Write-Output "Login is " $user.Login
# We can change values
$computer["OS"] = "Linux Mint"
$computer.version = "LMDE GNOME"
# or even add new keys
$computer.ram = 2048
$computer.price = $computer.price - 170
Write-Output $computer
1.9.6 XML
XML, siglas en inglés de eXtensible Markup Language ('lenguaje de
marcas extensible'), es un lenguaje de marcas desarrollado por el W3C,
utilizado para almacenar y estructurar datos en forma legible. XML da soporte
a bases de datos, siendo útil cuando varias aplicaciones se deben comunicar
entre sí o integrar información.
XML no ha nacido sólo para su aplicación para Internet, sino que se
propone como un estándar para el intercambio de información estructurada
entre diferentes plataformas.
Para crear una variable en XML hay que hacer un casting del string al tipo
[xml], de la siguiente manera:
<# example6.ps1
# Shows the use of XML in PowerShell scripts
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 24
# Eugenia Pérez Martínez - [email protected]
#>
$myXml = [xml] @"
<AddressBook>
<Person contactType="Personal">
<Name>Mikel</Name>
<Phone type="home">948-45-67-89</Phone>
<Phone type="work">676-38-20-75</Phone>
</Person>
<Person contactType="Business">
<Name>Javier</Name>
<Phone>696-48-20-95</Phone>
</Person>
</AddressBook>
"@
<#PowerShell exposes all child nodes and attributes as properties.
When it does this, PowerShell automatically groups children
that share the same node type:
#>
Write-Output $myXml.AddressBook
#Returns the contact type of each person node exposes
Write-Output $myXml.AddressBook.Person[0].ContactType
Write-Output $myXml.AddressBook.Person[1].ContactType
#Returns the name of each person node exposes
Write-Output $myXml.AddressBook.Person[0].Name
Write-Output $myXml.AddressBook.Person[1].Name
PowerShell trata todos los nodos hijos y atributos como propiedades, de
tal forma que automáticamente agrupa todos sus hijos en un mismo tipo:
$myXml.AddressBook
Que a su vez retorna un objeto que contiene la lista de nodos de Persona:
$myXml.AddressBook.Person
Cada Persona contiene:
contactType, Name, y Phone como propiedades.
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 25
A continuación se muestra cómo obtener la primera de las personas:
$myXml.AddressBook.Person[0]
Y el tipo de contacto de la misma:
$myXml.AddressBook.Person[0].ContactType
1.10 OPERADORES Y EXPRESIONES
Se van a detallar los siguientes operadores principalmente;
1.10.1 Operador de concatenación
El + se utiliza para concatenar cadenas de caracteres.
PS C:\> $concat = "This is a string" + " splitted into different" + "
snippets" + " bla bla bla"
PS C:\> Write-Output $concat
Algo curioso que realiza PowerShell es que dependiendo del tipo de
parámetro que encuentre a la izquierda, intentará realizar una operación u
otra.
Si el parámetro que encuentra a la izquierda es un valor numérico,
entonces intentará convertir el valor del lado derecho a un número también (si
es que no lo es):
PS (1) > 2 + "123"
125
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 26
Así, consecuentemente, si lo que encuentra a la izquierda es un string,
hace una concatenación (interpretando que el valor de la derecha también lo
es):
PS (2) > "2" + 123
2123
1.10.2 Operadores aritméticos
1.10.3 Operadores de asignación
1.10.4 Operadores de comparación
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 27
1.10.5 Operadores lógicos
1.11 ARGUMENTOS POR LÍNEA DE COMANDOS
A los scripts de PowerShell se les pueden pasar argumentos por la
consola. No hay más que poner la lista de argumentos separada por espacios y
estos se recogen en un array especial llamado $args.
De todas formas podemos usar una estructura llamada param con la que
podremos definir parámetros con nombre y llevar a cabo acciones en caso de
que los parámetros no se suministren. La forma tradicional está comentada:
<# example7.ps1
Show how to pass and use arguments for the script
Eugenia Pérez Martínez - [email protected]
#>
# The simple way
#Write-Output "Number of arguments passed: $($args.Count)"
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 28
#Write-Output "FIRST " $args[0] " AND SECOND: " $args[1]
param (
[int]$opcion1=42,
[string]$opcion2="otrovalor"
)
Write-Output "El primer parámetro:" $opcion1
Write-Output "El segundo parámetro:" $opcion2
1.12 ESTRUCTURAS DE CONTROL
1.12.1 La estructura condicional
Como es ya sabido, las estructuras de control condicionales nos permite
cambiar el flujo de ejecución del programa en función de una condición:
if(condition)
statement block
elseif(condition)
statement block
else
statement block
Por ejemplo:
<# example8.ps1
Shows the use of if statement
Eugenia Pérez Martínez - [email protected]
#>
$textToMatch = Read-Host "Introduzca una frase: "
$pattern = Read-Host "Introduzca un patrón para comparar: "
$matchType = Read-Host "Indica 1 si quieres saber si el patrón está contenido,
o 2 si tiene que ser exactamente igual"
if($matchType -eq "1")
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 29
$textToMatch -like $pattern
elseif($matchType -eq "2")
$textToMatch -match $pattern
else
Write-Host "Debes indicar el número 1 o bien el 2..."
En este caso, se introduce la frase “HOLA 1 DAM”, el patrón DAM y la
opción 2, dando como resultado True. Para que el resultado fuese True
indicando la opción 1, el patrón deberá coincidir completamente con la frase
introducida (“HOLA 1 DAM”).
Otro ejemplo:
$x = Read-Host "Enter a number"
if ($x -lt 5)
$false
else
$x
#Another way to express the same, just on a single line.
$temp = $( if ($x -lt 5) $false else $x )
#Using the previous variable
if ($temp -gt 20)
$false
else
$true
1.12.2 Estructura de Switch
Cuando necesitamos llevar a cabo una acción según el valor que tenga
una única variable en lugar de utilizar una serie de ifelse utilizamos una
estructura switch.
switch options expression
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 30
comparison value statement block
O bien:
comparison expression statement block
(...)
default statement block
También es aplicable a ficheros:
switch options -file filename
comparison value statement block
O bien
comparison expression statement block
(...)
default statement block
Por ejemplo:
<# example9.ps1
Shows the use of the switch statement
Eugenia Pérez Martínez - [email protected]
#>
$number = Read-Host "Please, enter a number: "
switch ($number)
1 Write-Output "The meaning of life"
2 Write-Output "This number symbolizes opposition and conflicts"
3 Write-Output "This is the fundamental number"
4 Write-Output "Symbolically number 4 represents the cross and quadrant"
5 Write-Output "This symbolizes the union of heavenly and worldly
aspects."
6 Write-Output "Compared to number 5, number 6 is seen as macro cosmos
against micro cosmos."
7 Write-Output "There are 7 days in a week. It points to the whole
cycle, a dynamic perfection."
default Write-Output "Without meaning"
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 31
# Optional Flags for switches
# CaseSensitive
# File
# Exact
# Paralel
# Wildcard
switch -wildcard ('abc')
a* "a*: $_"
*c "*c: $_"
#In the result strings, you can see that $_ was replaced by the full string of
the actual
#switch value. For example:
switch (8)
$_ -gt 3 "greater than 3"
$_ -gt 7 "greater than 7"
#Notice that you can combine values and expressions (these with )
switch(1,2,3,4,5,6)
$_ % 2 "Odd $_"; continue
4 "FOUR"
default "Even $_"
#Inside the condition you can use a break or continue as keywords.
<#$dll=$txt=$log=0
switch -wildcard (dir c:\windows)
*.dll $dll++
*.txt $txt++
*.log $log++
Write-Output "dlls: $dll text files: $txt log files: $log"
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 32
$dll=$txt=$log=0
switch -wildcard (dir)
*.dll $dll+= $_.length; continue
*.txt $txt+=$_.length; continue
*.log $log+=$_.length; continue
Write-Output "dlls: $dll text files: $txt log files: $log"#>
#Processing files
switch -regex -file c:\windows\windowsupdate.log
'START.*Finding updates.*AutomaticUpdates' $au++
'START.*Finding updates.*Defender' $du++
'START.*Finding updates.*SMS' $su++
1.12.3 La estructura While y do-While
while
:loop_label while(condition)
statement block
Do-while
:loop_label do
statement block
while(condition)
O bien:
:loop_label do
statement block
until(condition)
Veamos un ejemplo a continuación:
<# example10.ps1
Shows the use of the while/do-while loop structure
Eugenia Pérez Martínez - [email protected]
#>
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 33
[int]$times = Read-Host "Please, insert how many times"
while ($times -gt 0 )
Write-Output "Hello World"
$times--
$number = Get-Random -Maximum 10 -Minimum 1
$count = 0
do
Write-Output "Guess the number"
$guess = Read-Host "Try: $count"
$count++
while($number -ne $guess);
Write-Output "Finally you guessed it: $number after $count tries"
1.12.4 El bucle for
Aunque el efecto que se consigue es el mismo (repetir la ejecución
código) se diferencia del while en que el for está pensado para que esa
repetición sea un número concreto de iteraciones. Se suelen utilizar también
para recorrer estructuras.
for (initialization; condition; increment)
statement block
Por ejemplo:
<# example11.ps1
Shows the use of the for loop structure
Eugenia Pérez Martínez - [email protected]
#>
for($counter = 0; $counter -lt 10; $counter++)
Write-Host "Processing item $counter"
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 34
# Looping each value of the resulting array
$windows = @("Windos 95","Windows 98","Windows ME", "Windows XP", "Windows
Vista", "Windows Server 2012 R2", "Windows 7", "Windows 8")
Write-Output "Some Windows versions:"
for($i=0;$i -lt $windows.Length;$i++)
Write-Output $windows[$i]
1.12.5 El bucle foreach
Es lo mismo que el for, pero se utiliza especialmente para las estructuras
como los arrays, hashtables, ya que no nos obliga a indicar el número de
repeticiones.
foreach (variable in expression)
statement block
Por ejemplo:
<# example12.ps1
Shows the use of the foreach loop structure
Eugenia Pérez Martínez - [email protected]
#>
$windows = @("Windows 95","Windows 98","Windows ME", "Windows XP", "Windows
Vista", "Windows Server 2012 R2", "Windows 7", "Windows 8")
foreach ($win in $windows)
Write-Output "Versions of windows: $win"
# Counts the number of files with TXT extension and their lengths.
$count,$l = 0, 0
foreach ($f in dir *.txt)
$count++
$l += $f.Length
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 35
Write-Output "The number of TXT files: $count , and the total length: $l"
#This is the same as the following:
$count,$l = 0, 0; foreach ($f in dir *.txt) $count++; $l += $f.Length;
# foreach with current dir files
foreach ($file in dir c:\*.*)
Write-Output "Found $file : " $file.LastWriteTime
#The foreach statement and the range operator
foreach ($i in 1..10) if ($i % 2) "$i is odd"
#You can implement the same using pipelines
1..10 | foreach if ($_ % 2) "$_ is odd"
#Let's test with a hashtable
$films =@ "film1" = @name="The Godfather";
year="1972";
studio="Paramount Pictures"
"film2" = @name="Apocalypse Now";
year="1979";
studio="Zoetrope Studios"
foreach ($film in $films.GetEnumerator())
Write-Output "Film: $($film.Key)"
Write-Output "Film name: $($film.value['name'])"
Write-Output "Film year: $($film.value['year'])"
El foreach también lo podemos usar en el propio shell de PowerShell con
el cmdlet Foreach-Object, el cual nos permite iterar sobre la salida de
comandos:
dir | ForEach-Object Write-Output $_.Name
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 36
o
$total = 0
dir | ForEach-Object $total += $_.length
Write-Output $total
1.12.6 Sentencias de control de bucle: break y continue
Cómo en muchos otros lenguajes dentro de lo bucles podemos utilizar
dichas sentencias:
break: provoca la salida inmediata del bucle.
continue: termina la vuelta en el bucle y pasa a la siguiente vuelta,
es decir, no se sale del bucle.
En caso de doble bucle, si metemos un break dentro del bucle interior
pero queremos salir al exterior de los dos bucles tendríamos que utilizar una
etiqueta para indicarle al break hacia dónde ir:
<# example13.ps1
Shows the use of the flow control statements: break and continue.
Eugenia Pérez Martínez - [email protected]
#>
#Breaks the inner for loop.
for($counter = 0; $counter -lt 5; $counter++)
for($counter2 = 0; $counter2 -lt 5; $counter2++)
if($counter2 -eq 2)
break
Write-Host "Processing item $counter,$counter2"
#Breaks the outer for loop.
:outer_loop for($counter = 0; $counter -lt 5; $counter++)
for($counter2 = 0; $counter2 -lt 5; $counter2++)
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 37
if($counter2 -eq 2)
break outer_loop
Write-Host "Processing item $counter,$counter2"
#Continues with the current execution flow.
for($counter = 0; $counter -lt 5; $counter++)
for($counter2 = 0; $counter2 -lt 5; $counter2++)
if($counter2 -eq 2)
continue
Write-Host "Processing item $counter,$counter2"
#Continues with the next iteration of the specified loop instead.
:outer_loop for($counter = 0; $counter -lt 5; $counter++)
for($counter2 = 0; $counter2 -lt 5; $counter2++)
if($counter2 -eq 2)
continue outer_loop
Write-Host "Processing item $counter,$counter2"
1.13 EXPRESIONES REGULARES
Las expresiones regulares son una potente herramienta que nos permite
hacer búsquedas de texto, comprobar validez de datos.
¿Cómo podemos validar si un campo contiene el tipo de valor que
esperamos? Se puede hacer a mano sin embargo en la mayoría de los
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 38
lenguajes de programación disponemos de una herramienta llamada
expresiones regulares. Las expresiones regulares son en cierto modo un
resumen de un conjunto o de un tipo de información. Son como un patrón que
describe determinado tipo de dato. Visto con ejemplos se ve muy claro: Si
tenemos un conjunto así:
aa, aaa, a, aaaaa, aaaaaaa, …
¿Qué tienen en común esos elementos? Todos contienen una o más letras 'a'.
La expresión regular que describe eso, que lo resume, sería: a+ Si tenemos
otro conjunto así:
ab, aab, abbb, aaaaabb, aabb, …
¿Qué tienen en común? Todos son un conjunto de una o más letras 'a'
seguidas de una o más letras 'b'. En ese caso la expresión sería: a+b+
¿Y este otro?:
32234, 67843, 23455, 12334,...
Son números, y siendo más precisos son números de 5 dígitos. La
expresión regular para describir o resumir ese conjunto podría ser:
[09]5
¿Para qué sirven las expresiones regulares? Tienen muchas utilidades tanto en
programación como en administración de sistemas. En el ámbito de la
programación nos pueden servir para:
Buscar patrones en texto
Hacer sustituciones basadas en un patrón
Comprobar si un texto sigue un patrón, para validarlo.
Este último es el que nos interesa para poder aplicarlo como
herramienta de validación de parámetros.
De hecho, hoy en día es habitual hacer uso de frameworks de programación y
librerías que nos facilitan esta labor, de manera que no suele ser necesario
crear expresiones desde 0 ya que ese es un trabajo que ya está hecho para la
mayoría de expresiones de uso común: dni, teléfonos, códigos postales,
cuentas corrientes, etc… No obstante, cabe destacar que el uso de dichas
expresiones regulares nos permite un patrón determinado, no ofrece cierta
flexibilidad. Es decir, si además de saber que el dni tiene un formato correcto,
quisiéramos comprobar la validez del mismo o bien de una CC, habría que
hacerlo de forma programática.
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 39
Las expresiones regulares pueden usar conjuntos, cuantificadores y algunos
caracteres especiales.
Conjuntos:
aD: un carácter 'a' y a continuación una 'D'
[az]: caracteres de la 'a' a la 'z'
[AZ09az]: caracteres a z, números del 0 al 9.
[dk]: caracteres de la 'd' a la 'k', lo mismo que [d-k]
$ : terminado en
^ : empieza por
. : el punto, cualquier carácter.
Cuantificadores:
*: asterisco, 0 o más , por ejemplo [az]*
+ : 1 o más: [09]+
? : una o ninguna: http[s]?
5 : exactamente 5 veces
1,4 : de 1 a 4 ocurrencias
3, : mínimo de 3
Metacaracteres
\d : dígitos [09]
\D : NO dígitos
\w : palabras [azAZ09]
\W: NO palabras
\s : espacios o caracteres en blanco
\S : NO espacios [ \t\n\x0b\r\f]
Para hacer uso de estos patrones o expresiones regulares, se suelen utilizar los
operadores:
match: comprueba si una cadena cumple o no con una expresión. El
operador contrario sería notmatch.
"Hello" –match "[jkl]" # Da como resultado $true
replace: reemplaza una cadena con otra:
"Hello" –replace "ello","i" # Como resultado "Hi"
bien borra la cadena coincidente con el patrón:
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 40
"abcde" –replace "bcd" # Da como resultado "ae"
Por ejemplo:
# example14.ps1
# Shows the use of regular expressions
# Eugenia Pérez Martínez - [email protected]
$sample = Read-Host "Please enter some string"
# match operator, to check if a string
# with a regular expression
if ($sample -match "[0-9]1,3")
Write-Output "$sample is a digit"
# $matches array populates...
Write-Output $($matches[0])
else
Write-Output "$sample is NOT digit"
# Note: match is case INsensitive, just like imatch
# cmatch IS case sensitive
# Replace: we can replace contents using replace operator
# we have also creplace ireplace
$email= "[email protected]"
$newEmail = $email -replace ".org",".com"
Write-Output $newEmail
# To remove something
$greet= "Hello 1 DAM"
$newGreet= $greet -replace "Hello"
Write-Output $newGreet
Otras posibilidades del replace:
"The car is red" -replace 'is (red|blue)','was $1'
The car was red
"My boat is blue" -replace 'is (red|blue)','was $1'
My boat was blue
¿Qué pasaría si el patrón no coincide? Pues lo siguiente:
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 41
"My bike is yellow" -replace 'is (red|blue)','was $1'
My bike is yellow
1.14 FICHEROS
A continuación se adjunta una imagen con una lista de cmdlets, alias y
equivalentes en otros shells, de utilidad para esta parte:
1.14.1 Leyendo y escribiendo ficheros
Para leer ficheros se utiliza el cmdlet Get-Content. A continuación se
exponen los parámetros que admite dicho comando:
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 42
Por ejemplo:
Get-Content myfile.txt
Con estas dos líneas estaríamos creando tres ficheros, se listan, y
finalmente se muestra su contenido:
1..3 | foreach "This is file $_" > "file$_.txt"
dir
Get-Content file1.txt,file2.txt,file3.txt
También podemos hacer uso de los patrones:
Get-Content *.txt
Para copiar uno de los ficheros anteriores se podría utilizar:
copy-item file1.txt -destination c:\
Y para eliminarlo:
remove-item c:\file1.txt
Con Set-Content se puede establecer nuevo contenido en el fichero.
Vamos a hacer una lectura de todas las líneas de un fichero, y volcarlas en el
mismo, pero solo leyendo las seleccionadas (a partir de la tercera):
$file ="C:\Cuatrovientos\file1.txt"
$lines = Get-Content $file -ReadCount 0
write-output $lines
$lines = $lines | select -Skip 3
write-output $lines
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 43
$lines | Set-Content temp.txt
move temp.txt $file -Force
1.14.2 Procesando texto no estructurado
Split
Un uso habitual de PS es procesar ficheros de log para extraer
información relevante. Para lo cual es necesario fragmentar las líneas de
ficheros por un carácter delimitador.
#Si no se indica nada, el delimitador será el espacio en blanco
"Hello there world".Split()
"Hello there world".Split()
#El siguiente parámetro permitiría borrar las apariciones vacías
"Hello there world".split(" ",[StringSplitOptions]::RemoveEmptyEntries)
Podemos obtener la propiedad Length:
"Hello there world".Split().length
"Hello there world".Split().length
También es posible especificar los caracteres que serán utilizados para
delimitar los tokens:
"First,Second;Third".Split(';')
#O más de uno
"First,Second;Third".Split(',;')
Imaginémonos que tenemos el siguiente texto y queremos contar el
número de palabras:
$words = "Hello there world Hello world again!".split(" ")
$words.count
Da como resultado 6.
Si quisiéramos obtener aquellas palabras únicas:
$uniq = $words | sort –Unique
$uniq.count
Join
Es un operador que realiza la operación contraria a Split. Permite unir
contenido y que sea tratado como un string o un array.
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 44
La forma de ordenar en sentido contrario una cadena de caracteres es
declarándola como tal, y luego aplicando la propiedad de los arrays Reverse.
Por ejemplo:
$ca = [char[]] "abcd"
[array]::Reverse($ca)
# Esto me muestra un array de caracteres
$ca
#Join me permite convertirlo a texto
$ra = -join $ca
$ra
Si utilizo el join así, obtendría un array de caracteres, si hago la definición
con paréntesis se convertirá a una cadena de texto:
-join 1,2,3
-join (1,2,3)
También podemos crear un string a partir de una colección de valores,
separados por un carácter indicado:
$numbers = 1,2,3
$exp = $numbers -join '+'
Se obtiene: 1+2+3
1.14.3 Realizando búsquedas
El comando Select-String es muy útil para hacer búsquedas en textos y en
ficheros.
Por ejemplo:
"Hello","HELLO" | select-string -pattern "HELLO" -casesensitive
Éste busca en todos los archives .txt del directorio actual las líneas que
contengan la cadena “”.
select-string -path *.xml -pattern "Windows"
En este otro se buscan los 100 eventos más recientes del registro de de
aplicaciones del Visor de eventos, los almacena en la variable events, y sobre la
misma se usa un operador de canalización (“|”). Utiliza el parámetro
InputObject para representar la entrada de la variable $events. El valor del
parámetro InputObject es la propiedad Message de cada objeto cuando pasa a
través de la canalización. El objeto actual viene representado por el símbolo $_.
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 45
Cuando cada uno de los eventos llega a la canalización, Select-String
busca en el valor de su propiedad Message la cadena "failed" y muestra las
líneas que incluyen una coincidencia.
$events = get-eventlog -logname application -newest 100
$events | select-string -inputobject $_.message -pattern "failed"
Este comando examina todos los archivos de los subdirectorios de
C:\Windows\System32 que tienen la extensión .txt y busca la cadena
"Microsoft".
get-childitem c:\windows\system32\* -include *.txt -recurse |select-string -
pattern "Microsoft" -casesensitive
Si tuviésemos un fichero de log, llamado audit.log en system32, a través
de las siguientes sentencias podríamos buscar la cadena "logon failed" en el
archivo indicado. Con el parámetro Context se puede capturar 2 líneas antes
de la coincidencia y 3 líneas después de la coincidencia.
El segundo comando usa la propiedad Count de las matrices de objetos
para mostrar el número de coincidencias encontradas; en este caso, son 2.
El tercer comando muestra las líneas almacenadas en la propiedad
Context del primer objeto.
select-string -path audit.log -pattern "logon failed" -context 2, 3
$f.count
($f)[0].context
1.14.4 Ejemplo de procesamiento de un fichero CSV
Vamos a ver como ejemplo un programa que lee los contenidos de un
fichero csv y trata cada línea siendo capaz de sacar los campos de cada una.
El código es muy sencillo y es algo que abre las puertas a muchas tareas
de administración:
Esté será nuestro file.csv de ejemplo:
Year,Make,Model,Description,Price
1997,Ford,E350,"ac, abs, moon",3000.00
1999,Chevy,"Venture ""Extended Edition""","",4900.00
1999,Chevy,"Venture ""Extended Edition, Very Large""",,5000.00
1996,Jeep,Grand Cherokee,"MUST SELL!
air, moon roof, loaded",4799.00
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 46
Este script nos permitirá mostrar la primera columna correspondiente al
año:
<# example15.ps1
# Shows how to read a csv file and isolate fields
# Eugenia Pérez Martínez - [email protected]
#>
$fileContent = Get-Content file.csv
foreach ($line in $fileContent)
# We split the line using , line is converted into an array
$contents = $line.Split(",")
# And so we isolate data from each line...
# shows first field
Write-Output $contents[0]
Nota: Los ficheros CSV (del inglés comma-separated values) son un tipo
de documento en formato abierto sencillo para representar datos en forma de
tabla, en las que las columnas se separan por comas y las filas por saltos de
línea. Los campos que contengan una coma, un salto de línea o una comilla
doble deben ser encerrados entre comillas dobles.
Otra opción para tratar con ficheros CSV sería el comando Importcsv que
nos carga un fichero de este tipo directamente en un array.
1.14.5 Exportando e importando ficheros CSV
Import-CSV
Convierte las propiedades de objeto de un archivo CSV (valores separados
por comas) en versiones CSV de los objetos originales.
get-process | export-csv processes.csv
Para acceder a cada una de las propiedades de un objeto (de un process)
debemos utilizar el import-csv.
$p = import-CSV processes.csv
$p | get-member
También podríamos especificar el limitador que queremos utilizar (por
defecto la ,):
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 47
get-process | export-csv processes.csv -Delimiter :
$p = import-csv processes.csv -Delimiter :
1.14.6 Convirtiendo a HTML
El cmdlet ConvertTo-HTML permite crear ficheros HTML a partir de:
get-eventlog -logname "Windows PowerShell" | convertto-html > pslog.htm
1.15 FUNCIONES
Las funciones son códigos aislados en un bloque a las que podemos
llamar todas las veces que queramos, a las que se pueden pasar parámetros y
que retornan un resultado.
Suele ser necesario desarrollar funciones porque:
o En lugar de repetir código lo metemos en una función y le llamamos
por su nombre. Eso facilita el mantenimiento y mejora de esa
función.
o Separamos el problema que trata de resolver el script en pequeños
problemas.
Cuando creas una función en PowerShell se convierte en un comando, al
menos mientras dure la sesión.
Una función se define de la siguiente manera:
function name(parameters)
statement block
Vamos a ver dos maneras de declarar funciones:
a) Sin parámetros explícitos
La primera, tal y como veremos en los siguientes ejemplos sería la
declaración de funciones en las que explícitamente no se declaran
parámetros pero se pueden recibir.
<# example16.ps1
Shows some ways to create functions and
how to deal with parameters without declaring them
Eugenia Pérez Martínez - [email protected]
#>
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 48
# The extremelly powerful HelloWorld function
function helloWorld
"Hello 1 DAM!!"
# A function that checks params
# call it with checkParams Hello 1 DAM 4 VIENTOS
function checkParams
"The number of params: "
$args.count
"Passed parameters"
foreach ( $param in $args)
$param
# If we want to pass params using "," we have
# to set $ofs var
# this function prints teachers names
function teachers
$ofs = ","
"Greetings to:"
foreach ($name in $args)
$name
# param assignment, the easy way
# This function takes two numbers and calculates
# the body mass index height weight
function bodyMassIndex
# direct assignment
$weight, $height = $args
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 49
$bmi = 0
" Height: $height, Weight: $weight "
$bmi = $weight / ($height * $height)
"BodyMassIndex $bmi"
# Now we call them all
helloWorld
checkParams Hello 1 DAM 4 VIENTOS
teachers "Maria","Angel","Alberto","Susana","Pello"
bodyMassIndex 81 1.85
Nota: fíjate en la invocación a las funciones de este tipo. Un fallo
típico es intentar pasar los argumentos a las funciones mediante
paréntesis.
b) Parámetros explícitos y con tipo. Valores por defecto
Para mejorar un poco la comprensión y legibilidad de las funciones
podemos meter la lista de parámetros y además incluir los tipos para mejorar
los mensajes de error en caso de que se usen las funciones mal; así como la
asignación de valores por defecto.
Adicionalmente se puede hacer que algunos valores sean obligatorios. O
añadir opciones para elegir los mismos.
<# example17.ps1
Shows functions with explicit parameter declaration
and shows Two ways to pass parameters
Eugenia Pérez Martínez - [email protected]
#>
# The simplest of all
function divValues ($value1, $value2)
$result = $value1 / $value2
"Result is $result"
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 50
divValues 50 2
divValues -value2 2 -value1 50
# We can also declare param type to provide
# better error messages
function sayHello ([string] $name, [int] $times)
for($i=0;$i -lt $times;$i++)
"Hello $i : $name"
sayHello -name Iker -times 3
#Inizialiting function parameters with default values
function add ($x=1, $y=2)
$x + $y
add
add 5
add 5 6
function dow ([datetime] $d = $(get-date))
$d.dayofweek
dow
dow "feb 16, 2014"
<#Handling mandatory parameters
#>
function showX ($x=$(throw "need x"))
"x is $x"
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 51
showX 5
#Shows an exception because the x argument should be needed
#showX
<#Using switch parameters to define command switches
#>
function get-soup ([switch] $please,[string] $soup= "chicken noodle")
if ($please)
"Here's your $soup soup"
else
"No soup for you!"
get-soup
get-soup -please
get-soup -please tomato
1.16 MÓDULOS
Además de crear funciones que podamos reutilizar dentro del propio
script, a menudo será frecuente la necesidad de que sean utilizadas en otros
scripts o incluso que puedan ser utilizadas desde el propio shell. Para ello
necesitaremos exportarlas como módulos, por lo que estos scripts pasarán a
tener extensión psm1.
Por defecto todas las funciones que existan en el mismo serán públicas,
aunque es posible controlar aquéllas que quieres hacer privadas (o que no
querrás exportar).
Veamos un ejemplo:
<# example18.psm1
How to write a module in PS
Eugenia Pérez Martínez - [email protected]
#>
$count = 0
$increment = 1
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 52
function Get-Count
return $count += $increment
function Reset-Count
$count=0
setIncrement 1
function setIncrement ($x)
$increment = $x
A continuación vamos a hacer que este script pase a ser un módulo con la
siguiente orden:
copy example18.ps1 example18.psm1 -Force –Verbose
Finalmente tendremos que cargarlo para poder hacer uso del mismo:
Import-Module .\example18.psm1
Vamos a escribir el cmdlet Get-Module, para ver si efectivamente lo
encuentra como módulo. Para ver el objeto y sus funciones, que serán
públicas, más en detalle tecleamos: Get-Module | fl. Y éste para ver solamente
sus funciones: Get-Command -Module example18.
A continuación probamos a ejecutarlo, invocando a una de sus funciones
una serie de veces:
PS C:\Windows\system32> Get-Count
1
______________________________________________________________________________
PS C:\Windows\system32> Get-Count
1
_____________________________________________________________________________
PS C:\Windows\system32> Get-Count
1
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 53
Observarás que el valor del contador no varía. Esto es porque el valor de
las variables se “resetea” en cada ejecución. Para hacer que éste perdure
deberíamos declarar las variables como estáticas con el $script: delante de la
variable:
<# example18.psm1
How to write a module in PS
Eugenia Pérez Martínez - [email protected]
#>
$script:count = 0
$script:increment = 1
function Get-Count
return $script:count += $increment
function Reset-Count
$script:count=0
setIncrement 1
function setIncrement ($x)
$script:increment = $x
De esta forma la ejecución cambia a:
PS C:\Windows\system32> Get-Count
1
______________________________________________________________________________
PS C:\Windows\system32> Get-Count
2
_____________________________________________________________________________
PS C:\Windows\system32> Get-Count
3
Adicionalmente podríamos hacer que el contador se resetease:
PS C:\Windows\system32> Reset-Count
______________________________________________________________________________
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 54
PS C:\Windows\system32> Get-Count
1
PS C:\Windows\system32> setIncrement 7
______________________________________________________________________________
PS C:\Windows\system32> Get-Count
8
Para eliminar el módulo anterior del espacio de nombres, utilizaremos:
Remove-Module example18
Para controlar las funciones visibles dentro de los módulos se utiliza el
cmdlet Export-ModuleMember. Es decir, ya que por defecto todas las
funciones son exportadas como públicas podríamos controlar cuales queremos
que sean públicas y cuáles serán privadas.
Ahora añadiremos esta línea al final de nuestro módulo:
Export-ModuleMember *-Count
De esta forma si ahora volvemos a importarlo e intentamos utilizar
cualquier función no especificada como pública (cualquiera que no sea Get-
Count o bien Reset-Count), es decir, setIncrement, nos dará un error como era
de esperar:
PS C:\Windows\system32> setIncrement 4
El término 'setIncrement' no se reconoce como nombre de un cmdlet, función,
archivo de script o programa ejecutable. Compruebe si escribió correctamente
el nombre o, si incluyó una ruta de acceso, compruebe que dicha ruta es
correcta e inténtelo de nuevo.
En línea: 1 Carácter: 13
+ setIncrement <<<< 4
+ CategoryInfo : ObjectNotFound: (setIncrement:String) [],
CommandNotF oundException
+ FullyQualifiedErrorId : CommandNotFoundException
______________________________________________________________________________
PS C:\Windows\system32> Get-Count
1
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 55
2 EJERCICIOS: SINTAXIS DEL LENGUAJE
Para los ejercicios crea un directorio donde los vayas almacenando y vete
numerándolos dentro del mismo.
2.1 EJERCICIO 1
Crea un script donde recojas diferentes datos del usuario:
- Nombre,
- Edad,
- si es mayor de edad,
- salario
- y la fecha de hoy.
A continuación muestra la información por pantalla. Concatena el parámetro
dos (edad) con el tercero (mayor de edad).
2.2 EJERCICIO 2
Realiza el ejercicio anterior, pero pidiendo los datos por pantalla en lugar
de inicializando tú las variables.
2.3 EJERCICIO 3
De manera similar a como sucede en otros lenguajes, estos scripts
admiten recepción de argumentos por consola. Investiga cómo puedes acceder
a ellos mediante el array especial $args, y realiza el ejercicio anterior de esta
forma.
2.4 EJERCICIO 4
Realiza una calculadora que muestre la suma, resta, multiplicación,
división y módulo de dos operandos que pedirás por pantalla.
2.5 EJERCICIO 5
Realiza un script que pida dos números por pantalla y compruebe:
- Que el segundo número es mayor que el primero, en caso contrario
muestre mensaje de error.
Si se cumple la condición anterior, deberás:
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 56
- Mostrar el resultado de la división entre el segundo número y el
primero, e indicar el tipo del resultado.
- solicitar dos cadenas, mostrando aquélla cuya longitud sea mayor.
Acuérdate de que tienes la ayuda y el IntelliSense.
2.6 EJERCICIO 6
Crea un script que solicite al usuario un
número, verifique que es par y programe un bucle para que muestre un
mensaje por consola tantas veces como indique el número. Utiliza las tres
estructuras de bucle que conoces.
2.7 EJERCICIO 7
Crea un script que solicite al usuario un número. Mientras lo que
introduzca el usuario no esté entre 1 y 100 se lo tiene que solicitar
una y otra vez. Una vez introducido el número correcto el programa
debe hacer lo siguiente: si ha cometido algún error al introducir un
número válido debe hacerse un bucle en el que se increpe al usuario
tantas veces como errores haya cometido. Si lo hizo bien a la primera
saca un mensaje felicitándolo.
2.8 EJERCICIO 8
Crea un script que espere dos parámetros un llamado
$primero que espere un [int], otro llamado $segundo que espere un
String que si no se introduce debe solicitarlo al usuario. Una vez
hecho el programa debe hacer un bucle for que muestre el valor de
$segundo tantas veces como indique $primero.
2.9 EJERCICIO 9
Crea un array que contenga los nombres de tus jugadores favoritos de
fútbol. A continuación añade otro jugador al array creado anteriormente.
Muestra los nombres de los jugadores contenidos en el array recorriendo el
mismo mediante un bucle while, un for y un foreach.
2.10 EJERCICIO 10
Desarrolla un cmdlet de powershell que defina un array de 10
números inicializados a 0.
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 57
A continuación haz un bucle (for o foreach) que inicialice el array
con números enteros aleatorios entre 10 y -10 (recuerda el cmdlet Get-
Random).
Una vez generado ese array debes hacer otro bucle for que contabilice
cuántos números positivos, negativos e iguales a 0 hay en ese array.
2.11 EJERCICIO 11
Desarrolla un cmdlet de Powershell que solicite al usuario un nombre de
directorio. El cmdlet debe crear ese directorio y meterse en él. Una vez dentro
debe crear 10 directorios cuyo nombre debe ser un número aleatorio, y dentro
de cada uno de ellos debe crear 10 ficheros de texto cuyo nombre también
será un número aleatorio.
Nota: se trata de que investigues el uso de algún comando que veremos
posteriormente. Recuerda que puedes combinar la ayuda (help) con los alias
que ya conoces de Batch (existen cmdlets en PS asociados a los comandos de
otros shell conocidos…) Por ejemplo, help md o bien help cd, etc…
2.12 EJERCICIO 12
Mediante el uso de arrays y números aleatorios genera un cmdlet de
Powershell que genere contraseñas. El planteamiento es el siguiente:
Dispones de un array con los siguientes caracteres:
('a','b','c','d','$','.','&','0','8','9')
Solicita por pantalla una longitud para tu contraseña, que deberá estar
entre 3 y 10 caracteres; si no haz que el usuario vuelva a introducir dicha
longitud.
A continuación deberás ir componiendo la contraseña carácter a carácter
con los indicados anteriormente. Para ello obtén las posiciones de forma
aleatoria. Por ejemplo, la primera iteración obtendré la 3 de forma aleatoria,
luego mi contraseña debería empezar por d.
Una vez que lo tengas hecho, haz que el ejercicio anterior genere los
nombres de directorios a partir de este cmdlet.
2.13 EJERCICIO 13
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 58
Crea un array de alumnos, que contenga información de varios de tus
compañeros de clase (en forma de array asociativo o hashtable): al menos,
nombre y edad para cada uno de ellos.
Recorre el array de alumnos y vete mostrando los valores de cada uno.
Prueba ahora a borrar a uno de tus compañeros.
2.14 EJERCICIO 14
Crea un script que muestre un menú al usuario con
cuatro operaciones disponibles: crear directorio, eliminar directorio,
mostrar directorio y salir.
Una vez elegida una opción correcta el programa debe solicitar un
nombre de directorio y hacer la operación seleccionada.
Operaciones:
Crear: New-Item -Name Nombre_De_Carpeta -Itemtype directory
Eliminar: Remove-Item Nombre_De_Carpeta
Mostrar directorio: Get-ChildItem Nombre_De_Carpeta
2.15 EJERCICIO 15
Comprueba los procesos que se ejecutan en tu ordenador actualmente
con el cmdlet Get-Process. A continuación crea un array con el nombre de
alguno de estos procesos (otros podrían ser inventados).
Recorre dicho array obteniendo el id de cada proceso. Si éste mayor que
cero sabrás que el proceso existe y mostrarás un mensaje por pantalla. En caso
contrario, mostrarás un error.
2.16 EJERCICIO 16
Aunque no hemos dado aún funciones, éstas no distan de las que
conoces. Admiten parámetros y retorno. Solo tienes que declararlas con la
palabra reservada function.
A partir de lo visto en expresiones regulares,
Crea una función que reciba un texto y compruebe que tiene
exactamente cuatro letras.
Crea una función que permita validar el formato de un dni.
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 59
2.17 EJERCICIO 17
Crea un cmdlet de PowerShell que defina un array relacional con cuentas
de usuarios de 1º DAM.
Los campos de cada elemento deben ser:
nombre_cuenta
nombre completo
password
grupo (al que pertenece)
El programa debe mantener ese array con un menú en el que se
pueda:
Añadir un usuario
Buscar por nombre
Buscar por grupo
Eliminar un usuario
Mostrar todos
Al crear un nuevo usuario se le pedirán todos los datos. El campo
contraseña debe ocultarse al escribir.
2.18 EJERCICIO 18
Crea un cmdlet de powershell que defina una función llamada
generateSecureAccount . La función debe generar una cadena que tenga 4
letras aleatorias seguida de 6 números aleatorios.
Para realizar este ejercicio podrías utilizar un array de letras (aunque
también contiene caracteres no alfanuméricos) y un array de números, tal y
como se muestra a continuación:
$letters =
'a','b','c','d','e','f','g','h','i','j','k','l','m','n','ñ','o','p','q','r','s
','t','u','v','x','y','z','A','B','C','D','E','F','G','H','I','J','K','L','M',
'N','Ñ','O','P','Q','R','S','T','V','W','X','Y','Z','º','ª','\','!','|','"','@
','·','#','$','~','%','€','&','¬','/','(',')','=','?','''','¡','¿','`','[','^'
,'+','*',']','´','','¨','ç','Ç','',',',';','.',':','-','_'
$numbers = 0,1,2,3,4,5,6,7,8,9
2.19 EJERCICIO 19
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 60
Crea un cmdlet de powershell que defina una función llamada
generateAccount. La función debe como parámetro un Nombre y un Apellido y
debe ser capaz de generar un string con la forma nombre_apellido con
todo en minúsculas:
Identidad: nombre_apellido
Password: crea una función que incluya el mecanismo de creación
de passwords del ejercicio 12, y utilízala.
Forma de ejecución: si invoco a la función como
generateAccount EUGENIA PEREZ
Se mostrará un cuadro de diálogo pidiéndome la longitud de la
contraseña:
Y finalmente se mostrará como resultado:
2.20 EJERCICIO 20
Crea un cmdlet de powershell que defina una función llamada
generateName. La función debe recibir como parámetro un número que serán
las sílabas. La función debe devolver un nombre que intercale consonante con
vocal…
Puedes utilizar los siguientes arrays:
$consonants =
'b','c','d','f','g','h','j','k','l','m','n','ñ','p','q','r','s','t','v','x','y
','z'
$vowels = 'a','e','i','o','u'
De tal forma que si ejecuto:
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 61
generateName 3
susana
2.21 EJERCICIO 21
Crea un cmdlet que recoja como parámetro un nombre de directorio.
Debes verificar que ese directorio existe. Luego debes listar los contenidos del
directorio ordenados por tamaño, y de cada elemento debes sacar el tamaño y
el nombre.
Tendrás que combinar el comando de listar un directorio con los
siguientes:
Select-Object length, name (te devuelve la longitud y el nombre de
los objetos del directorio)
El comando Sort-Object te permitirá ordenar, comprueba en la
ayuda cómo poder ordenar por longitud.
2.22 EJERCICIO 22
Haz un módulo maths.psm1 que exporte una serie de funciones como
públicas:
Add
Minus
Multiply
Divide
Y haz uso del mismo desde comandos.
2.23 EJERCICIO 23
Crea un cmdlet llamado CheckPorts que defina un array con los
puertos que queremos que estén en listening. Ejecuta el comando para sacar
los puertos y verifica que están abiertos los indicados en el array.
Vete sacando un mensaje que indique qué puertos están correctamente
en estado listening y cuáles no.
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 62
3 UTILIZAR POWERSHELL PARA TAREAS DE
ADMINISTRACIÓN
http://technet.microsoft.com/es-es/library/dd315304.aspx
U.T.5. BLOQUE II – WINDOWS POWERSHELL
EUGENIA PÉREZ MARTÍNEZ
Página 63
4 BIBLIOGRAFÍA Y REFERENCIAS
Windows Poweshell in Action, 2nd edition, Bruce Payette, Manning
Learn Windows Powershell 3 in a month of lunches, Don Jones, Manning
Windows Server 2012 Automation with PowerShell Cookbook, Ed Goad,
PACKT
Windows Powershell Cookbook 3rd edition, Lee Holmes, O’reilly