Operador OR de Java explicado: || vs |, cortocircuito y errores comunes

markdown.

1. ¿Qué es “OR” en Java?

En Java, OR se usa principalmente en ramas condicionales (como sentencias if) para tomar una decisión del tipo “vale si cualquiera de los dos es verdadero.”
También es un punto de tropiezo frecuente para los principiantes, por lo que es importante comprender correctamente cómo difiere de AND y qué significan los símbolos.

1.1 Situaciones comunes en las que se necesitan condiciones OR

Las condiciones OR aparecen con mucha frecuencia tanto en el desarrollo real como en el aprendizaje. Por ejemplo:

• Cuando quieres ejecutar lógica si se cumple cualquiera de las condiciones wp:list /wp:list

  • Si es un día festivo o un fin de semana, deseas ramificar el proceso

  • Cuando deseas comprobar varias condiciones de entrada a la vez wp:list /wp:list

  • Si el valor es null o una cadena vacía, lo tratas como un error

  • Cuando deseas permitir una acción para varios roles o estados wp:list /wp:list

  • Permitir la operación si el usuario es administrador o el propietario

En el lenguaje cotidiano, es como decir:

“A o B está bien.”

Es esencialmente traducir esa decisión directamente al código.

1.2 La forma básica de escribir OR en Java

En Java, el OR lógico se escribe usando el operador || (dos barras verticales).

if (conditionA || conditionB) {
    // Runs when either conditionA or conditionB is true
}

Este código significa:

• conditionA es true o
• conditionB es true

Si cualquiera de los dos es true, el código dentro del bloque if se ejecutará.

1.3 “OR” es un estilo de decisión que se adapta bien al lenguaje natural

Como las condiciones OR coinciden estrechamente con la forma en que razonamos en lenguaje natural, un buen atajo al principio es “traducirlo a una oración”.

if (isHoliday || isWeekend) {
    System.out.println("今日は休みです");
}

En inglés, esto significa:

“Si es un día festivo o fin de semana, imprime ‘Hoy es un día libre.’”

Como principiante, en lugar de:

• memorizar los símbolos tal cual
• intentar forzarlos como gramática

a menudo es más rápido (y reduce errores) reformularlo primero en palabras.

1.4 Qué explicará este artículo a continuación

Muchas personas que buscan “java or” están confundidas no solo sobre qué significa OR, sino también sobre:

• ¿Cuál es la diferencia entre || y |?
• ¿Por qué a veces “el lado derecho no se ejecuta”?
• ¿Qué debes vigilar al usarlo con AND (&&)?
• ¿Cómo escribirlo de forma segura en código real?

En este artículo, abordaremos esas preguntas en el siguiente orden:

• Fundamentos → Mecanismo → Trampas → Uso práctico

con explicaciones claras y amigables para principiantes.

2. El operador lógico OR || – Conceptos básicos (más usado en sentencias if)

Al escribir condiciones OR en Java, el operador más básico y más frecuentemente usado es el operador lógico OR ||.
Si buscaste “java or”, es seguro decir que || es lo primero que debes entender.

2.1 Significado y función de ||

El operador lógico OR || evalúa a true si cualquiera de las condiciones izquierda o derecha es true.

ConditionA || ConditionB

Esta expresión se evalúa de la siguiente manera:

En otras palabras:

Solo es false cuando ambas son false
En cualquier otro caso es true

Es una regla muy simple.

2.2 Uso básico en una sentencia if

En código real, || casi siempre se usa dentro de una condición if.

int age = 20;

if (age >= 18 || age == 17) {
    System.out.println("入場可能です");
}

Esto significa:

“Se permite la entrada si la edad es 18 o más o la edad es 17.”

Si cualquiera de las condiciones se cumple, el código dentro del bloque if se ejecutará.

2.3 || conecta expresiones booleanas

Ambos lados de || deben ser expresiones que evalúen a un valor booleano (true/false).

Ejemplo correcto:

if (score >= 80 || score == 100) {
    // OK
}

Ejemplo incorrecto:

if (score || 100) {
    // Compile error
}

No puedes aplicar OR directamente a números o cadenas.
En su lugar, combinas OR con:

• operadores de comparación ( == , >= , < , etc.)
• variables booleanas
• métodos que devuelven boolean

para formar condiciones válidas.

