Tipos de datos en PowerShell | Operating systems, scripting, PowerShell and security

PowerShell

Contenidos

Variables
Objetos

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

1 2	$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

1 2	[Int]$num=5 $num

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

.getType()

1	.getType()

Ejemplo

Ver el tipo de las siguientes variables

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

[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()

[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

1 2	$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

1 2	$car='c' $car

Ejercicios

Mostrar todos los números del 0 al 9 como caracteres

[char]'0'..[char]'9' | %{[char]$_}

48..57 | %{[char]$_}

[char]'0'..[char]'9' | %{[char]$_}

48..57 | %{[char]$_}

Mostrar todas las letras minúsculas

[char]'a'..[char]'z' | %{[char]$_}

97..122 | %{[char]$_}

[char]'a'..[char]'z' | %{[char]$_}

97..122 | %{[char]$_}

Mostrar todas las letras mayúsculas

[char]'A'..[char]'Z' | %{[char]$_}

65..90 | %{[char]$_}

[char]'A'..[char]'Z' | %{[char]$_}

65..90 | %{[char]$_}

Mostrar todos los caracteres ASCII

0..255 | %{Write-Host ([char]$_ +" ") -NoNewline}

1	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]

#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

1 2	$true $false

Declarar una variable de tipo booleano

$bool=$true
$bool

1 2	$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

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}

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)

1	(Get-Date)

Mostrar año

(Get-Date).Year

1	(Get-Date).Year

La fecha del sistema se puede cambiar utilizando el cmdlet

Set-Date

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}

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"

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

(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()

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

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

Mostrar las fechas de la semana pasada

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

1	-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)

#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

1	(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

1	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}

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)

1	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

1	((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]

$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

1 2	$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]

#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] }}

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

[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}

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

[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

$palabra1='hola-'

$palabra2='adios'

$frasecontatenada=$palabra1+$palabra2

$frasecontatenada

Determinar longitud

Ejemplo

Determinar la longitud de una cadena

'Hola'.Length

1	'Hola'.Length

Convertir en mayúsculas

Ejemplo

Convertir una cadena en mayúsculas

'Hola'.ToUpper()

1	'Hola'.ToUpper()

Convertir la primera letra de una palabra en mayúscula

$palabra="palabra"
$palabra.substring(0,1).toupper()+$palabra.substring(1).tolower()

1 2	$palabra="palabra" $palabra.substring(0,1).toupper()+$palabra.substring(1).tolower()

Convertir en minúsculas

Ejemplo

Convertir una cadena en minúsculas

'Hola'.ToLower()

1	'Hola'.ToLower()

Reemplazar caracteres

Ejemplo

Remplazar caracteres en una palabra y una frase

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

1 2	'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)(*&amp;^TUVWXyz'
$patron = '[^a-zA-Zá-úÁ-Ú]'
$cadena -replace $patron, ''

$cadena = 'áéíóúabcdefg12345HIJKLMNOP!@#$%qrs)(*&^TUVWXyz'

$patron = '[^a-zA-Zá-úÁ-Ú]'

$cadena -replace $patron, ''

Partir cadenas

Ejemplo

Partir dos cadenas mediante una coma

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

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

Ejercicio

Dividir en grupos de cinco elementos una cadena

'1234512345123451234512345123451234512345' -split '(?&lt;=\G\d{5})(?=.)'

1	'1234512345123451234512345123451234512345' -split '(?<=\G\d{5})(?=.)'

Eliminar espacios

Ejemplo

Eliminar espacios de una frase

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

' 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)

'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
}

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

1	'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)

'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')

1	'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')

1	'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')

1	'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')

1	'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')

1	'Hola'.Contains('a')

Buscar

Ejemplo

Buscar una cadena dentro de otra

'Hola'| Select-String 'o'

1	'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

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)

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

1 2	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($_) }

$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

#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)))

# 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:

1	Get-Childitem env:

Se pueden crear variables de entorno de la siguiente forma

$env:TestVariable = "Test variable"
Get-ChildItem Env:\TestVariable

1 2	$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

1	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

$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

1	$objeto=New-Object Object

Añadir una propiedad a un objeto

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

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

Listar propiedades y métodos

$objeto | Get-Member

1	$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

#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()

#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
    }
}

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

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

1	[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
}

#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()

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

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"

}