2. Programación en PowerShell

Variables
- Constantes
- Ámbito
- Tipos
- Tipos simples
  - Numéricas
  - Caracteres
  - Fechas
  - Arrays
  - Arrays de números
  - Arrays de caracteres (cadenas)
- Tipos complejos
  - Enumeraciones
Objetos
Ficheros
Operaciones aritméticas
Operaciones lógicas
Operaciones de comparación
Sentencias condicionales
Sentencias de repetición
Funciones

La programación es necesaria para realizar tareas de forma automática y consiste en indicar ordenes al sistema, en PowerShell el conjunto de ordenes se puede realizar mediante scripts. Un script es un conjunto de comandos (cmdlets) y elementos de programación (bucles, condicionales, comparaciones, etc.) que se ejecutan sobre PowerShell y realizan alguna función.

Ahora podemos hacernos algunas preguntas relacionadas con lo que queremos hacer utilizando scripts:

¿Cómo almacenar un valor de forma temporal?
¿Cómo almacenar un valor de forma permanente?
¿Cómo buscar una cadena?
¿Cómo buscar una cadena que ha introducido el usuario?
¿Cómo distinguir entre dos opciones?
¿Cómo distinguir entre varias opciones?
¿Cómo repetir algo?
¿Cómo utilizar algo nuevamente y no queremos añadirlo al código?

Variables

El sistema operativo almacena valores temporales en memoria que desaparecen cuando se cierra el sistema operativo, en PowerShell se pueden utilizar datos y almacenarlos hasta que se cierra PowerShell.

En programación, las variables son espacios reservados en la memoria que, como su nombre indica, pueden cambiar de contenido a lo largo de la ejecución de un programa. Una variable corresponde a un área reservada en la memoria principal del ordenador.

Características de las variables

Se almacenan valores temporales en memoria que desaparecen cuando se cierra PowerShell.
Almacenan información.
Se pueden almacenar números te todo tipo, letras, conjunto de letras.
Los datos con los que estamos trabajando también se pueden almacenar en el
sistema de forma permanente.
Concepto de variable relacionado con almacenar datos durante un tiempo.
Datos que pueden ser introducidos por el usuario.
Datos que se pueden modificar mediante cálculos.
Datos que se pueden escribir.
Datos que se pueden dar formato.
Datos que residen en la memoria.

Ejemplo

Asignar un valor a una variable y mostrar el valor por pantalla

$cantidad=20
Write-Host $cantidad

Constantes

En programación, una constante es un valor que no puede ser alterado/modificado durante la ejecución de un programa, únicamente puede ser leído.

Una constante corresponde a una longitud fija de un área reservada en la memoria principal del ordenador, donde el programa almacena valores fijos.

Ámbito

El ámbito de una variable (llamado “scope” en inglés) es la zona del programa en la que se define la variable.

Tipos

En PowerShell no es necesario establecer el tipo de dato aunque se puede hacer indicando el tipo de variable entre corchetes [ ]. Pero se puede hacer si se quiere.

Ejemplo

Crear una variable de tipo numérica y mostrar el valor por pantalla

[Int]$num=5
$num

Para ver el tipo de variable se utiliza el método

$var.getType()

Ejemplo

Ver el tipo de las siguientes variables

[Int]$num=5
$num.GetType()
[Char]$num=5
$num.GetType()

Ejercicio

Crear una variable con el valor 20 indicando el tipo entero para una de las variables y el tipo carácter para la otra, después ver el contenido y comprobar el tipo después

[int]$cantidad=20
Write-Host $cantidad
$cantidad.GetType()

[string]$cantidad2=20
Write-Host $cantidad2
$cantidad2.GetType()

Tipos simples

Numéricas

Variables que representan valores enteros.

Ejemplo

$num=5
$num

Caracteres

Variables que representan valores tipo carácter.

Ejemplo

#Caracteres
$car='c'
$car

Booleanos

Representan el valor verdadero (1) o falso (0).

Ejemplo

$true
$false

Fechas

Fechas también son un tipo de variable, las fechas sirven para saber en qué momento ocurrió algo en relación con el momento actual.

Cmdlet para mostrar la fecha del sistema

Get-Date

Ejemplos

Mostrar la fecha actual

(Get-Date)

Mostrar año