2.4 Cuándo el OR Hace el Código Más Legible

Usar || te permite agrupar múltiples verificaciones en una sola decisión.

if (status.equals("ADMIN") || status.equals("OWNER")) {
    System.out.println("操作が許可されています");
}

Esto expresa claramente:

“Permitir la operación si el usuario es un administrador o un propietario.”

Si evitas el OR y lo escribes por separado, se vuelve verboso:

if (status.equals("ADMIN")) {
    System.out.println("操作が許可されています");
} else if (status.equals("OWNER")) {
    System.out.println("操作が許可されています");
}

Usar OR proporciona beneficios como:

• menos código
• la intención es obvia de un vistazo
• más fácil de modificar o extender

y así sucesivamente.

2.5 Puntos Clave que los Principiantes Deben Aprender Primero

En esta etapa, es suficiente recordar estos tres puntos:

1. || significa “OK si cualquiera de los lados es verdadero”
2. Se usa típicamente en condiciones if
3. Ambos lados deben ser expresiones booleanas

3. Importante: || Usa Evaluación de Cortocircuito

La característica más importante del operador OR lógico || es
evaluación de cortocircuito.

Si entiendes esto o no puede marcar una gran diferencia en
si escribes código seguro o introduces errores.

3.1 ¿Qué es la Evaluación de Cortocircuito?

La evaluación de cortocircuito significa: si el resultado ya está determinado por el lado izquierdo, el lado derecho no se evalúa.

Para condiciones OR, la regla es:

• Si el lado izquierdo es true → toda la expresión está garantizada para ser verdadera
• Por lo tanto, el lado derecho no se ejecutará

  if (conditionA || conditionB) {
      // process
  }
  

En este caso:

• Si conditionA es true → conditionB no se evalúa

3.2 Un Ejemplo Concreto de Evaluación de Cortocircuito

Mira el siguiente código:

boolean result = true || expensiveCheck();

En este caso:

• El lado izquierdo es true
• Porque es una condición OR, el resultado ya está determinado

Por lo tanto, el método expensiveCheck() no se llama.

Esto no es un error—es el comportamiento correcto según la especificación de Java.

3.3 ¿Por Qué es Importante la Evaluación de Cortocircuito?

La evaluación de cortocircuito tiene beneficios prácticos importantes.

1. Evita Trabajo Innecesario

if (isAdmin || checkDatabase()) {
    // process
}

• Si el usuario es un administrador, no hay necesidad de llamar a checkDatabase()
• Operaciones pesadas como el acceso a la BD pueden omitirse automáticamente

➡ Mejor rendimiento

2. Previene Excepciones (Errores)

La evaluación de cortocircuito también se usa intencionalmente muy a menudo para evitar errores.

if (user == null || user.isGuest()) {
    // guest logic
}

En este código:

• Si user == null es true
• user.isGuest() no se evalúa

Por lo tanto, no ocurrirá una NullPointerException.

Aquí hay un patrón peligroso que los principiantes a menudo escriben:

if (user.isGuest() || user == null) {
    // Dangerous: may cause NullPointerException
}

➡ Cuando dependas de la evaluación de cortocircuito, siempre pon la verificación de null en el lado izquierdo
Esto es esencialmente una práctica común en el código del mundo real.

3.4 Una Trampa Común con la Evaluación de Cortocircuito

El cortocircuito es útil, pero si lo usas sin darte cuenta, también puede causar confusión.

No Pongas Operaciones con “Efectos Secundarios” en el Lado Derecho

if (flag || count++) {
    // some process
}

En este caso:

• Si flag es true
• count++ no se ejecuta

Esto puede llevar fácilmente a errores donde “un proceso que asumiste que siempre se ejecuta” a veces no se ejecuta.

3.5 Resumen para Principiantes (Evaluación de Cortocircuito)

Puntos clave de esta sección:

1. || significa si el lado izquierdo es verdadero, el lado derecho no se evalúa
2. Esto no es un error, es el comportamiento previsto de Java
3. Úsalo para evitar errores de nulidad y omitir trabajo costoso
4. No coloques operaciones con efectos secundarios dentro de condiciones

4. La diferencia entre || y | (el punto de confusión más común)

Una de las principales razones por las que la gente se confunde al buscar “java or” es que
|| y | se ven similares.

