Sei sulla pagina 1di 100

A. P. PowerShell v.

1
Indice
PowerShell Comandos .NET
Arranque Funciones WMI
Modos de operación Pipeline COM
Proveedores XML
Registro Expresiones Regulares

Scripts Variables Programar Tareas


Tipos Datos EventLogs
Números Errores
Cadenas Rendimiento
Fecha/Hora Acceso remoto
Arrays
Internet
Hash Tables
Reflexión
Operadores
Bucles
Variables
entorno
Invocación
Módulos

A. P. PowerShell v.1 2
Indice
Windows PowerShell (WPS)

Proporciona el mejor entorno posible de shell* y script para Microsoft Windows.


 PowerShell es sobretodo un shell* interactivo, que incorpora capacidades de script.
 PowerShell es un nuevo entorno de consola para Windows basado en .NET.
 En PowerShell todo son objetos, al igual que en .NET en que se basa.
 WPS opera como .NET: llamando a métodos y accediendo a propiedades de clases .NET.
 Acceso a objetos .NET, COM (Component Object Model), y WMI (Windows Management Instrumentation).
 PowerShell acepta comandos estándar de Windows (p.ej. ipconfig o ping) y aplicaciones.
 PowerShell introduce nuevos comandos – cmdlets - más potentes y fáciles de usar.
 Potente interacción entre cmdlets con pipelines, basada en objetos.
 La salida de un cmdlet (objeto .NET), se pasa a otro cmdlet mediante pipeline (|).
 PowerShell soporta arrays y diccionarios.
 Posiblidad de alojar WPS en cualquier aplicación, particularmente en .NET.
 Misma forma de navegación en sistema de ficheros, registro, providers, variables, alias.
 No hay compilación, solo entrar comandos o scripts, y ejecutar.
 Los mismos comandos se usan en el modo interactivo, en los scripts, y en las funciones.
 PowerShell soporta XML como tipo primitivo de datos y facilita su tratamiento.
 WPS dá acceso a Procesos, Servicios, Event logs, Hard, Soft, FileSystem, Registro, ...
 PowerShell usa una sintaxis similar a C#, pero a diferencia de C#, WPS es case-insensitive.
 PowerShell corre VBScripts.
 PowerShell cuenta con la notable funcionalidad del acceso remoto a otros equipos en red.
A. P. * Shell: soft que da acceso a las funcionalidades del sistema operativo. PowerShell v.1 3
Indice
VBScript vs. PowerShell
 VBScript está dirigido a páginas Web,  PowerShell está dirigido sobretodo a
no a administradores. administradores.
 VBScript se compila y por eso las  WPS es interpretado y las funciones
funciones pueden ir al final. deben definirse antes de ser llamadas.
 Hay funciones y subrutinas.  Sólo hay funciones.
 Interactúa con objetos COM.  Interactúa con objetos .NET, WMI, y COM.

Lenguaje IDE Compilado Autónomo

Visual Basic Si Si Si

VBA Si Si No*

VBScript No** Si No***

PowerShell Si**** No***** Si


*) VBA requiere una aplicación host como Microsoft Office, generalmente Excel.
**) Aunque no disponen de IDE, hay editores de script de otros proveedores
***) VBScript requiere una aplicación host como WSH o Internet Explorer
****) En WPS hay un ISE = Integrated Scripting Environment, que es de uso opcional.
****) Aunque WPS es un lenguaje interpretado, algunas partes – los cmdlets - se compilan en DLL.
A. P. PowerShell v.1 4
Indice
PowerShell y .NET Framework
.NET Framework forma el núcleo del moderno lenguaje scripting que es Windows PowerShell.
.NET es un entorno para desarrollo aplicaciones de escritorio, de red, de internet, móviles, y scripts.

PowerShell

cmdlets
WPS hace uso de los
recursos de .NET a
Métodos través de los cmdlets,
Librería de Clases ocultando los detalles
Propiedades .NET de programación.

CLR provee:
Compilación
WMI Seguridad CLR COM
Gestión memoria Common Languague Runtime
Excepciones
Windows Management Component Object Model
Instrumentation
.NET Framework

Ejecución
A. P. PowerShell v.1 5
Indice
Arranque de PowerShell
PowerShell requiere que esté instalado .NET Framework 2.0 ó posterior
Verificar su existencia en C:\Windows\Microsoft.NET\Framework\v.2.0.50727 (o versión superior).

PowerShell formaba ya parte de Windows 7. Con Windows 8  PowerShell v3

Get-Host nos permite ver la versión


y características de PowerShell.
+ R
Al arrancar, WPS crea un proceso, y
todos los comandos corren dentro de él.
+ Ejecutar [En la consola clásica de Windows, ejecutables
.exe corren en procesos separados.]

El shell es
una simple Clear-host
ventana clear
con un
cls
símbolo >, Recupera última entrada, y anteriores,
donde se
al seguir pulsando flecha arriba. Get-History
entran
comandos Recupera todas las entradas hechas
y presentan Recupera siguiente, y siguientes, Invoke-History
resultados. al seguir pulsando flecha abajo. ejecuta una de las entradas por nº

Cuando se lanza PowerShell, se abre en el directorio C:\Users\userName.


Esto asegura que se encuentra en un directorio desde el que se pueden lanzar acciones.
Esta técnica es más segura que abrirlo en el directorio raiz o del sistema.

A. P.
Entrando Start-Process powershell -Verb runAs se entra en modo Administrador.
PowerShell v.1 6
Indice
Graphical Windows PowerShell
Microsoft ofrece a partir de PS v2.0 un interface gráfico para una gestión mejorada de PowerShell
PowerShell v3 tiene 2 componentes: la consola estándar de texto y el entorno integrado ISE.
Panel de scripts arriba,
Ejecutar script
panel consola abajo.

Panel gráfico ISE


[graphical host]

ISE = Integrated Scripting Environment


Panel de consola
[console host]

PowerGui es un editor de scripts gratuito, que


puede usarse como alternativa al IDE propio de PS.

A. P. PowerShell v.1 7
Indice
Perfiles en PowerShell
Al arrancar PS, se cargan automáticamente una serie de ajustes, agrupados en perfiles, que marcan su entorno de uso.
Un perfil en PS es simplemente un script con un nombre especial que reside en una ubicación determinada.
Estos perfiles no se crean de forma predeterminada, ni son obligatorios. Sólo existen si se crean.
$Profile corre automáticamente al arrancar la sesión, y sirve para ejecutar scripts y poner variables al Usuario actual (current user).
El valor de la variable interna $Profile, depende desde donde se llame, pero retorna la vía a Usuario actual, Host actual (PowerShell).
Desde consola PowerShell

Desde consola PowerShell ISE

C:\windows\system32\windowspowershell\v1.0\profile.ps1 Todos usuarios Todos hosts


1
C:\windows\system32\windowspowershell\v1.0\Microsoft.PowerShell_profile.ps1 Todos usuarios PowerShell
2
C:\windows\system32\windowspowershell\v1.0\Microsoft.PowerShellISE_profile.ps1 Todos usuarios PowerShell ISE
ISE

C:\Usuarios\Alfonso\Documentos\WindowsPowerShell\profile.ps1 Usurario actual


3 Todos hosts

C:\Usuarios\Alfonso\Documentos\WindowsPowerShell\Microsoft.PowerShell_profile.ps1 Usurario actual PowerShell


4
C:\Usuarios\Alfonso\Documentos\WindowsPowerShell\Microsoft.PowerShellISE_profile.ps1 Usurario actual PowerShell ISE
ISE
Se usa el perfil general (todos hosts) cuando se quieren aplicar los ajustes a PowerShell al arrancar desde aplicaciones de terceros.
Se usa el perfil PowerShell cuando se desea aplicar los ajustes al arrancar sólo la consola PowerShell. Es recomendable usar con preferencia este perfil.

Hay 6 tipos de perfiles, reflejados en la tabla. Estos ficheros se cargan en el orden 1,2,3,4, siendo posible redefinir la misma función en diferentes ficheros.
Por defecto $Profile hace referencia a Usuario actual, PowerShell (current user, current host).
$home y $pshome son variables internas. $home guarda el directorio del usuario actual y $pshome guarda el directorio de instalación de PowerShell.
A. P. PowerShell v.1 8
Indice
Crear/editar un perfil
PowerShell soporta 4 tipos de ficheros de perfiles y los ejecuta en un orden predeterminado al arrancar.
La variable interna $Profile contiene la ruta y nombre del fichero que contiene el perfil, que por defecto es de Usuario actual, Host actual.

$Profile Segun desde donde se ejecute, dará la ruta y nombre de un fichero u otro

Desde PowerShell
$Profile tiene 4 propiedades:
-AllUsersAllHosts Desde PowerShell ISE
-AllUsersCurrentHost
-CurrentUserAllHosts
-CurrentUserCurrentHost. True Test-Path $Profile Comprueba si existe el fichero $Profile
Por defecto hace referencia a
Current User, Current Host.
False
Es posible acceder a las otras
Crea nuevo fichero $Profile vacio, si no existía.
propiedades mediante
$PROFILE.CurrentUserAllHosts,
New-Item -path $profile -type file -force Parámetro –force fuerza la creación del fichero.
$PROFILE.AllUsersAllHosts,
$PROFILE.AllUsersCurrentHost.
notepad $profile Abre la aplicación NotePad y abre el fichero que contiene $profile

El cmdlet Get-Host devuelve


un objeto que detalla el En NotePad se entra o edita el contenido del
entorno PS. Uno de sus fichero dado por $profile,
miembros es la propiedad UI puede ser uno de los indicados arriba,
que a su vez cuenta con la según se esté en PowerShell o PowerShellISE.
propiedad RawUI que dá las
caracteristicas de la consola.
$Host.UI.RawUI BackgroundColor
La variable interna $host dá Guardar Contiene una serie BufferSize
acceso al objeto Get-Host, y a de propiedades de CursorPosition
sus propiedades UI y RawUI. la consola.
CursorSize
ForegroundColor
Apagar PS KeyAvailable
Hay que distinguir entre el propio motor PowerShell y MaxPhysicalWindowSize
la aplicación –host – que lo aloja. MaxWindowSize
Estas hosts pueden ser la consola o PowerShellISE, que WindowPosition
son responsables de cargar y ejecutar los perfiles cada Iniciar PS
WindowSize
vez que se arranca. Al arrancar PS, aplican las características definidas en $Profile. WindowTitle
A. P. PowerShell v.1 9
Modos de operación Indice

PowerShell es antes que nada una aplicación de consola que opera básicamente en modo interactivo con el usuario
para gestionar la administración de un ordenador local y/o red de ordenadores, que además ofrece las posibilidades
de automatización que brinda su lenguaje de programación para la elaboración de scripts y operar en modo script.

2 modos de operación

Modo interactivo (comando) Modo script


Al arrancar, WPS crea un proceso, y Modo Expresión: Un script WPS es un fichero de texto
todos los comandos corren dentro de él. que incluye cmdlets y elementos del
lenguaje script de PowerShell.
-Cálculo de expresiones
Se guarda como fichero xxx.ps1, y se
-Cmdlets, alias o funciones de WPS
invocan desde la consola WPS.
- Comandos externos o programas .exe
Se procesan números y cadenas
- Comandos de DOS, cmd y Unix
Usar cmdlets en modo interactivo da
- Entrar Modo consola con “cmd” Modo Comando:
gran potencia a WPS, pero el mayor
- Ejecución aislada comandos cmd
partido se saca reutilizando código
con parámetro /c. Ej. cmd/c xxx .
ya probado y guardado en scripts.
Todas las entradas se tratan como cadenas

Al entrar comandos de varias líneas en la Ejecución de programas


consola, WPS solicita nuevas líneas con el Por defecto, no se permite la
carácter >>. ejecución de scripts [en restricted].
Se continúa entrando comandos, y ENTER. Abre el bloc de notas de Windows Debe editarse la “execution policy”.

A. P. PowerShell v.1 10
Indice
WPS y sus objetos
En PowerShell todo son objetos
LIBRERIAS
DE CLASES

WPS se basa en la tecnología .NET de forma cada vez más completa.


La mayoría de objetos que maneja WPS son instancias de clases .NET.
.NET

Clases agrupadas en
namespaces, y éstos
en ensamblados.

Prácticamente todo lo que hay en Windows está representado en una clase WMI.
WMI usa COM para acceder a infraestructura – hard y soft - de sistemas Windows. Adaptador
Es la respuesta de Microsoft al estándar de la industria CIM – Common Information Model. WMI WMI

COM es una tecnología predecesora de .NET.


Adaptador
Aunque todavía disponible, cada vez más de sus funciones son integradas en WPS.
COM
COM

WPS trata de igual forma a todos los objetos, sean propios WPS, de .NET, WMI, o COM.

A. P. PowerShell v.1 11
Indice
Comandos en WPS
cmdlets Cuando se ejecuta un comando, su salida
vuelve al shell en forma de objetos .NET.
funciones Estos objetos.NET se pueden utilizar
usando sus propiedades y métodos.
WPS tiene 4 tipos de comandos: scripts El cmdlet Get-Member permite examinar
Los comandos son fundamentales las propiedades y métodos del objeto
en cualquier lenguaje. Es lo que se Comandos que sale sale del “pipeline”.
teclea para obtener resultados. Win32 PS C:\> 222 | Get-Member

Nombre comando Parámetro sin argumento Parámetro con argumento Argumento posicional

Comando –parametro1 –parametro2 arg1 arg2


El verbo y nombre del comando van separados por un guión (-), los parámetros opcionales van separados por espacios.

Nomenclatura recomendada: Un parámetro es un bloque que Un argumento es un string El parámetro sale de la


Verbo-Nombre comienza con “-” y controla el asociado al comando. posición en el comando.
Verbo = acción a realizar. comportamiento del comando. Sin “” si no tiene espacios. No se necesita su nombre.
Nombre = objeto afectado. Entrecomillardo si tiene espacios.
Nombre siempre en singular. Un parámetro es una variable Un argumento es un valor
Ej. Write-Host aceptable por un comando, script, o Puede usarse comodines, como en asignado a un parámetro.
función. -Get-Process i*

Hay 2 formas de ver los Los switches son parámetros sin valor, que activan determinada
parámetros de un cmdlet: funcionalidad, p.ej. –recurse.
PS C:\> Nombrecmdlet -?
PS C:\> get-help Nombrecmdlet Se puede calcular el valor de un parámetro,
También con con los operandos entre parántesis.
(get-help Nombrecmdlet).parameters Ejemplos:
El paréntesis pide a WPS que -Get-ChildItem (“c:\” + “temp”) //concatenación de cadenas con +.
genere un objeto, del que pedir -Get-ChildItem ($a + $b) // siendo p.ej. $a = “c:\” y $b = “temp”
una propiedad. -Get-Process -id (120+10)
A. P. PowerShell v.1 12
Indice
Cmdlets
Un cmdlet es una instancia de una clase .NET que corre dentro de un proceso PowerShell.
Un cmdlet es una pieza autocontenida de soft que realiza determinada tarea.

Nombre comando Parámetro sin argumento Parámetro con argumento(s) Argumento posicional

Los parámetros son opcionales

Verbo-Nombre [ –parametro1 –parametro2 arg1,arg2 arg3 ]


Los comandos pueden tener varios parámetros diferenciados por sus nombres [Get-ChildItem -Path C:\temp -Filter *.txt].
Si no se indican los nombres de los parámetros, es preciso poner los parámetros en cierta secuencia [Get-ChildItem C:\temp *.txt].

Verbo = acción a realizar. Un parámetro es un bloque que Argumento es un valor asociado El parámetro sale de la
Nombre = objeto afectado. comienza con “-” y controla el al comando. posición en el comando.
comportamiento del comando. Entrecomillar si tiene espacios. No se necesita su nombre.

Parámetros comunes son un conjunto de parámetros que se pueden usar con cualquier cmdlet.
-whatif No se ejecuta el comando, sólo se indica lo que sucedería si se ejecutara
Parámetros comunes

-confirm Hace que el cmdlet pida confirmación antes de ejecutarse


<common parameters>

-verbose Cmdlet dá más detalles que cuando no hay este parámetro


-debug Cmdlet dá información de errores
-erroraction En caso de error: continuar, parar, continuar en silencio, y preguntar
-errorvariable Uso de variable específica para información de error, además de $error estandar.
-outvariable Cmdlet usará una variable específica para guardar información de salida
-outbuffer Retendrá un cierto nº de objetos antes de llamar al siguiente cmdlet en el pipeline.
Get-Process [[-name] <string[]>] [<CommonParameters>]
A. P. PowerShell v.1 13
Indice
Cmdlets destacados I
# Generar nº aleatorio entre 1 – 9.
Get-PSprovider lista los proveedores disponibles de datos.
Get-Random –Minimum 1 -Maximum 9
Get-PSdrive lista los “drives” disponibles como providers.
Get-Random # crea nº aleatorio entre 0 y 1

Get-PSDrive
Info datos accesibles
Mismo resultado con:
$a = New-Object System.Random
$n = $a.Next(1,10) > 1400 cmdlets:
 Get-xxx
 Set-xxx
 Add-xxx
 Enable-xxx
Get-Command xxx.exe
PowerShell muestra la ruta al ejecutable.
La búsqueda sólo se realiza en
 Disable-xxx
 New-xxx
