sistemas-informáticos-scripts - PowerShell.pdf

U.T.5. BLOQUE II – WINDOWS

POWERSHELL

2013/2014 CFGS Desarrollo de Aplicaciones Multiplataforma

Eugenia Pérez Martínez · ITC Cuatrovientos

[email protected]

http://eugeniaperez.es

mailto:[email protected]

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



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



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



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



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.

http://microsoft.como/powershell



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.



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.



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.

http://quest.com/powershell

http://primaltools.com/

http://powerwf.com/

http://idera.com/



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



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...



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



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



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"



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.



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: “

http://msdn.microsoft.com/enus/library/windows/desktop/ms714657(v=vs.85).aspx

http://msdn.microsoft.com/enus/library/windows/desktop/ms714657(v=vs.85).aspx

http://windowsitpro.com/blog/my12powershellbestpractices

mailto:



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



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



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."



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 ::


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'



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


$num3 = 4.2


$num4 = 4.2d


#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.



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 ::


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]



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.



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


#>

#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

http://es.wikipedia.org/wiki/Lenguaje_de_marcado

http://es.wikipedia.org/wiki/Lenguaje_de_marcado

http://es.wikipedia.org/wiki/Lenguaje

http://es.wikipedia.org/wiki/Internet



Página 24


#>

$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.



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



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



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


#>

# The simple way

#Write-Output "Number of arguments passed: $($args.Count)"



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


#>

$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")



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



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


#>

$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"



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"



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


#>



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


#>

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

Write-Host "Processing item $counter"



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


#>

$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



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



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.


#>

#Breaks the inner for loop.


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++)




Página 37

if($counter2 -eq 2)

break outer_loop


#Continues with the current execution flow.



if($counter2 -eq 2)

continue


#Continues with the next iteration of the specified loop instead.

:outer_loop for($counter = 0; $counter -lt 5; $counter++)


if($counter2 -eq 2)

continue outer_loop


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



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.



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:



Página 40

"abcde" –replace "bcd" # Da como resultado "ae"

Por ejemplo:

# example14.ps1

# Shows the use of regular expressions


$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:



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:



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



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.



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 $_.



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



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


#>

$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 ,):

http://es.wikipedia.org/wiki/Formato_abierto



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


#>



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



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


#>

# The simplest of all

function divValues ($value1, $value2)

$result = $value1 / $value2

"Result is $result"



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"



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


#>

$count = 0

$increment = 1



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

______________________________________________________________________________


1

_____________________________________________________________________________


1



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


#>

$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:


1

______________________________________________________________________________


2

_____________________________________________________________________________


3

Adicionalmente podríamos hacer que el contador se resetease:

PS C:\Windows\system32> Reset-Count

______________________________________________________________________________



Página 54


1

PS C:\Windows\system32> setIncrement 7

______________________________________________________________________________


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

______________________________________________________________________________


1



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:



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.



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



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.



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



Página 60


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


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:



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.



Página 62

3 UTILIZAR POWERSHELL PARA TAREAS DE

ADMINISTRACIÓN

http://technet.microsoft.com/es-es/library/dd315304.aspx

http://technet.microsoft.com/es-es/library/dd315304.aspx



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

Documents

sistemas-informáticos-scripts - PowerShell.pdf