Tipos de datos en PowerShell

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

Ejercicios
Mostrar todos los números del 0 al 9 como caracteres
[char]'0'..[char]'9' | %{[char]$_}

48..57 | %{[char]$_}
Mostrar todas las letras minúsculas
[char]'a'..[char]'z' | %{[char]$_}

97..122 | %{[char]$_}
Mostrar todas las letras mayúsculas
[char]'A'..[char]'Z' | %{[char]$_}

65..90 | %{[char]$_}
Mostrar todos los caracteres ASCII
0..255 | %{Write-Host ([char]$_ +" ") -NoNewline}
Mostrar todos los caracteres Base64
#Array que va a contener todos los caracteres en Base64
$arrayBase64=""
#Añadir al array las mayúsculas
$arrayBase64+=[char]'A'..[char]'Z' | %{[char]$_}
#Añadir al array las minúsculas
$arrayBase64+=[char]'a'..[char]'z' | %{[char]$_}
#Añadir al array los números
$arrayBase64+=[char]'0'..[char]'9' | %{[char]$_}
#Añadir al array el carácter + y /
$arrayBase64+="+"
$arrayBase64+="/"
#Quitar los espacios del array
$arrayBase64=$arrayBase64-replace " "
#Mostrar los caracteres
$arrayBase64
#Número de caracteres en Base64
$arrayBase64.Length
#Primer carácter
$arrayBase64[0]
#Último carácter
$arrayBase64[$arrayBase64.Length-1]

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

Ejercicio
Calcular de forma aleatoria un día entre hoy y hace cinco años
#Día aleatorio entre hoy y hace cinco años
$diaaleatorio=Get-Random (1..(5*365))
(Get-Date).AddDays(-$diaaleatorio)
Calcular el día de la semana para una fecha
(Get-Date).AddDays(-((get-date)-([datetime]"12/22/2016 00:00")).Days).DayOfWeek

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

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.

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]

Ejercicios
Tratar arrays de caracteres. Mostrar cada uno de los elementos de un array de caracteres
"PowerShell"|%{for ($i=0;$i -lt $_.Length; ++$i) { $_[$i] }}
Tratar arrays de caracteres. Mostrar el valor entero de cada uno de los elementos de un array de caracteres
[string]$a="En cierto lugar de la mancha"
for($i=0; $i -lt $a.Length; $i=$i+1)
{([int]$a[$i])}
Tratar arrays de caracteres. Incrementar en uno cada uno de los valores enteros que contiene un array de caracteres
[string]$a="En cierto lugar de la mancha"
for($i=0; $i -lt $a.Length; $i=$i+1)
{([int]$a[$i])+1}
Tratar arrays de caracteres. Incrementar en uno cada uno de los valores enteros que contiene un array de caracteres y mostrar el valor como tipo carácter
[string]$a="En cierto lugar de la mancha"
for($i=0; $i -lt $a.Length; $i=$i+1)
{[char]([int]$a[$i]+1)}

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

Ejercicios
Crear el juego de piedra, papel o tijera utilizando enumeraciones para las combinaciones posibles
enum PPT{
    Piedra = 1
    Papel = 2 
    Tijera = 3
}
enum Combinacion
{
    EmpatePiedra = 11
    EmpatePapel = 22
    EmpateTijera = 33
    GanaPiedra = 13
    GanaPapel = 21
    GanaTijera = 32
    PierdePiedra = 12
    PierdePapel = 23
    PierdeTijera = 31
    
}
$jugador1=random(1..3);[PPT]$jugador1
$jugador2=random(1..3);[PPT]$jugador2
[Combinacion]([String]$jugador1+[String]$jugador2)
[Combinacion]([String]$jugador2+[String]$jugador1)
Crear el juego de piedra, papel o tijera utilizando enumeraciones para las combinaciones posibles (versión reducida)
enum Combinacion{EmpatePiedra = 11;EmpatePapel = 22;EmpateTijera = 33;GanaPiedra = 13;GanaPapel = 21;GanaTijera = 32;PierdePiedra = 12;PierdePapel = 23;PierdeTijera = 31}
$([Combinacion]([String](random(1..3))+[String](random(1..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 Value

Listas

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