PS> vías incluidas en la variable de  Remove-xxx
PS> [Tab] entorno %Path%.  Write-xxx
PS> [cmdlet] | [cmdlet]  Out-xxx
Get-Member PS> [cmdlet] | More
Get-Command  Import-xxx
Lista comandos disponibles  Export-xxx
Para obtener información sobre métodos y PS> [cmdlet] ; [cmdlet]
propiedades de un objeto: pasar una instancia del Get-Command  Invoke-xxx
PS> …….. ` presenta cmdlets en una pantalla  Register-xxx
mismo, como resultado de un cmdlet, a través del
PS> # comentario Get-Command write-*
pipeline al cmdlet Get-Member:  Select-xxx
cmdlets que empiezan por write-.
Get-PSdrive | Get Member –membertype method  Start-xxx
o directamente pasar el objeto al pipeline:  Stop-xxx
Info sobre comando(s)

$objeto1 | Get-Member  Test-xxx


Alias de Get-Member: gm …
Get-Help

o también usando el parámetro –InputObject


Get-Member –InputObject $objeto2 Get-Help Get-Process
ayuda sobre cmdlet get-process Por defecto WPS,
Get-Process ? toma Get como el
Alternativa a get-help verbo del cmdlet,
Get-Help lista ayudas por cmdlets y por conceptos. Con 3 niveles diferentes: por defecto.
Get-Help about_* #lista ayudas por conceptos. -normal, -detailed, y -full.
A. P. PowerShell v.1 14
Indice
Cmdlets destacados II
El cmdlet Show-Command presenta de forma ForEach-Object realiza una operación con cada
gráfica los parámetros de otro comando. item de una colección de objetos de entrada,
que pueden venir del pipeline o especificados
por el parámetro InputObject.

Con un
bloque de
instrucciones

Pipeline 2 formas de implementar ForEach-Object.

Con una
sentencia de
operación

Entrar la variable que contiene los objetos, o entrar el


comando o expresión que los obtiene.
Al usar el parámetro InputObject con ForEach-Object,
el valor de InputObject se trata como un simple objeto,
InputObject
sin individualiar los objetos de la colección.
Esto favorece usar el pipeline en casos de colecciones.

El cmdlet Show-Command sin parámetros abre una ventana


con un desplegable de los módulos disponibles y una lista
completa de cmdlets, alias, unidades y funciones disponibles
ForEach-Object opera de forma parecida a ForEach,
en cada módulo..
excepto que ForEach no admite entradas del pipeline.

A. P. PowerShell v.1 15
Cmdlets destacados III Indice

El cmdlet Get-Cipboard recupera el contenido El cmdlet Start-Job procede a la ejecución del


del portapapeles. script de una ubicación determinada.

El cmdlet Set-Cipboard pone contenido en el El cmdlet Start-Job procede a la ejecución de un


portapapeles. scriptblock.

El cmdlet Add-Type permite definir una clase .NET en sesión PS


El cmdlet Test-Path chequea ficheros, directorios y elementos
especificando el nombre del ensamblado que contenga la clase.
del Registro, antes de su uso, evitando problemas inesperados.
Con el cmdlet New-Object se pueden instanciar objetos de esa clase,
los cuales pueden hacer uso de sus métodos, propiedades y eventos.

La variable interna $PSVersionTable dá la versión de PS instalada.


El cmdlet Write-Host envia salida a la consola.

Salida de texto a consola con selección de colores de texto y fondo

A. P. PowerShell v.1 16
Indice
Cmdlets destacados IV : Get-Help
Get-Help facilita información sobre comandos como sinopsis, descripción, sintaxis, parámetros, ejemplos, notas, etc.

Para recabar ayuda sobre un cmdlet concreto : PS C:\> Get-Help Write-Host –ShowWindow El parámetro
PS C:\> Get-Help Write-Host –ShowWindow
La información se puede dar –Detailed, –Full o -Examples. visualiza la
PS C:\> Get-Help Write-Host –Full información de
PS C:\> Get-Help Write-Host –Detailed ayuda en ventana.
PS C:\> Get-Help Write-Host –Examples

Para ver los parámetros de un cmdlet:


PS C:\> get-help get-childitem -parameter *

Una prestación interesante es la ayuda Help About_.


Es una amplia ayuda adicional sobre módulos PowerShell
y otros temas conceptuales como sintaxis, cmdlet, etc.
Comienzan siempre como el prefijo about_. Información sobre clases .NET que trabajan con WPS:
PS C:\> Get-Help about_parameters ■ Get-Help System.Management.Automation
PS C:\> Get-Help about_commonparameters
Y sobre temas concretos como
PS C:\> Get-Help about_remote
PS C:\> Get-Help about_remote_requirements
PS C:\> Get-Help about_remote_troubleshooting

Ver todos los temas tratados con about_ con


help about_*

A. P. PowerShell v.1 17
Indice
Los alias
Un alias es la abreviatura de un cmdlet o de un ejecutable, sin parámetros.
Por ejemplo dir es un alias del cmdlet Get-ChildItem. [También los es ls del mundo Unix].

Alias predefinidos Definición


Crear nuevo Alias
[gh para Get-Help] Copy, CP Copy-Item
Dir, ls Get-ChildItem
Listado de Alias existentes Move Move-Item
Get-Alias | sort Rm, rmdir, erase, del ,rd Remove-Item
Chdir, Cd Set-Location
Si
¿Existe ya el Alias ? Cat, type Get-Content
gh Where Where-Object
No Select Select-Object
Crear nuevo Alias gh Sort Sort-Object
Set-Alias gh Get-Help ft, fl, fw Format table, list, wide

Un mismo cmdlet puede tener varios alias, provenientes


de Windows y Unix.
No
¿Verificar nuevo Alias ?
Get-Alias gh Get-Alias lista unos 100 alias predefinidos, que
provienen de cmd.exe y/o Unix.
Set-Alias crea la nueva asociación de alias con su
Si cmdlet, p. ej. gh con Get-Help.
Get-Alias gh confirma que existe el alias gh.
Estos alias se pierden al cerrar la sesión PS.
Pueden usarse Export-Alias e Import-Alias para exportar e importar alias respectivamente.
A. P. PowerShell v.1 18
Indice
Funciones/Filtros en PowerShell
Función: bloque de código con nombre, que acepta y ejecuta comandos, y puede devolver valores.
Son como los alias pero más potentes y flexibles ya que aceptan parámetros (los alias no).
Las funciones se alojan y operan en scripts, y desaparecen al salir del script que las aloja.
SCOPE (ámbito) válidos: Las funciones existen en ámbito en que se crean. Nombre : debe comenzar con una letra y puede contener
- Global la función es accesible a todo el shell, cualquier secuencia de caracteres, guiones o subrayado.
- Script función sólo accesible al script actual, Recomendable: Verbo-Nombre como los cmdlets.
- Local función accesible al ámbito actual y subámbitos.
Por defecto local, que sigue iguales reglas que las variables.

Function/Filter SCOPE: <nombre> (<parámetro1, parámetro2, parámetro3>)


{
Las sentencias de la función se Funciones (y Filtros) , se componen de 4 partes:
<cuerpo de la función> colocan en líneas separadas, nombre, parámetros, cuerpo de la función y retorno.
(return) o bien separadas por ;. Sólo el nombre y el cuerpo son necesarios.
}
La función puede ser tan simple como
Function Nombre-Funcion { comandos }
o puede usar parámetros, p.ej. en este caso parámetro posicional
Scripts
Un Filtro es un tipo de En los scripts WPS, las funciones
función que se ejecuta en deben definirse antes de su uso.
La función se puede definir en la consola de WPS o en un script. cada objeto del pipeline.
Es lo contrario que en VBScript.

Se llama a la función por su nombre, en este caso, con parámetro posiconal,


representado por la variable array $args.

Si una función se usa a menudo, conviene definirla con ámbito Global. Así, la función está disponible no sólo en la consola WPS, sino también para
cualquier script que se ejecute desde la consola. Hay 3 opciones para definir un ámbito (scope) Global:
✓ Manualmente: se define manualmente la función en la consola WPS.
✓ Perfil script: se coloca el código de la función en el perfil script para que cada vez que se abra WPS se cargue automaticamente.
✓ Dot-sourcing: se coloca el código de la función en un script y se invoca con (.).
En dot-sourcing se guarda el código en un script tal como C:\temp\test.ps1. Luego se ejecuta .c:\temp\test.ps1,
y el script corre en ámbito Global, que significa que cualquier variable o función definida en él persistirá todo lo que dure el shell.
A. P. PowerShell v.1 19
Indice
Parámetros de cmdlets y funciones
PowerShell trata a los parámetros de cmdlets de la misma forma que a los parámetros de funciones.
Cmdlet [ –parametro1 –parametro2 arg1,arg2 arg3 ] Function nombre (parámetro1, parámetro2) {...código funcion...}

Todos los cmdlets tienen parámetros, identificados por sus nombres. Function Ver-Raiz ($base) { $raiz= [Math]::Sqrt($base) ; Write $raiz}
En caso de no indicar los nombres, se toma un orden predefinido.
Get-ChildItem C:\temp *.doc # se dan 2 parámetros en su orden predefinido
Dá lo mismo que
Get-ChildItem -Path C:\temp -Filter *.doc # nombres identifican parametros El parámetro(s) puede ir dentro de la llave general, separados por comas, y entre paréntesis.

Function Ver-Raiz {Param($base) $raiz= [Math]::Sqrt($base) ; Write $raiz}


Get-ChildItem c:\temp
Get-ChildItem lista todas las ramas desde el objeto dado.
Los parámetros se tratan como cadenas aunque no lleven entrecomillado,
que es opcional. Son necesarias si hay algún espacio dentro del propio
parámetro, ya que los espacios se toman como delimitadores. Function Ver-Raiz {Param($b1,$b2) $r1= [Math]::Sqrt($b1) ; Write $r1 ;
$r2 = [Math]::Sqrt($b2);write $r2}
Hay parámetros sin valor. Usando su nombre se activa la función.
Remove-Item c:\temp\dir5 –recurse # directorios y subdirectorios

Ciertos cmdlets admiten comodín en sus parámetros:


Get-Command get* Parametro predefinido por defecto
Function Ver-Raiz($base = “100”) { $raiz = [Math]::Sqrt($base) ; Write $raiz }
Para conocer los parámetros que soporta un cmdlet determinado: Al llamar la función sin parámetro, se toma su valor por defecto (100).
PS C:\> get-help Get-ChildItem –parameter *
PS C:\> (get-help Get-ChildItem).parameters

Se puede hacer un cálculo en los parámetros. Ejemplos:


Get-Process -id (100+200) # realiza cálculo 100+200
VALIDACIONES Get-Process –id($a+$b) # combinando variables

Las mismas reglas de validación de parámetros son aplicables a los parámetros de cmdlets que a los de funciones.
Actúan como un filtrado que restringe los valores de parámetros entrados. Aplicables también a valores de variables.
Function Ver-Raiz([ValidateRange(0,200)]$base) { .....} #restringe los valores de entrada del parámetro entre 0 ...200.

A. P. PowerShell v.1 20
Indice
Funciones Avanzadas - Advanced Functions
Advanced Functions brindan una forma de escribir funciones propias que se comportan como cmdlets.
#REQUIERE WPS version 2.0 o superior
Function Ver-NombreMayusculas
{ La primera sección, entre <# y #>, contiene información para el cmdlet de ayuda Get-Help.
<#
.Synopsis
Escribe nombre entrado por consola
.Description
Función de prueba de Advanced Functions
.Parameter out
String
.Example
PS> Ver-Nombre “¡Muestra nombre!”
.Link
about_functions
about_functions_advanced
about_functions_advanced_methods
about_functions_advanced_parameters
.Notes
Autor: A.P.
#>
[CmdletBinding()] Ejemplo
Param Lo que distingue a una función avanzada es CmdletBinding, que permite
( la asignación de atributos, si bien en la mayoría de casos se usan sin ellos:
[Parameter(mandatory=$true)]
[ValidateLength(1,10)]
[CmdletBinding()]
[String]$Nombre
)
Se definen los parámetros y atributos que tendrá la función:
Begin { [Parameter(mandatory=$true)] # parámetro obligatorio,
} [ValidateLength(1,10)] #validación : longitudes entre 1 y 10 caracteres.
Process { [String]$Nombre #nombre del parámetro, del tipo string.
Write-Host $Nombre.ToUpper()
} Cada función define 3 métodos que determinan su operatividad:
End {  Begin{}: Se llama una sóla vez en cada instancia.
}  Process{}: Se llama una vez por cada entrada para su procesamiento.
}  End{}: Se llama una sóla vez al terminar.
Esta es la forma de definir una función personalizada
que se comporta como un cmdlet en PowerShell.
A. P. PowerShell v.1 21
Indice
Atributos de parámetros
Los parámetros aceptan atributos que regulan su comportamiento y validan entradas recibidas.

Atributo Significado Validación Significado


Mandatory = $true Obligatorio [Alias(" name ")] Nombre alternativo

Position = position Posición cuando hay [AllowNull()] Permite recibir valor $null (*)
varios parámetros.
[AllowEmptyString()] Permite recibir cadena vacia (*)
ParameterSetName = name Define el parámetro
como perteneciente a [AllowEmptyCollection()] Permite recibir colección vacia (*)
un conjunto de otros
parámetros [ValidateCount(limite inferior, limite superior)] Restringe nº elementos en colección
relacionados.
[ValidateLength(limite inferior, limite superior)] Restringe longitud de cadena
ValueFromPipeline = $true Admite valor desde entrada para este parámetro
pipeline
[ValidatePattern("regular expression ")] Fuerza que la entrada responda a un
ValueFromPipelineByPropertyName = $true Acepta entrada de patrón especificado
pipeline si propiedad
del objeto coincide [ValidateRange(limite inferior, limite superior)] Restringe a valores mínimo y
con el nombre. máximo una entrada numérica

Acepta todas las [ValidateScript( { script block } )] La entrada debe cumplir la condición
ValueFromRemainingArguments = $true
entradas que no han que aparece en el bloque script.
sido asignadas a La entrada debe coincidir con uno
[ValidateSet(“Op1",”Op2”, ..., “Opn")]
parámetros por de los valores dados
posición o nombre.
Sólo un parámetro [ValidateNotNull()] La entrada no puede ser null.
puede tener este
atributo. [ValidateNotNullOrEmpty()] La entrada no es ni null ni vacia.

(*) Requerido sólo para parámetros obligarorios. Si no se especifica, los parámetros


obligatorios no pueden recibir un valor $null, una cadena vacia o una colección vacia,
aunque sí otros parámetros opcionales.

[Parameter(mandatory=$true, ValueFromPipeline=$true)] Function Ver-Raiz([ValidateRange(0,200)]$base) {


[ValidateLength(3,10)] $raiz = [Math]::Sqrt($base)
[String]$Nombre Write-Host $raiz
}
A. P. PowerShell v.1 22
Indice
Pipeline [canalización de datos]
Pipeline es cuando la salida de un comando se aplica como entrada a otro comando.
Un pipeline es una serie de comandos separados por el operador “|”.
Windows PowerShell pasa objetos .NET entre los comandos, no pasa texto.
El comando receptor, puede usar los métodos y propiedades del objeto pasado.
WPS ofrece cmdlets para manipular dichos objetos como filtros, ordenaciones, cálculos, etc.
Cmdlet Where-Object – alias Where –filtra La salida de los cmdlets es siempre un objeto, no texto.
objetos pasados con expresion dentro {…}.

Pipeline
cmdlet1 cmdlet2 cmdlet3
2 3 1 3

Get-Process | Where-Object {$_.Id -lt 499} | Format-Table -property Name,Id


Pipeline Pipeline

Al llamar a comandos individuales, se $_ es una variable objeto creada Format-Table presenta columnas de interés.
crea un nuevo pipeline por cada uno. automáticamente por defecto por WPS. Sin -property, igual salida que Out-Default.
Cada comando corre en un pipeline Viene a significar “este objeto”. Format-List, alternativa de presentación.
propio, al ser llamado desde consola. (Arriba, su propiedad .Id se compara con 499). Group-Object agrupa por valores de propiedad(es)
Dentro de un script, los comandos
Select-Object es un modo más genérico Otros comandos útiles con Pipelines:
corren en un unico pipeline.
de obtener propiedades del pipeline. ■ Sort-Object para clasificar
■ Measure-Object para suma, media, max y min.
La salida del pipeline es Out-Default Foreach-Object recorre elementos de
que pasa el objeto a Out-Host para su una colección ejecutando código en {…}
formateado y salida a consola. sobre cada elemento. Nº de comdlets en un pipeline es ilimitado.

Unix y DOS ya tenían pipelines, la salida de un comando a otro era texto, y no objetos .NET, como ahora en WPS
A. P. PowerShell v.1 23
Indice
Cmdlets relacionados con Pipeline
Where-Object filtra objetos cuya Select-Object tras –Property van Sort-Object tras –Property van las
propiedad responde a valores dados. los valores que se desea visualizar. propiedades según las cuales clasificar.
Alias where o el simbolo ?- Alias select.
- Sólo se puede realizar 1 comparación.

Pipeline Pipeline

Get-Process | Where-Object {$_.Id –lt 499} | Select-Object –Property Id | Sort-Object –Property Id


Selecciona los objetos cuyo Id < 499. Selecciona por ja propiedad Id. Ordena por la propiedad Id.

| Measure-Object id | Measure-Object id -maximum | Measure-Object id -minimum | Measure-Object id -average

Similar resultado con

Measure-Object realiza cálculos sobre la propiedad indicada con los objetos en el pipeline (número, media, suma, máximo, mínimo).

A. P. PowerShell v.1 24
Indice
Pipeline salidas
Los cmdlet no crean salida, sólo ponen objetos en el pipeline. Cmdlets especializados crean las salidas.
cmdlet1 cmdlet2

Get-ChildItem c:\temp2 *.txt | Format-Table name, length


Pipeline Pipeline

Salida estándar de WPS (DotNetTypes.Format.ps1xml).

Misma que Out-Default pero con salida opcional de ancho de página

No se produce salida

Se puede especificar a que impresora

Se puede especificar a que fichero


-property Especifica que propiedades aparecen en la salida
Format-List

A la vista de las propiedades disponibles, se pueden elegir las que


interese que aparezcan en Format-List, Format-Table y Format-Wide.

Format-Table -property

-property
Format-Wide

A. P. PowerShell v.1 25
Indice
Pipeline - Ramificaciones
El cmdlet Tee-Object permite hacer una ramificación hacia otro depósito de datos, sin dejar de pasar
el objeto al siguiente cmdlet en el pipeline.
Tee-Object pasa el contenido al siguiente cmdlet en el pipeline, y también, en paralelo, a una variable o un fichero.

La salida del pipeline


se guarda en variable $p. RAMIFICACIONES La salida del pipeline se guarda en fichero dado.
(Aqui no se necesita símbolo $)

Get-Process | Tee-Object –var p | Where-Object {$_.Id -lt 9} | Tee-Object –filepath c:\temp\p.txt

Pipeline Pipeline

Se puede volcar el contenido del pipeline en variables.


Es posible examinar la salida que tendrá el pipeline, Las variables van precedidas por un signo dolar ($).
asignando su salida a una variable.

$y = Get-Process| Where-Object {$_.Id -lt 9}

A. P. PowerShell v.1 26
Indice
Proveedores (Providers)
PowerShell ofrece un conjunto coherente de cmdlets para recorrer y navegar
diferentes estructuras de datos – Providers - como el sistema de ficheros, el registro,
las funciones, las variables, Active Directory, o WMI (Windows Management Interface).
Get-PsProvider lista los proveedores de datos - providers - disponibles en WPS.
Provider Datos
Alias Aliases en PowerShell
Certificate Certificados de firmas digitales
Environment Variables de entorno Windows

FileSystem Discos, directorios, ficheros

Function Funciones WPS


Registry Registro de Windows

Variable Variables de WPS

WSMan Web Services for Management

Cada proveedor soporta navegar en sus datos de


forma similar a como se hace en el sistema de
ficheros tradicional de Windows.

Los “drives” son estructuras de datos que expone WPS. Un proveedor actúa como un interface entre
Se obtienen con: get-psdrive. PowerShell y la fuente interna de datos.
Cada proveedor - provider - esta asociado a un drive.
Get-PSDrive lista los drives fisicos existente C, D, .., y además las variables
de entorno (env), el registro (HKCU, HKLM), Windows certificate store
(Cert), Alias, variables en Variable y funciones en Function.
A. P. PowerShell v.1 27
Indice
Navegación de datos
WPS tiene un único modelo de navegación en las distintas fuentes de datos (providers).

Cmdlet Alias Descripción


Get-ChildItem dir, ls Lista ramas a partir de ese punto
Get-Cwd cd, pwd Cambio de ubicación
Get-Content type, cat Muestra contenido de elemento
New-Item mkdir Crea una nueva rama
Get-Location gl Muestra directorio actual
Set-Location cd Cambia a ubicación

Las rutas en WPS admiten los siguientes símbolos: Las rutas pueden ser relativas o absolutas.
Las rutas relativas dependen del directorio actual.
■ .\ representa al directorio actual  cd .
.\test.txt se refiere al fichero test.txt en directorio acutal.
■ ..\ representan al directorio padre del actual  cd .. ..\test.txt se refiere al fichero test.txt en directorio padre.
■ \ representa al directorio raiz  cd \ Las rutas absolutas son independientes del directorio actual.
WPS convierte automaticamente las rutas relativas en absolutas.
■ ˜\ representa directorio inicial del “provider”  cd ~
Esto mismo se consigue con el cmdlet Resolve-Path.

A. P. PowerShell v.1 28
Indice
Sistema de Ficheros I
Directorios y Ficheros admiten como acciones: crear, borrar, copiar, mover y renombrar.
Los cmdlet Get-ChildItem y Get-Item dan los directorios y ficheros ya existentes a partir de un determinado punto.
Se pueden crear nuevos directorios y ficheros, renombrarlos, llenarlos con contenido, copiarlos, moverlos y borrarlos.

La ruta actual la dá el propio prompt de PowerShell.


Get-Location devuelve la ruta actual como string.
Set-Location, alias CD, cambia al directorio deseado.
C:\ Sistema Ficheros

PS C:\temp > temp

Directorios dir1 dir2 dir3

Ficheros

f11 f21 f31 f32


f12

Mismos cmdlets para manejar directorios y ficheros.


A. P. PowerShell v.1 29
Indice
Sistema de Ficheros II
Directorios y Ficheros admiten como acciones: crear, borrar, copiar, mover y renombrar.
Los cmdlet Get-ChildItem y Get-Item dan los directorios y ficheros ya existentes a partir de un determinado punto.
Se pueden crear nuevos directorios y ficheros, renombrarlos, llenarlos con contenido, copiarlos, moverlos y borrarlos.
La ruta actual la dá el propio prompt de PowerShell.
Get-Location devuelve la ruta actual como string.
Set-Location c:\temp, alias CD, cambia al directorio dado.

C:\ Sistema Ficheros

PS C:\temp > temp Set-Location, alias CD, cambia al directorio deseado.

MD C:\temp\dir1 crea nuevo directorio dir1.


MKDir C:\temp\dir2 alternativa para crear dir2
MKDir C:\temp\dir2 alternativa para crear dir3.

Directorios
¡No hay cmdlet para crear directorios, si para borrarlos, etc!.
dir1 dir2 dir3
Copy-Item C:\temp\dir3 C:\temp\dir4, copia directorio
Move-Item C:\temp\dir3 C:\temp\dir5, mueve directorio
Rename-Item C:\temp\dir5 C:\temp\dir3, renombra directorio
Remove-item C:\temp\dir4, borra directorio con confirmación
Ficheros Remove-item C:\temp\dir4 -recurse, borra directorio sin más.

New-Item C:\dir1\f11.txt crea nuevo fichero


Copy-Item C:\temp\dir3\f31.txt C:\temp\dir3\f32.txt
Move-Item C:\temp\dir3\f31.txt C:\temp\dir4\f33.txt
f11 f21 f31 f32 Rename-Item C:\temp\dir3\f33.txt C:\temp\dir3/f32.txt
f12
Remove-item C:\temp\dir3\f31.txt, borra fichero con confirmación

Mismos cmdlets para manejar directorios y ficheros. - recurse borra directorios sin pedir confirmación de borrado.
A. P. PowerShell v.1 30
Indice
Lectura de ficheros
El cmdlet Get-Content sirve para leer ficheros de texto .
Se usa como parámetro el nombre del fichero a leer.
Líneas leidas se guardan en array $a.
$a = Get-Content C:\temp\test.txt

$a = Get-Content C:\temp\test.txt -totalCount 5 Lee 5 lineas

Get-Content
lee el contenido
Uso de Get-Content y el pipeline para
de un fichero
obtener el nº de líneas, palabras o
línea a línea, y caracteres de fichero
pasa cada
línea de texto
al pipeline,
como objeto.

Get-Content lee el contenido de cualquier fichero, no sólo de texto.


También lee otros tipos de ficheros, p. ej. binarios, pero especificando a través
del parámetro –Encoding el tipo de que se trata.
A. P. PowerShell v.1 31
Indice
Escritura en ficheros
Set-Content –Path C:\temp\test.txt -Value “Prueba de contenido”
Escritura en fichero con cmdlet Set-Content con parámetros –Path : ruta a fichero, y –Value : texto a escribir.

Set-Content C:\temp\test.txt “Prueba de contenido”


Escritura en fichero con cmdlet Set-Content del texto entrado como parámetro, en el fichero dado.
Set-Content borra el contenido previo del fichero, si lo hubiera, para escribir el texto dado.

Add-Content C:\temp\test.txt “Otra linea de contenido”


Añade el texto entrado como parámetro al fichero indicado.

Get-ChildItem C:\windows\system32 > C:\temp\contenido.txt


Uso del símbolo “>” de redirecionamiento a fichero de la salida de Get-ChildItem.
Get-ChildItem C:\windows\system32 | Out-File C:\temp\contenido.txt
Aquí se usa el el pipeline y el cmdlet Out-File para redireccionar a fichero la salida de Get-ChildItem.
Parámetro Significado Ejemplo
Parámetros de Out-File

-encoding Codificación de caracteres utilizada: Unicode, UTF7, UTF8, UTF32, Out-File c:\test.txt -encoding ASCII
ASCII, BigEndianUnicode, Default, o OEM. Por defecto : Unicode.
-append Añade datos al fichero, en lugar de sobreescribir. Out-File c:\ test.txt -append .txt
-width Define máximo nº de caracters en cada línea. Out-File c:\test.txt –width 150 .csv
Si la línea que se escribe, tiene más , se trunca. .xml
Por defecto se usa el ajuste de consola PS. .html
-force Fuerza escritura, por encima de restricciones como sólo lectura, Out-File c:\test.txt -force
pero no modifica permisos de seguridad.
-noClobber Impide que Out-File escriba en fichero existente Out-File c:\test.txt -noClobber
-confirm Pide confirmación antes de continuar Out-File c:\test.txt -confirm
Posibilidades adicionales que brinda el redireccionamiento con “>” y el uso del cmdlet Out-File.

Get-ChildItem C:\windows\system32 | Set-Content C:\temp\contenido.txt


Set-Content no dispone de los mismos parámetros que Out-File. No tiene –append, hay que usar Add-Content.
A. P. PowerShell v.1 32
Indice
Registro de Windows – General I
Estructura del Registro
El Registro guarda valores de configuración para el sistema operativo, aplicaciones, usuarios, y hardware.
El Registro guarda claves y valores que se agrupan bajo una determinada clave-raiz genérica.
Con scripts, se cambia el valor de claves existentes, o se asigna valores a claves de nueva creación.
La tabla muestra el nombre corto bajo el cual se hace referencia a la clave raiz en un script.
Las claves con nombres cortos son las más usadas.

Nombre corto Nombre completo Descripción


WPS HKCU HKEY_CURRENT_USER Información sobre el usuario que inició la sesión

WPS HKLM HKEY_LOCAL_MACHINE Ajustes generales del PC, hard y soft, comunes a todos los usuarios.

HKCR HKEY_CLASSES_ROOT Ajustes de configuración para aplicaciones y ficheros.


Extensiones de archivos, que se abren con su aplicación asociada.

HKU HKEY_USERS Guarda ajustes de usuario por defecto y otros usuarios.

HKCC HKEY_CURRENT_CONFIG Información sobre el perfil de hardware en uso.

El registro está organizado en 5 niveles de claves, similares a carpetas, que guardan otras claves y valores.
Una clave o subclave puede tener ninguno o varios valores, un valor por defecto y ninguna o varias subclaves.
Los valores son análogos a ficheros. Los datos en el registro se guardan dentro de valores.
De las 5 claves del registro, PowerShell dá acceso, por defecto, a 2 de ellas : HKCU y HKLM.
Para acceder a otras claves, habría que declararlas como nuevos proveedores –PSProvider- de PowerShell.
new-psdrive –name hkcr –psprovider registry –root hkey_classes_root
new-psdrive –name hku –psprovider registry –root hkey_users
new-psdrive –name hkcc –psprovider registry –root hkey_current_config
Ahora ya se podría acceder directamente a estas nuevas claves.

A. P. PowerShell v.1 33
Indice
Registro de Windows – General II
El Registro almacena valores de configuración para el sistema operativo, aplicaciones y usuarios.
Windows cuenta con la aplicación regedit.exe Valores : Tipos
en el directorio C:\Windows que sirve para Por defecto como cadenas, tipo REG_SZ, pero pueden ser:
acceder y editar datos del Registro. ■ REG_BINARY: Valores binarios, mostrados en hexadecimal.
Se accede desde Inicio EjecutarRegedit ■ REG_SZ: Secuencia de caracteres o cadena.
■ REG_DWORD: Un único número en hexadecimal o decimal.
Los cambios en el Registro son permanentes. ■ REG_MULTI_SZ: Cadena que puede tener varias líneas.
Verificar cuidadosamente antes de realizarlos. ■ REG_EXPAND_SZ: Texto, para rutas o variables de entorno.
Cada clave o subclave tiene un valor asociado con ella, el cual tiene 3 componentes: nombre, tipo, y datos.

El Registro es la base de datos


de configuración de Windows.

Una clave puede tener varios valores

A. P. PowerShell v.1 34
Indice
Acceso al Registro con WPS
PowerShell tiene el proveedor Registro, para acceder y manipular el registro en la máquina local.
Directorios accesibles del Registro: HKEY_LOCAL_MACHINE (HKLM) y HKEY_CURRENT_USER (HKCU).
Estos directorios están representados por 2 objetos PSDrive, llamados HKLM: y HKCU: .

Mismos comandos de navegación para el Registro que para p. ej. el Sistema de Ficheros

Get-ChildItem hklm:\software
Da las subclaves de una clave

Get-Item hklm:\software\Microsoft\PowerShell
Accede a una clave

New-Item –path hklm:\software –name ….


Crea una nueva clave

Copy-Item hklm:\software\... hklm\software\...


Copia claves
Los cambios en el Registro son permanentes.
Remove-Item hklm:\software\... -recurse ¡¡Verficar cuidadosamente antes de realizarlos!!
Borra una clave y sus valores

A. P. PowerShell v.1 35
Indice
Acceso al Registro con WPS
HKEY_CURRENT_USER HKCU – guarda información sobre el usuario actual
HKEY_LOCAL_MACHINE HKLM – guarda ajustes generales del ordenador

Comando Alias Descripción Los cambios en el Registro son


HKCU Drives pedefinidos del registro inmediatos y permanentes, y
HKLM
pueden tener consecuencias
Get-ChildItem dir Lista el contenido de una clave
graves e inesperadas sobre
Set-Location cd Cambia el directorio actual (clave) Windows y todo el sistema.
Get-ItemProperty Lee el valor de una clave
¡¡Verificar cuidadosamente
antes de realizarlos!!.
Set-ItemProperty Modifica el valor de una clave Es conveniente hacer copias de
New-ItemProperty Crea un nuevo valor para una clave seguridad antes de los cambios.
Clear-ItemProperty Borra el contenido de una clave

Remove-ItemProperty Borra el valor de una clave

New-Item md Crea una clave nueva

Copy-Item Copia una clave en otra

Remove-Item Borra una clave

Test-Path Verifica si existe una clave

A. P. PowerShell v.1 36
Indice
Unidades de datos [drives]
Una unidad – drive - es una ubicación de almacenamiento de datos a la que se puede acceder en PowerShell.
Los Providers de PS crean algunas unidades automáticamente, como las unidades de sistema de archivos (C: y D:),
y las unidades de Registro (HKCU: y HKLM:).
También se crean unidades propias de PS. Estas unidades son muy útiles, pero estan disponibles sólo en PS.
No se puede tener acceso a ellas con otras herramientas de Windows, como el Explorador de Archivos o cmd.exe.
PowerShell usa el término PSDrive en los comandos que funcionan con las unidades de PowerShell.
El cmdlet Get-PSDrive lista las unidades de PowerShell en su sesión de PowerShell.
PowerShell crea nuevos drives con el cmdlet New-PSDrive.
Y no solo drives de red, sino también como fáciles accesos La referencia a la nueva unidad de PowerShell se hace como
a importantes ubicaciones en el sistema de ficheros u otros. con cualquier otra unidad de PowerShell; es decir, por su
New-PSDrive -name cx -PSprovider FileSystem –root c:\temp1 nombre seguido de dos puntos (:). Ej. cx:.

El cmdlet New-PsDrive agrega la nueva unidad solo en la sesión


actual de WPS. Al cerrar WPS, la nueva unidad se perderá.

Para eliminar una unidad específica de Windows PowerShell, basta


con dar el nombre de la unidad al cmdlet
Remove-PSDrive -Name cx

A. P. PowerShell v.1 37
Indice
Entrada de datos
1 Desde la propia consola con read-host.
La salida se coloca en el pipeline [canal].
$n = read-host “Entrar Nombre” se guarda en variable $n.

2 Aceptar

Desde ventana externa

Cancelar

3
La lectura se guarda en variable $a como un array. Desde ficheros

Mediante módulos,
que se guardan con .psm1,
se recorren los scripts.

A. P. PowerShell v.1 38
Salida de datos Indice

La salida de WPS puede ser cualquier objeto .NET cuyo ensamblado esté cargado en PowerShell.
Los datos de salida pueden ser dirigidos a una variable, a un fichero, a otro comando (via pipeline) o a la consola.
Por defecto, son enviados a la consola (host).

1 Asignación de valor a variable


y salida por consola.

Salida por consola


Las salidas de comandos
Uso de cmdlet write-host. se pasan por defecto a
Salida directa a consola.
Salida a consola Out-Default que a su vez
Uso del alias de write-host (host) se las pasa a Out-Host
para su presentación en
Uso de cmdlet write-output.
Salida a pipeline que pasa a out-host.
consola, por defecto.

Uso de cmdlet out-host

Variable fundida con cadena


entre comillas dobles.

2
A ficheros .txt, .csv, .xml, .html

Salida a fichero
[Append]

[, como separador]
Registro de
Windows

A. P. PowerShell v.1 39
Indice
Mas salidas de datos
PowerShell genera salidas de otras formas, que no pasan por el pipeline.
Lo peculiar de estas salidas es que pueden ser suprimidas.
Cada uno de estas salidas alternativas cuenta con una variable de configuración incorporada.
Cuando la variable se pone en Continue, los comandos producen una salida.
Cuando la variable se pone en SilentlyContinue, no se produce ninguna salida.

Cmdlet Objeto Variable de configuración


Write- Presenta mensaje de aviso en marrón precedido de $WarningPreference
Warning etiqueta “ADVERTENCIA”. (Continue por defecto)

Write- Presenta mensaje informativo en azul, precedido de $VerbosePreference


Verbose etiqueta “DETALLADO”. (SilentlyContinue por defecto)

Write-Debug Presenta mensaje de eliminación de error en amarillo, $DebugPreference


precedido de “DEPURAR:” (SilentlyContinue por defecto)

Write-Error Genera mensaje de error en la lista de errores. $ErrorActionPreference


(Continue por defecto)

A. P. PowerShell v.1 40
Formatos de salida Indice

3 son los cmdlets de WPS para el formateado de salidas: Format-List, Format-Table y Format-Wide.
-property Las propiedades que aparecen en la salida se
Format-List pueden obtener mediante

A la vista de las propiedades disponibles, se pueden elegir


las que interese que aparezcan en los listados, tanto de
Format-List como de Format-Table y Format-Wide.

-property
Format-Table Format-Wide Limita la salida a una sola propiedad por objeto.

Se puede usar el parámetro de columnas:


PS C:\> Get-Process | Format-Wide -Column 3
O usar el parámetro Autosize:
PS C:\> Get-Process | Format-Wide -AutoSize

Personalización del formato de salida con @{ }

Se asigna a la variable $a, mediante @{ ... },


Expresiones separadas por comas,
que incluyen la variable a presentar, su nombre,
y opcionalmente el ancho (width) de la columna.
Se pueden hacer operaciones dentro de los bloques. En el comando de salida se da como parámetro
En la 2ª línea se redondea a GB el valor de la memoria obtenida. la variable definida $a al cmdlet format-table.
Solo 2 campos de
salida, reflejados en
las Expression.

A. P. PowerShell v.1 41
Indice
PowerShell Script Language – scripts y scriptblocks
Además de los cmdlets, WPS ofrece un lenguaje propio de scripting para crear secuencias de comandos.
El lenguaje incluye variables, arrays, comandos, funciones, bucles, y tratamiento de errores.
Microsoft reconoce la influencia de Unix, PERL, PHP, Python y C# en la creación del lenguaje de WPS.
WPS hace uso de corchetes { }, y punto y coma ; , aunque éstos no se necesitan como separadores de líneas.

Un script - secuencia de comandos - se guarda en un fichero con extensión .ps1, y se ejecuta posteriormente.
La principal diferencia con los comandos del shell es que los scripts se guardan en disco, y por tanto no se borran al abandonar la sesión WPS.

Cada línea en un script es un comando.


Un comando puede consistir de varios cmdlets separados por un símbolo (|).
Se pueden colocal varios comandos en una línea, pero separados por punto y coma (;).
Se puede colocar punto y coma al final de cada línea como en C#, pero no es obligatorio.
Si un comando ocupa varias líneas, un apóstrofe (`) al final de la 1ª línea indica que la siguiente línea debe añadirse al comando.
Get-childitem c:\temp | `
Write-host
Los comentarios empiezan con simbolo #:
# Esto es un comentario

Scriptblocks
PowerShell soporta bloques de scripts que actúan exactamente igual que las funciones sin nombre y los scripts.
$scriptblock1 = { bloque de sentencias }
Como las funciones y los scripts, los bloques se pueden invocar :
- directamente & { “bloque sentencias"}
- Invocando la variable que lo define & $scriptblock1.

A. P. PowerShell v.1 42
Símbolos en PowerShell Indice

WPS hace un uso especial de ciertos simbolos y notaciones.


Simbolo Significado
$ Precede a nombre de variable
“ “ - Enmarca una cadena o expresión a evaluar
‘ ‘ - Enmarca un literal
# Introduce un comentario monolínea. Multilínea entre ># ……<#.
- - Separador entre Verbo-Nombre en cmdlets
- Identificador de que sigue parámetro con/sin argumentos
( ) - Encierra condición a verificar en operadores condicionales. La operación entre () se ejecuta antes que otras.
< > - Encierra parámetros o argumentos requeridos
- Apertura / cierre de elementos XML
[ ] - Encierran parámetros opcionales. En arrays delimitan el nº del elemento.
- Encierran el nombre de una clase cuando se van a usar sus propiedades o métodos.
:: - Tras clase, denota que sigue método o propiedad. Ej. [nombreclase]::método.
{ } - Encierra bloque de código, en operadores condicionales, claúsulas Where, filtros, etc.
` - (Backstick) Al final de una línea, indica línea incompleta, el comando sigue en la línea siguiente.
`t # TAB - Si precede a carácter de variable, significa pasarla sin modificación ni proceso.
`n # LF - Actúa como carácter de escape dentro de una cadena: el carácter siguiente es un carácter especial.
, - Separa argumentos de un parámetro
; - Separa 2 comandos en una misma línea o denota final de línea, como en C#.
. - Tras objeto, denota que sigue método o propiedad
| - Pipeline
> - Redirecciona salida a ...
- Prompt de WPS
>> - Prompt de WPS para entradas multilínea, cuando WPS detecta que el elemento que se entra no está completo.
A. P. PowerShell v.1 43
Indice
Visión general de Scripts en PS
PowerShell es un nuevo lenguaje script para administradores de Windows.
Los scripts se componen de comandos, operadores, funciones y sus referencias a .NET, y DLLs.

