# Adicional

## Estructuras lógicas

### if, elseif, else

En PowerShell, los operadores condicionales permiten que el programa tome decisiones y ejecute diferentes bloques de código según las condiciones.

* La estructura `if() {}` verifica la condición en los paréntesis y ejecuta el bloque de código si la condición es verdadera.
* Las palabras clave `elseif{}` y `else{}` se utilizan para agregar verificaciones adicionales y acciones alternativas.
* Los bloques `elseif` y `else` no son obligatorios: se puede usar solo `if`.

Ejemplo:

```powershell
if ($number -gt 10) {
    Write-Output "El número es mayor que 10"
} elseif ($number -eq 10) {
    Write-Output "El número es igual a 10"
} else {
    Write-Output "El número es menor que 10"
}
```

Si la condición en `if` es verdadera, los siguientes `elseif` y `else` se omiten.

Se pueden usar varios `elseif` en cadena para verificar múltiples opciones.

El bloque `else` se ejecuta cuando todas las condiciones anteriores son falsas.

Puede consultar información adicional en el siguiente enlace:

{% embed url="<https://docs.microsoft.com/ru-ru/powershell/scripting/learn/deep-dives/everything-about-if?view=powershell-7.1>" %}

### switch

switch es una estructura conveniente para verificar una variable contra múltiples valores y seleccionar el bloque de código correspondiente.

```powershell
switch ($variable) {
    0 { Write-Output "El valor es 0" }
    1 { Write-Output "El valor es 1" }
    2 { Write-Output "El valor es 2" }
    default { Write-Output "El valor no coincide con ninguna de las condiciones" }
}
```

* Para cada valor, se enumera un bloque de código que se ejecutará si el valor de la variable coincide.
* El bloque `default` es opcional y se ejecuta si ninguno de los valores coincide.
* `switch` es útil para múltiples opciones de selección, reduciendo las construcciones if anidadas.

Puede consultar información adicional en el siguiente enlace:

{% embed url="<https://docs.microsoft.com/ru-ru/powershell/scripting/learn/deep-dives/everything-about-switch?view=powershell-7.1>" %}

## Verificación de $null

En PowerShell, se recomienda siempre colocar $null a la izquierda en la expresión para verificar la igualdad con $null:

```powershell
$null -eq $value
```

Esto se debe a las particularidades del manejo de valores en PowerShell, para evitar errores inesperados si $value no está definido.

En las expresiones lógicas de PowerShell, se pueden usar cmdlets y funciones que se evaluarán como valores booleanos según su lógica de verdad/falsedad. Por ejemplo, la condición:

```powershell
if ($null_object) {
    $False
} else {
    $True
}
```

Considerará `$null_object` como una condición falsa (si está vacío o es $null) y ejecutará el bloque correspondiente.

También es posible asignar valores a variables directamente dentro de la condición, lo que es conveniente para la asignación y verificación simultáneas de $null. Por ejemplo:

```powershell
if ($var = (function)) {
    $True
} else {
    $False
}
```

Aquí, a la variable `$var` se le asigna el resultado de la función y se verifica inmediatamente si no es $null (o vacío).

De manera similar, la verificación de la variable consigo misma:

```powershell
if ($var = $var) {
    $True
} else {
    $False
}
```

Puede consultar información adicional en el siguiente enlace:

{% embed url="<https://docs.microsoft.com/ru-ru/powershell/scripting/learn/deep-dives/everything-about-null?view=powershell-7.1>" %}

## Cadenas de sustitución

En PowerShell, existen varias formas de formar y concatenar cadenas.

### Comillas

Se pueden insertar variables directamente en cadenas con diferentes tipos de comillas:

```powershell
$string = "’objeto’"
$string1 = "vendido"

"Prueba’ $string exitosamente”” $string1”   # Resultado: Prueba’ ‘objeto’ exitosamente” vendido

'Prueba” '+$string+' exitosamente’’ '+$string1  # Resultado: Prueba” ‘objeto’ exitosamente’ vendido
```

### HereString

Se puede usar HereString para declarar una cadena de varias líneas conservando el formato:

```powershell
@"
Prueba+@’ $string exitosamente” $string1
"@
```

El resultado será estrictamente conforme a lo que contiene.

### Cadenas F

También existen cadenas F para formatear cadenas con parámetros:

```powershell
("Prueba {0} exitosamente {1}" -f $string, $string1)
```

## PSCustomObject

PSCustomObject es un objeto de PowerShell que almacena datos según el principio de tabla hash, pero se puede trabajar con él como un objeto, accediendo a los campos a través de un punto.

Esto permite estructurar los datos de manera conveniente, crear objetos con las propiedades necesarias y realizar operaciones.

Puede consultar información adicional sobre PSCustomObject en el siguiente enlace:

{% embed url="<https://docs.microsoft.com/ru-ru/powershell/scripting/learn/deep-dives/everything-about-pscustomobject?view=powershell-7.1>" %}

## Credenciales

En PowerShell, existen mecanismos especiales para trabajar de manera segura con credenciales, incluyendo funciones y parámetros integrados, así como construcciones que informan al usuario sobre cambios y permiten gestionar el proceso de ejecución (por ejemplo, ShouldProcess).

Puede consultar información adicional sobre ShouldProcess en el siguiente enlace:

{% embed url="<https://docs.microsoft.com/ru-ru/powershell/scripting/learn/deep-dives/everything-about-shouldprocess?view=powershell-7.1>" %}

## Error al ejecutar archivos ps1

El error al ejecutar archivos .ps1 en PowerShell está relacionado con la política de ejecución de scripts, que por defecto prohíbe la ejecución de cualquier script para proteger el sistema de código malicioso.

El mensaje de error se ve así:

```powershell
«No se puede cargar el archivo ... .ps1, ya que la ejecución de scripts está deshabilitada en este sistema».
```

La razón es que Windows utiliza la Política de Ejecución: un conjunto de reglas que determina qué scripts se pueden ejecutar. Por defecto, la política es `Restricted`, que bloquea los scripts.

Puede verificar la política actual con el comando:

```powershell
Get-ExecutionPolicy
```

Para permitir la ejecución de scripts:

1. Inicie PowerShell o PowerShell ISE como administrador.
2. Ejecute el comando:

```powershell
Set-ExecutionPolicy Unrestricted
```

3. Confirme el cambio presionando "Sí" (Yes).

Esto permitirá ejecutar scripts con la extensión .ps1 sin restricciones.

Para un control más estricto, se pueden elegir otros niveles de política, como `RemoteSigned` o `AllSigned`.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.sherparpa.ru/es/sherpa-rpa/sherpa-designer/sherpa-designer-otvety-na-chasto-zadavaemye-voprosy/powershell/dopolnitelno.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
