2013/2014 CFGS Desarrollo de Aplicaciones Multiplataforma Multiplataforma · ITC Cuatrovientos
[email protected] http://eugeniaperez.es
TABLA DE CONTENIDO
1.1 INTRODUCCIÓN INTRODUC CIÓN ............................... ............... ................................. ................................. ............................... ............... 4 1.2 ESCOGIENDO EL ENTORNO ................................ ............... ................................ ............................... ................ 4 1.2.1 La consola interactiva intera ctiva ................................ ............... ................................. ................................ .................. .. 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 obt ener comandos ................................ ................ ................... ... 10 1.4 COMANDOS Y CMDLETS ................................ ................ ................................. ................................. ................ 12 1.4.1 Autocompletado Autocomple tado ................................ ............... ................................. ................................ ........................ ........ 13 1.5 CATEGORÍAS CATEGORÍ AS DE COMANDOS ............................... ............... ................................ ........................... ........... 14 1.6 CONVENCIONES CONVENCI ONES DEL LENGUAJE ................................ ................ ................................. ...................... ..... 15 1.7 ENTRADA/SALIDA ENTRADA/S ALIDA ............................... ............... ................................ ................................. ........................... .......... 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 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 ari tmé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 1
TABLA DE CONTENIDO
1.1 INTRODUCCIÓN INTRODUC CIÓN ............................... ............... ................................. ................................. ............................... ............... 4 1.2 ESCOGIENDO EL ENTORNO ................................ ............... ................................ ............................... ................ 4 1.2.1 La consola interactiva intera ctiva ................................ ............... ................................. ................................ .................. .. 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 obt ener comandos ................................ ................ ................... ... 10 1.4 COMANDOS Y CMDLETS ................................ ................ ................................. ................................. ................ 12 1.4.1 Autocompletado Autocomple tado ................................ ............... ................................. ................................ ........................ ........ 13 1.5 CATEGORÍAS CATEGORÍ AS DE COMANDOS ............................... ............... ................................ ........................... ........... 14 1.6 CONVENCIONES CONVENCI ONES DEL LENGUAJE ................................ ................ ................................. ...................... ..... 15 1.7 ENTRADA/SALIDA ENTRADA/S ALIDA ............................... ............... ................................ ................................. ........................... .......... 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 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 ari tmé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 1
1.12 ESTRUCTURAS ESTRUCTU RAS DE CONTROL ................................ ................. ................................ ......................... ........ 28 1.12.1 La estructura condicional ......................................................... 28 1.12.2 Estructura de Switch ................................................................ ................................................................ 29 1.12.3 La La estructura While y do-While ................................. ................. ................................ ................ 32 1.12.4 El El bucle for .............................................................................. .............................................................................. 33 1.12.5 El 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 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 FUNCION ES................................ ............... ................................. ................................ ................................ ................... ... 47 1.16 MÓDULOS.................... MÓDULOS.... ................................ ................................. ................................. ................................ ................ 51 2.1 EJERCICIO EJERCICI O 1................................. ................ ................................. ................................ ................................ ................... ... 55 2.2 EJERCICIO EJERCIC IO 2................................. ................ ................................. ................................ ................................ ................... ... 55 2.3 EJERCICIO EJERCICI O 3................................. ................ ................................. ................................ ................................ ................... ... 55 2.4 EJERCICIO EJERCICI O 4................................. ................ ................................. ................................ ................................ ................... ... 55 2.5 EJERCICIO EJERCICI O 5................................. ................ ................................. ................................ ................................ ................... ... 55 2.6 EJERCICIO EJERCICI O 6................................. ................ ................................. ................................ ................................ ................... ... 56 2.7 EJERCICIO EJERCICI O 7................................. ................ ................................. ................................ ................................ ................... ... 56 2.8 EJERCICIO EJERCICI O 8................................. ................ ................................. ................................ ................................ ................... ... 56 2.9 EJERCICIO EJERCICI O 9................................. ................ ................................. ................................ ................................ ................... ... 56 2.10 EJERCICIO EJERCICI O 10 ................................ ............... ................................. ................................ ................................ ................ 56 2.11 EJERCICIO EJERCICI O 11 ................................ ............... ................................. ................................ ................................ ................ 57 2.12 EJERCICIO EJERCICI O 12 ................................ ............... ................................. ................................ ................................ ................ 57 2.13 EJERCICIO EJERCICI O 13 ................................ ............... ................................. ................................ ................................ ................ 57 2.14 EJERCICIO EJERCICI O 14 ................................ ............... ................................. ................................ ................................ ................ 58 2.15 EJERCICIO EJERCICI O 15 ................................ ............... ................................. ................................ ................................ ................ 58 2.16 EJERCICIO EJERCICI O 16 ................................ ............... ................................. ................................ ................................ ................ 58
Página 2
2.17 2.18 2.19 2.20 2.21 2.22 2.23
EJERCICIO 17 ................................................................................ 59 EJERCICIO 18 ................................................................................ 59 EJERCICIO 19 ................................................................................ 59 EJERCICIO 20 ................................................................................ 60 EJERCICIO 21 ................................................................................ 61 EJERCICIO 22 ................................................................................ 61 EJERCICIO 23 ................................................................................ 61
Página 3
1 U.T. 5-B. WINDOWS POWERSHELL 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.
Página 4
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.
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.
Página 5
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:
De la mima forma que has obtenido la consola anteriormente, puedes llegar al ISE o Entorno de desarrollo de scripts integrado . Página 6
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. 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 7
Panel de edición: aunque 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, simultáneamente, te permite seleccionar una 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 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.
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
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.
Página 8
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]
] [-ComputerName DependentServices] [-Exclude ] [-Include RequiredServices] []
] ]
[[-
…
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 9
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 , 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
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 de eventos, o una lista de los...
Obtiene los eventos de un registro
Clear-EventLog Cmdlet registros de eventos especifica...
Elimina todas las entradas de los
Página 10
Write-EventLog de eventos.
Cmdlet
Escribe un evento en un registro
…
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 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 11
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 12
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.
Una de las características de PowerShell es el autocompletado, mediante la tecla Tab. Por ejemplo, si tecleamos: PS (1) > cd c:\pro*files
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 PS (3) > $a.sub
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 13
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
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
En PowerShell existen 4 categorías de comandos:
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, VerboNombre.
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.
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.
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 14
PS (2) > notepad foo.txt
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
Vamos a ejecutar el primer programa de ejemplo: # :: example1.ps1 :: # Eugenia Pérez Martínez - [email protected] Write-Output "Hello 1DAM"
Para realizar una impresión por pantalla se utiliza el comando WriteOutput, 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: “
Página 15
# 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"
El comando utilizado para leer información desde la consola es el ReadHost. 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 , 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 .
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"
Como ya habrás comprobado, un script en PowerShell tiene como extensión . 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 16
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.
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.
System.Int32
Entero con signo 32 bits
System.Int64
Entero con signo 64 bits
Página 17
System.String
Cadena unicode
System.Char
Un carácter unicode de 16 bits
System.Byte
Un carácter de 8 bits sin signo
System.Boolean
Booleano, True/False
System.Decimal
Número con decimales de 128bits
System.Single
Número de coma flotante de 32bits
System.Double
Número de coma flotante de 64bits
System.Xml.XmlDocument
Objeto Xml
System.Array
Un array de valores
System.Collections.Hashtable
Un Hashtable
Para obtener el tipo de una variable basta con teclear: $name.GetType()
Y obtendremos las siguientes caracter ís ticas: IsPublic IsSerial Name
BaseType
-------- -------- ----
--------
True
System.Object
True
String
Como todo objeto de .NET heredan del tipo base Object . Si queremos obtener el nombre completo: PS C:\> $name.GetType().FullName System.String
Para realizar el casting, bastará con indicar el valor el tipo al que se desea convertir, 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 18
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
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 variable:"$string1.getType().FullName
The
type
of
this
$string2 = 'This is a string in single quotes'
Página 19
Write-Output "$string2 variable:"$string2.getType().FullName
The
type
of
this
# 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 variable:"$LongMessage.getType().FullName
The
type
of
this
#Date $date = $(Get-Date) Write-Output "$date - The type of this variable:"$date.getType().FullName
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 20
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]
Página 21
#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]"
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 22
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
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
Página 23
# Eugenia Pérez Martínez - [email protected] #> $myXml = [xml] @" Mikel 948-45-67-89 676-38-20-75 Javier 696-48-20-95 "@ <#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 24
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
Se van a detallar los siguientes operadores principalmente;
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 25
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
Página 26
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 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)"
Página 27
#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
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")
Página 28
{ $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 }
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 29
{ 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" } }
Página 30
# 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 31
$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++} }
:loop_label while(condition) { statement block }
: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] #>
Página 32
[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"
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" }
Página 33
# 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] }
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 }
Página 34
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 35
o $total = 0 dir | ForEach-Object {$total += $_.length } Write-Output $total
Cómo en muchos otros lenguajes dentro de lo bucles podemos utilizar dichas sentencias:
: provoca la salida inmediata del bucle. : 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++) {
Página 36
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" } }
Las son una potente herramienta que nos permite hacer búsquedas de texto, comprobar validez de datos. Se puede hacer a mano sin embargo en la mayoría de los
Página 37
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, …
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}
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 38
Las expresiones regulares pueden usar conjuntos, cuantificadores y algunos caracteres especiales.
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.
*: 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
\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 39
"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:
Página 40
"My bike is yellow" -replace 'is (red|blue)','was $1' My bike is yellow
A continuación se adjunta una imagen con una lista de cmdlets, alias y equivalentes en otros shells , de utilidad para esta parte:
Para leer ficheros se utiliza el cmdlet Get-Content. A continuación se exponen los parámetros que admite dicho comando:
Página 41
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 42
$lines | Set-Content temp.txt move temp.txt $file -Force
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
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 43
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
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 l a 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 44
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
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
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 45
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] }
Los ficheros (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.
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 ,):
Página 46
get-process | export-csv processes.csv -Delimiter : $p = import-csv processes.csv -Delimiter :
El cmdlet ConvertTo-HTML permite crear ficheros HTML a partir de: get-eventlog -logname "Windows PowerShell" | convertto-html > pslog.htm
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 }
a) 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] #>
Página 47
# 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 48
$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
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) 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" }
Página 49
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 50
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
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 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
Página 51
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
Página 52
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 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 ______________________________________________________________________________
Página 53
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 archivo de el nombre correcta e
'setIncrement' no se reconoce como nombre de un cmdlet, función, script o programa ejecutable. Compruebe si escribió correctamente o, si incluyó una ruta de acceso, compruebe que dicha ruta es inténtelo de nuevo.
En línea: 1 Carácter: 13 + setIncrement <<<<
4
+ CategoryInfo CommandNotF oundException
: ObjectNotFound: (setIncrement:String) [],
+ FullyQualifiedErrorId : CommandNotFoundException
______________________________________________________________________________ PS C:\Windows\system32> Get-Count 1
Página 54
2 EJERCICIOS: SINTAXIS DEL LENGUAJE Para los ejercicios crea un directorio donde los vayas almacenando y vete numerándolos dentro del mismo.
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).
Realiza el ejercicio anterior, pero pidiendo los datos por pantalla en lugar de inicializando tú las variables.
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.
Realiza una calculadora que muestre la suma, resta, multiplicación, división y módulo de dos operandos que pedirás por pantalla.
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 55
- 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.
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.
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.
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.
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 .
Desarrolla un cmdlet de powershell que defina un array de 10 números inicializados a 0.
Página 56
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.
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. 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 …
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 ('a','b','c','d','$','.','&','0','8','9')
con
los
siguientes
caracteres:
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.
Página 57
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.
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.
Crear : New-Item -Name Nombre_De_Carpeta -Itemtype directory
Eliminar : Remove-Item Nombre_De_Carpeta
Mostrar directorio : Get-ChildItem Nombre_De_Carpeta
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.
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 58
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.
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
Página 59
Crea un
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:
cmdlet de powershell que
nombre_apellido 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:
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:
Página 60
generateName 3 susana
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.
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.
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 61
3 UTILIZAR POWERSHELL ADMINISTRACIÓN
PARA
TAREAS
DE
http://technet.microsoft.com/es-es/library/dd315304.aspx
Página 62
