Hasta el momento todo lo que has visto seguía un flujo secuencial. Es decir, ejecutabas una instrucción, luego otra, luego otra, y así sucesivamente. Pero al igual que en la vida real, no siempre es así. En ocasiones, tienes que decidir entre realizar una acción u otra, tomar un camino u otro, ejecutar una instrucción u otra. Todo ello, dependiendo de las condiciones de contorno. Esto mismo lo puedes extrapolar a cualquier script que realices, en el que en función de determinadas condiciones, vas a querer hacer unas cosas u otras. Para conseguir esto tienes los condicionales en PowerShell.

Los condicionales en PowerShell te van a permitir realizar una acción u otra en base a que una condición que establezcas sea cierta o no lo sea. Y evidentemente, para poder decidir si algo es cierto o no, tienes que utilizar operadores de comparación.

Condicionales en PowerShell

Antes de entrar a ver los diferentes condicionales que tienes a tu disposición en PowerShell, el primer caso es conocer los operadores de comparación que puedes utilizar.

Operadores de comparación

-eq

El primer operador de comparación a considerar es -eq. Este operador de comparación te permite saber si dos valores son exactamente iguales. Por ejemplo,

PS> $valor = 5
PS> $valor -eq 5
True

Además tienes dos variaciones de este operador. La primera variación es -ieq que no distingue entre mayúsculas y minúsculas, al igual que sucede con -eq. Mientras que la segunda variación es -ceq, que si distingue entre mayúsculas y minúsculas. Por ejemplo,

PS> $valor = "Hola"
PS> $valor -eq "hola"
True
PS> $valor -ieq "hola"
True
PS> $valor -ceq "hola"
False

-ne

Este operador de comparación es justo el antagónico del anterior, es decir, devolverá cierto en el caso de que dos elementos sean distintos. Y al igual que sucedía en el caso anterior, también tiene dos variaciones, como son -ine, que no distingue entre mayúsculas y minúsculas, y -cne que distingue entre mayúsculas y minúsculas.

-gt -ge -lt -le

Estos cuatro junto con sus correspondientes para distinguir o no, mayúsculas y minúsculas, te permiten las siguientes opciones,

• -gt mayor que
• -ge mayor o igual que
• -lt menor que
• -le menor o igual que

Y como te comentaba, tienes que añadir todas sus variantes, -cgt, -cge, -clt, -cle y -igt, -ige, -ilt, -ile

Tienes que tener en cuenta que cuando utilizas alguno de estos operadores de comparación con un array, el comportamiento es ligeramente distinto, en tanto en cuanto. Por ejemplo,

PS> $array = @(1,2,3,4)
PS> $array -gt 3
4

Es decir, que lo que te devolverá el operador de comparación será todos aquellos valores que sean superiores al indicado. Esto no quita a que en el caso de que lo utilices en un if then, como veremos mas adelante también se comporte como esperas.

Así, en el ejemplo anterior, la respuesta es $true, porque existen valores superiores a 3. Si el array no hubiera contenido valores superiores a 3 el resultado hubiera sido $false.

-like

El operador de comparación -like te permite comparar de forma aproximada dos valores. Para esto utiliza dos comodines,

• ? reemplaza un carácter
• * hace las veces de n caracteres.

Por ejemplo

PS> $valor = "Hola"
PS> $valor -like "?ola"
True
PS> $valor -like "*a"
True

Para este operador de comparación tienes algunas variantes como,

• -ilike no distingue entre mayúsculas y minúsculas
• -clike distingue entre mayúsculas y minúsculas
• -notlike no cumplen la condición de ser parecidos
• -inotlike no distingue entre mayúsculas y minúsculas
• -cnotlike distingue entre mayúsculas y minúsculas

-match

El operador de comparación -match es el que te va a permitir comparar utilizando expresiones regulares. Además como en el caso anterior, tienes las correspondientes variantes -imatch, -cmatch y -notmatch, -inotmatch, -cnotmatch. Por ejemplo

PS> $valor = "12H"
PS> $valor -match "\d\d[a-z]"
True
PS> $valor -cmatch "\d\d[a-z]"
False
PS> $valor -cmatch "\d\d[A-Z]"
True

-is

Este operador te permite conocer si una determinada variable es de un tipo concreto. Por ejemplo, si quieres saber si una variable es del tipo String, lo puedes hacer fácilmente de la siguiente forma,

PS> $valor = "Hola"
PS> $valor -is [String]
True

Además, este operador de comparación también tiene una variante que es -isnot, que mira justo lo contrario, es decir, que una variable no sea de un tipo concreto.

-contains

Este es un operado de comparación que te permite determinar si un array contiene un valor. Por ejemplo

PS> $array = 1..10
PS> $array -contains 5
True

Igual que en otros operadores de comparación que has visto hasta el momento, -contains también tiene variaciones que te permiten distinguir entre mayúsculas y minúsculas, y para operar justo al contrario que lo hace -contains. Estas variantes son -ccontains, -icontains, -notcontains, -cnotcontains, -inotcontains.

-in

Otro operador muy similar al anterior, pero que actúa justo al contrario que éste, o al menos esa es la impresión que tengo yo, es -in. Este nos permite saber si un elemento está en un array, como puedes ver en el siguiente ejemplo,

PS> $array = 1..10
PS> 6 -in $array
True

Operadores lógicos

Además de los operadores que has visto hasta el momento, también hay una serie de operadores lógicos que te pueden ser de gran utilidad para completar los anteriores.

• -not y ! invierte el resultado de cualquier operador
• -and te permite anidar operaciones lógicas de forma que el resultado es el $true, si se cumplen todas las operaciones y $false, si una de ellas no se cumple.
• -or este operador también te permite anidar operaciones lógicas, pero, en este caso, el resultado es $true, si una de las operaciones es cierta. Mientras que el resultado será $false, solo si todas las operaciones son falsas.

if en PowerShell

Y por fin llegó el momento, de abordar a mi tan amado if en PowerShell. Con if, puedes definir un camino u otro de ejecución en función de que se cumpla una condición lógica u otra. Por ejemplo,

$valor = "Hola"
if ($valor -eq "Hola"){
    Write-Output "Son iguales"
}else{
    Write-Output "Son distintos"
}

Además tienes la opción de utilizar elseif. Este nos permite realizar una comprobación adicional en caso de que la anterior haya fallado.

$valor = "Hola"
if ($valor -eq "Hola"){
    Write-Output "es igual a Hola"
}elseif($valor -eq "Adios"){
    Write-Output "es igual a Adios"
}else{
    Write-Output "Ni es igual a Hola ni a Adios"
}

Otra interesante característica que tiene if es la posibilidad de asignar el resultado de una comparación a una variable tal y como te muestro en el siguiente código,

PS> $valor = 5
PS> $resultado = if ($valor -eq 5){"Cinco"}else{"Otro"}
PS> Write-Output $resultado
Cinco

switch

Similar a if tienes switch que te permite realizar varias comprobaciones encadadas de forma similar al punto anterior,

$valor = "Hola"
switch($valor){
    "Hola"{Write-Output "Es igual a Hola"}
    "Adios"{Write-Output "Es igual a Adios"}
    default{Write-Output "No se parece a nada
}

Conclusión

Como ves las posibilidades de la programación con PowerShell, utilizando los operadores de comparación en combinación los condicionales if y switch han aumentado de forma exponencial. Ya no necesitas seguir una línea recta de pasos de ejecución. De pendiendo de determinadas condiciones puedes tomar una línea de ejecución u otra.

---

Imagen de portada de Jon Tyson en Unsplash