Condicionales `si` / `sino` / `retornar` / `o si`

Los condicionales en Forja usan si y sino — equivalentes a if / else en otros lenguajes. Para else if podés usar sino si o o si. Además, el operador || tiene su equivalente en español o, y podés usar retornar directamente como sino para acortar el código.

Sintaxis básica

📐 Estructura básica

si (condición) {
    // se ejecuta si la condición es verdadera
} sino {
    // se ejecuta si la condición es falsa
}

Ejemplo básico

📐 Comparación simple

variable x = 10
variable y = 5

si (x > y) {
    escribir("x es mayor que y")
} sino {
    escribir("x no es mayor que y")
}
// → x es mayor que y

`retornar` como `sino`

Cuando un si está dentro de una función, podés usar retornar directamente como reemplazo de sino. Esto evita un bloque anidado y hace el código más compacto:

↩️ retornar como else directo

funcion max(a: Entero, b: Entero) -> Entero {
    si (a > b) {
        retornar a
    } retornar b
    // ↑ equivale a: sino { retornar b }
}

También funciona encadenado con si:

🔗 retornar si como else-if

funcion clasificar_nota(nota: Entero) -> Texto {
    si (nota >= 90) {
        retornar "Excelente"
    } retornar si (nota >= 70) {
        retornar "Bueno"
    } retornar "A mejorar"
    // ↑ encadena: sino si → sino { retornar }
}

⚠️ Atención: retornar como sino solo tiene sentido dentro de funciones, ya que implica un retorno de la función.

Múltiples condiciones: `sino si` / `o si`

En lugar de anidar si dentro de sino, podés usar sino si o o si para encadenar condiciones de forma más limpia:

📊 Evaluación de nota

variable nota = 85

si (nota >= 90) {
    escribir("¡Excelente!")
} sino si (nota >= 70) {
    escribir("Buen trabajo!")
} sino {
    escribir("Sigue intentando!")
}
// → Buen trabajo!

También podés usar o si como alternativa a sino si:

🔀 o si como alternativa

variable x = 2

si x == 1 {
    escribir("uno")
} o si x == 2 {
    escribir("dos")
} sino {
    escribir("otro")
}
// → dos

Condiciones compuestas

Usá operadores lógicos para combinar condiciones. Podés usar tanto los operadores simbólicos como sus versiones en español:

🔗 Con o (OR en español)

variable edad = 20
variable tiene_permiso = verdadero

si (edad >= 18 o tiene_permiso) {
    escribir("Acceso permitido")
} sino {
    escribir("Acceso denegado")
}

Tabla de operadores relacionales

Operador	Significado	Ejemplo
`==`	Igualdad	`x == 5`
`!=`	Diferente	`x != 0`
`>`	Mayor que	`x > 10`
`<`	Menor que	`x < 20`
`>=`	Mayor o igual	`x >= 18`
`<=`	Menor o igual	`x <= 100`
`&&` / `y`	Y lógico	`x > 0 && x < 10`
`\|\|` / `o`	O lógico	`x == 0 o y == 0`
`!` / `no`	NO lógico	`!activo` / `no activo`

Además de los operadores simbólicos, podés usar keywords en español para escribir condiciones más naturales:

🇪🇸 Lógica en español

variable activo = falso
variable temporal = verdadero

si (no activo y temporal) {
    escribir("Temporal inactivo")
} o si (activo o no temporal) {
    escribir("Algo está activo")
}

Equivalencia con Rust

Forja	Rust
`si (cond) { ... } sino { ... }`	`if cond { ... } else { ... }`
`sino si (cond) { ... }`	`else if cond { ... }`
`o si (cond) { ... }`	`else if cond { ... }`
`} retornar expr`	`} else { return expr; }`
`} retornar si (cond) { ... }`	`} else if cond { ... }`
`cond1 o cond2`	`cond1 \|\| cond2`
`verdadero`	`true`
`falso`	`false`

Condicionales si / sino / retornar / o si