Get-Date).Year

La fecha del sistema se puede cambiar utilizando el cmdlet

Set-Date

Ejemplo

Cambiar la fecha del sistema

Set-Date -date "6/1/2006 8:30 AM"

A las fechas se les puede dar formato

Ejemplos

Mostrar la fecha con distintos formatos

Get-Date -Format 'HH:mm:ss dddd MMMM d'
Get-Date).Year.tostring()+(Get-Date).Month.tostring()+(Get-Date).Day.tostring()
Get-Date).ToString("yyyyMMdd")
Get-Date).ToString("ddMMyyyy")

Las operaciones sobre fechas (métodos) son:

AddSeconds
AddMinutes
AddHours
AddDays
AddMonths
AddYears

Ejemplos

Mostrar la fecha del día anterior (con y sin formato)

(Get-Date).AddDays(-1)
(Get-Date).AddDays(-1).ToString("ddMMyyyy")

Mostrar las fechas de la semana pasada

-1..-7 | % {(Get-Date).AddDays($_).ToString("ddMMyyyy")}

Para crear una variable que representa un intervalo de tiempo se utiliza el cmdlet

New-TimeSpan

Ejemplo

Mostrar el intervalo de tiempo entre dos fechas

New-TimeSpan $(Get-Date) $(Get-Date -month 7 -day 19 -year 2016)

Arrays

Una zona de almacenamiento continuo, que contiene una serie de elementos del mismo tipo.

Los arrays pueden contener cualquier carácter, los arrays más utilizados son los arrays de números y de caracteres que se conocen como cadenas.

Arrays de números

Arrays que contienen números.

Ejemplo

Crear un array de números y mostrar el primer elemento

$arraynumeros="12345"
Write-Host $arraynumeros
Write-Host $arraynumeros[1]

Arrays de caracteres

Arrays que contienen cualquier tipo de carácter y se denominan cadenas.

Ejemplos

Mostrar una cadena

$palabra=’hola’
Write-Host $palabra

Ver elementos de arrays de caracteres, extraer varios elementos

#Extraer primer elemento (elemento 0)
$frase='Texto largo'
Write-Host $frase[0]

#Extraer segundo elemento (elemento 1)
$frase='Texto largo'
Write-Host $frase[1]

#Extraer último elemento
$frase='Texto largo'
Write-Host $frase[10]

Sobre las cadenas se pueden realizar varias operaciones, algunas operaciones que se pueden realizar en PowerShell son:

Concatenar

Ejemplo

$palabra1='hola-'
$palabra2='adios'
$frasecontatenada=$palabra1+$palabra2
$frasecontatenada

Determinar longitud

Ejemplo

'Hola'.Length

Convertir en mayúsculas

Ejemplo

'Hola'.ToUpper()

Convertir en minúsculas

Ejemplo

'Hola'.ToLower()

Reemplazar caracteres

Ejemplo

'Hola'.Replace('o', '0')
"Hola buenas Lucas"-replace "hola|buenas","adios"

Partir cadenas

Ejemplo

'Hola,buenas'.Split(',')

Eliminar espacios

Ejemplo

'Hola buenas '.TrimStart()
'Hola buenas '.TrimEnd()
'Hola buenas '.Trim()

Extraer elementos

Ejemplo

'Hola'.Substring(0)
'Hola'.Substring(0,2)
'Hola'.Substring(2)
'Hola'.Substring(2,1)

Insertar elementos

Ejemplo

'Hola'.Insert(2, "oooo")

Eliminar elementos

Ejemplo

'Hola'.Remove(3)
'Hola'.Remove(2)
'Hola'.Remove(1)
'Hola'.Remove(1,1)
'Hola'.Remove(2,2)
'Hola'.Remove(1,2)
'Hola'.Remove(1,3)

Determinar la primera posición de un carácter

Ejemplo

'Holasa'.IndexOf('a')

Determinar la última posición de un carácter

Ejemplo

'Holasa'.LastIndexOf('a')

Determinar si el principio de una cadena coincide con otra cadena

Ejemplo

'Hola'.StartsWith('H')

Determinar si el principio de una cadena coincide con otra cadena

Ejemplo

'Hola'.EndsWith('lo')

Determinar si un carácter está contenido en una cadena