Pero la conclusión es simple: estos dos son completamente diferentes en propósito y comportamiento.

4.1 Entiende la conclusión primero: tienen casos de uso diferentes

Resumamos la diferencia en una línea:

• || : operador OR lógico (para condiciones de ramificación, con evaluación de cortocircuito)
• | : operador OR a nivel de bits (para operaciones bit a bit en números, sin evaluación de cortocircuito)

Como principiante, solo recuerda esta regla:
En sentencias if, usa básicamente solo ||.
Casi nunca te quedarás atascado si sigues eso.

4.2 La diferencia cuando se usa con booleanos

De hecho, | también puede usarse con booleanos.
Esto es precisamente lo que lo hace confuso.

boolean a = true;
boolean b = false;

System.out.println(a || b); // true
System.out.println(a | b);  // true

Si solo miras el resultado, ambos se vuelven verdaderos.
Sin embargo, el comportamiento de evaluación es completamente diferente.

4.3 La diferencia clave: cortocircuito vs sin cortocircuito

|| (con evaluación de cortocircuito)

if (a || check()) {
    // process
}

• a es verdadero
• El resultado se determina
• check() no se ejecuta

| (sin evaluación de cortocircuito)

if (a | check()) {
    // process
}

• Incluso si a es verdadero
• check() siempre se ejecuta

Esta es la diferencia decisiva.

4.4 Por qué usar | en condiciones es peligroso

Aquí hay un error típico de principiantes:

if (user != null | user.isActive()) {
    // dangerous
}

Con este código:

• Incluso si user != null es falso
• user.isActive() todavía se ejecuta

Como resultado, se produce una NullPointerException.

La versión correcta es:

if (user != null || user.isActive()) {
    // safe
}

➡ No uses | para ramificar condicionalmente
Memorízalo bien.

4.5 Dónde se usa realmente | (OR a nivel de bits)

| es un operador a nivel de bits usado para manipulación de bits.

int READ  = 1; // 0001
int WRITE = 2; // 0010

int permission = READ | WRITE; // 0011

Se utiliza en escenarios como:

• combinar banderas
• gestionar configuraciones usando bits

y patrones similares.

4.6 Reglas simples para principiantes

Cuando tengas dudas, sigue estas reglas:

1. Sentencias if / condiciones → ||
2. Operaciones bit a bit en números → |
3. Casi no hay necesidad de usar | con booleanos
4. Si deseas cortocircuito, siempre usa ||

En la siguiente sección, explicaremos
cómo combinar múltiples condiciones OR y mantener tu código legible.

5. Combinar múltiples condiciones OR (paréntesis y legibilidad)

En programas del mundo real, las condiciones OR rara vez se limitan a solo dos verificaciones.
Mucho más a menudo, necesitas combinar tres o más condiciones.

Esta sección explica la sintaxis correcta y cómo mantener tu código legible a medida que las condiciones crecen.

5.1 Patrón básico: encadenar condiciones OR

Puedes encadenar condiciones OR usando || repetidamente.

if (status.equals("ADMIN") || status.equals("OWNER") || status.equals("EDITOR")) {
    // permission granted
}

Esto literalmente significa:

“Si el estado es ADMIN o OWNER o EDITOR, se concede el permiso.”

Cuando el número de condiciones es pequeño, esto está perfectamente bien.

5.2 Problemas cuando aumentan las condiciones

A medida que aumentan las condiciones OR, suelen aparecer los siguientes problemas:

• Las líneas se vuelven largas y difíciles de leer
• La intención de la condición se vuelve poco clara
• Los errores son más probables durante el mantenimiento