Editor de texto:
comandos y
Fichero texto Fichero texto Fichero texto
expresiones,
****.vbs con la sintaxis de ****.ps1 ****.txt
(visual basic script) PowerShell.

Cmdlets Variables
Funciones
Constantes

Operadores
Arrays
xxx.ps1
Bloques código
Hash Tables

Un script WPS se escribe en un editor de texto, y se guarda en fichero con extensión .ps1.
Este fichero .ps1 es el equivalente a ficheros .exe en aplicaciones .NET.

. NET Framework
.NET Framework actúa como un interface entre WPS y el sistema operativo, traduciendo el código a formato ejecutable.
A. P. PowerShell v.1 44
Indice
Estructura de los scripts
[int]$a = 222
Zona declarativa $b = “Pepe”
Definición y asignacion variables
Estructura (recomendable) de los scripts

Zona de procedimientos Función F1


[Funciones reutilizables.
Deben definirse antes de su uso.
[Lo contrario que en VBScript]

Se guarda
cmdlets como fichero
xxx.ps1

expresiones

bucles, decisiones
Comandos cmdlets,
expresiones, bucles,
llamada a funciones pipelines

Llamadas función

A. P. PowerShell v.1 45
Indice
“Execution policy” de scripts
Por defecto WPS corre en modo Restricted, que no permite la ejecución de scripts.
Se comprueba la política de ejecución en curso, llamando al cmdlet Get-ExecutionPolicy.

Restricted: no se ejecuta ningún


No Si Por defecto WPS corre en modo Restricted. script, ni de administrador.
¿ Modo Script ? Sólo se ejecutan los comandos
interactivos entrados por
consola.

Get-ExecutionPolicy
?

PS C:\> Set-ExecutionPolicy RemoteSigned RemoteSigned: se requiere una


firma de confianza para los scripts
Este cmdlet tiene que se ejecutado por el administrador. que procedan de Internet.
Para ello pulsar botón derecho en el icono WPS y elegir Los creados localmente se
“Ejecutar como Administrador” en el menú contextual.
O entrar Start-Process powershell -Verb runAs en sesión.
ejecutan sin necesidad de firma.

AllSigned: sólo se ejecutan los


PS C:\> Set-ExecutionPolicy AllSigned scripts con firma de confianza.

Unrestricted: todos los scripts se


PS C:\> Set-ExecutionPolicy Unrestricted ejecutan sin restricciones de
origen o firma.
A. P. PowerShell v.1 46
Indice
Variables en WPS
Las variables guardan cualquier tipo de dato : números, caracteres o incluso objetos.
No se requiere definir explicitamente el tipo de la variable.
Todos los nombres de variables en WPS, van precedidos por el signo $.
Sintaxis Significado
$var1 =“Pepe“ El nombre se compone de caracteres y números. Nombres son case-sensitive.
$var2 = 222 Equivale a int var2 = 222 en C#.

$var1, $var2 = “Pepe", “Juan” Asignación múltiple de variables.


${abc!@#`{var}`def} =“Pepe" Nombre arbitrario entre corchetes, especialmente si el nombre contiene espacios.
Los corchetes dentro del nombre deben ir entre caracteres apóstrofe (`) .
${c:\filename.extension} Variable con sintaxis “Get and Set Content”, similar al nombre arbitrario.
Si el nombre es una ruta WPS válida, se puede obtener o poner el contenido del item en esa
localización, leyendo o escribiendo en la variable.
[datatype] $var= "Valor“ Variable “strongly typed”. Sólo admite datos del tipo declarado.
[int] $var = 555 Los tipos de datos son opcionales. Pueden ser clases .NET o predefinidas de WPS.

[constraint] $var = "Valor“ Variable restringida a los valores permitidos por la regla de validación.
[validaterange(0,10)][int]$var=7

$SCOPE:variable Obtiene o establece el ámbito de la variable. Ambitos válidos:


$global:v1 = 222 - Global : variable disponible en todo el shell
$script:v2=“Juan” - Script : variable disponible en script actual o persistente en modulos
- Local: variable disponible al ambito actual y subambitos.
Por defecto : global cuando se define interactivamente en el shell,
script cuando se define fuera de funciones o bloques, y local en lo demás.
Cmdletss para listar, crear, manipular variables
 get-variable
❑ set-variable
❑ new-variable
❑ clear-variable
❑ remove-variable
A. P. PowerShell v.1 47
Acceso a variables Indice

Al iniciar una sesión WPS, se establece un ámbito global.


Ambito global Cualquier variable en esta sesión desde consola es global.
Las variables globales se pueden acceder desde el ámbito
actual (línea comandos así como desde ambitos hijo).

Variables definidas dentro de una función son locales a la


función, y su ámbito padre es el script.
Por defecto, variables creadas en ámbito hijo se pueden
ver y acceder desde ámbito padre, a menos que hayan
Al acceder a una variable, sido definidas como private, en cuyo caso sólo se pueden
WPS la busca en su ámbito, acceder desde dentro de la propia función.
y si no la encuentra sigue la $private n : =“Juan”
búsqueda por los ámbitos
padre hasta el global, salvo
que haya sido declarada Cuando se ejecuta un script, se crea un nuevo ámbito
como “private” o “script”. script, que es un ámbito hijo del global.
Variables definidas en scripts, fuera de alguna función,
son locales y accesibles desde cualquier punto del script.

PowerShell libera el contenido de las variables al cerrar la


sesión. Por tanto, si una variable ya no se necesita más,
se puede borrar asignándole la variable $null.
$a = $null
Es posible usar un mismo nombre para
varias variables siempre que éstas tengan
distinto ámbito de accesibilidad.

✓ Global scope: Visible en todo el shell


Ambitos ✓ Script scope: Visible sólo en script
✓ Private scope: Visible sólo dentro de la función
A. P. PowerShell v.1 48
Indice
Constantes en WPS
Las constantes son variables cuyo valor, asignado al inicializarlas, no cambia.
Hay 2 tipos : las constantes y las constatnes de sólo lectura (read-only)

constante Sólo lectura


(read-only)

No se puede cambiar No se puede cambiar


No se puede borrar Se puede borrar

Set-Variable fix 222 -option Constant Set-Variable Nom1 “Pepe” -option ReadOnly

Remove-Variable Nom1 -force


Se borran al salir de WPS
El parámetro –force es necesario para el borrado

El signo $ sólo se requiere al definir variables. No se requiere al usar el cmdlet Set-Variable.

A. P. PowerShell v.1 49
Indice
Variables internas de WPS
WPS tiene una serie de variables predefinidas, llamadas variables internas o integradas.
Nombre variable Descripción Nombre variable Descripción

$LastExitCode Contiene el código de salida del último $$ Ultimo simbolo en la última linea recibida en el shell
programa Windows ejecutado
$? Estado de última operación. True si se realizó con éxito.
$MyInvocation Información sobre el comando en curso.
$^ Primer símbolo en la última línea recibida en el shell
$NULL Contiene NULL o valor vacio. $_ Objeto actualmente en el pipeline
$args Array para parámetros iniciales de funciones o scripts
$PID Identificador de proceso
$ConsoleFileName Nombre fichero de consola más recientemente exportado
$PSHome Ruta de la instalación de PowerShell $True True

$Pwd Ruta del directorio actual $False False


$ForEach Enumerador del buche foreach-
$ShellID Identificador del shell actual
$Home Ruta del directorio raiz del usuario
$PSCulture Cultura en uso
$Host Aplicación host de Windows PowerShell acutal
$PSVersionTable Versión PS en uso $Input Objeto en pipeline en el bloque Process de una función.

A. P. PowerShell v.1 50
Indice
Tipos de datos
PowerShell es un lenguaje loosely typed* (en contraposición p. ej. a C# que es strongly typed*).

Abreviatura Tipo Descripción Tipo completo


[bool] Boolean True o False System.Boolean
[byte] Byte 8-bit enterio sin signo.Rango 0 … 255. System.Byte
[char] Char 16-bit enterio sin signo. Rango 0 … 65.535. System.Char

[datetime] DateTime Fecha de calendario: ej. $a = [System.DateTime] "1.1.2000" System.DateTime


[decimal] Decimal Valores decimales con signo de -7.9 x 1028 a 7.9 x 1028 Sistem.Decimal
[double] Double 64-bit de -1.79769313486232x10308 a 1.79769313486232x10308 System.Double
[int] Integer 32-bit entero con signo. De –2.147.483.648 a 2.147.483.647 System.Integer
[long] Long 64-bit entero con signo: –9,223,327,036,854,775,808 9,223,372,036,854,775,807 System.Long
[short] Short 16-bit entero sin signo. Rango –32.768 … 32.,767. System.Short
[single] Single 32-bit de -3.402823x 1038 a 3.402823x 1038 System.Single
[string ] String Grupo de caracteres. Single.String
[array] Array Array de valores System.Array
[xml] Xml. Documento XML System.Xml.XmlDocument

[object] Object Cualquier tipo de objeto. System.Object


Al ser cada variable en WPS una instancia de una clase, cada variable dispone del método GetType() para obtener su tipo dato.
Se puede obtener el nombre completo, con espacio de nombres, con la propiedad Fullname o bien el nombre simple con Name.
*strongly typed: cada variable debe definrse con su tipo de dato [ej. C#] ; *loosely typed: no se requiere definir el tipo de la variable [ej. WPS].

A. P. PowerShell v.1 51
Indice
Números
Los números en PowerShell son instancias de las clases numéricas de .NET.

ENTEROS En WPS los nº son simples números, fórmulas, rangos de FRACCIONARIOS


valores, o hexadecimales con prefijo 0x.
Clases .NET Al asignar un nº literal a una variable sin tipo, WPS crea una Clases .NET
byte System.Byte instancia de la clase System.Int32. Si el rango de Int32 no decimal System.Decimal
basta, se crea un Int64 o Decimal.
System.Int16 Si es fracción se crea Double o Decimal.
short single System.Single
Se restringe el tipo explicitandolo: [Byte] , [Decimal] etc.
Para decimales, se puede añadir la letra d al literal, p. ej. 5.1d.
integer System.Int32 Cuando se explicita el tipo, se pueden elegir entre los tipos double System.Double
WPS [int], [long], etc, o los nombres correspondientes de las
long System.Int64 clases .NET [System.Int32], [System.Int64], etc.
WPS también soporta la notación científica: $e = 0.222e3.

Operaciones matemáticas a través de clase [System.Math]. CONVERSION DE NUMEROS


System.Math WPS convierte automaticamente
números al tipo que sea necesario
Abs ( a , b ) para la operación demandada,
particularmente cuando ello no
Max ( a , b ) implica pérdida de precisión.
Variable con valor hexadecimal
Min ( a , b ) Para evitar un error en caso de
pérdida de precisión, se debe
Round ( a , b ) hacer una conversión forzando el
Sqrt ( a ) tipo de alguno de los operandos.
La conversión – casting – se realiza
Truncate ( a ) poniendo entre corchetes [ ] el tipo
a convertir.
Los corchetes [ ] sirven para referenciar una clase .NET.
También para llamar a un miembro estático de una clase .NET.
Se coloca un :: entre el nombre de la clase y el método estático.
[System.Math]::Truncate(2.222)
A. P. PowerShell v.1 52
Indice
Strings – cadenas y “here-strings”
Cadena (String) es una secuencia de caracteres entre comillas simples o dobles.
Comillas simples: un “literal” que se reproduce sin cambios. Comillas dobles: se reemplazan variables por su valor.
Una cadena nula (null string) es una que todavía no se ha asignado, y por tanto está vacia. Es $null.
Una cadena vacía (empty string) es la que no contiene ningún carácter.

Las cadenas en WPS son instancias de la clase System.String de .NET.


Cadenas en WPS tienen mismas operaciones que en .NET, con métodos como Insert(), Remove(), Replace() y Split().
Además, las cadenas tienen una serie de extensiones que mejoran su manipulación y efectividad.
Además, se cuenta con las expresiones regulares – regex – para búsquedas y reemplazos, tal como sucede en .NET.

$x = “Erase " Concatenar PS C:\> -split “Erase una vez" $x = “Erase una vez un chico”
$y = “ una vez.." Erase $y = $x -replace “un chico", “una chica"
$z = $x + $y una $y
$z = Erase una vez.. vez Dividir Erase una vez una chica Reemplazar

$cadena = -join (“ca", “de", “na") PS C:\> "1,2,3,4,5" -split ','


-split divide cadena en subcadenas con un separador.
PS C:\> “ca", “de", “na" -join ""
El inverso de split es -join (concatenar),
con “” como delimitador.

“Here-Strings”
Las cadenas here-string se usan para declarar bloques de texto.
$hs = @" # Pueden ser comillas simples. Un “here-string” comienza con @” en la primera línea.
Texto
en varias
líneas
"@ # Pueden ser comillas simples. Un “here-string” termina con “@ en la última línea.
En las "here-string" entre comillas simples, las variables se interpretan literalmente y se reproducen exactamente.
En las "here-string" entre comillas dobles, las variables se reemplazan por sus valores.
A. P. PowerShell v.1 53
Indice
DATA sections
Data sections son una técnica usada en PowerShell para separar la parte de código de la de datos.

Las secciones DATA almacenan cadenas que se usarán en Una segunda forma de seprar código y texto es generar 2 ficheros
algún punto de un script. Puede haber varias secciones distintos, uno para el código (.ps1) y otro para datos(.psd1).
DATA en el mismo script.

Fichero test.ps1
Arriba el fichero con el código, que referencia el fichero de datos test.psd1.

La variable texto1 no se precede con el símbolo $ en la


definición de DATA, aunque sí al llamarla para visualización.
Cada DATA section ocupa 1 sola línea. Fichero test.psd1
Hay restricciones a lo que puede aparecer dentro de DATA. Aqui el fichero referenciado test.psd1 que contiene pares de
claves/valores que se convierten a una tabla hash.
El cmdlet ConvertFrom-StringData convierte una cadena
que contiene uno o más pares clave/valor en tabla hash. Al ejecutar el script test.ps1,
se obtiene los resultados dados.

Aqui los datos


son 3 líneas de
texto. Cada
línea se trata
como un
elemento de
un array.

A. P. PowerShell v.1 54
Indice
Fecha y hora
Get-Date crea una instancia de la clase .NET System.DateTime, que contiene la fecha/hora actual.
Para dar sólo la fecha:
Get-Date -displayhint date Para dar sólo la hora:
Get-Date -displayhint time Get-Date también una fecha/hora, asignable a una variable:
$f1 = Get-Date –displayhint time “12/12/2012 12:10:10"

Internalmente WPS procesa periodos de tiempo como instancias de la clase System.TimeSpan. El cmdlet Start-Sleep suspende la
actividad en un script o sesión
$avance = New-TimeSpan -Days 10 -hours 12 -minutes 30 # crea un periodo de tiempo durante un tiempo especificado
en segundos o milisegundos.
$now = Get-Date # obtiene fecha/hora actual
PS C:\> Start-Sleep -s 5
$futuro = $now + $avance # crea nueva fecha/hora Detiene el proceso 5 segundos.

El objeto (Get-Date) permite usar Declarar una $variable = Get-Date A partir de la clase .NET DateTime,
sus métodos y propiedades: permite usar sus métodos y propiedades. usando sus propiedades y métodos.
Propiedades Métodos Propiedades Métodos Propiedades Métodos
-Date -Add -Date -Add -MaxValue -Compare
-Day -AddDays -Day -AddDays -MinValue --DaysinMonth
-DayOfWeek -AddHours -DayOfWeek -AddHours -Now -Equals
-DayOfYear -AddMinutes -DayOfYear -AddMinutes -Today -FromBinary
-Hour -AddMonths -Hour -AddMonths -UtcNow -FromFileTime
-Minute -AddSeconds -Minute -AddSeconds ...
-Month -AddYears -Month -AddYears
-Second -Substract -Second -Substract
-Year ... -Year ...
... ...

A. P. PowerShell v.1 55
Indice
Arrays
Un array en PowerShell es un objeto .NET System.Array.
Un array es una estructura simple de organización de datos en la cual se accede a sus elementos a través de un índice (a partir de 0).

Los elementos del array pueden ser de distinto tipo, salvo que se declare strongly typed.
Se puede crear un array vacio usando @( ). Al ser los arrays objetos, se pueden usar sus métodos
Para crear un array, declarar sus items entre comas, y propiedades de instancia, además de los de clase.
$array1 = 1, 2, “Pepe“ Propiedades Métodos
Una forma alternativa es, tratándolo como una colección:
$array1.Count $array1.Clear()
$array2 = @(1,2,”Pepe”)
$array1.Length $array1.IndexOf()
Un array de todos enteros, se puede definir:
[int[]] $ArrayEnteros = 4,5,6 $array1.IsReadOnly $array1.Insert()
$array1.Remove()
Si el array tiene un solo elemento, anteponer una coma.
$array1.RemoveAt()
$array1 = , 22
$array1.Item()
Se añaden dinamicamente elementos al array, con += :
$array1.ForEach()
$array1 += “Juan“, “Paco”

Se accede a los elementos por el indice con [ ].


Los arrays disfrutan también de los métodos de la
$array1[0]  Indices entre [ ], comienzan en 0.
clase .NET System.Array.
El indice puede empezar por el último elemento [-1].
También se puede pedir un rango de indices: [0 .. 5].
[array]::Reverse($array1)
Con “+” se pueden añadir rangos: $myArray[0,2 +4..5]. Métodos de clase
Clear()
IndexOf()
Se pueden recorrer los elementos del array con claúsula foreach. LastIndexOf()
Reverse()
$bidimensional = (1,2,3) , (5,6,7) Sort()
A. P. PowerShell v.1 56
Indice
Hash Tables – tablas asociativas
Una hash table es una estructura de datos que asocia una clave (o llave) a un valor asociado a ella.
Una hash table es similar al objeto Dictionary en VBScript.
Crear una Hash Table vacía
@{} crea una tabla hash vacía: Al ser las claves cualquier cosa, no es posible recorrer una tabla hash.
$ht = @{} Se puede formar un array con las claves, y recorrer luego el array.

Añadir un item Añadir una nueva clave/valor a una hash table existente, se usa:
Creada una tabla vacía, se pueden entrar claves y valores. $ht.add(“paco”,28800)
$ht = @{} El método add no asume que la clave es una cadena.
$ht.pepe=28001 Para eliminar un elemento:
$ht.juan = 28028 $ht.remove(“pepe”)

Inicializar una Hash Table con items Recuperar el valor asociado a una clave, hay 2 formas de acceder:
Se puede crear e inicializar una tabla hash: $ht[“pepe”]
$ht = @{pepe=28001; juan=28028} O usando el operador “.” [dot]:
WPS asume que las claves son cadenas, al inicializar. $ht.pepe

Se crea un here-string y se guarda en la variable $string.

ConvertFrom-StringData
El cmdlet ConvertFrom-StringData convierte una cadena o
una here-string de pares de claves/valores en tabla hash.
Se puede usar ConvertFrom-StringData en la sección Data
El cmdlet ConvertFrom-StringData convierte el here-string en tabla hash.
de un script.
Here-strings son especialmente útiles cuando los valoes en
la tabla hast incluyen comillas.

A. P. PowerShell v.1 57
Indice
Operadores
Los operadores en PowerShell son polimórficos, actúan sobre muchos tipos de objetos.
Operador Descripción Ejemplos Resultados Operador Significado

2+4 6 -and $valor1 -and $valor2


+ Suma 2 valores
$true cuando ambos operandos son $true..
2 + “4” 6
“2” + 22 222 -or $valor1 -or $valor2
2 + "0xabc" 2750 $true si uno de los operandos es $true
“Hola “ + “Pepe” Hola Pepe
1,2,3 + 4,5,6 1,2,3,4,5,6 -xor $valor1 -xor $valor2
$true si alguno de los argumentos es $true, pero no
* Multiplica 2 2*4 8 ambos. $false en otro caso.
valores “a” * 5 “aaaaa”
-not -not $valor
1,2,3 * 2 1,2,3,1,2,3 $true si su único argumento es $false.
- Resta 2 valores 7-3 4 $false en cualquier otro caso.

/ Divide 2 valores 10/2 5


3/2 1,5
% Retorna resto división 7%/4 3 Operador Significado
binario
Operador Ejemplos Equivale a Descripción -band $valor1 -band $valor2
Comparación binaria entre dígitos en misma posición
= $a = 5 Asigna valor $a1=[convert]::ToByte(111000,2)
$a2=[convert]::ToByte(100001,2)
+= $a += 2 $a = $a + 2 Suma, multiplica, resta, divide
$res = $a1 -band $a2 # $res=32
*= $a *= 3 $a = $a * 3 por valor y asigna variable
-= $a -= 4 $a = $a – 4 -bor $valor1 -bor $valor2
/* $a /= 5 $a = $a / 5 Comparación binaria entre dígitos en misma posición
$a1=[convert]::ToByte(111000,2)
% $a %= 3 $a = $a % 3 Divide y asigna resto a la variable
$a2=[convert]::ToByte(100001,2)
++ $n++ $n = $n + 1 Postincremento al llamar a la variable $res = $a1 -bor $a2 # $res=57
++$n $n = $n + 1 Preincremento directo
-bxor $valor1 -bxor $valor2
-- $k— $k = $k -1 Postdecremento al llamar a la variable
$k = $k - 1 Postdecremento directo -bnot -bnot $valor
--$k
A. P. PowerShell v.1 58
Indice
Operadores de comparación
Operador Descripción Ejemplo(s) Resultado(s)

-eq –ceq –ieq Igual (equal) -5 –eq 5 $true

-ne –cne –ine -No igual (not equal) 5 –ne 5 $false

-gt –cgt –igt Mayor que (greater than) 5 –gt 3 $true


Como ocurre con
los operadores de
-ge –cge –ige Mayor o igual (greater or equal) 5 –ge 3 $true
asignación, los de
Operadores de
comparación se
comparación -lt –clt –ilt Menor que (less than) 5 –lt 3 $false comportan según
que se usan en
el tipo de
expresiones y
-le –cle -ile Menor o igual (less or equal) 5 –le 3 $false operando de
en cmdlets
la izquierda.
tales como
-like -clike ilike Igualdad valores con * ?[a-z][mn] “123” –like “1*” $true El operando
Where-Object
derecho se
y otros. -notlike -cnotlike -inotlike Desigualdad valores * ? [a-z][cd] “123” –notlike “1*” $false convertiá al
“Soy yo” –match “yo” $true mismo tipo que el
-match -cmatch -imatch Igualdad con regex
izquierdo para
-notmatch -cnotmatch inotmatch Desigualdad con regex “Soy yo” –notmatch “yo” $false poder
compararlos.
-contains La colección de la izquierda 1,2,3 –contains 2 $true
-ccontains contiene el valo de la derecha.
-icontains
-notcontains La colección de la izquierda no 1,2,3 –notcontains 2 $false
-cnotcontains contiene
-inotcontains el valo de la derecha.

PowerShell tiene un elevado nº de operaciones de comparación, en parte debido a que


hay operadores case-sensitive y otros case-insensitive.
Tomando por ejemplo –eq, hay la versión –ieq (insensitive) y la versión –ceq (sensitive).
A. P. PowerShell v.1 59
Indice
Otros operadores
Operador Significado
- replace “objetivo" -replace "patron","reemplazo“ [Por defecto es case-insensitive]
- ireplace Devuelve nueva cadena, donde el texto del “objetivo” igualado por “patron” es reemplazado por "reemplazo".
-ireplace opera case-insensitive
- creplace
-creplace opera case-sensitive.
Si "target" es un array, -replace actúa sobre cada elemento del array.
-f [formato] "Format String" -f Array de valores a colocar en puntos de reemplazo
Colocar {0} {1} etc. en la cadena en los puntos donde los items se reemplazan por los valores del array.

-is Se usa para testear un objeto.

- as $valor -as [Type]


Convierte $valor al tipo dato .NET. Si la conversion no es posible, no se devuelve nada.
- split -split "Input String"
Convierte la cadena dada en un array, usando los espacios (\s+) para identificar los elementos.
- join -join ("item1","item2",...,"item_n")
Yuxtapone los items en una cadena única, sin separador. También puede definirse el delimitador.

A. P. PowerShell v.1 60
Bucles de decisión if y switch Indice

En WPS el valor True es representado por $True, y el valor False por $False

Switch options expression


if (condition) {...} else {...}
Switch options -file filename [lee datos fichero]

Condition
= $True ? No
Case 3 Case 4
Si Switch
(expression)
{ { {
{ Case 1 Case 2
sentencias1 sentencias2 sentencias4
sentencias3 default
} } }
}

{ { {
sentencias1 sentencias5 sentencias2
if (condition) {...} elseif (condition {...} else {…} } } }

elseIf Condition else


= $True ? Ejemplo:
switch ($var) { valor1 {...} valor2 {...} default {..} } }
{ {
sentencias3 Opciones: Determinan como se hace la comparación.
sentencias2 Si
-casesensitive
} { } -exact
sentencias1 -regex
} -wildcard Comparación case-insensitive
? Cualquier caracter individual no especificado
* Cero o más caracteres no especificados
[a-z] Cualquier carácter en rango a–z
[ab] Los caracteres especificados a o b
$a = “xyzw"
if ($a -eq “Juan") {“Es Juan"}
elseif ($a -eq “Luis") {“Es Luis"}
A. P. else {“Es Paco"} PowerShell v.1 61
Indice
Bucles While y Until
En WPS el valor True es representado por $True, y el valor False es representado por $False

While (condition) {statements;next} Do {statements;next} While (condition) Do { statements;next } Until (condition)

While Do Do

Condition { Exit Do {
No
= $True ? sentencias setenciass Exit Do
} }
Si
{ Loop While
Exit Do Loop Until
sentencias
} Condition
Condition
=$True ? = $True ?
Loop Si No
No No Si

$a = 1 $a = 1 $a = 1
While ($a –lt 10) {$a;$a++} do {$a; $a++} while ($a -lt 10) do {$a; $a++} until ($a –gt 10)

condición Sentencias condición Sentencias condición


a ejecutar a ejecutar
Sentencias
a ejecutar Siguiente Siguiente
en el bucle en el bucle
Siguiente ($a=$a+1) ($a=$a+1)
en el bucle
($a=$a+1)
A. P. PowerShell v.1 62
Indice
Bucles for y foreach
En WPS el valor True es representado por $True, y el
El cmdlet Foreach-Object
valor False es representado por $False
tiene igual funcionalidad

for (inicial; condición; next) {sentencias } foreach ($var in $collection) {sentencias}

Expresión Inicial foreach ($i in 5…9)


Guarda la colección de
valores en la variable $i.
Next
Next 5
No Condición
6
True ? No
¿Fin Colección?
7

8
Si
9

{
sentencias … Si
Cada item de la colección
} { se asigna a la variable, y
sentencias … con cada valor se van
} ejecutando las sentencias.

for ($i=0; $i -lt 5; $i++) {..... } foreach ($i in 5..9) {......}

Sentencias Sentencias
condición a ejecutar
a ejecutar
inicial Siguiente
en el bucle Para cada objeto de $collection ejecuta {…}
($i=$i+1)
A. P. PowerShell v.1 63
Indice
Variables de entorno en PowerShell
Las variables de entorno son usadas por aplicaciones y otras utilidades para acceder a ficheros concretos, directorios,
y datos de configuración. Hay variables de entorno para cada usuario y variables del sistema propias del ordenador.
Las variables de entorno son distintas de las variables definidas en PowerShell. Las variables de entorno se
Las variables WPS tienen ámbito PowerShell y desaparecen al finalizar la función o script que las contiene. guardan de forma
Las variables de entorno no desaparecen al finalizar el script o función en que se incorporaron. permanente en el Registro.
Al iniciarse PS, lee el Registro
La variable de entorno PATH controla donde PowerShell busca aplicaciones .exe y scripts para ejecución. para obtener las variables
para la sesión.
PowerShell facilita el acceso a las variables de entorno a través del environment provider: Env:.
PS no actualiza el Registro
Se accede al proveedor Env de igual forma que a otros proveedores, como sistema ficheros, registro, etc. cuando se crea una variable
Get-ChildItem Env: # lista las variables de entorno y sus valores. en el proveedor Env:.
Get-Item Env:Path # visualiza nombre de la variable Path y su valor Las variables en el Registro
se crean/borran de forma
En PowerShell se opera con las variables de entorno usando $Env:. permanente usando clases
$Env:Path # visualiza los valores de la variable de entorno PATH. de .NET.

Añadir un directorio a la variable: Asignar valor a variable entorno Borrar variable entorno Al cambiar una variable de
$Env:Path += ";C:\NuevoDir“ $Env:var1 = 222 $Env:var2 = “” entorno, el cambio afecta
sólo a la sesión de WPS.
Para añadir este directorio al Path cada Para un cambio permanente,
También cambiar variables con: También con:
vez que se inicie WPS, se puede añadir la hay que hacer el cambio en
Set-Item Env:var1 Remove-Item Env:var2 el Registro o bien usar .NET.
línea de comando como una entrada en $Env:var1 = 333
un perfil PowerShell.
Copy-Item Env:var1 Env:var2
Un perfil es un tipo de script usado para
configurar PowerShell cuando arranca.
Remove-Item Env:var1

Listado de variables de entorno que contienen la palabra PATH, ordenados alfabeticamente , y en formato tabla.
Path contiene la
direcciones buscadas
para scripts y
PSModulePath las
buscadas para
módulos.
A. P. PowerShell v.1 64
Invocación de scripts Indice

Los scripts se pueden llamar desde una sesión PowerShell o desde la línea de comandos de cmd.exe.

WPS test arg1 arg2 Ejecuta el primer script de nombre test.ps1 que encuentra en la variable de entorno $ENV:PATH.
PS primero chequea si se trata de un alias, función, cmdlet, script y finalmente de ejecutable.

----------------------------------------------------------------------------------------------------------
.\test.ps1 Si el script está en el directorio de PS, entrar sólo nombre script tras “.\”.
El script no aparece en la variable de entorno

Invoke-Expression .\test.ps1 Cmdlet específico para llamar scripts.


Se puede omitir la extensión .ps1.

Start-Job -FilePath C:\temp\form1.ps1 Cmdlet específico para ejecutar scripts.

C:\temp\test.ps1 [Parámetros] Con ruta al script.

. "C:\temp\test.ps1" [Parámetros] Si ruta no tiene espacios, se puede quitar “”.

Estos parámetros representan los valores de la variable interna


$args, que en realidad es un array : $args[0], $args[1], ...

& "C:\temp\test.ps1" [Parámetros] Invocación con “&” cuando hay espacios blanco.

cmd
powershell –command .\test.ps1 powershell –noexit .\test.ps1
-noexit asegura que la ventana PS permanezca al
Si el script está en el mismo directorio que WPS. finalizar el script.

powershell –command C:\temp\test.ps1


Si está en otro directorio, se usa la dirección absoluta del script.
A. P. PowerShell v.1 65
Indice
Módulos
Un módulo es un empaquetado de cmdlets, alias, funciones, etc, que se pueden cargar y descargar en una sesión.
PowerShell facilita la organización de cmdlets, scripts, alias, funciones, etc, en módulos.

Guardar definiciones de funciones, etc, en fichero con extensión .psm1. El cmdlet get-module –listavailable lista los módulos disponibles.
Asegurar que los comandos sigan la sintaxis
Verbo-Nombre estándar de WPS.

Moduloxxx.psm1 Moduloxyz.psm1 Modulozyx.psm1


Manifiesto.psd1 Manifiesto.psd1 Manifiesto.psd1

Si un módulo debe ser accesible al usuario actual, colocarlo en el directorio Los módulos no requieren registro.
<My Documents>\WindowsPowerShell\Modules\<module name>. WPS busca módulos en una serie de ubicaciones
Si debe ser accesible a todos los usuarios del sistema, colocarlo en su definidas en la variable de entorno PSModulePath.
propio directorio bajo Program Files, y añadir este directorio a la variable PS C:\> get-content env:psmodulepath
de entorno PSModulePath. Guardar el fichero Moduloxxx.psm1 en directorio Modules,
Si no se desea instalar permanentemente el módulo, guardarlo en una de PSModulePath, en un subdirectorio con mismo nombre.
ubicación que hay que especificar al cargarlo con Import-Module –path. Se puede añadir un módulo de cualquier otra ubicación,
supuesto se conozca su via completa.
Añadir ubicaciones a la variable de entorno PSModulePath,
para que WPS localize automaticamente los módulos.
Cuando se carga un módulo desde un script, el módulo es accesible en la sesión. Una vez WPS encuentra los módulos, están disponibles.
Al salir del script, las funciones del módulo están todavía cargadas. Si un módulo no está ubicado en PSModulePath,
Para evitar interferencias con scripts no operativos, proceder a borrar módulos de hay que llamar al cmdlet Import-Module -path
la sesión en curso con el cmdlet Remove-Module. especificando su ubicación exacta.
A. P. PowerShell v.1 66
Indice
Clases y Objetos - fundamentos
En PowerShell todo son objetos.
Las clases son el elemento de programación más importante dentro de la plataforma .NET, y base de la POO.

Objetos
Propiedades
[p.e. color] Métodos
[p.ej. mover]

Clases de
. NET Framework,
-WMI,
-COM,
Clases definidas o de terceros
por el usuario
Instanciación

Las clases son una plantilla conceptual a


través de la cual generar, mediante el
proceso de “instanciación”, objetos con
Las clases representan
sus mismos atributos y comportamiento,
entidades del mundo real
los cuales interactuando entre sí y con
a través de sus atributos y
Clase otros objetos de otras clases, realizan las
comportamiento.
tareas previstas por el programa.

A. P. PowerShell v.1 67
Indice
Acceso a .NET Framework
.NET es una estructura de Microsoft diseñada para dar soporte a aplicaciones de todo tipo y a scripts.
Microsoft ha generado una serie de lenguajes de programación alrededor de .NET: Visual Basic, C++, C#, y J#.
Microsoft decidió dar soporte .NET a WPS y a su lenguaje de scripts, dándole así acceso a sus vastos recursos.
.NET Framework actúa como interface entre WPS y el sistema operativo Windows.
.NET Framework tiene 2 componentes clave:
• La libreria de clases .NET en que las clases están organizadas en espacios de nombres (namespaces).
• CLR (common language runtime) que posibilita la ejecución de aplicaciones para .NET (p.ej. escritas en C# o VB).

Al ser cada variable una instancia de una clase .NET, cada variable posee las propiedades y métodos de su clase.
Se accede a ellas con la notación de (. ) tras la variable. Propiedades: $a.propiedad1. Métodos: $a.método1( ).

Al entrar por consola un texto entrecomillado, WPS lo entiende como un


objeto de la clase String de .NET, y ello permite usar las propiedades y
métodos de dicha clase String, haciendo uso de la notación de punto.

Add-Type #añade una clase(tipo=type) de .NET Framework a una sesión de PowerShell.


Add-Type -AssemblyName System.Windows.Forms
New-Object #crea una instancia de una clase NET. Para ello sólo hace falta dar el nombre completo de la clase .NET a instanciar.
$form = New-Object System.Windows.Forms.Form
$form.Text = "Formulario de Entrada" # De estas instancias – objetos – pueden usarse las propiedades y métodos de su clase.

Al ser cada variable en WPS una instancia de una clase .NET, cada variable posee el método GetType( ), conferido a todos los objetos
.NET por la clase madre de todas las clases, System.Object.
En la mayoría de casos, se desea sólo el nombre de la clase, devuelto por la propiedad Fullname o Name.

Para conocer mejor las clases, WPS [nombreclase] | Get-Member -static


Lista métodos y propiedades estáticos de una clase
dispone del cmdlet Get-Member.
Get-Member lista los miembros (métodos, $a | Get-Member
propiedades, y eventos) de los objetos en la línea Lista métodos y propiedades de variable $a como objeto

de comandos. $b| Get-Member -static


A. P. PowerShell Lista
v.1 métodos y propiedades estáticas de variable $b como objeto. 68
Acceso a clases de .NET Framework Indice

Clases estáticas Clases [no-estáticas]


Todos sus miembros son estáticos. Puede tener miembros estáticos y no-estáticos.
No instanciables: no tienen objetos. Clases instanciables: pueden crearse objetos.
No tienen constructor. Tienen constructor : New.
Métodos estáticos Llamada a métodos Métodos estáticos
Llamar un método estático: desde la propia clase Llamar un método estático: desde la propia clase
[NombreClase]::NombreMetodo(parámetros) Los métodos siempre con
parámetros incluso vacio ( ). [NombreClase]::NombreMetodo(parámetros)

Llamada a métodos Métodos no-estáticos


Llamar un método no-estático: desde la propia clase, con “.”.
Se pone el nombre de la clase entre corchetes [ ], y tras 4
puntos :: el nombre del miembro: método o propiedad. [NombreClase].NombreMetodo(parámetros)

Llamada a métodos Métodos de instancia


Llamar un método de una instancia: desde objeto, con “.”.
$objeto1.NombreMetodo(parámetros)

Propiedades estáticas Acceso a propiedades Propiedades estáticas


Acceso a propiedad estática: desde la propia clase Acceso a propiedad estática: desde la propia clase
[NombreClase]::NombrePropiedad [NombreClase]::NombrePropiedad

Los corchetes [ ] encierran una referencia .NET . Acceso a propiedades Propiedades no-estáticas
Estas referencias pueden ser : Acceso a propiedad no-estática: desde la propia clase, con “.”.
• El nombre completo de una clase : [string], [int32], etc. [NombreClase].NombrePropiedad
• Un type accelerator: [ADSI], [WMI], [Regex], etc.
Acceso a propiedades Propiedades de instancia
Métodos estáticos de clases Propiedades estáticas de clases Métodos estáticos (shared): Acceso a propiedad de instancia: desde un objeto, con “.”.
estáticas: pertenecen a la clase estáticas : pertenecen a la clase de la clase y todas sus instancias. $objeto2.NombrePropiedad
( La clase no tiene objetos). (La clase no tiene objetos). Acceso desde la clase.
Acceso desde la clase. Acceso desde la clase. Propiedades estáticas (shared):
Métodos de instancia: de las Propiedades de instancia: de las
instancias (objetos) de la clase. de la clase y todas sus instancias. instancias (objetos) de la clase.
Acceso desde objetos. Acceso desde la clase. Acceso desde objetos.
A. P. PowerShell v.1 69
Indice
Eventos en PowerShell
PowerShell ha dado cabida a la gestión de eventos, con una serie de cmdlets, y con el siguiente procedimiento base:
según el tipo de objeto generador del evento -> registrar el objeto -> el evento -> y la acción a generar de respuesta.
Cmdlet Descripción Hay varios cmdlet para registrar distintos tipos de
Register-ObjectEvent Registra una subscripcion a evento de objeto .NET. eventos:
Registrar evento Registro
Gestor eventos
Register-EngineEvent,
Register-WmiEvent Registra una subscripción a evento de objeto WMI.
Register-ObjectEvent, y
Register-EngineEvent Registra una subscripción a evento de PowerShell. Register-WmiEvent.
Get-EventSubscriber Lista las subscripciones a eventos en la sesión. Esperar el evento

Unregister-Event Eliminar una o más subscripciones registradas.


Wait-Event Espera la ocurrencia de un evento antes de continuar. Puede
limitarse el tiempo de espera. El valor por defecto es ilimitado.
Get-Event Lista eventos pendientes en la cola.
Remove-Event Elimina un evento pendiente de la cola. Ejecutar Action
New-Event Permite a un script añadir sus propios eventos a la cola.
Los cmdlet de PowerShell para el tratamiento de eventos. Esquema del tratamiento de eventos en PowerShell

Ejemplo de evento de objeto .NET


$n=0
$timer = New-Object System.Timers.Timer #creación del objeto $timer
$timer.Interval=1000 #asignación de propiedad de $timer
$timer.Start() #método de $timer
Register-ObjectEvent -InputObject $timer -EventName Elapsed -Action {$n=$n+1;write-host $n;if($n -gt 9){$timer.stop()}}
cmdlet Objeto afectado Evento del objeto Acción de respuesta al evento. Es un scriptblock.

Register-ObjectEvent tiene una serie de parámetros aparte de los arriba usados, como MessageData, SourceIdentifier, etc.
Register-ObjectEvent permite parámetros posicionales en el mismo orden : objeto / evento /accion.
Register-ObjectEvent $timer Elapsed {$n=$n+1;write-host $n;if($n -gt 9){$timer.stop()}}.
A. P. PowerShell v.1 70
Indice
Uso de eventos de clases .NET en diseño de ventanas gráficas [forms]
Además de métodos y propiedades, las clases .NET cuentan con los eventos como elemento de desarrollo.
Con el cmdlet Get-Member se pueden obtener los Con el cmdlet Get-Member se pueden obtener los
Clase Form eventos, además de métodos y propiedades, Clase Button eventos, además de métodos y propiedades,
de un objeto, p. ej. $form, de una clase .NET. de un objeto, p. ej. del botón $Cerrar, de una clase .NET.

Al entrar código, los métodos, propiedades y eventos del Al entrar código, los métodos, propiedades y eventos del
objeto, aparecen tras introducir el objeto y el punto: $form.. objeto, aparecen tras introducir el objeto y el punto: $Cerrar..

$form.Add_Shown({$TextBox.Select()}) $Cerrar.Add_Click({$form.Close()})
Objeto Respuesta al evento [Event Handler] Objeto Respuesta al evento [Event Handler]
Evento Evento

Lo mismo vale para toda la serie de controles que se usan en formularios como Label, TextBox, CheckBox, etc:
crear una instancia ($objeto), y llamar al método Add_*() con el scriptblock de respuesta entre corchetes{}.

A. P. PowerShell v.1 71
Indice
Cuadros de Diálogo
ShowDialog()
ShowDialog()
Este método presenta una ventana de diálogo modal. La aplicación no continúa hasta que se cierra la ventana de diálogo.
Devuelve un valor de la enumeración DialogResult que puede asignarse a la propiedad DialogResult de botones o del formulario.
Pulsar la tecla X del borde superior derecho del cuadro, devueve DialogResult.Cancel.
Este valor puede usarse para procesar las acciones realizadas en la ventana de diálogo.
Cuando el cuadro de diálogo ya no sea necesario, procede llamar al método Dispose() para cerrarlo definitivamente.
Se crea la ventana

Se crea objeto Label

Se crea botón Aceptar

Se crea botón Cancelar

Nombre Descripción Enumeración DialogResult


Abort El cuadro de diálogo devuelve Abort, normalmente de un botón Abortar

Cancel El cuadro de diálogo devuelve Canel, normalmente de un botón Cancelar

Ignore El cuadro de diálogo devuelve Ignore, normalmente de un botón Ignorar


Se asignan los resultados Yes y No del cuadro a los botones Aceptar y Cancelar.
Se da una salida Si / No por consola, y se cierra el cuadro de diálogo con Dispose(). No El cuadro de diálogo devuelve No, normalmente de un botón No

None No hay devolución, el diálogo modal continua corriendo

OK El cuadro de diálogo devuelve OK, normalmente de un botón OK

Retry El cuadro de diálogo devuelve Retry normalmente de un botón Reintentar

Yes El cuadro de diálogo devuelve Yes, normalmente de un botón Si


A. P. PowerShell v.1 72
Indice
Ejemplo de uso de clases .NET para crear una ventana gráfica [form]
Add-Type -AssemblyName System.Windows.Forms Se trata de diseñar un script que cree un cuadro de entrada gráfico
Add-Type -AssemblyName System.Drawing
Carga ensamblados, si necesario
$form = New-Object System.Windows.Forms.Form [form] en PowerShell utilizando las clases al efecto de .NET Framework.
$form.Text = "Formulario de Entrada" Form El proceso no es simple, pero muestra la potencialidad que aporta a
$form.Size = New-Object System.Drawing.Size(400,300) Con new-object se define objeto.
$form.StartPosition = "CenterScreen" Se definen propiedades del objeto. Powershell descansar sobre la gran infraestructa de .NET Framework.
$form.Topmost = $True

Botón Aceptar.
$Aceptar = New-Object System.Windows.Forms.Button
Con new-object se define objeto.
El cmdlet New-Object tiene especial relevancia ya que
$Aceptar.Location = New-Object System.Drawing.Point(75,220)
$Aceptar.Size = New-Object System.Drawing.Size(75,23) Se definen propiedades del objeto. permite obtener objetos a partir de las clases .NET, de los
$Aceptar.Text = "Aceptar" Se añade el objeto al formulario. cuales usar sus amplia gama de métodos y propiedades para
$form.AcceptButton = $Aceptar
$form.Controls.Add($Aceptar) el diseño de formularios y controles.
Botón Cancelar.
$Cancelar = New-Object System.Windows.Forms.Button Con new-object se define objeto.
$Cancelar.Location = New-Object System.Drawing.Point(250,220)
Se definen propiedades del objeto.
$Cancelar.Size = New-Object System.Drawing.Size(75,23)
$Cancelar.Text = "Cancelar" Se añade el objeto al formulario.
$form.CancelButton = $Cancelar
$form.Controls.Add($Cancelar) Etiqueta
Con new-object se define objeto.
$label = New-Object System.Windows.Forms.Label
Se definen propiedades del objeto.
$label.Location = New-Object System.Drawing.Point(130,100)
$label.Size = New-Object System.Drawing.Size(100,20)
Se añade el objeto al formulario.
$label.Text = "Entrar clave"
$form.Controls.Add($label) TextBox .
Con new-object se define objeto.
$textBox = New-Object System.Windows.Forms.TextBox Se definen propiedades del objeto.
$textBox.Location = New-Object System.Drawing.Point(130,120)
Se añade el objeto al formulario.
$textBox.Size = New-Object System.Drawing.Size(150,20)
$form.Controls.Add($textBox)
Imagen
$Image = [system.drawing.image]::FromFile(“c:\altamira.jpg”) Se crea objeto image de fichero.
$Form.BackgroundImage = $Image Se asigna a la propiedad
$Form.BackgroundImageLayout = "None" BackgroundImage del formulario.
$form.Add_Shown({$textBox.Select()}) Pone el foco sobre el TextBox, en respuesta a evento Al invocar el script aparece la ventana con sus controles.
$Aceptar.DialogResult = [System.Windows.Forms.DialogResult]::OK
$result = $form.ShowDialog() Código de La propiedad DialogResult del botón OKButton (aqui OK),
if ($result -eq [System.Windows.Forms.DialogResult]::OK -and $textBox.text -eq "1234") respuesta a la
{$form.Dispose()} se guarda en variable $result = $form.ShowDialog().
if ($result -eq [System.Windows.Forms.DialogResult]::Cancel )
entrada en TextBox $Aceptar.DialogResult = [System.Windows.Forms.DialogResult]::OK
{$form.Dispose()} y a la actuación El valor de esta variable se usa para las acciones posteriores en a la
do {$textBox.text = "" ; $result = $form.ShowDialog() } sobre los botones pulsación de botones Aceptar o Cancelar o botón de Cierre.
until (($result -eq [System.Windows.Forms.DialogResult]::OK -and $textBox.text -eq "1234") ` Aceptar y Cancelar.
-or $result -eq [System.Windows.Forms.DialogResult]::Cancel )
$form.Dispose()
A. P. Script guardado en fichero C:\temp\form1.ps1 PowerShell v.1 73
Indice
Ensamblados y espacios de nombres (namespace)
Framework es una extensa colección de clases organizada en Espacios de Nombres (Namespaces),
los cuales a su vez se organizan en Ensamblados.
Ensamblado Espacio de nombres

Ensamblado (assembly): es una unidad básica de agrupación de código. Espacio de nombres (namespace) es una unidad lógica de
Los ensamblados contienen módulos, los módulos contienen clases, y las clases tienen agrupación de código.
miembros (métodos, propiedades, eventos). Los espacios de nombres organizan los tipos en ensamblados.
Es la unidad básica de despliegue en .NET y también un contenedor de tipos. No sustituyen a los ensamblados, sino que los complementan.
En general, comprende un fichero .exe si es una aplicación, o .dll si es una librería. Los espacios de nombres son una forma de agrupar nombres
La principal diferencia entre una .exe y una .dll, es que una .exe define un punto de entrada. de clases (tipos) reduciendo la probabilidad de colisiones de
Es una colección de tipos y recursos que conforma una unicad lógica de funcionalidad. nombres. Un espacio de nombres puede contener otros
Todos los tipos residen en ensamblados. El CLR no da soporte a clases fuera de ensamblados. espacios de nombres y tipos (clases).
El ensamblado es la unidad para la cual se solicitan y confieren permisos de seguridad. El nombe completo de un tipo (clase) se forma concatenando
La identidad de un tipo depende del ensamblado donde se define. los espacios de nombres que contienen dicho tipo (clase), lo
Cada ensamblado tiene un nº de versión de 128-bit que se presenta como 4 nº decimales: que evita problemas de colisiones de nombres.
mayor, menor, bloque, revisión (p.ej. 3.3.5.1). Los ensamblados pueden contener múltiples namespaces, los
Los ensamblados son la unidad natural de despliegue. Al arrancar una aplicación, ésta carga cuales a su vez pueden contener otros namespaces y tipos.
los ensamblados necesarios. Un namespace es en definitiva una forma lógica de organizar
Cada ensamblado contiene un manifiesto : conjunto de metadatos sobre dicho ensamblado. clases y otros tipos de una simple estructura jerárquica.
Los ensamblados pueden ser private o shared. Por defecto son private y las clases contenidas Los namespaces son transparentes en runtime.
en ellos son sólo accesibles a las aplicaciones en el mismo directorios que el ensamblado.
Pero todos los ordenadores con el .NET instalado, disponen de GAC (global assembly cache)
donde se alojan ensamblados que pueden compartir múltiples aplicaciones.

System
Windows
Forms La primera parte del nombre completo, hasta el último punto a la derecha, es el namespace.
La última parte, desde el último punto, es el nombre del tipo (clase).
Button
Por ejemplo: System.Windows.Forms.Button representa el tipo (clase) Button, que pertenece
al namespace System.Wndows.Forms.

A. P. PowerShell v.1 74
Indice
Ensamblados .NET
Framework es una extensa colección de clases organizada en Espacios de Nombres (Namespaces),
los cuales a su vez se organizan en Ensamblados.
Los ensamblados contienen módulos, los módulos contienen clases, y las clases tienen miembros (métodos, propiedades, eventos).

Buscar las clases disponibles comienza por localizar los ensamblados disponibles cargados donde se alojan las clases.
La clase AppDomain se usa para encontrar los ensamblados cargados.
Su método estático CurrentDomain() dá acceso a .NET donde el método dinámico GetAssemblies() obtiene la lista buscada.

Lista parcial de ensamblados cargados,


limitada a los 5 primeros.

Ensamblados
Añade algún ensamblado que pudiera faltar.
[contenedores de tipos]
Se puede cargar un ensamblado *.dll completo con
$Assembly = [System.Reflection.Assembly]::LoadFrom("C:\folder\file.dll")

Para encontrar los tipos que contiene un ensamblado, se usa el método


GetExportedTypes() de los ensamblados.

El ensamblado es la estructura formal


para carga, despliegue, visibilidad,
Tipos (clases) versionado, y seguridad en el CLR.
Un ensamblado puede contener tipos
de varios espacios de nombres
(namespaces).

Como un ensamblado puede tener muchos tipos, se ha hecho una


búsqueda con la palabra clave “Button”, y limitada a los 5 primeros.
A. P. PowerShell v.1 75
Indice
Espacios de Nombres (Namespaces) .NET
Framework es una extensa colección de tipos organizada en Espacios de Nombres (Namespaces),
los cuales a su vez se organizan en Ensamblados.

Espacios de nombres
System Es la raiz de los tipos fundamentales de .NET Framework.
Incluye clases que se usan en todas las aplicaciones.

System.Windows.Forms Tipos para crear aplicaciones Windows con formularios

System.IO Tipos para manejo del sistema de ficheros

System.Drawing Tipos para trazado de gráficos, textos e imágenes

System.Net Tipos para gestión y manejo de redes con protocolos

System.Environment Tipos para acceso al entorno y componentes del equipo

System.Reflection Tipos acceso a datos de tipos en runtime

En un namespace se pueden definir clases, módulos, interfaces, delegados, enumeraciones, estructuras y otros namespaces,
pero no métodos, propiedades, variables o eventos, que deben declararse en contenedores como clases, módulos o estructuras.
A. P. PowerShell v.1 76
Indice
Algunas clases .NET
Clase Descripción
System.DateTime Instante actual en fecha y hora
Para encontrar los tipos que contiene un ensamblado, se usa
el método GetExportedTypes() de los ensamblados.
System.Math Constantes y métodos matemáticos
System.Random Generador números aleatorios
System.Convert Convierte un tipo de dato a otro
System.Console Entrada, salida y salida de error estándar
System.Diagnostics.Pocess Acceso a procesos locales y remotos
System.Diagnostics.EventLog Interacciona con Windows EventLog
Como un ensamblado puede tener muchas clases, se ha hecho una
System.Diagnostics.Stopwatch Métodos para medir lapsos de tiempo búsqueda con la palabra clave “Button”, limitada a las 5 primeras.
System.Media.Sound.Player Reproduce sonidos de ficheros .wav

System.Array Manipulación de arrays


System.String Texto como serie de caracteres Unicode

System.IO.Directory Métodos estáticos para manejar directorios


System.IO.DirectoryInfo Métodos de instancia para manejo directorios

System.IO.File Métodos estáticos para manejo de ficheros


System.IO.FileInfo Métodos de instancia para manejo de ficheros
System.IO.StreamReader Implementa TextReader para leer caracteres
System.IO.StreamWriter Implementa TextWriter para escribir caracteres
System.IO.FileSystemWatcher Evento al detectar cambio en directorios o ficheros

System.Windows.Forms.Form Para crear interfaces gráficos de una aplicación

System.Drawing.Image Funcionalidad para clases Bitmap y Metafile

El nombre completo de una clase se forma concatenando los namespaces que la


A. P.
contienen. P. ej. System.Windows.Forms.Button es el nombre de Button.
PowerShell v.1 77
Indice
Instanciar objetos .NET con New-Object
El cmdlet New-Object crea objetos de clases .NET accediendo al constructor genérico de clases .ctor().
New-Object puede usarse con otros constructores de la clase, que soporten diferentes argumentos.
Un constructor es un bloque de código de una clase que es llamado cuando se instancia o crea un objeto.
Sólo se pueden instanciar clases .NET cuyo ensamblado, donde se encuentran las clases, haya sido cargado en memoria.
Se usa el cmdlet Add-Type para cargar las clases que se desean de un cierto ensamblado.
Add-Type -AssemblyName System.Windows.Forms
[System.Windows.Forms.MessageBox]::Show("Prueba","Titulo")

El método GetConstructors() de que disponen todas las clases, El método GetConstructors() de que disponen todas las clases,
dá los métodos disponibles en la clase. dá los métodos disponibles en la clase.

La clase System.Windows.Forms.Form tiene un único constructor genérico.

New-Object crea objeto, asignado a variable $form, sin parámetros.


La personallización del objeto se hará a través de sus propiedades.

La clase System.String dispone de varios constructores (sobrecargados).


Esto permite llamar a New-Object personalizando según el constructor.
No es preciso preocuparse por la instanciación e invocación de
objetos, ya que PS facilita cmdlets que se ocupan de ello.
New-Object crea objeto personalizado a través de los parámetros.

Los objectos son el resultado de los comandos de PowerShell y no


se convierten en texto hasta que salen por consola. Guardando el
objeto en una variable, se pueden usar sus propiedades y métodos.
Para ver todas las propiedades de un objeto:
La clase System-Object de la que derivan todas las clases
.NET, tiene como constructor a ctor() que heredan las demás.

A. P. PowerShell v.1 78
Indice
WMI – Windows Management Instrumentation
WMI es un interface de adquisición de datos del ordenador: aplicaciones, hardware, software, y servicios.
WMI se basa en COM, el modelo de objetos predecesor de .NET, y se instala automaticamente con Windows.
WMI es la adaptación de Microsoft al estándar del sector CIM – Common Information Model*.

WMI es completamente independiente de PowerShell. Clase WMI Descripción


WMI se puede usar desde PS, pero también desde VBScripts, VBNet. Win32_BaseBoard Placa base del sistema
Desde PS se puede usar WMI para obtener y manipular información
sobre muchos aspectos de Windows y del ordenador. Win32_BIOS Representa la BIOS del sistema
WMI está organizado en clases, agrupadas en namespaces. Win32_BootConfiguration La configuración d arranque
Win32_CDROMDrive CD-ROM en el sistema
Las clases se agrupan en espacios de nombres [namespaces].
El namespace por defecto en Windows es root\cimv2. Win32_ComputerSystem PC en entorno Windows
Aqui residen todas las clases WIN32_ * listadas por Get-WMIObject.
Win32_Processor Procesador en sistema Windows
También clases para gestionar Windows event logs,
y para información sobre el software instalado en el ordenador. Win32_ComputerSystemProduct Hardware y software del sistema
Si se quiere llamar una clase fuera de este namespace, es preciso incluir su
Win32_Desktop Escritorio
nombre usando el parámetro –namespace.
El namespace root\default contiene clases para leer, escribir, crear y Win32_DesktopMonitor Monitor
borrar claves/valores del registro.
Win32_DiskDrive Disco en sistema Windows
Win32_Directory Un directorio
El cmdlet Get-WMIObject –list *Win32_*
lista las clases WMI disponibles que contienen Win32_. Win32_Environment Entorno en sistema Windows
Win32_PhysicalMemory Memoria física del sistema.
Get-WMIObject -list | where {$_.name.startswith(“Win32_”)}
lista las clases que empiezan por Win32_ , las más usadas. Win32_OperatingSystem Sistema operativo del sistema

Win32_Printer Impresora conectada al sistema


WPS facilita el acceso a WMI a través de cmdlets como:
Win32_PrinterConfiguration Configuración impresora
• Get-WMIObject. Recupera objetos WMI.
• Invoke-WMIMethod. Ejecuta métodos WMI. Win32_PrintJob Trabajo de impresión aplicación Windows
• Remove-WMIObject. Borra objetos WMI y clases. Representa un proceso
Win32_Process
• Set-WMIInstance. Pone propiedades en objeto o clase WMI.
Win32_Product Productos instalado por Windows Installer
* CIM define de forma genérica todo lo relacionado con un ordenador,
tanto a nivel hard como soft, para uso de todo el sector.
A. P. PowerShell v.1 79
Indice
WMI – Windows Management Instrumentation
WMI es la infraestructura para la gestión de datos y procesos en sistemas basados en Windows.
PowerShell y WMI se combinan a la perfección para la gestión y administración de sistemas Windows.
WMI tiene clases que comienzan con CIM_ y otras que comienzan con Win32_.
Las clases Win32_* son las clases implementadas por Microsoft, que en muchos casos son idénticas a las correspondientes CIM_*.

Las clases WMI están agrupadas en namespaces.


Los objetos WMI son instancias de clases WMI, y hacen visibles sus métodos y propiedades, con algunas propiedades no visibles.
Algunos namespaces, especialmente los relacionados con seguridad, requieren privilegios de administrador.
A diferencia de lo que pasa con .NET, los objetos se obtienen con “get” en lugar de crearse con “new”.
Esto es así porque WMI es básicamente un conjunto de almacenes de objetos fuertemente tipados, organizados en namespaces.
Estos almacenes de objetos se llaman WMI providers, y son análogos a los WPS providers, aunque tecnológicamente independientes.
Ejemplos de uso de PowerShell y WMI para la obtención de datos de hardware y software del ordenador local.

Lectura de datos básicos del ordenador local Lectura del sistema operativo del ordenador local

Lectura de discos del ordenador local Lectura del procesador del ordenador local
A. P. PowerShell v.1 80
Indice
WMI – Windows Management Instrumentation
El cmdlet Get-WmiObject explora clases y namespaces WMI.
Se accede a los métodos de propiedades de las clases WMI de igual manera que se accede a los miembros de clases .NET.

Almacén WMI
Get-WmiObject –class Win32_diskdrive ordenador local
Presenta todas las instancias de la clase. Se puede omitir –class.

Get-WmiObject –list Win32_disk* root\cimv2

namespaces
Lista todas las clases del namespace que empiezan por Win32_disk
root\default
root\wmi
root\snmp
Get-WmiObject –list –namespace root\wmi
Lista todas las clases del namespace (root\wmi)
El almacén es la base de datos de instancias WMI.
Las instancias de las clases almacenadas se
Acceso a propiedades recuperan dinámicamente por medio de un
provider* al ser requerido por un consumidor
$s =Get-WmiObject Win32_diskdrive tal como un cmdlet de PowerShell.
$s.size El almacén se organiza en namespaces.
Asignando una variable al objeto y llamando a la propiedad buscada
Almacén WMI
Get-WmiObject Win32_diskdrive | select –property size
Seleccionando a través del pipeline la propiedad buscada
ordenador Toshiba

root\cimv2

namespaces
root\default
Get-WmiObject –list Win32_disk* -computername Toshiba root\wmi
root\snmp

* provider: software que da acceso a datos en almacenes especializados:


Win32, Registry, SNMP, Event Log, Windows Installer, WDM, Performance Counter. Root\cimv2 es el namespace por defecto y el que
A. P. PowerShell v.1 contiene las clases Win32_ . 81
COM - Component Object Model Indice

COM es la tecnología predecesora de .NET para la gestión de Windows y base de OLE* de Windows.
No hay que cargar los componentes COM (no se llaman ensamblados) porque la infraestructura COM carga automaticamente las DLL
adecuadas según los datos guardados en el registro cuando se instaló el componente.
Algunas clases COM

El acceso a objetos COM, es igual que a objetos .NET, con 2 excepciones: Clase COM Descripción
■ Los objetos COM no tienen constructores con parámetros.
Excel.Application Interacción con aplicación Excel
■ Los objetos COM no tienen miembros estáticos.
Excel.Sheet Interacción con hojas Excel
PowerPoint.Application Interacción con PowerPoint
Scripting.FileSystemObject Interactúa con sistema ficheros
Shell.Aplication Acceso a aspectos de la aplicación
Explorer Shell, tales como
La tecnología COM ha sido y está siendo sustituida por la tecnología .NET, ventanas, ficheros y directorios y
sesión en curso.
siendo por tanto preferible usar .NET en todo lo posible, en lugar de COM.
Un caso en que puede ser necesario recurrir a COM en PowerShell es Shell.LocalMachine Acceso a info sobre máquina
cuando se desea interactuar con aplicaciones de Microsoft Office. actual relativa a Windows Shell.
Shell.User Acceso a aspectos del usuario.
Word.Application Interactúa con aplicación Word
Word.Document Interactúa con documento Word
WScript.Network Acceso al entorno de red
Windows: impresoras, discos de
red, información de dominio.
$WshShell = new-object -comobject “wscript.shell” WScript.Shell Acceso a aspecto de Windows
$WshShell.run(“calc.exe”) # llama a la calculadora de Windows Shell: aplicaciones, alias, variables
de entorno, registo, entorno
operativo.
$WshShell = new-object -comobject “wscript.shell”
$WshShell.Popup(“Entrar código”,9,” Ventana”) Get-Childitem REGISTRY::HKEY_CLASSES_ROOT\CLSID `
# presenta ventana emergente al usuario. -include PROGID -recurse |foreach {$_.GetValue("")}
A. P. PowerShell v.1 Lista todas las clases públicas de todos los componentes COM instalados. 82
COM - Component Object Model Indice

COM es la tecnología predecesora de .NET para la gestión de Windows y base de OLE* de Windows.
PowerShell dispone de un adaptador para COM que hace parecer los objetos COM “casi” como objetos .NET.
Un caso en que se hace necesario recurrir a COM en PowerShell es cuando se desea interactuar con las conocidas aplicaciones de Microsoft Office.

Objetos COM se instancian con New-Object y con el parámetro -comobject seguido del nombre (ProgID) de la clase.
Para Excel, el ProgID es Excel.Application, para Word es Word.Application, y así para el resto de aplicaciones de Microsoft Office.
La clase COM tiene que estar listada en el registro del sistema local. La infraestructura COM carga automaticamente las DLL adecuadas .
Objetos Excel Objetos Word
$Ex = new-object -comobject Excel.Application $W = new-object -comobject Word.Application
$Ex.Visible = $true $w.visible= $true
$b = $Ex.Workbooks.Open(“C:\Libro1.xlsx”) # abre libro dado $h = $W.Documents.Open(“c:\w1.docx”) # abre doc dado
Operaciones dentro hoja cálculo ... Operaciones dentro de documento Word ...
$b.SaveAs(“C:\Libro2.xlsx") # en nuevo fichero, no sobreescribir $h.SaveAs(“c:\w2.docx”) # en nuevo fichero, no sobreescribi

$Ex.Quit() # sale de Excel $W.Quit() # sale de Word

$Ex = New-Object -comobject "Excel.Application“ $word = New-Object -ComObject "Word.Application"


$Ex.Visible=$true $word.visible = $true
$b = $Ex.Workbooks.Add() # añade un nuevo libro $doc = $word.Documents.Add()
$s1 = $b.Worksheets.Item(1) # hoja 1 del libro $doc.Activate()
$s1.Cells.Item(1,1) = “Ventas“ # escribe en celda (1,1) $word.Selection.Font.Name = "Calibri"
$s1.Cells.Item(2,1) = 100 # escribe en celda (2,1) $word.Selection.Font.Size = “36"
$s1.Cells.Item(3,1) = 200 # escribe en celda (3,1) $word.Selection.TypeText("PowerShell") # escribe texto
$c1= $s1.cells.item(2,1).Value2 # lee valor celda a $c1 $word.Selection.TypeParagraph() # nueva línea
$c2= $s1.cells.item(3,1).Value2 # lee valor celda a $c2 $word.Selection.Font.Size = “20"
$s1.Cells.Item(4,1).Formula = $c1 + $c2 # aplica fórmula $word.Selection.TypeText(“Es fantástico")
$ct = $s1.cells.item(4,1).Value2 # lee valor celda a $ct. $word.Selection.TypeParagraph()
$Ex.Quit() # sale de Excel #$word.Quit()
Ejemplo de creación de hoja Excel, escritura en celdas, cálculo, y lectur de celda. Ejemplo de creación de documento Word, escritura de 2 líneas de texto.

Los objetos expuestos a PowerShell son los mismos expuestos a VBA.

Siempre se puede usar get-member para ver los métodos y propiedades de objetos COM.

* Object Linking and Embedding (OLE), "incrustación y enlazado de objetos“ usada en Office .
A. P. PowerShell v.1 83
Indice
XML
XML se usa para todo, desde ficheros de configuración, hasta ficheros log, o bases de datos.
PowerShell soporta XML como un tipo primitivo de datos.

Elemento: entre
Elemento Agenda Raiz
Atributo
Atributos: son
marcadores < ...>. informaciones
Un elemento adicionales de un
Persona $Mixml=[xml] “<Agenda> Persona
puede contener nodo individual.
Clase = “Personal” <Persona Clase="Personal"> Clase = “Trabajo” Se compone de un
texto u otros
elementos <Nombre>Pepe</Nombre> nombre, el signo
subordinados. <Apellido>Rodriguez</Apellido> “=“ y un valor
Nombre </Persona> Nombre entrecomillado.
Pepe <Persona Clase=“Trabajo"> Juan
<Nombre>Juanl</Nombre>
Apellido <Apellido>Gómez</Apellido> Nombre
Rodriguez </Persona> Gómez
</Agenda>”

Se entran datos con editor de texto y se guarda en


C:\temp\AgendaXML.xml
[xml] antes de la variable, indica el tipo de dato que se va a leer.
[xml]$Mixml = Get-Content C:\temp\AgendaXML.xml $Mixml.save(“C:\temp\AgendaXML.xml”)
Esta variable es del tipo System.Xml.XmlDocument.
Se accede los elementos como si fueran propiedades de un objeto.
En este formato se pueden leer sus datos con la notación (. dot).
Cada Elemento (objeto) tiene sus datos que se leen con (.dot).
Guarda modificaciones

Se pueden modificar sus elementos

Al usar la notación (.dot), WPS no distingue entre elementos y atributos.


Al tratar WPS los documentos XML como objetos, se puede usar el pipeline
y los
A. P. cmdlet Where-Object, Select-Object o ForEach para filtrar datos. PowerShell v.1 84
Indice
XML
Cada elemento (objeto) tiene propiedades y métodos que se consultan con Get-Member. Ej. $Mixml | Get-Member.

Añadir Elementos Localizar Elementos


Una forma sencilla de añadir elementos a un documento XML, Para ficheros grandes, se pueden usar otros métodos como el cmdlet
es crear una copia de un elemento existente, y modificar sus Select-XML y XPath.
datos según proceda.
Luego se inserta el elemento creado, al final de la colección. XPath es una sintaxis que define las partes de un documento XML.
Cada nodo se relaciona con otros nodos en forma de árbol.
Si un nodo contiene otros, el primero sería el padre y los otros hijos.
Se inicia la sentencia Xpath con “/” o “//”.
“/” se usa con vias absolutas.
“//” se usa con vias relativas.

Se pueden usar los métodos de cualquier nodo XML.


P. ej. SelectNodes() combinado con XPath.

Con dirección absoluta

Si se desea añadir el nuevo elemento en una ubicación concreta, Con dirección relativa
se usa InsertAfter en lugar de AppendChild

InsertAfter no sólo añade


elementos sino que también los
mueve a la dirección que se
indica.

A. P. PowerShell v.1 85
Indice
Importar – Exportar ficheros XML
WPS permite guardar datos de objetos en fichero XML, usando el cmdlet Export-Clixml.
Get-ChildItem c:\temp | Export-Clixml C:\temp\Textxml.xml
Get-ChildItem genera la lista de ficheros del directorio C:\temp, y guarda el resultado en Textxml.xml.

pipeline

C:\temp C:\temp\Textxml.xml
Get-ChildItem C:\temp Export-Clixml
Ejemplo generador
objetos para Export
Export-CliXML exporta objetos a fichero XML.

WPS dispone del cmdlet Import-Clixml que recupera datos XML, usables de nuevo por WPS.
$varxml = Import-Clixml C:\temp\Textxml.xml

$varxml Import-Clixml C:\temp C:\temp\Textxml.xml

Variable WPS
Import-CliXML importa ficheros XML a objetos.

A. P. PowerShell v.1 86
Indice
Expresiones Regulares
Regular expression -RegEx- es una cadena codificada que define un patrón de búsqueda en otra.
Las expresiones regulares en WPS usan los métodos y propiedeades de la clase Regex de .NET.
Las expresiones regulares facilitan la búsqueda y reemplazo de cadenas de caracteres.
Por defecto, las expresiones regulares son case sensitive.

Métodos Clase Regex PowerShell


Los métodos tienen parámetros. PowerShell dispone de métodos
Las expresiones regulares tratan de igualar
Texto en el más directos para las expresiones
que se busca Regular expression y encontrar patrones en textos, desde los
IsMatch regulares.
más simples a los más complejos.
[regex]::IsMatch(“esta casa es mia”,”casa”)  Literales : se entra la cadena “literalmente”
Devuelve True o False.
 Dígitos: dígitos buscados [123] entre corchetes. –match
Match [0-9] busca todos  abreviadamente \d. Texto en el que se busca Regular expression
 No dígitos: [^0-9] equivale a [^\d] y también \D. “esta casa es mía” -match “casa”
[regex]::Match(“Era Pepe”,”Pepe”)
Devuelve True o False y otros datos del match.  Letras y números: \w equivale a [a-zA-Z0-9]. Devuelve True o False
Negaciones con [^\w] que equivale a [^a-zA-Z0-9].
Replace  Caracteres especiales: -replace
“Era Pepe” -replace “Pepe”, “Juan”
[regex]::Replace(“Era Pepe”,”Pepe”,”Juan”) \s para igualar espacios equivale a [\f\t\n\r] donde
Devuelve la cadena con el reemplazo
Devuelve cadena con el reemplazo. \f para alimentación forma,
\t para tabulación,
-split
Split \n para nueva línea,
\r para retorno de carro. “Era Pepe” -split “Pepe”
[regex]::Split(“Era Pepe”,”Pepe”) Devuelve la cadena cortada
Devuelve la cadena cortada

[ ] los corchetes cuadrados no se igualan, son metacaracteres.


\ carácter de inicio abreviatura, escape del siguiente caracter.
A. P. PowerShell v.1 87
Indice
Expresiones Regulares – caracteres especiales I
La verdadera potencia de las expresiones regulares no proviene de la búsqueda de literales, sino del uso de caracteres especiales.

Carácter Descripción
\ Marca el siguiente carácter como un carácter especial o un literal. Para “escapar” caracteres especiales en regex.
^ Iguala el comienzo del patrón.
$ Iguala el final del patrón.
* Iguala caracter precedente cero o más veces.
+ Iguala el caracter precedente una o más veces.
? Iguala el carácter precedente cero o una vez.
. Iguala cualquier caracter simple excepto el caracter de nueva línea.
(pattern) Iguala pattern y recuerda la igualdad. La subcadena igualada se puede recuperar de la colección Matches resultante
usando Item [0]...[n] . Para igualar los caracteres de paréntesis, precederlos con barra inclinada “ \“.
(?:pattern) Iguala pattern pero no captura la igualdad, es decir no se guarda la igualdad para posible uso futuro. Esto resulta útil para
combinar partes de un patrón con el carácter “or” (|). P. ej. “anomal(?: y|ies)” es más corto que “anomaly|anomalies” .
(?=pattern) Búsqueda positiva hacia adelante iguala la cadena en cualquier punto donde se inicie una coincidencia con el patrón.
P.ej. “ Windows (?=95|98|NT| 2000|XP|Vista) ” iguala “Windows” en “Windows Vista” pero no “Windows” en “Windows 3.1”.
(?!pattern) Búsqueda negativa hacia adelante iguala la cadena en cualquier punto donde se inicie una no coincidencia con el patrón.
P.ej. “ Windows (?!95|98|NT|2000|XP|Vista) ” iguala “Windows” en “Windows 3.1” pero no “Windows” en “Windows Vista”.
x|y Iguala x ó y.
{n} Iguala exactamente n veces ( n debe ser siempre un entero no negativo).
{n,} Iguala al menos n veces ( n tiene que ser número no-negativo. Observar la coma al final.
{n,m} Iguala un mínimo de n y máximo de m veces ( m y n tienen que ser enteros no-negativos).
[xyz] Iguala a cualquier de los caracteres contenidos ( xyz es un juego de caracteres).
[^xyz] Iguala cualquier carácter no incluido ( ^xyz es un juego negativo de caracteres).
[a-z] Iguala cualquier carácter en el rango especificado ( a-z es un rango de caracteres).
[m-z] Iguala cualquier caracter no contenido en el rango especificado ( ^m-z es un rango negativo de caracteres).
\b Iguala el límite de una palabra, es decir la posición entre una palabra y un espacio.
\B Iguala un límite sin palabra.
\d Iguala un caracter numérico. Equivalente a [0-9] .
\D Iguala un caracter no numérico. Equivalente a [^0-9] .

A. P. PowerShell v.1 88
Indice
Expresiones Regulares – caracteres especiales II
La verdadera potencia de las expresiones regulares no proviene de la búsqueda de literales, sino del uso de caracteres especiales.

Carácter Descripción
\f Iguala un carácter de salto de página.
\n Iguala un carácter de salto de línea.
\r Iguala un carácter de retorno de carro.
\s Iguala cualquier espacio blanco incluyendo espacio, tab, salto página, etc. Equivalente a “[\f \n \r \t \v ]” .
\S Iguala cualquier espacio no blanco. Equivalente a [^\f \n \r \t\v]” .
\t Iguala un carácter tab .
\v Iguala un carácter tab vertical.
\w Iguala cualquier carácter de palabra incluyendo subrayado. Equivalente a “[A-Za-z0-9_]” .
\W Iguala cualquier carácter no de palabra. Equivalente a “[^A-Za-z0-9\_]” .
\. Iguala .
\| Iguala |
\{ Iguala {
\} Iguala }
\\ Iguala \
\[ Iguala [
\] Iguala ]
\( Iguala (
\) Iguala )
$ num Iguala num , donde num es un entero positivo.
\n Iguala n, donde n es un valor octal de escape, que tienen que ser de 1, 2, o 3 dígitos de longitud.
\uxxxx Iguala el carácter ASCII expresado por el UNICODE xxxx.
\xn Iguala n, donde n es un valor hexadecimal de escape, que tiene que ser de 2 dígitos de longitud.

A. P. PowerShell v.1 89
Indice
Programación de Tareas en PowerShell
PowerShell dispone de cmdlets para la programación de tareas, sin recurrir a Windows Task Scheduler.

Para programar Tareas hay que abrir PowerShell como administrador.


Start-Process powershell -Verb runAs
Se crea un objeto (variable) que define cuando arrancará la tarea : desencadenante de tarea (jobtrigger).
Tarea1 : ¿ Cuando ? PS C:\ > $Tarea1 = New-JobTrigger –Once –At 20:00PM
El parámetro At acepta un objeto DateTime de formato correcto.
Tarea2 : ¿ Cuando ? RandomDelay acepta un objeto TimeSpan, que causa un retardo del valor dado sobre el valor de At.
PS C:\ > $Tarea2 = New-JobTrigger –Daily –At 20:00PM –RandomDelay (New-TimeSpan – Minutes 5)

Tarea1 : { Qué } PS C:\ > $Accion1 = {Get-ChildItem c:\temp | Out-File c:\temp\dir1.txt}


Acción a realizar cuando llegue el tiempo programado. Puede ser un script o un scriptblock.
Tarea2 : { Qué } PS C:\ > $Accion2 = {Get-ChildItem c:\temp2 | Out-File c:\temp\dir2.txt}
Acción a realizar cuando llegue el tiempo programado. Puede ser un script o un scriptblock.

Para que el cmdlet New-JobTrigger funcione, se pasa su resultado a Register-ScheduledJob.


Registro de Tareas y Las variable $Tarea1 y $Tarea2 se pasan a Register-ScheduledJob para programar las tareas:
EJECUCION PS C:\ > Register-ScheduledJob -Name Tarea1 -ScriptBlock $Accion1 -Trigger $Tarea1
PS C:\ > Register-ScheduledJob -Name Tarea2 -ScriptBlock $Accion2 -Trigger $Tarea2

La tarea creada se obtiene con


PS C:\ > Get-ScheduledJob
Y una tarea en particular, entrando su nombre o Id.
PS C:\ > Get-ScheduledJob -Name Tarea1
El cmdlet Get-Job retorna la tarea programada o completa.
PS C:\ > Get-Job Start-Job -Name Tarea1 -ScriptBlock $Accion1
Para desactivar una tarea programada: Ejecución inmediata de una tarea programada.
PS C:\> Disable-ScheduledJob –Name Tarea1
Para volver a reactivarla:
PS C:\> Enable-ScheduledJob –Name Tarea1
Cuando ya no se necesite una tarea, se quita con:
PS C:\> Unregister-ScheduledJob –Name Tarea1
A. P. PowerShell v.1 90
EventLogs Indice

Los EventLogs son el núcleo de las funciones de monitorización y diagnóstico de Windows.


PowerShell ofrece los cmdlets Get-EventLog y Get-WinEvent, entre otros, para interactuar con los eventlogs.
Cuando se instala PowerShell, se crea un nuevo eventlog llamado “Windows PowerShell”.
En él se guardan una serie de informaciones accesibles con el cmdlet Get-EventLog.
Los cmdlets que contienen el término EventLog operan sólo con eventos clásicos (Application, System, Security).
Para eventos en Windows Vista y posteriores versiones de Windows, se usa el cmdlet Get-WinEvent.
Logs

Get-EventLog obtiene Get-EventLog


los eventos y logs Application EventLog
-LogName Get-WinEvent trata
clásicos y de “Windows -ComputerName eventos de logs
Get-WinEvent sin parámetros obtiene

Logs clásicos + WPS


PowerShell”. -Newest clásicos y los todos los eventos de todos los logs.
-LogName es el nombre System EventLog Se para con CTRL + C.
-After generados por
del log al que se accede. Windows Vista y Get-WinEvent está diseñado para
-Before
-EntryType es un array sustituir a Get-EventLog en Windows
-UserName posteriores.
con el tipo de evento.
-InstanceID Vista o posteriores versiones Windows.
Valores aceptables: Get-WinEvent
-Index Security EventLog (readonly) Get-EventLog sólo trata logs clásicos , y
-Error -MaxEvents sigue en WPS por compatibilidad hacia
-Information -EntryTipe
-ComputerName atrás.
-Warning. -Source “Windows PowerShell” -Force PS C:\> Get-WinEvent -ListLog *
Get-EventLog –List -Message EventLog
Da los logs en PC local.
-Oldest Este cmdlet obtiene todos los logs.
-List
> Windows Vista

-ListLog Primero aparecen los logs clásicos, y


Propiedades de ... luego el resto.
Get-EventLog. Seleccionar nombre del log.
LogName es el Propiedades de
nombre del log. Get-EventLog
(no completas).
......
Otros cmdlet EventLog:
Clear-EventLog WPS permite leer/escribir en los EventLog clásicos, con la clase .NET. System.Diagnostics.EventLog .
Remove-EventLog Antes, es preciso definir la source que generará los eventos, y abrir esta source en el sistema de logs.
Show-EventLog Para registrar la source, llamar al método estático [System.Diagnostics.EventLog] :: CreateEventSource.
Write-EventLog Esto se hace como administrador.
New-EventLog Registrada la source, se accede sin ser administrador, creando objetos de System.Diagnostics.EventLog y
Limit-EventLog utilizando sus propiedades (entries, log, source, ..) y métodos (Clear,CreateEventSource,Delete,WriteEntry,.).
A. P. PowerShell v.1 91
Indice
Manejo de errores y excepciones
PowerShell soporta 2 clases de errores : terminales y no-terminales.
La variable automática $error [array] guarda los errores de ambos tipos generados en una sesión WPS.

Cuando un comando detecta error, Un error terminal detiene la ejecución del


lo registra en la variable array $error. cmdlet, script, función o pipeline.
$error $error.count # dá nº errores Errores terminales se pueden interceptar con
$error.clear() # borra todos los errores try / catch / finally, o con claúsula trap.
$error[0] # error más reciente
Respuesta a errores terminales:
Respuesta a mensajes de aviso: Respuesta a errores no-terminales: - con sentencias try/ catch/finally o
$warningPreference = "Continue" $errorActionPreference ="SilentlyContinue" - con sentencia trap

La mayoria try
de cmdlets { Código a ser examinado. Si se detecta error se
Ignore No presenta error y no añade a $error.
permiten pasa a sentencia catch correspondiente al error }
SilentlyContinue No presenta error, pero si añade a $error. catch [Error 1]
configurar
esto en su Stop Trata no-terminales como terminales. { Código de respuesta a Error1 detectado en try}
parámetro Continue Muestra y añade a $error, pero continua. Por defecto. catch
-ErrorAction. Inquire Solicita como se debe tratar el error. { Respuesta a resto de errores detectados en try}
finally
{ Código a ejecutar tanto si actúa catch como si no }
El parámetro
-ErrorVariable
asigna el error Para notificar al usuario, se usan los cmdlets: Trap [Error1] {
a la varialbe - Write-Warning para notificar una mera ADVERTENCIA Código a ejecutar
especificada, Return [valor] | Continue | Break }
sin afectar a
- Write-Error para notificar un error superable
$error.

$error tiene, - Exception. Dá un mensaje informativo. Throw causa un error terminal.


entre otras, las
siguientes - CategoryInfo. Indica la clasificación del tipo de error ocurrido. Se puede usar throw en una sentencia catch
propiedades - ErrorDetails. Dá detalles sobre el error. o dentro de una claúsula If para responder a
que ayudan a - TargetObject. Identifica el objeto activo cuando el error. determinada condición de error o excepción.
aclarar errores.

$_ representa la excepción o error detectado


A. P. PowerShell v.1 92
Indice
Rendimiento
El Monitor de Rendimiento de Windows, Panel de Control, Herramientas administrativas, examina el modo en el que los
programas afectan al rendimiento del equipo, tanto en tiempo real como mediante la recopilación de datos del registro.
El Monitor de rendimiento solicita el valor actual de los contadores de rendimiento a intervalos de tiempo especificados.
Los rendimientos deben medirse en periodos de tiempo, y guardados en bases de datos para su examen posterior.
PowerShell no dispone de ningún cmdlet para obtener valores de rendimiento. Hay que usar clases .NET para ello.
Se crea objeto System.Diagnostics.PerformanceCounter, se usan sus propiedades, y se llama al método NextValue().

máquina
categoría
Instancia categoría
contador
El contador (counter) es el elemento que recoge los
datos de rendimiento. Los contadores se guardan
máquina por su nombre en el registro.
categoría Hay contadores para el tiempo de ocupación del
procesador, uso de memoria, etc.
Instancia categoría Los contadores se identifican con 4 elementos:
contador máquina, categoría, instancia de la categoría, y
nombre del contador.

Para leer de un contador, hay que crear un objeto de la máquina WMI provee clases para el rendimiento a través
clase PerformanceCounter , usar sus propiedades categoría del provider WMI Performance Counter.
CategoryName, CounterName, y opcionalmente, Las clases comienzan con Win32_PerfRawData.
InstanceName o MachineName , y luego llamar a su Instancia categoría
método NextValue() para hacer una lectura del contador. contador

A. P. PowerShell v.1 93
Indice
Acceso remoto – Introducción I
El objetivo del acceso remoto es ejecutar comando(s) en ordenador(es) remoto(s).
La funcionalidad remota de PowerShell, a partir de PS 2., permite ejecutar comandos PowerShell en equipos remotos en redes Windows.

Hay 2 formas de hacerlo

Comunicación remota sin configuración Comunicación remota de Windows PowerShell


Con comandos que cuentan con su propio acceso remoto. La comunicación remota de WPS, que usa el protocolo WS-Management,
Algunos cmdlets cuentan con el parámetro –computername que permite permite ejecutar cualquier comando de PS en uno o varios equipos remotos.
leer objetos de equipos remotos. Se pueden usar estos cmdlets con Para la comunicación remota con Windows PowerShell, todos los equipos
cualquier equipo en que corra Windows PowerShell. implicados deben tener una configuración adecuada para uso remoto.
Los cmdlets que admiten la comunicación remota sin una configuración especial
tienen un parámetro ComputerName y carecen de un parámetro Session. Requerimientos
get-command | where{$_.parameters.keys –contains “computername” and –notcontains “session”}
Los ordenadores local y remoto deben tener:
-- Windows PowerShell 5.1 [ al menos >3.0]
-- Microsoft .NET Framework > 2.0
-- Windows Remote Management (WinRM) [viene con >PS 2.0]
La funcionalidad remota corre bajo WinRM,
que es la versión de Microsoft del protocolo
WS-Man (Web Services for Management).
La red Windows debe ser Private (no Public).

Tipo de red ?

P. ej. Para obtener los servicios en ordenador remoto Elisa:


Mismo dominio Grupo Hogar
get-service -computername Elisa

Aunque de apariencia simple, conseguir una conexión remota En su caso, consultar las ayudas de PowerShell sobre el tema:
resulta dificil en la práctica por diferencias entre versiones,
configuraciones, etc, dependiendo fuertemente de cada caso.
El acceso remoto es un tema particularmente complejo.
! - get-help about_remote
- get-help about_remote_requirements
- get-help about_remote_troubleshooting
A. P. PowerShell v.1 94
Acceso remoto – Introducción II Indice

Una de las más importantes características de WPS es su capacidad de gestión remota de ordenadores en red.
PowerShell usa WinRM (Windows Remote Management), basado en el protocolo WS-Management de Microsoft.
PowerShell como Administrador PowerShell como Administrador
Este cmdlet inicia el servicio WinRM, y lo configura para arranque automático,
y crea un firewall que permite conexiones entrantes.
Enable-PSRemoting –force El parámetro –force evita confirmaciones intermedias. Enable-PSRemoting –force
Se desactiva en cualquier momento con Disable-PSRemoting.

Public Red Private ? La red formada debe ser declarada Private, no Public, para operar de este modo. Red Private ? Public

Set-Item wsman:\localhost\client\trustedhosts elisa Ambos tienen que ser miembros Set-Item wsman:\localhost\client\trustedhosts lenovo
del mismo dominio de confianza.
LOCAL REMOTO
“Lenovo” “Elisa”

PowerShell Red doméstica PowerShell


v2 o v3 o v2 o v3 o
superior [Grupo Hogar] superior
> Windows XP Mismo proceso en todos > Windows XP

los equipos de la red


Restart-Service WinRM Restart-Service WinRM
declarada como Private
Error Test-WsMan Elisa Test-WsMan lenovo Error

Invoke-Command -ComputerName elisa -ScriptBlock { get-service } -credential elisa Comando


Resultado
Scriptblock : comandos a ejecutar en pc remoto, separados por ; . Credencial : nombre usuario del pc remoto
Script : usar parámetro –filepath, con nombre y via del script.

Enter-PSSession -ComputerName elisa -Credential elisa


Comando
[elisa]: PS C:\Users\Alfonso\Documents> get-service
Resultado
En la sesión, es como si se estuviera en equipo remoto
Exit-PSSession
A. P. PowerShell v.1 95
Acceso remoto – Introducción III Indice

Una de las más importantes características de WPS es su capacidad de gestión remota de ordenadores en red.
PowerShell usa WinRM (Windows Remote Management), basado en el protocolo WS-Management de Microsoft.

Conexión remota dentro de un dominio


PowerShell como Administrador PowerShell como Administrador
Este cmdlet inicia el servicio WinRM, y lo configura para arranque
automático, y crea un firewall que permite conexiones entrantes.
Enable-PSRemoting –force El parámetro –force evita confirmaciones intermedias.
Enable-PSRemoting –force
Se desactiva en cualquier momento con Disable-PSRemoting.

LOCAL
Red en mismo dominio REMOTO
“Lenovo” Un dominio de Internet es una red de identificación asociada “Elisa”
a un grupo de dispositivos o equipos conectados a Internet.
PowerShell PowerShell
Un dominio se define por una dirección IP común o un
v2 o v3 o v2 o v3 o
conjunto de direcciones IP similares.
superior superior
Un nombre de dominio tal como www.undominio.es
> Windows XP se compone, tras www, de dos partes: el nombre de la > Windows XP
organización y el tipo de organización (p.ej. es, com, etc).

Test-WsMan Elisa Error Error Test-WsMan lenovo

Invoke-Command -ComputerName elisa -ScriptBlock { get-service } -credential elisa Comando


Resultado
Scriptblock : comando a ejecutar en pc remoto Credencial : nombre usuario del pc a que se dirige

Enter-PSSession -ComputerName elisa -Credential elisa


Comando
[elisa]: PS C:\Users\Alfonso\Documents> get-service
Resultado
En la sesión, es como si se estuviera en equipo remoto
Exit-PSSession
A. P. PowerShell v.1 96
Indice
Internet
PowerShell no dispone de funciones para cargar o descargar ficheros, ni siquiera para trabajar con páginas web.
Pero .NET Framework dá excelente soporte para operar con el protocolo HTTP, cuyo objeto es compartir documentos de hipertexto.
Los documentos se identifican con su URL (Uniform Resource Locator) y pueden tener enlaces a documentos, multimedia, etc.
Cuenta con clases para trabajar con ficheros ubicados en servidores remotos: System.Net.WebClient es una de ellas.

Obtener el contenido de una página web es muy sencillo, contando con la clase System.Net.WebClient.
Ejemplo con una página web de inicio de Yahoo:
PS> $client = New-Object System.Net.WebClient
PS> $client.DownloadString("http://www.elpais.com")
Sólo se necesitan 2 líneas.
La primera crea una instancia de la clase System.Net.WebClient .
La segunda usa el método DownloadString de la instancia recién creada para conseguir la página como una cadena.
La cadena (string) obtenida es el código HTML de la página web, y cuenta con propiedades para manipular la cadena, como
-length
-contains
-equals
-insert
-remove
-replace
-split
- ..

A. P. PowerShell v.1 97
Indice
Reflexión [Reflection]
En el entorno .NET, la reflexión es el proceso de obtener datos de tipos en tiempo de ejecución.
Mediante reflexión se pueden obtener por programa los tipos contenidos en un ensamblado, incluyendo métodos, propiedades, y eventos.
También se pueden obtener otros detalles relacionados: información de espacio de nombres, datos de manifiesto, etc.
Las clases del namespace System.Reflection, junto con System.Type, obtienen información sobre los ensamblados cargados y sus tipos.
También se puede usar la reflexión para crear instancias de tipos en tiempo de ejecución, llamarlas y para acceder a ellas.

Desde PowerShell se puede aprovechar la funcionalidad de .NET Framework para trabajar con la reflexión (reflection).
La reflexión permite inspeccionar ensamblados, tanto .dll como .exe, y examinar sus metadatos.
Los ensamblados contienen módulos, los módulos contienen clases, y las clases tienen miembros (métodos, propiedades, eventos).
La reflexión permite inspeccionar esta jerarquía de ensamblados, módulos, clases y miembros.

El cmdlet Get-Member de PS, al estar PowerShell basado en .NET Framework, dispone de esta función de reflexión.
Este cmdlet analiza un objeto o colección que se le pasa por el pipeline, presentado sus métodos y propiedades.
PS C:\> $a = “hola”
PS C:\> $a | get-member –membertype methods para obtener los métodos de objeto(s).
PS C:\> $a | get-member –membertype properties para obtener propiedades de objeto(s).

La alternativa, usando puramente .NET, consiste en el uso del método GetType(), aplicable a todos los objetos .NET.
El método GetType() retorna un objeto Type (exactamente RuntimeType) que dispone de muchos métodos y propiedades. Una instancia de Type
Type es la base de la funcionalidad de reflexión y es forma más rápida de acceder a datos de ensamblados y clases. puede representar a
cualquiera de los
siguientes tipos:
-Clases
-Tipos de valor
-Arrays
-Interfaces
-Enumeraciones
-Delegados
-Tipos genéricos

Además de leer el ensamblado, namespace, y nombre, el objeto Type que representa a estos objetos tiene métodos, propiedades, etc

A. P. PowerShell v.1 98
Reflexión [Reflection] Indice

Clase raiz de todas las clases .NET


System.Object
Método aplicable a todos los objetos,
Type* al derivar todos de System.Object.
Devuelve un objeto Type.
Clase abstracta, hereda de System.Object Miembo de System.Object

# Obtención de objetos Type*


# Con método GetType () de System.Object. Todas las clases,
heredan de System.Object.
$a = “hola”
$a.GetType( )
Se necesita un objeto, $a en este caso GetFields(), GetMethods(), GetProperties(), Assembly
GetEvents() y GetConstructors()

Namespace
System.Reflection
dan como respuesta una matriz
GetField() GetFields() FieldInfo[] , MethodInfo[] , PropertyInfo[], FieldInfo
EventInfo[], y ConstructorInfo[] respectivamente.
Métodos relevantes

GetProperty() GetProperties() Estas matrices son miembros de System.Reflection. PropertyInfo

A partir del Type MethodInfo


GetMethod() GetMethods()
$a.GetType().GetMethods ( )

GetEvent() GetEvents() EventInfo

GetConstructor() GetConstructors() ConstructorInfo


Ejemplo de reflexión : hay un objeto $a) que se quiere modificar en runtime.
El namespace System.Reflection
Name $a = “hola”
contiene tipos que recuperan
propiedades

# Asignación de variable, que es también un objeto.


$a.GetType() información sobre ensamblados,
Namespace # Obtención de objeto Type del objeto $a. modulos, miembros, parámetros,
$a.GetType().GetMethods ( ) | format-table name y otros metadatos en runtime.
# Lista los métodos disponibles del Type obtenido. Buscamos ToUpper().
Assembly $a.GetType().GetMethods ( )[98].GetType().GetMethods() | ft name
´# El método ToUpper() es el 98 en el array de métodos. Buscamos su Type y métodos.
$a.GetType().GetMethods ( )[98].Invoke($a,$null)
• Type es una clase abstracta, no instanciable, # Llama al método invoca del método [98], con parámetros $a y $null.
que es la base de la reflexión. HOLA
Dá información sobre un ensamblados, # Resultado de la reflexión al objeto $a, y aplicación del método ToUpper().
módulos o clases en tiempo de ejecución.
A. P. PowerShell v.1 99
Indice

A. P. PowerShell v.1 100

Potrebbero piacerti anche