Ejemplo

'Hola'.Contains('a')

Buscar

Ejemplo

'Hola'| Select-String 'o'

Tipos complejos

Enumeraciones

Ejemplo

Crear una variable de tipo complejo con las principales ciudades del mundo

enum Ciudades
{
    Hannover
    Madrid
    Seattle
    Barcelona
    London
    NewYork
}

function Seleccion-Ciudades
{
    param ([Ciudades][Parameter(Mandatory=$true)]$Ciudad)
    Write-Host "Has elegido la ciudad de $Ciudad"
}

Seleccion-Ciudades 3

Objetos

Los objetos, propiedades, métodos y eventos son las unidades básicas de la programación orientada a objetos. Un objeto es un elemento de una aplicación, que representa una instancia de una clase. Propiedades, métodos y eventos son las unidades de creación básicas de los objetos y constituyen sus miembros.

En PowerShell los cmdlets se tratan como objetos.

Ejemplo

Almacenar la ejecución de los cmdlets ls y ps y ver las propiedades y los métodos de cada variable

$variable=ls
$variable | Get-Member

$variableproce=ps
$variableproce | Get-Member

Algunas características de los objetos:

Un objeto representa una instancia de una clase.
Una propiedad es un atributo de un objeto que define una de las características del objeto, como tamaño, color o ubicación en pantalla, o un aspecto de su comportamiento.
Un método es una acción que un objeto puede realizar.
Un evento es una acción que un objeto reconoce, como hacer clic con el mouse (ratón) o presionar una tecla, y para el que puede escribir código para responder. Los eventos se producen como consecuencia de una acción del usuario o de código de programa, o bien pueden ser desencadenados por el sistema. También puede desarrollar eventos personalizados propios para que los generen sus objetos y los controlen otros objetos.

En PowerShell se pueden crear objetos y añadir propiedades y métodos a dichos objetos.

Crear un objeto

$objeto=New-Object Object

Añadir una propiedad a un objeto

Add-Member -MemberType NoteProperty -Name Nombre Valor -InputObject $objeto

Listar propiedades y métodos

$objeto | Get-Member

Ejemplo

Crear un objeto coche con propiedades y métodos

#Crear objeto coche
$coche=New-Object Object
#Añadir propiedad color de coche
Add-Member -MemberType NoteProperty -Name Color Negro -InputObject $coche
#Añadir método temperatura del motor
$coche | Add-Member ScriptMethod TemperaturaMotor {60}

#Mostrar el color del coche
$coche.color
#Mostrar la temperatura del motor
$coche.TemperaturaMotor()

Ficheros

Las variables tienen el problema de ser temporales por eso necesitamos poder almacenar datos de forma permanente mediante los ficheros.

Operaciones aritméticas

Con las variables se pueden realizar las siguientes operaciones aritméticas:

Sumar

Ejemplo

Sumar dos números

$num1=5
$num2=6
$resultado=$num1+$num2
Write-Host "La suma del número $num1 y el número $num2 es: "+ $resultado

Restar

Ejemplo

Restar dos números

$num1=10
$num2=6
$resultado=$num1-$num2
Write-Host "La resta del número $num1 y el número $num2 es: "+ $resultado

Multiplicar

Ejemplo

Multiplicar dos números

$num1=3
$num2=6
$resultado=$num1*$num2
Write-Host "La multiplicación del número $num1 y el número $num2 es: "+ $resultado

Dividir

Ejemplo

Dividir dos números

$num1=10
$num2=5
$resultado=$num1/$num2
Write-Host "La división del número $num1 entre el número $num2 es: "+ $resultado

Resto

Ejemplo

Resto de la división de números

$num1=4
$num2=2
$resultado=$num1%$num2
Write-Host "El resto de dividir el número $num1 entre el número $num2 es: "+ $resultado

Ejercicio

Saber si un número es par o impar, pidiendo al usuario que introduzca el número con el cmdlet Read-Host

$numero=Read-Host ("Introduzca un número para saber si es par o impar")
if($numero % 2 -eq 0)
{
Write-Host "El número $numero es par"
}
else
{
Write-Host "El número $numero es impar"
}

Operaciones lógicas

Las operaciones lógicas son expresiones matemáticas cuyo resultado es un valor booleano (verdadero o falso true o false), algunas expresiones lógicas que se pueden realizar en PowerShell son:

Tabla lógica del operador and

x	y	resultado
true	true	true
true	false	false
false	true	false
false	false	false

Ejemplo

Realizar operaciones con el operador lógico and

(1 -eq 1) -and (2 -eq 2)
#La primera operación de comparación (1 -eq 1) es True
#La segunda operación de comparación (2 -eq 2) es True
#El resultado de juntar las dos operaciones es True ya que True y True es True

(1 -eq 2) -and (2 -eq 3)
#La primera operación de comparación (1 -eq 2) es False
#La segunda operación de comparación (2 -eq 3) es False
#El resultado de juntar las dos operaciones es False ya que False y False es False

(1 -eq 1) -and (2 -eq 3)
#La primera operación de comparación (1 -eq 1) es True
#La segunda operación de comparación (2 -eq 3) es False
#El resultado de juntar las dos operaciones es False ya que True y False es False

Tabla lógica del operador or

x	y	resultado
true	true	true
true	false	true
false	true	true
false	false	false

Ejemplo

Realizar operaciones con el operador lógico or

(1 -eq 1) -or (2 -eq 2)
#La primera operación de comparación (1 -eq 1) es True
#La segunda operación de comparación (2 -eq 2) es True
#El resultado de juntar las dos operaciones es True ya que True o True es True

(1 -eq 2) -or (2 -eq 3)
#La primera operación de comparación (1 -eq 2) es False
#La segunda operación de comparación (2 -eq 3) es False
#El resultado de juntar las dos operaciones es False ya que False o False es False

(1 -eq 1) -or (2 -eq 3)
#La primera operación de comparación (1 -eq 1) es True
#La segunda operación de comparación (2 -eq 3) es False
#El resultado de juntar las dos operaciones es True ya que True o False es True

Tabla lógica del operador not

x	resultado
true	false
false	true

Ejemplo

Realizar operaciones con el operador lógico not

(1 -eq 1) -and -not (2 -eq 2)
#La primera operación de comparación (1 -eq 1) es True
#La segunda operación de comparación (2 -eq 2) es Not True es decir False
#El resultado de juntar las dos operaciones es False ya que True y False es False

(1 -eq 2) -and -not (2 -eq 3)
#La primera operación de comparación (1 -eq 2) es False
#La segunda operación de comparación (2 -eq 3) es Not False es decir True
#El resultado de juntar las dos operaciones es False ya que False y True es False

(1 -eq 1) -and -not (2 -eq 3)
#La primera operación de comparación (1 -eq 1) es True
#La segunda operación de comparación (2 -eq 3) es Not False es decir True
#El resultado de juntar las dos operaciones es False ya que True y True es True

(1 -eq 1) -or -not (2 -eq 2)
#La primera operación de comparación (1 -eq 1) es True
#La segunda operación de comparación (2 -eq 2) es Not True es decir False
#El resultado de juntar las dos operaciones es True ya que True o False es True

(1 -eq 2) -or -not (2 -eq 3)
#La primera operación de comparación (1 -eq 2) es False
#La segunda operación de comparación (2 -eq 3) es Not False es decir True
#El resultado de juntar las dos operaciones es False ya que False o True es True

(1 -eq 1) -or -not (2 -eq 3)
#La primera operación de comparación (1 -eq 1) es True
#La segunda operación de comparación (2 -eq 3) es Not False es decir True
#El resultado de juntar las dos operaciones es True ya que True o True es True

Operaciones de comparación

Algunas operaciones de comparación que se pueden realizar en PowerShell son:

eq (Equal to -> Igual a)

Ejemplo

Realizar operaciones con el operador de comparación eq

$numero=1
$resultado=$numero -eq 1
#El resultado es True, esto significa que el resultado es verdadero
Write-Host $resultado

$cadena='pepito'
$resultado=$cadena -eq 'pepito'
#El resultado es True
Write-Host $resultado

$cadena='pepito'
$resultado=$cadena -eq 'Pepito'
#El resultado es True
Write-Host $resultado

#En el caso de cadenas de caracteres cuando comparamos dos cadenas que tienen incluidas mayúsculas y minúsculas nos indica que son iguales, para diferenciar hay que utilizar:
#-ceq

