Contenidos
- Introducción
- Variables
- Constantes
- Ámbito
- Tipos
- Tipos simples
- Tipos complejos
- Variables de entorno
- Objetos
- Ficheros
- Operaciones aritméticas
- Conversiones entre sistemas numéricos
- Operaciones lógicas
- Operaciones de comparación
- Sentencias condicionales
- Sentencias de repetición
- Funciones
- ¿Más ejercicios sobre programación en PowerShell?
- Vídeo resumen
Introducción
La programación es fundamental para realizar tareas de forma automática y consiste en indicar órdenes al sistema, en PowerShell el conjunto de órdenes se puede realizar mediante scripts. Un script contiene un conjunto de comandos (cmdlets) y elementos de programación (bucles, condicionales, comparaciones, etc.) que se ejecutan sobre PowerShell y realizan alguna función concreta.
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 (palabra)?
- ¿Cómo buscar una cadena (palabra) 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
.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
Declarar una variable numérica y mostrar su valor
$num=5 $num
Caracteres
Variables que representan valores tipo carácter.
Ejemplo
Declarar una variable de tipo carácter y mostrar su valor
$car='c' $car
Booleanos
Representan el valor verdadero (1) o falso (0).
Ejemplos
Mostrar los valores de los que dispone PowerShell de las variables de tipo booleano
$true $false
Declarar una variable de tipo booleano
$bool=$true $bool
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
Parámetros y alias de los parámetros para el cmdlet Get-Date
Date {LastWriteTime}
Year {}
Month {}
Day {}
Hour {}
Minute {}
Second {}
Millisecond {}
DisplayHint {}
UFormat {}
Format {}
Verbose {vb}
Debug {db}
ErrorAction {ea}
WarningAction {wa}
InformationAction {infa}
ErrorVariable {ev}
WarningVariable {wv}
InformationVariable {iv}
OutVariable {ov}
OutBuffer {ob}
PipelineVariable {pv}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
Parámetros y alias de los parámetros para el cmdlet Set-Date
Date {}
Adjust {}
DisplayHint {}
Verbose {vb}
Debug {db}
ErrorAction {ea}
WarningAction {wa}
InformationAction {infa}
ErrorVariable {ev}
WarningVariable {wv}
InformationVariable {iv}
OutVariable {ov}
OutBuffer {ob}
PipelineVariable {pv}
WhatIf {wi}
Confirm {cf}Ejemplo
Cambiar la fecha del sistema
Set-Date -Date "6/1/2006 8:30 AM"
A las fechas se les puede dar formato
Ejemplo
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")Algunas operaciones que se pueden realizar sobre fechas son (métodos):
.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
Parámetros y alias de los parámetros para el cmdlet New-TimeSpan
Start {LastWriteTime}
End {}
Days {}
Hours {}
Minutes {}
Seconds {}
Verbose {vb}
Debug {db}
ErrorAction {ea}
WarningAction {wa}
InformationAction {infa}
ErrorVariable {ev}
WarningVariable {wv}
InformationVariable {iv}
OutVariable {ov}
OutBuffer {ob}
PipelineVariable {pv}Ejemplos
Mostrar el intervalo de tiempo entre dos fechas
New-TimeSpan $(Get-Date) $(Get-Date -month 7 -day 19 -year 2016)
Ver la diferencia horaria que hay entre España y Alemania
((Get-Date)-([TimeZoneInfo]::ConvertTime((Get-Date),[TimeZoneInfo]::FindSystemTimeZoneById("Central European Standard Time")))).HoursArrays
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.
En PowerShell al crear un array de números se considera un tipo de dato string.
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
Concatenar dos palabras
$palabra1='hola-' $palabra2='adios' $frasecontatenada=$palabra1+$palabra2 $frasecontatenada
- Determinar longitud
Ejemplo
Determinar la longitud de una cadena
'Hola'.Length
- Convertir en mayúsculas
Ejemplo
Convertir una cadena en mayúsculas
'Hola'.ToUpper()
Convertir la primera letra de una palabra en mayúscula
$palabra="palabra" $palabra.substring(0,1).toupper()+$palabra.substring(1).tolower()
- Convertir en minúsculas
Ejemplo
Convertir una cadena en minúsculas
'Hola'.ToLower()
- Reemplazar caracteres
Ejemplo
Remplazar caracteres en una palabra y una frase
'Hola'.Replace('o', '0')
"Hola buenas Lucas" -replace "hola|buenas","adios"Ejercicio
Eliminar caracteres que no sean alfabéticos y conservar los caracteres que tengan acentos
$cadena = 'áéíóúabcdefg12345HIJKLMNOP!@#$%qrs)(*&^TUVWXyz' $patron = '[^a-zA-Zá-úÁ-Ú]' $cadena -replace $patron, ''
- Partir cadenas
Ejemplo
Partir dos cadenas mediante una coma
'Hola,buenas'.Split(',')Ejercicio
Dividir en grupos de cinco elementos una cadena
'1234512345123451234512345123451234512345' -split '(?<=\G\d{5})(?=.)'- Eliminar espacios
Ejemplo
Eliminar espacios de una frase
' Hola buenas '.TrimStart() 'Hola buenas '.TrimEnd() 'Hola buenas '.Trim()
- Extraer elementos
Ejemplo
Extraer elementos de una palabra
'Hola'.Substring(0) 'Hola'.Substring(0,2) 'Hola'.Substring(2) 'Hola'.Substring(2,1)
Ejercicio
Reducir texto con puntos suspensivos
$LongitudMax = 10
$Texto = 'Texto para acortar'
if ($Texto.Length -gt $LongitudMax)
{
$Texto.Substring(0,$LongitudMax) + '...'
}
else
{
$Texto
}- Insertar elementos
Ejemplo
Insertar un elemento en una posición de la una palabra
'Hola'.Insert(2, "oooo")
- Eliminar elementos
Ejemplo
Eliminar elementos de una palabra
'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
Determinar la posición de un carácter dentro de una palabra
'Holasa'.IndexOf('a')- Determinar la última posición de un carácter
Ejemplo
Determinar la última posición de un carácter dentro de una palabra
'Holasa'.LastIndexOf('a')- Determinar si el principio de una cadena coincide con una cadena
Ejemplo
Saber si el principio de una palabra comienza con un carácter
'Hola'.StartsWith('H')- Determinar si el final de una cadena coincide con otra cadena
Ejemplo
Saber si el final de una palabra finaliza con un carácter
'Hola'.EndsWith('la')- Determinar si un carácter está contenido en una cadena
Ejemplo
Saber si una cadena contiene un carácter
'Hola'.Contains('a')- Buscar
Ejemplo
Buscar una cadena dentro de otra
'Hola'| Select-String 'o'
Tipos complejos
Enumeraciones
Son un tipo de datos que permite que una variable sea un conjunto de constantes predefinidas.
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
Hash tables
Representa una colección de pares de clave y valor que se organizan por código hash de la clave.
Ejemplos
Crear una hash table sencilla y añadir un elemento después de iniciar la tabla
$hash = @{
a = 2
b = 4
c = 6
}
$hash.add('d',8)
$hash.Keys | % { "key = $_ , value = " + $hash.Item($_) }Crear una hash table con elementos, mostrar los elementos, el número de elementos y ordenar los elementos
#Agrega elementos a la clase HashTable
$hashtable = @{uno='valoruno'; dos='valordos'; tres='valortres'}
#Número de elementos de HashTable
$hashtable.Count
#ArrayList sin ordenar
$hashtable
#Ordenar elementos de HashTable
$hashtable.GetEnumerator() | Sort-Object -Property ValueListas
Son objetos fuertemente tipados a la que se puede obtener acceso por índice. Proporciona métodos para buscar, ordenar y manipular listas.
Ejemplo
Crear una colección de tipo lista para gestionar objetos
# Clase coche con propiedades
class Coche
{
$Marca
$Modelo
$FechaCompra
$Color
#Constructor
Coche($Color,$Marca,$Modelo,$FechaCompra)
{
$this.Color=$Color
$this.Marca=$Marca
$this.Modelo=$Modelo
$this.FechaCompra=$FechaCompra
}
}
# Colección de tipo List para gestionar los objetos de la clase Coche
$concesionario1 = New-Object 'System.Collections.Generic.List[Coche]'
$concesionario1.Add([Coche]::new('Rojo','Audi','A2',(get-date)))
$concesionario1.Add([Coche]::new('Negro','Audi','A1',(get-date)))
# También se puede crear así la colección de tipo List
$concesionario1 = [System.Collections.Generic.List[Coche]]::new()
$concesionario1.Add([Coche]::new('Rojo','Audi','A2',(get-date)))
$concesionario1.Add([Coche]::new('Negro','Audi','A1',(get-date)))Variables de entorno
Son variables definidas por el sistema operativo y que contienen información sobre el sistema.
Para ver todas las variables de entorno se ejecuta el siguiente cmdlet
Get-Childitem env:
Se pueden crear variables de entorno de la siguiente forma
$env:TestVariable = "Test variable" Get-ChildItem Env:\TestVariable
Para eliminar una variable de entorno hay que ejecutar el siguiente cmdlet junto con el nombre de la variable
Remove-Item Env:\TestVariable
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
Ejemplos
Crear un objeto coche con propiedades
#Clase coche con propiedades
class Coche
{
$Marca
$Modelo
$FechaCompra
$Color
}
#Crear objeto coche de la clase Coche
$coche=New-Object -TypeName Coche
#Añadir propiedades del coche
$coche.Marca="Audi"
$coche.Modelo="A2"
$coche.Color="Rojo"
$coche.FechaCompra= Get-Date
#Mostrar el color del coche
$coche.Color
#Mostrar información sobre el coche
$coche
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()
En PowerShell se pueden crear clases y de las clases crear objetos.
En las clases se pueden definir además de lo dicho anteriormente también se pueden crear constructores dentro de las clases.
class Clase
{
[string]$Valor
Constructor([string]$Valor)
{
$this.Valor = $Valor
}
}Ejemplos
Crear una clase con un constructor
class Coche
{
[string]$Marca
[string]$Modelo
#Constructor 1
Coche([string]$Marca, [string]$Modelo)
{
$this.Marca = $Marca
$this.Modelo = $Modelo
}
}Crear el objeto para la clase creada
[Coche]::new("Audi","A3")
Otra forma de crear una clase y un objeto (sin constructor). Crear una clase
#Clase coche con propiedades
class Coche
{
$Marca
$Modelo
$Color
}Otra forma de crear una clase y un objeto (sin constructor). Crear un objeto (dos posibilidades)
#Crear objeto coche de la clase Coche $coche1=New-Object -TypeName Coche #Otra forma de crear objeto coche de la clase Coche $coche2=[Coche]::new()
Los objetos en PowerShell se pueden sobrecargar, la sobrecarga se refiere a la posibilidad de tener dos o más funciones con el mismo nombre pero funcionalidad diferente. Es decir, dos o más funciones con el mismo nombre realizan acciones diferentes.
Ejemplo
Realizar sobrecargas en constructores de una clase
class Coche
{
[string]$Marca
[string]$Modelo
#Constructor 1
Coche([string]$Marca, [string]$Modelo)
{
$this.Marca = $Marca
$this.Modelo = $Modelo
}
#Constructor 2
Coche ([string]$Modelo)
{
$this.Marca = "NS"
$this.Modelo = $Modelo
}
#Constructor 3
Coche ()
{
$this.Marca = "No definido"
$this.Modelo = "No definido"
}
}Más información
- https://www.jesusninoc.com/03/11/crear-una-clase-en-powershell-que-herede-de-otra-clase-con-propiedades-constructor-get-y-set/
- https://www.jesusninoc.com/03/12/crear-una-clase-y-anadir-una-propiedad-en-powershell-que-herede-de-otra-clase-con-propiedades-constructor-get-y-set/
- https://www.jesusninoc.com/03/12/crear-una-clase-que-hereda-de-una-clase-que-a-su-vez-hereda-de-otra-clase-con-propiedades-constructor-get-y-set/
Ficheros
Las variables tienen el problema de ser temporales por eso necesitamos poder almacenar datos de forma permanente mediante los ficheros.
El cmdlet para crear archivos de texto
Out-File
Parámetros y alias de los parámetros
FilePath {}
LiteralPath {PSPath}
Encoding {}
Append {}
Force {}
NoClobber {NoOverwrite}
Width {}
NoNewline {}
InputObject {}
Verbose {vb}
Debug {db}
ErrorAction {ea}
WarningAction {wa}
InformationAction {infa}
ErrorVariable {ev}
WarningVariable {wv}
InformationVariable {iv}
OutVariable {ov}
OutBuffer {ob}
PipelineVariable {pv}
WhatIf {wi}
Confirm {cf}Ejemplo
Almacenar contenido en un archivo de texto
"Hi" | Out-File file.txt
El cmdlet para leer archivos de texto
Get-Content
Alias
gc cat type
Parámetros y alias de los parámetros
ReadCount {}
TotalCount {First, Head}
Tail {Last}
Path {}
LiteralPath {PSPath}
Filter {}
Include {}
Exclude {}
Force {}
Credential {}
Verbose {vb}
Debug {db}
ErrorAction {ea}
WarningAction {wa}
InformationAction {infa}
ErrorVariable {ev}
WarningVariable {wv}
InformationVariable {iv}
OutVariable {ov}
OutBuffer {ob}
PipelineVariable {pv}
UseTransaction {usetx}
Delimiter {}
Wait {}
Raw {}
Encoding {}
Stream {}Ejemplo
Obtener el contenido de un archivo de texto
Get-Content file.txt
Obtener las dos primeras líneas de un fichero
Get-Content .\fichero.txt -First 2
Obtener las dos últimas líneas de un fichero
Get-Content .\fichero.txt -Tail 2
Leer el contenido de un fichero en decimal
[System.IO.File]::ReadAllBytes('.\eje.txt')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"
}Conversiones entre sistemas numéricos
Se pueden realizar conversiones entre sistemas de numeración.
Los sistemas numéricos están compuestos por símbolos y por las normas utilizadas para interpretar estos símbolos. El sistema numérico que se usa más a menudo es el sistema numérico decimal, o de Base 10. El sistema numérico que se usa más a menudo es el sistema numérico decimal, o de Base 10. El sistema numérico de Base 10 usa diez símbolos: 0, 1, 2, 3, 4, 5, 6, 7, 8 y 9. Estos símbolos se pueden combinar para representar todos los valores numéricos posibles.
Los ordenadores reconocen y procesan datos utilizando el sistema numérico binario, o de Base 2. El sistema numérico binario usa sólo dos símbolos, 0 y 1, en lugar de los diez símbolos que se utilizan en el sistema numérico decimal. La posición, o el lugar, que ocupa cada dígito de derecha a izquierda en el sistema numérico binario representa 2, el número de base, elevado a una potencia o exponente, comenzando desde 0. Estos valores posicionales son, de derecha a izquierda, 2 potencia 0, 2 potencia 1, 2 potencia 2, 2 potencia 3, 2 potencia 4, 2 potencia 5, 2 potencia 6 y 2 potencia 7, o sea, 1, 2, 4, 8, 16, 32, 64 y 128, respectivamente.
El inconveniente de la codificación binaria es que la representación de algunos números resulta muy larga. Por este motivo se utilizan otros sistemas de numeración que resulten más cómodos de escribir: el sistema octal y el sistema hexadecimal. Afortunadamente, resulta muy fácil convertir un número binario a octal o a hexadecimal.
Otro sistema utilizado es hexadecimal, el sistema hexadecimal usa dieciséis símbolos: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E y F. Se utilizan los caracteres A, B, C, D, E y F representando las cantidades decimales 10, 11, 12, 13, 14 y 15 respectivamente, porque no hay dígitos mayores que 9 en el sistema decimal. Cada dígito tiene, naturalmente, un valor distinto dependiendo del lugar que ocupen. El valor de cada una de las posiciones viene determinado por las potencias de base 16.
Ejemplos
Convertir un número binario a decimal
$binario = "11111111" [Convert]::ToInt32($binario,2)
Convertir un número decimal a binario
$decimal = 32 [Convert]::ToString($decimal, 2)
Convertir un número decimal a octal
$decimal = 3232 [Convert]::ToString($decimal, 8)
Convertir un número decimal a hexadecimal
$decimal = 3232 [Convert]::ToString($decimal, 16)
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:
And
Tabla lógica del operador and
| x | y | resultado |
| true | true | true |
| true | false | false |
| false | true | false |
| false | false | false |
Ejemplos
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
Or
Tabla lógica del operador or
| x | y | resultado |
| true | true | true |
| true | false | true |
| false | true | true |
| false | false | false |
Ejemplos
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
Not
Tabla lógica del operador not
| x | resultado |
| true | false |
| false | true |
Ejemplos
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
Operadores bit a bit
PowerShell admite los operadores bit a bit estándar, incluidos bitwise-AND (-bAnd), los operadores inclusivos y exclusivos bitwise-OR (-bOr y -bXor) y bitwise-NOT (-bNot).
bAnd Bitwise AND
Ejemplo
Uso de bAnd (Bitwise AND)
10 -band 3
La estructura de bits del número 10 es 00001010 (basado en 1 byte) y la estructura de bits del número 3 es 00000011. Cuando se usa un operador AND bit a bit para comparar 10 y 3, se comparan los bits individuales de cada byte.
1010 (10)
0011 ( 3)
————– bAND
0010 ( 2)
bOr Bitwise OR (inclusive)
Ejemplo
Uso de bOr (Bitwise OR)
10 -bor 3
En una operación OR bit a bit (inclusiva), el bit resultante se establece en 1 cuando uno de los bits de entrada o ambos son 1. El bit resultante se establece en 0 solo cuando ambos bits de entrada se establecen en 0.
1010 (10)
0011 ( 3)
————– bOR (inclusive)
1011 (11)
bXor Bitwise OR (exclusive)
Ejemplo
Uso de bXor (Bitwise OR)
10 -bxor 3
En una operación OR bit a bit (exclusiva), el bit resultante se establece en 1 solo si un bit de entrada es 1.
1010 (10)
0011 ( 3)
————– bXOR (exclusive)
1001 ( 9)
bNot Bitwise NOT
Ejemplo
Uso de bNot (Bitwise NOT)
-bNot 10
El operador NOT bit a bit es un operador unario que genera el complemento binario del valor. Un bit 1 se establece en 0 y un bit 0 se establece en 1.
Por ejemplo, el complemento binario de 0 es -1, el mayor número entero sin signo (0xffffffff), y el complemento binario de -1 es 0.
Ejercicio
Poner a 1 el cuarto bit en una cadena de bits
$decimal = 32 [Convert]::ToString($decimal, 2) $bit = 3 $decimal = $decimal -bor [Math]::Pow(2, $bit) [Convert]::ToString($decimal, 2)
También existen los desplazamientos lógicos (logical shifts). El desplazamiento lógico hacia la izquierda (left shift) y el desplazamiento lógico hacia la derecha (right shift). En el desplazamiento lógico los bits de un registro son desplazados (movidos) una o más posiciones hacia la derecha o hacia la izquierda. Los bit que salen del registro por un extremo se pierden y en el otro extremo del registro se rellena con un bit cero por cada bit desplazado.
Ejemplo
Realizar desplazamientos
#Desplazamiento izquierdo #Número sin desplazamiento 21 -shl 0 #Ver número en binario sin desplazamiento [Convert]::ToString(21, 2) #Número con desplazamiento a la izquierda de un bit 21 -shl 1 #Ver número en binario con desplazamiento a la izquierda de un bit [Convert]::ToString(21 -shl 1, 2) #Desplazamiento derecho #Número sin desplazamiento 21 -shr 0 #Ver número en binario sin desplazamiento [Convert]::ToString(21, 2) #Número con desplazamiento a la derecha de un bit 21 -shr 1 #Ver número en binario con desplazamiento a la derecha de un bit [Convert]::ToString(21 -shr 1, 2)
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:
If
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
Ejemplos
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
}
}Clasificar un número entre rangos
$valor=1001
switch($valor)
{
{$_ -ge 0 -and $_ -le 1000}{"Poco importante"}
{$_ -ge 1001 -and $_ -le 10000}{"Algo importante"}
{$_ -ge 10000 -and $_ -le 100000000}{"Muy importante"}
}Ejercicio
Conocer la relevancia de una búsqueda en Google
$urls='https://www.google.com/search?q=powershell'
$result=Invoke-WebRequest $urls
$valor=($result.AllElements | ? {$_.id -eq "resultStats"}).innerText
$valor=$valor.replace("Aproximadamente","").replace("resultados","").replace(".","")
$valor=$valor.Trim()
switch([Int]$valor)
{
{$_ -ge 0 -and $_ -le 1000}{"Poco importante"}
{$_ -ge 1001 -and $_ -le 10000}{"Algo importante"}
{$_ -ge 10000 -and $_ -le 100000000}{"Muy importante"}
}
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
Ejemplos
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 | % {$_}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-NombreHacer 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
funcion5 Carlos ContraseñaHacer 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"
}
}
###############################################################################Más información
- https://www.jesusninoc.com/10/14/funciones-con-parametros-y-sin-parametros/
- https://www.jesusninoc.com/10/22/uso-de-funciones/
- https://www.jesusninoc.com/01/24/ejercicios-de-powershell-como-hacer-un-login-paso-a-paso-en-powershell-utilizando-funciones/
- https://www.jesusninoc.com/04/25/crear-una-funcion-en-powershell-que-permita-autocompletar/