.«` if (a || b || c || d || e) { // unclear intent }

En estos casos, **debes mejorar la estructura** en lugar de seguir ampliando la condición.



### 5.3 Mejorar la legibilidad extrayendo variables booleanas



La técnica más simple y eficaz es **extraer variables booleanas significativas**.

boolean isAdmin = status.equals(«ADMIN»); boolean isOwner = status.equals(«OWNER»); boolean isEditor = status.equals(«EDITOR»);

if (isAdmin || isOwner || isEditor) { // permission granted }

Esto proporciona inmediatamente grandes beneficios:



* La intención del código es obvia a simple vista
* Las condiciones son fáciles de añadir o eliminar
* Es menos probable que ocurran errores







### 5.4 Mezclar AND (`&&`) y OR (`||`): usar paréntesis



Al mezclar condiciones OR y AND, **siempre usa paréntesis**.

// Recommended if (isLogin && (isAdmin || isOwner)) { // process }

Sin paréntesis, **el orden de evaluación puede no coincidir con tu intención**.

// Not recommended (confusing) if (isLogin && isAdmin || isOwner) { // hard to understand }

Cualquier condición que no sea inmediatamente clara para el lector se convierte en **deuda técnica para tu yo futuro**.



### 5.5 Cuando las condiciones se vuelven complejas, extrae un método



Si las condiciones se vuelven aún más complejas, el enfoque más seguro es **extraerlas a un método**.

if (isAllowedUser(user)) { // process }

boolean isAllowedUser(User user) { return user != null && (user.isAdmin() || user.isOwner()); }

Esto brinda varias ventajas:



* La sentencia `if` se mantiene limpia
* La lógica se vuelve más fácil de probar
* La lógica puede reutilizarse



### 5.6 Resumen de la sección



Al usar múltiples condiciones OR, ten en cuenta estas reglas:



1. **Desglosa las condiciones** a medida que crecen
2. **Siempre usa paréntesis** al mezclar AND y OR
3. **Extrae métodos** cuando la lógica se vuelve compleja



## 6. Precedencia de operadores (una fuente común de errores)



En Java, cada operador tiene una **precedencia (orden de evaluación)** definida.  
Si no entiendes esto al usar condiciones OR,  
puedes introducir errores donde el código **no se comporta como se espera**.



### 6.1 Precedencia de `&&` y `||`



Entre los operadores lógicos, el orden de precedencia es:



1. `&&` (AND)
2. `||` (OR)



Esto significa que **AND se evalúa antes que OR**.

boolean result = false || true && false;

Esta expresión se evalúa en el siguiente orden:



1. `true && false` → false
2. `false || false` → false



El resultado final es `false`.



### 6.2 Orden de evaluación con paréntesis



Cuando añades paréntesis, **la expresión entre ellos se evalúa primero**.

boolean result = (false || true) && false;

El orden de evaluación se vuelve:



1. `false || true` → true
2. `true && false` → false



El resultado sigue siendo `false`, pero el **flujo de evaluación es completamente diferente**.



### 6.3 Un malentendido común en sentencias if



Considera la siguiente sentencia `if`:

if (isLogin && isAdmin || isOwner) { // process }

Según las reglas de precedencia de Java, esto se interpreta como:

if ((isLogin && isAdmin) || isOwner) { // process }

Como resultado:



* El usuario puede no estar conectado
* Si `isOwner` es true, el proceso aún se ejecuta



Esto puede conducir a **comportamientos no deseados**.



### 6.4 Una forma segura de dejar clara tu intención



Si tu intención es:


> “El usuario está conectado, y (es administrador o propietario)”

entonces siempre usa paréntesis:

if (isLogin && (isAdmin || isOwner)) { // correct }

Este estilo:



* Es fácil de entender para los lectores
* No requiere memorizar reglas de precedencia
* Es más seguro para el mantenimiento futuro



### 6.5 No necesitas memorizar las reglas de precedencia



Los errores comunes de principiantes incluyen:



* Intentar memorizar todas las reglas de precedencia de operadores
* Acostumbrarse a escribir condiciones sin paréntesis



En el desarrollo real, simplemente sigue esta regla:


> **“Cuando tengas dudas, siempre usa paréntesis.”**



Eso por sí solo es suficiente.

### 6.6 Resumen de la Sección



Puntos clave de esta sección:



1. `&&` tiene mayor precedencia que `||`
2. Los paréntesis anulan la precedencia
3. Las condiciones poco claras son peligrosas
4. **Usa paréntesis para legibilidad y seguridad**



## 7. Errores Comunes (Bugs Típicos y Cómo Evitarlos)



Para ahora, deberías entender los conceptos básicos y la mecánica del operador OR.  
Esta sección introduce **bugs típicos que los principiantes a menudo encuentran** y **formas seguras de evitarlos**.



La mayoría de estos son casos en los que pensarás: “Si hubiera sabido esto, podría haberlo evitado”.  
Asegúrate de revisarlos al menos una vez.



### 7.1 Errores Causados por el Orden Incorrecto de Verificación de null



El error más común es **verificar `null` en el orden incorrecto**.



#### Ejemplo Peligroso

if (user.isActive() || user == null) { // process }

En este código:



* Si `user` es `null`
* `user.isActive()` se evalúa primero



Como resultado, ocurre una **NullPointerException**.



#### Ejemplo Correcto (Usando Evaluación de Corto Circuito)

if (user == null || user.isActive()) { // safe }

* La verificación de `null` está a la izquierda
* Si es true, el lado derecho no se evalúa



➡ **Cuando dependas de la evaluación de corto circuito, siempre pon las condiciones seguras a la izquierda**



Este principio es extremadamente importante no solo para condiciones OR, sino también para condiciones AND.



### 7.2 Usar `|` por Error (No Aplica Corto Circuito)



Porque se ven similares, es fácil usar accidentalmente `|` en lugar de `||`.

if (user != null | user.isActive()) { // source of bugs }

En este caso:



* Incluso si `user != null` es false
* `user.isActive()` se **ejecuta siempre**



➡ Si `user` es `null`, ocurre un error inmediatamente.



**Siempre usa `||` en ramificaciones condicionales.**  
Haz de esto un hábito estricto.



### 7.3 Escribir Operaciones con Efectos Secundarios Dentro de Condiciones



También es peligroso escribir **operaciones que cambian el estado** dentro de condiciones.

if (isValid || count++) { // some process }

* Si `isValid` es true
* `count++` no se ejecuta



Si asumes “count siempre se incrementa”, esto se convierte en un **bug sutil y difícil de encontrar**.



#### Solución: Separar Condiciones de Acciones

if (isValid) { count++; }

O:

count++; if (isValid) { // process }

➡ **Usa condiciones solo para decisiones**



### 7.4 Condiciones OR Poco Legibles Llevan a Bugs Futuros



La siguiente condición puede funcionar, pero es peligrosa:

if (a || b && c || d && e) { // unclear intent }

* La precedencia no es intuitiva
* Es fácil romperla durante el mantenimiento



#### Ejemplo Mejorado

boolean condition1 = a || b; boolean condition2 = c || d;

if (condition1 && condition2) { // much clearer }

### 7.5 Resumen de la Sección



La mayoría de los bugs relacionados con OR caen en estas cuatro categorías:



1. Orden incorrecto de verificación de null
2. Confundir `|` y `||`
3. Escribir efectos secundarios dentro de condiciones
4. Dejar condiciones poco legibles como están



Evitar estos solos te acercará mucho más a  
**código Java seguro y legible**.



## 8. Ejemplos Prácticos para Uso en el Mundo Real (Copia e Intenta)



Esta sección introduce **ejemplos prácticos de condiciones OR comúnmente usadas en el desarrollo real**.  
Cada ejemplo está escrito para que los principiantes puedan copiarlo e intentarlo directamente.



### 8.1 Validación de Entrada (null o Cadena Vacía)



Al manejar entrada de usuario o datos externos, verificar tanto **null como cadenas vacías** es extremadamente común.

if (text == null || text.isEmpty()) { System.out.println(«Please enter a value»); }

* Si `text == null` es true
* `text.isEmpty()` no se evalúa



➡ Un **patrón seguro usando evaluación de corto circuito**.



### 8.2 Verificaciones de Permisos (Permitir Múltiples Roles)



Usa OR cuando permitas una acción para múltiples roles.

if (isAdmin || isOwner) { // allowed users only }

Puedes extender esto naturalmente a medida que aumenten los roles:

if (isAdmin || isOwner || isEditor) { // permission granted }

### 8.3 Verificaciones de Estado (Abortar Si Cualquier Condición Es Mala)



Las condiciones OR también son ideales para casos en los que  
**si cualquier estado individual es malo, el procesamiento debe detenerse**.

if (isTimeout || isError || isDisconnected) { return; }

* Alta legibilidad
* El retorno temprano mantiene la lógica limpia



➡ Un patrón muy común en el mundo real.



### 8.4 Condiciones Diseñadas para Evitar Excepciones



Usa OR para llamar métodos de manera segura basados en el estado del objeto.

if (user == null || user.isGuest()) { showGuestPage(); }

* Coloca la verificación de null a la izquierda
* El lado derecho se ejecuta solo cuando es seguro



Esta es una **combinación clásica** de OR y evaluación de cortocircuito.



### 8.5 OR con Marcas de Bits (Donde `|` Es Apropiado)



Hay casos en los que necesitas **OR bit a bit**, no OR lógico.

int READ = 1; // 0001 int WRITE = 2; // 0010 int EXEC = 4; // 0100

int permission = READ | WRITE;

Este patrón se usa para combinar:



* marcas de configuración
* permisos
* marcas de estado



En estos casos, `|` es el operador correcto.



### 8.6 Resumen de la Sección



Al escribir condiciones OR en proyectos reales, ten en cuenta estas ideas:



1. Coloca **verificaciones de null a la izquierda**
2. **Agrupa condiciones relacionadas** con OR
3. Usa **retornos tempranos** para simplificar la lógica
4. Mantén las condiciones **seguras, simples y sin efectos secundarios**



## 9. Resumen (Con una Tabla de Referencia Rápida)



Hasta ahora, hemos cubierto el concepto y uso de **condiciones OR en Java** en detalle.  
Para concluir, organicemos los **puntos clave que necesitas en el desarrollo del mundo real**.



### 9.1 Referencia Rápida: `||` vs `|`


Operator
Primary Purpose
Short-Circuit
Typical Usage
||
Logical OR
Yes
Conditional branching (if)
|
Bitwise OR
No
Bit flags, numeric bit operations




**La regla de decisión es muy simple:**



* Ramificación condicional → **`||`**
* Manipulación de bits → **`|`**



Casi nunca hay una buena razón para usar `|` en condiciones booleanas.



### 9.2 Reglas Fundamentales para Escribir Condiciones OR



Para escribir condiciones OR seguras en Java, ten en cuenta las siguientes reglas:



1. **Siempre coloca verificaciones de null a la izquierda**
2. **Escribe código asumiendo evaluación de cortocircuito**
3. **Nunca pongas efectos secundarios dentro de las condiciones**
4. **Descompón o extrae métodos cuando las condiciones se vuelvan complejas**
5. **Siempre usa paréntesis cuando mezcles AND y OR**



Si sigues solo estas reglas, incluso los principiantes pueden escribir **código Java seguro y de bajo riesgo**.



### 9.3 La Conclusión de Una Oración que los Principiantes Deben Recordar



En una oración, la conclusión de este artículo es:


> **En Java, usa `||` para condiciones OR, entiende la evaluación de cortocircuito y escribe las condiciones en un orden seguro.**



No necesitas memorizar cada regla.  
Si entiendes **por qué las condiciones se escriben en un cierto orden**, el código correcto seguirá naturalmente.



## 10. Preguntas Frecuentes (FAQ)



### 10.1 ¿Puedo escribir OR como `or` en Java?



No, no puedes.  
En Java, las condiciones OR se **siempre escriben usando símbolos**.



* OR lógico: `||`
* OR bit a bit: `|`



La palabra clave `or` no existe en Java.



### 10.2 ¿Cuál debo usar: `||` o `|`?



**Siempre usa `||` en declaraciones `if` y ramificación condicional.**



`|` es para operaciones bit a bit.  
Usarlo en condiciones deshabilita la evaluación de cortocircuito y a menudo causa errores.



### 10.3 ¿Por qué el lado derecho de `||` a veces no se ejecuta?



Porque `||` usa **evaluación de cortocircuito**.



* Si el lado izquierdo es `true` , el resultado ya está determinado
* El lado derecho no se evalúa



Este es el comportamiento correcto según la especificación de Java.



### 10.4 ¿Cómo se evalúa `a && b || c`?



Porque `&&` tiene mayor precedencia que `||`, se evalúa como:

(a && b) || c «`

Si la intención no es obvia, siempre agrega paréntesis.

10.5 ¿Está bien usar | con booleanos?

Es sintácticamente válido, pero fuertemente desaconsejado.

• Sin evaluación de cortocircuito
• Menor legibilidad
• Mucho más fácil introducir errores

A menos que tengas una razón muy específica, siempre usa || para lógica booleana.

10.6 ¿Cuándo debo usar OR bit a bit (|)?

Casos de uso típicos incluyen:

• Gestionar banderas de permisos
• Combinar valores de configuración
• Representar estado usando bits

Estos son casos de uso completamente diferentes de la ramificación condicional.