$cadena='pepito'
$resultado=$cadena -ceq 'Pepito'
#El resultado es False porque no son iguales la 'p'y la 'P'
Write-Host $resultado

lt (Less than -> Menos que)

Ejemplo

Realizar operaciones con el operador de comparación lt

$numero1=1
$numero2=2
$resultado=$numero1 -lt $numero2
#El resultado es True, esto significa que el resultado es verdadero y que el número 2 es menor que el número 1
Write-Host $resultado

$numero1=1
$numero2=2
$resultado=$numero2 -lt $numero1
#El resultado es False, esto significa que el resultado es falso y que el número 1 no es menor que el número 2
Write-Host $resultado

gt (Greater than -> Más que)

Ejemplo

Realizar operaciones con el operador de comparación gt

$numero1=1
$numero2=2
$resultado=$numero1 -gt $numero2
#El resultado es False, esto significa que el resultado es falso y que el número 1 no es mayor que el número 2
Write-Host $resultado

$numero1=1
$numero2=2
$resultado=$numero2 -gt $numero1
#El resultado es True, esto significa que el resultado es verdadero y que el número 2 es mayor que el número 1
Write-Host $resultado

ge (Greater than or Equal to -> Mayor o igual a)

Ejemplo

Realizar operaciones con el operador de comparación ge

$numero1=1
$numero2=2
$resultado=$numero1 -ge $numero2
#El resultado es False, esto significa que el resultado es falso y que el número 1 no es mayor o igual que el número 2
Write-Host $resultado

$numero1=1
$numero2=2
$resultado=$numero2 -ge $numero1
#El resultado es True, esto significa que el resultado es verdadero y que el número 2 es mayor que el número 1
Write-Host $resultado

$numero1=1
$numero2=1
$resultado=$numero2 -ge $numero1
#El resultado es True, esto significa que el resultado es verdadero y que el número 2 es igual que el número 1
Write-Host $resultado

le (Less than or equal to – Menor o igual a)

Ejemplo

Realizar operaciones con el operador de comparación le

$numero1=1
$numero2=2
$resultado=$numero1 -le $numero2
#El resultado es True, esto significa que el resultado es verdadero y que el número 1 es menor o igual que el número 1
Write-Host $resultado

$numero1=1
$numero2=2
$resultado=$numero2 -le $numero1
#El resultado es False, esto significa que el resultado es falso y que el número 2 no es menor que el número 1
Write-Host $resultado

$numero1=1
$numero2=1
$resultado=$numero2 -le $numero1
#El resultado es True, esto significa que el resultado es verdadero y que el número 2 es igual que el número 1
Write-Host $resultado

ne (Not equal to – No es igual a)

Ejemplo

Realizar operaciones con el operador de comparación ne

$numero=1
$resultado=$numero -ne 1
#El resultado es False, esto significa que es falso que el número 1 no sea igual al número 1
Write-Host $resultado

$cadena='pepito'
$resultado=$cadena -ne 'pepitos'
#El resultado es True porque pepito no es igual a pepitos
Write-Host $resultado

Sentencias condicionales

En programación, una sentencia condicional es una instrucción o grupo de instrucciones que se pueden ejecutar o no en función del valor de una condición, los tipos de sentencias condicionales son:

Ejemplo

Comprobar si un número es igual a otro utilizando if

$a=5
if($a -eq 5)
{
Write-Host “5”
}

Else

Ejemplo

Comprobar si un número es igual a otro utilizando else

$a=5
if($a -eq 5)
{
Write-Host “5”
}
else
{
Write-Host “No 5”
}

ElseIf

Ejemplo

Comprobar si un número es igual a otro utilizando elseif

$a=6
if($a -eq 5)
{
Write-Host “5”
}
elseif($a -eq 6)
{
Write-Host “6”
}
else
{
Write-Host “No 5 o 6”
}

Switch

Ejemplo

Comprobar si un número es igual a otro utilizando switch

$a=5
switch($a){
5{
Write-Host “5”
break
}
6{
Write-Host “6”
break
}
7{
Write-Host “7”
break
}
}

Sentencias de repetición

Una estructura de repetición o bucle nos permite ejecutar un numero de veces determinado una serie de instrucciones, los tipos de sentencias de repetición son:

Bucle While

Ejemplo

Mostrar los números de 1 a 10 utilizando el bucle while

$i=1
while($i -lt 11){
$i
$i++
}

Bucle Do-While

Ejemplos

Mostrar los números de 1 a 10 utilizando el bucle do-while

$i=1
do{
$i
$i++
}while($i -lt 11)

Bucle For

Ejemplos

Mostrar los números de 1 a 10 utilizando el bucle for

for($i=1;$i -lt 11;$i++)
{
$i
}

Bucle Foreach

Ejemplo

Mostrar los números de 1 a 10 utilizando el bucle foreach

foreach($i in 1..10)
{
$i
}

Mostrar los números de 1 a 10 utilizando el bucle foreach abreviado

1..10 | % {$_}

Ejercicios

Recorrer de distintas formas de 1 a 3 con Foreach

#Forma 1
$numeros=1..3

#Forma 2
$numeros | %{$PSItem}

#Forma 3
$numeros | %{$_}

#Forma 4
foreach($numero in $numeros)
{
$numero
}

Funciones

Una función es un conjunto de líneas de código que realizan una tarea específica y puede retornar un valor.

Las funciones pueden tomar parámetros que modifiquen su funcionamiento.

Las funciones son utilizadas para descomponer grandes problemas en tareas simples y para implementar operaciones que son comúnmente utilizadas durante un programa y de esta manera reducir la cantidad de código.

Cuando una función es invocada se le pasa el control a la misma, una vez que esta finalizó con su tarea el control es devuelto al punto desde el cual la función fue llamada.

El esquema de una función:

function funcion1
{
  param
  (
    [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
    [String[]]
    [AllowEmptyString()]
    $Var,$Var2
  )
  begin
  {
  }
  process
  {
  }
  end
  {
  }
}

Ejemplos

Pedir a un usuario su nombre y mostrarlo mediante una función

function Get-Nombre
{
  param
  (
    $Name = $(
      Write-Host 'Introduzca su nombre: '-ForegroundColor Yellow -NoNewLine
      Read-Host
    )
  )

  "Tu nombre es: $Name"
}

#Ejecutar la función
Get-Nombre

Hacer un login creando una función que comprueba un nombre de usuario y una contraseña

function funcion5
{
  param
  (
    [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
    [String[]]
    [AllowEmptyString()]
    $User,$Pass
  )

  begin
  {
    Write-Host "Principio de login"
    $usercorrecto="Carlos"
    $passcorrecto="Contraseña"
  }

  process
  {
   if($User -eq $usercorrecto -and $Pass -eq $passcorrecto)
    {
        $ok=1
    }
    else
    {
        $ok=0
    }
  }
  end
  {
   if($ok)
    {
        Write-Host "User correcto"
    }
    else
    {
        Write-Host "User no correcto"
    }
    Write-Host "Fin de login"
  }
}

#Ejecutar la función
funcion4 Carlos Contraseña

Hacer un login avanzado creando una función que comprueba un nombre de usuario y una contraseña

###############################################################################
#Función login de user y pass
#El user y pass (hash en MD5) correcto se escriben en el bloque BEGIN

#Ejecutar la función
#PS C:\Users\usuario>loginH user pass

function loginH
{
  param
  (
    [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
    [String[]]
    [AllowEmptyString()]
    $User,$Pass
  )

  begin
  {
    Write-Host "Principio de login"
    $usercorrecto="user"
    #El pass en MD5
    #$passcorrecto="pass"
    $passcorrecto="1A1DC91C907325C69271DDF0C944BC72"
  }

  process
  {
   #Realizar el MD5 del pass introducido por el usuariO
   [Reflection.Assembly]::LoadWithPartialName("System.Web")
   $Pass
   if($User -eq $usercorrecto -and [System.Web.Security.FormsAuthentication]::HashPasswordForStoringInConfigFile($Pass, "MD5") -eq $passcorrecto)
    {
        $ok=1
    }
    else
    {
        $ok=0
    }
  }
  end
  {
   if($ok)
    {
        Write-Host "User correcto"
    }
    else
    {
        Write-Host "User no correcto"
    }
    Write-Host "Fin de login"
  }
}
###############################################################################

The post 2. Programación en PowerShell appeared first on Scripting and security.