¿Por qué solemos usar || sobre | ¿Cuál es la diferencia?


219

Me pregunto por qué usamos OR lógico ||entre dos booleanos, no OR bit a bit |, aunque ambos funcionan bien.

Quiero decir, mira lo siguiente:

if(true  | true)  // pass
if(true  | false) // pass
if(false | true)  // pass
if(false | false) // no pass
if(true  || true)  // pass
if(true  || false) // pass
if(false || true)  // pass
if(false || false) // no pass

¿Podemos usar en |lugar de ||? Lo mismo con &y &&.


16
La mayoría de la gente olvida que | es un operador booleano sin cortocircuito además de ser un operador bit a bit.
John Meagher

1
Los detalles sobre la diferencia están en el JLS. Ver java.sun.com/docs/books/jls/third_edition/html/…
John Meagher

64
Ellos no son los mismos. Consulte los tutoriales sobre ellos, especialmente con respecto a la evaluación de cortocircuito frente a la evaluación entusiasta . ||y &&cortocircuito mientras que |y &están ansiosos.
Aerodeslizador lleno de anguilas

44
Solo por curiosidad, ¿en qué caso desearía usar las versiones sin cortocircuito? Casi siempre veo &&y ||, pero nunca & |. Si está haciendo algo que depende de los efectos secundarios, no veo por qué usaría algo así, (a & b | c)ya que alguien podría pensar fácilmente "Puedo optimizar esto usando las versiones en cortocircuito".
Mike Bailey

2
Y, por supuesto, tienen una precedencia diferente.
Hot Licks

Respuestas:


349

Si usa los formularios ||y &&, en lugar de los |y& formularios de estos operadores, Java no se molestará en evaluar solo el operando de la derecha.

Es cuestión de si quieres hacer un cortocircuito en la evaluación o no, la mayoría de las veces lo deseas.

Una buena manera de ilustrar los beneficios del cortocircuito sería considerar el siguiente ejemplo.

Boolean b = true;
if(b || foo.timeConsumingCall())
{
   //we entered without calling timeConsumingCall()
}

Otro beneficio, como mencionaron Jeremy y Peter, para el cortocircuito es la verificación de referencia nula:

if(string != null && string.isEmpty())
{
    //we check for string being null before calling isEmpty()
}

más información


115
El ejemplo canónico esfoo != null && foo.hasBar()
Jeremy

1
Si agrega sobre una posible excepción de referencia nula usando | del comentario de @ Jeremy, entonces esta es una gran respuesta.
Peter Kelly

También recuerde que && y || significa una instrucción de bifurcación en el nivel de código de máquina (recuerde que las bifurcaciones pueden causar predicciones erróneas de bifurcación), por lo que si es muy pedante con respecto al rendimiento, solo úselas cuando sean realmente necesarias ( foo != null && foo.hasBar()) o más rápidas ( b || foo.timeConsumingCall()). Sin embargo, el 99% de los desarrolladores no deberían preocuparse por este nivel de microoptimización.
Jonathan Dickinson

3
Me sorprende que nadie mencione cuando quieres usarlo. El escenario más común que lo uso es cuando una variable se modifica en la verificación como (j> 3 | ++ i> 3) o (++ i> 3 | modificaGlobalAmongOtherThings () = verdadero). Aunque no es muy común.
AndSoYouCode

8
Otro ejemplo canónico es string == null || string.isEmpty();)
Peter Lawrey

83

| no realiza evaluaciones de cortocircuito en expresiones booleanas. ||dejará de evaluar si el primer operando es verdadero, pero| no lo hará.

Además, |se puede usar para realizar la operación bit-OR en valores de byte / short / int / long. ||no puedo.


Proporcione una respuesta completa y la aceptaré. Hasta ahora, eres el primero en entender este aspecto.
John Meagher

Falta el aspecto bit a bit de |
John Meagher

63

Entonces, para construir sobre las otras respuestas con un ejemplo, el cortocircuito es crucial en las siguientes comprobaciones defensivas:

if (foo == null || foo.isClosed()) {
    return;
}

if (bar != null && bar.isBlue()) {
    foo.doSomething();
}

Usar |y, en &cambio, podría provocar que NullPointerExceptionse arroje aquí.


Si aplicara el patrón NullObject, no lo haría (o más bien negaría la respuesta). Además, diría que verificar si el foo es azul es algo interno para foo. Si es azul, entonces hacer algo no debería hacer nada.
nicodemus13

@ nicodemus13: puntos buenos, aunque el patrón Objeto nulo solo es deseable en ocasiones, y el cuerpo podría ser algo más que otra llamada foo. El "ejemplo canónico" de Peter Lawrey es el mejor.
Paul Bellora

@Khan: Sí, estaba siendo bastante pernickety, y el objeto nulo no siempre es adecuado. Prefiero acostumbrarme a refactorizar las cosas de manera inconsciente. No hay nada particularmente malo con tu respuesta.
nicodemus13

39

Lógico ||y &&verifique el lado derecho solo si es necesario. El |y& verifique ambos lados cada vez.

Por ejemplo:

int i = 12;
if (i == 10 & i < 9) // It will check if i == 10 and if i < 9
...

Reescribirlo:

int i = 12;
if (i == 10 && i < 9) // It will check if i == 10 and stop checking afterward because i != 10
...

Otro ejemplo:

int i = 12;
if (i == 12 | i > 10) // It will check if i == 12 and it will check if i > 10
...

Reescribirlo:

int i = 12;
if (i == 12 || i > 10) // It will check if i == 12, it does, so it stops checking and executes what is in the if statement
...

18

Observe también una trampa común: los operadores no perezosos tienen prioridad sobre los flojos, por lo que:

boolean a, b, c;
a || b && c; //resolves to a || (b && c)
a | b && c; //resolves to (a | b) && c

Tenga cuidado al mezclarlos.


15

Además del cortocircuito, otra cosa a tener en cuenta es que realizar una operación lógica bit a bit en valores que pueden ser distintos de 0 o 1 tiene un significado muy diferente al de la lógica condicional. Si bien generalmente es lo mismo para |y ||, con &y &&obtiene resultados muy diferentes (por ejemplo, 2 & 4es 0 / falso mientras2 && 4 es 1 / verdadero).

Si lo que obtienes de una función es en realidad un código de error y estás probando que no es 0, esto puede ser bastante importante.

Este no es un problema tan grande en Java donde tiene que escribir explícitamente en booleano o comparar con 0 o similar, pero en otros lenguajes con una sintaxis similar (C / C ++ et al) puede ser bastante confuso.

Además, tenga en cuenta que & y | solo puede aplicarse a valores de tipo entero, y no todo lo que puede ser equivalente a una prueba booleana. Nuevamente, en lenguajes que no son Java, hay bastantes cosas que se pueden usar como booleanos con una != 0comparación implícita (punteros, flotantes, objetos con un operator bool(), etc.) y los operadores bit a bit casi siempre no tienen sentido en esos contextos.


3
Me alegra que al menos alguien haya mencionado el propósito de la existencia de operadores bit a bit.
ulidtko

9

La única vez que usaría |o en &lugar de ||o&& es cuando tiene expresiones booleanas muy simples y el costo del atajo (es decir, una rama) es mayor que el tiempo que ahorra al no evaluar las expresiones posteriores.

Sin embargo, esta es una microoptimización que rara vez importa, excepto en el código de nivel más bajo.


1
Sería interesante si el compilador hace esto automáticamente en algunos casos.
Starblue

Quizás el JIT podría, pero el compilador tiende a tratar solo con optimizaciones simples.
Peter Lawrey

2
Sí, también he visto situaciones en las que | es significativamente más rápido que la sobrecarga de rama de ||, especialmente en CPU sin predicción de rama o limitada. Es raro pero no desconocido. Uno de mis compañeros de trabajo entró en una guerra de reversión en un código con un contratista porque estaba (correctamente) usando | y el contratista seguía pensando que estaba "mal".
esponjoso

44
@Fluffy, la moraleja de la historia es que si haces algo complicado, es necesario comentar por qué hiciste esto o tus esfuerzos podrían desperdiciarse más tarde. ;)
Peter Lawrey

1
Sí, eventualmente agregó un comentario (a mi sugerencia sobre cómo hacer que el contratista deje de "arreglarlo"), y todo está bien.
esponjoso

8

|| es el lógico u operador mientras | es el bit a bit u operador.

boolean a = true;
boolean b = false;

if (a || b) {
}

int a = 0x0001;
a = a | 0x0002;

1
Falta eso | también es un operador booleano sin cortocircuito.
John Meagher

2
@ John Meagher: Eso está implícito, ya que es bit a bit .
L̲̳o̲̳̳n̲̳̳g̲̳̳p̲̳o̲̳̳k̲̳̳e̲̳̳

@ L̲̳o̲̳̳n̲̳̳g̲̳̳p̲̳o̲̳̳k̲̳̳e̲̳̳ ¿cómo hiciste que tu nombre tuviera un estilo diferente en tu perfil?
UdayKiran Pulipati

8

a | b: evaluar b en cualquier caso

a || b: evalúe b solo si a se evalúa como falso


7

Además del hecho de que | es un operador bit a bit: || es un operador de cortocircuito: cuando un elemento es falso, no verificará los otros.

 if(something || someotherthing)
 if(something | someotherthing)

si algo es VERDADERO || no evaluará otra cosa, mientras que | lo haré Si las variables en sus declaraciones if son en realidad llamadas a funciones, usando || posiblemente está ahorrando mucho rendimiento.


¿Por qué usarías alguna vez | en una declaración if. || es booleano | no es | solo sería booleano si ya está trabajando en dos valores booleanos.
FlySwat

Esta es la primera respuesta para obtenerlo todo.
John Meagher

Esta respuesta es incorrecta. Si algo es FALSO, ambos operadores pasarán al siguiente operando. La diferencia surge solo cuando el primer operando es verdadero.
Michael Myers

Para mal tiene un ejemplo absolutamente ridículo.
FlySwat

No tengo idea de por qué alguien usaría | o & en una declaración if para una simple comparación booleana, pero es perfectamente legal, y en realidad he visto ejemplos de eso cuando comencé a aprender programación.
Michael Stum

3
| is the binary or operator

|| is the logic or operator

2
Falta eso | también es un operador booleano sin cortocircuito.
John Meagher

3

Los operadores ||y &&se llaman operadores condicionales , mientras que |y &se llaman operadores bit a bit . Sirven para diferentes propósitos.

Los operadores condicionales solo funcionan con expresiones que evalúan estáticamente booleantanto en el lado izquierdo como en el derecho.

Los operadores bit a bit funcionan con cualquier operando numérico.

Si desea realizar una comparación lógica, debe usar operadores condicionales , ya que agregará algún tipo de seguridad de tipo a su código.


Um, |y &también son operadores condicionales. Por favor, vea el enlace en mi comentario a la publicación original.
Aerodeslizador lleno de anguilas

@Hovercraft Full Of Eels: ese gráfico es un poco engañoso; se refiere a ellos como operadores condicionales SOLO en el contexto de valores booleanos, donde son matemáticamente equivalentes a operadores lógicos ansiosos. Cuando comienzas a lidiar con cosas que tienen valores distintos de 0 o 1, o valores de punto flotante o punteros o lo que sea, la comparación se descompone.
esponjoso

@fluffy: no hay nada engañoso en el gráfico ya que la discusión fue solo sobre operadores booleanos. Que el |y &se pueda utilizar como operadores de bits es un problema completamente separado.
Aerodeslizador lleno de anguilas

1
Sería más preciso referirnos a ellos como operadores de bits utilizados en valores booleanos, y no como operadores booleanos. Simplemente SUCEDEN para ser matemáticamente equivalentes cuando solo hay un bit.
esponjoso

2

Una nota al margen: Java tiene | = pero no un || =

Un ejemplo de cuándo debes usar || es cuando la primera expresión es una prueba para ver si la segunda expresión explotaría. por ejemplo, usando un solo | en el siguiente caso podría resultar en un NPE.

public static boolean isNotSet(String text) {
   return text == null || text.length() == 0;
}

2

Las otras respuestas han hecho un buen trabajo al cubrir la diferencia funcional entre los operadores, pero las respuestas podrían aplicarse a casi todos los lenguajes derivados de C que existen en la actualidad. La pregunta está etiquetada con, por lo que me esforzaré por responder específica y técnicamente para el lenguaje Java.

&y |pueden ser operadores enteros a nivel de bit u operadores lógicos booleanos. La sintaxis para los operadores lógicos y a nivel de bits ( §15.22 ) es:

AndExpression:
  EqualityExpression 
  AndExpression & EqualityExpression

ExclusiveOrExpression:
  AndExpression 
  ExclusiveOrExpression ^ AndExpression

InclusiveOrExpression:
  ExclusiveOrExpression 
  InclusiveOrExpression | ExclusiveOrExpression

La sintaxis para EqualityExpressionse define en §15.21 , que requiere RelationalExpressiondefinido en §15.20 , que a su vez requiere ShiftExpressiony ReferenceTypedefinido en §15.19 y §4.3 , respectivamente. ShiftExpressionrequiere AdditiveExpressiondefinido en §15.18 , que continúa profundizando, definiendo la aritmética básica, operadores unarios, etc. ReferenceTypeprofundiza en todas las diversas formas de representar un tipo. (Si bien ReferenceTypeno incluye los tipos primitivos, la definición de los tipos primitivos se requiere en última instancia, ya que pueden ser el tipo de dimensión para una matriz, que es a ReferenceType.)

Los operadores lógicos y a nivel de bit tienen las siguientes propiedades:

  • Estos operadores tienen precedencia diferente, con &la precedencia más alta y |la precedencia más baja.
  • Cada uno de estos operadores es sintácticamente asociativo a la izquierda (cada grupo se agrupa de izquierda a derecha).
  • Cada operador es conmutativo si las expresiones de operando no tienen efectos secundarios.
  • Cada operador es asociativo.
  • Los operadores lógicos y de bits pueden usarse para comparar dos operandos de tipo numérico o dos operandos de tipo boolean. Todos los demás casos dan como resultado un error en tiempo de compilación.

La distinción entre si el operador sirve como operador bit a bit o como operador lógico depende de si los operandos son "convertibles a un tipo integral primitivo" ( §4.2 ) o si son de tipos booleano Boolean( §5.1.8 ).

Si los operandos son tipos integrales, promoción numérica binaria ( §5.6.2 ) se lleva a cabo en los dos operandos, dejando a los dos, ya sea como longs o ints para la operación. El tipo de la operación será el tipo de los operandos (promocionados). En ese punto, &será bit a bit AND, ^será bit a bit exclusivo, y |será bit a bit inclusivo. ( §15.22.1 )

Si los operandos son booleano Boolean, los operandos estarán sujetos a la conversión de unboxing si es necesario ( §5.1.8 ), y el tipo de operación será boolean. &dará como resultado truesi ambos operandos son true, ^dará como resultado truesi ambos operandos son diferentes, y |dará como resultado truesi cualquiera de los operandos es true. ( §15.22.2 )

Por el contrario, && es el "Operador condicional y" ( §15.23 ) y ||es el "Operador condicional u" ( §15.24 ). Su sintaxis se define como:

ConditionalAndExpression:
  InclusiveOrExpression 
  ConditionalAndExpression && InclusiveOrExpression

ConditionalOrExpression:
  ConditionalAndExpression 
  ConditionalOrExpression || ConditionalAndExpression

&&es como &, excepto que solo evalúa el operando derecho si el operando izquierdo es true. ||es como |, excepto que solo evalúa el operando derecho si el operando izquierdo es false.

Condicional-Y tiene las siguientes propiedades:

  • El operador condicional y es sintácticamente asociativo a la izquierda (agrupa de izquierda a derecha).
  • El operador condicional y es totalmente asociativo con respecto a los efectos secundarios y al valor del resultado. Es decir, para cualquier expresión a, by c, la evaluación de la expresión ((a) && (b)) && (c)produce el mismo resultado, con los mismos efectos secundarios que ocurren en el mismo orden, que la evaluación de la expresión (a) && ((b) && (c)).
  • Cada operando del operador condicional y debe ser de tipo booleano Boolean, o se produce un error en tiempo de compilación.
  • El tipo de condicional y expresión es siempre boolean.
  • En tiempo de ejecución, la expresión del operando de la izquierda se evalúa primero; si el resultado tiene tipo Boolean, está sujeto a la conversión de unboxing ( §5.1.8 ).
  • Si el valor resultante es false, el valor de condicional y expresión es falsey la expresión de operando de la derecha no se evalúa.
  • Si el valor del operando de la izquierda es true, entonces se evalúa la expresión de la derecha; si el resultado tiene tipo Boolean, está sujeto a la conversión de unboxing ( §5.1.8 ). El valor resultante se convierte en el valor de condicional y expresión.
  • Por lo tanto, &&calcula el mismo resultado que &en los booleanoperandos. Solo difiere en que la expresión del operando de la derecha se evalúa condicionalmente en lugar de siempre.

Condicional-Or tiene las siguientes propiedades:

  • El operador condicional u es sintácticamente asociativo a la izquierda (agrupa de izquierda a derecha).
  • El operador condicional u es totalmente asociativo con respecto a los efectos secundarios y al valor del resultado. Es decir, para cualquier expresión a, by c, la evaluación de la expresión ((a) || (b)) || (c)produce el mismo resultado, con los mismos efectos secundarios que ocurren en el mismo orden, que la evaluación de la expresión (a) || ((b) || (c)).
  • Cada operando del condicional-u operador debe ser de tipo booleano Boolean, o se produce un error en tiempo de compilación.
  • El tipo de una condicional-o expresión es siempre boolean.
  • En tiempo de ejecución, la expresión del operando de la izquierda se evalúa primero; si el resultado tiene tipoBoolean, está sujeto a la conversión de unboxing ( §5.1.8 ).
  • Si el valor resultante es true , el valor de la expresión condicional o es truey la expresión del operando de la derecha no se evalúa.
  • Si el valor del operando de la izquierda es false, entonces se evalúa la expresión de la derecha; si el resultado tiene tipoBoolean , está sujeto a la conversión de unboxing ( §5.1.8 ). El valor resultante se convierte en el valor de la condicional o expresión.
  • Por lo tanto, ||calcula el mismo resultado que |en booleanoBoolean operandos. Solo difiere en que la expresión del operando de la derecha se evalúa condicionalmente en lugar de siempre.

En resumen, como @JohnMeagher ha señalado repetidamente en los comentarios, &y |son, de hecho, operadores booleanos sin cortocircuito en el caso específico de que los operandos sean booleano Boolean. Con buenas prácticas (es decir: sin efectos secundarios), esta es una diferencia menor. Sin embargo, cuando los operandos no son booleans o Booleans, los operadores se comportan de manera muy diferente: las operaciones bit a bit y lógicas simplemente no se comparan bien en el alto nivel de programación Java.


2

1). (Expresión1 | expresión2), | El operador evaluará la expresión2 independientemente de si el resultado de la expresión1 es verdadero o falso.

Ejemplo:

class Or 
{
    public static void main(String[] args) 
    {
        boolean b=true;

        if (b | test());
    }

    static boolean test()
    {
        System.out.println("No short circuit!");
        return false;
    }
}

2). (Expresión1 || expresión2), || El operador no evaluará la expresión2 si la expresión1 es verdadera.

Ejemplo:

class Or 
{
    public static void main(String[] args) 
    {
        boolean b=true;

        if (b || test())
        {
            System.out.println("short circuit!");
        }
    }

    static boolean test()
    {
        System.out.println("No short circuit!");
        return false;
    }
}

1

|| devuelve un valor booleano OR con dos valores (es por eso que se conoce como LÓGICO o)

ES DECIR:

if (A || B) 

Devuelve verdadero si A o B es verdadero, o falso si ambos son falsos.

El | es un operador que realiza una operación bit a bit en dos valores. Para comprender mejor las operaciones bit a bit, puede leer aquí:

http://en.wikipedia.org/wiki/Bitwise_operation


1

Una diferencia principal es que || y && exhiben "cortocircuito", por lo que el RHS solo se evaluará si es necesario.

Por ej.

if (a || b) {
    path1...
} else {
    path2..
}

Arriba, si a es verdadero, entonces b no se probará y se ejecutará path1. Si | se usó, entonces ambos lados serían evaluados incluso si 'a' es verdadero.

Mira aquí y aquí , para un poco más de información.

Espero que esto ayude.


1

No cortocircuito puede ser útil. A veces quieres asegurarte de que dos expresiones evalúen. Por ejemplo, supongamos que tiene un método que elimina un objeto de dos listas separadas. Es posible que desee hacer algo como esto:

class foo {

    ArrayList<Bar> list1 = new ArrayList<Bar>();
    ArrayList<Bar> list2 = new ArrayList<Bar>();

    //Returns true if bar is removed from both lists, otherwise false.
    boolean removeBar(Bar bar) {
        return (list1.remove(bar) & list2.remove(bar));
    }
}

Si su método utilizara el operando condicional, no podría eliminar el objeto de la segunda lista si la primera lista devuelve falso.

//Fails to execute the second remove if the first returns false.
boolean removeBar(Bar bar) {
    return (list1.remove(bar) && list2.remove(bar));
}

No es sorprendentemente útil, y (como con la mayoría de las tareas de programación) podría lograrlo con otros medios. Pero es un caso de uso para operandos bit a bit.


1

La diferencia básica entre ellos es que | primero convierte los valores a binario y luego realiza el bit sabio u operación. Mientras tanto, || no convierte los datos en binario y solo realiza la expresión o en su estado original.

int two = -2; int four = -4;
result = two | four; // bitwise OR example

System.out.println(Integer.toBinaryString(two));
System.out.println(Integer.toBinaryString(four));
System.out.println(Integer.toBinaryString(result));

Output:
11111111111111111111111111111110
11111111111111111111111111111100
11111111111111111111111111111110

Leer más: http://javarevisited.blogspot.com/2015/01/difference-between-bitwsie-and-logical.html#ixzz45PCxdQhk


No es cierto cuando los operandos son booleanos y el formato estúpido.
Marqués de Lorne

2
Esto fue útil para mí al comprender por qué Long.valueOf (100 | 200) = 236. Aquí es por qué: 0 1 1 0 0 1 0 0 | 1 1 0 0 1 0 0 0 = 1 1 1 0 1 1 0 0 = 128 64 32 0 8 4 0 0 = 236
donlys

1

Cuando tuve esta pregunta, creé el código de prueba para tener una idea al respecto.

public class HelloWorld{

   public static boolean bool(){
      System.out.println("Bool");
      return true;
   }

   public static void main(String []args){

     boolean a = true;
     boolean b = false;

     if(a||bool())
     {
        System.out.println("If condition executed"); 
     }
     else{
         System.out.println("Else condition executed");
     }

 }
}

En este caso, solo cambiamos el valor del lado izquierdo de si la condición agrega a o b.

|| Escenario, cuando el lado izquierdo es verdadero [if (a || bool ())]

salida "If condition executed"

|| Escenario, cuando el lado izquierdo es falso [if (b || bool ())]

Salida-

Bool
If condition executed

Conclusion of || Cuando se usa ||, el lado derecho solo verifica cuando el lado izquierdo es falso.

| Escenario, cuando el lado izquierdo es verdadero [if (a | bool ())]

Salida-

Bool
If condition executed

| Escenario, cuando el lado izquierdo es falso [if (b | bool ())]

Salida-

Bool
If condition executed

Conclusion of | Cuando lo use |, verifique los lados izquierdo y derecho.



0

generalmente lo uso cuando hay un operador de incremento previo y posterior. Mira el siguiente código:

package ocjpPractice;
/**
 * @author tithik
 *
 */
public class Ex1 {

    public static void main(String[] args) {
    int i=10;
    int j=9;
    int x=10;
    int y=9;
    if(i==10 | ++i>j){
        System.out.println("it will print in first if");  
        System.out.println("i is: "+i);
    }

    if(x==10 ||++x>y){
        System.out.println("it will print in second if");   
        System.out.println("x is: "+x);
    }
    }
}

salida:

se imprimirá primero si
yo es: 11

se imprimirá en segundo lugar si
x es: 10

ambos ifbloques son iguales pero el resultado es diferente. cuando exista |, ambas condiciones serán evaluadas. Pero si es ||así, no evaluará la segunda condición, ya que la primera condición ya es verdadera.


1
Esto me parece muy confuso
NimChimpsky

0

Hay muchos casos de uso que sugieren por qué debería ir en ||lugar de hacerlo |. Algunos casos de uso tienen que usar el |operador para verificar todas las condiciones.

Por ejemplo, si desea verificar la validación del formulario y desea mostrar al usuario todos los campos no válidos con textos de error en lugar de solo un primer campo no válido.

|| operador sería,

   if(checkIfEmpty(nameField) || checkIfEmpty(phoneField) || checkIfEmpty(emailField)) {
      // invalid form with one or more empty fields
   }

   private boolean checkIfEmpty(Widget field) {
      if(field.isEmpty()) {
        field.setErrorMessage("Should not be empty!");
        return true;
      }
      return false;
   }

Entonces, con el fragmento anterior, si el usuario envía el formulario con TODOS los campos vacíos, SOLO nameFieldse mostrará con un mensaje de error. Pero, si lo cambias a,

   if(checkIfEmpty(nameField) | checkIfEmpty(phoneField) | checkIfEmpty(emailField)) {
      // invalid form with one or more empty fields
   }

Mostrará un mensaje de error apropiado en cada campo, independientemente de las truecondiciones.


0

Después de leer detenidamente este tema todavía no me queda claro si usarlo |como operador lógico es conforme a las prácticas de patrones Java.

Recientemente modifiqué el código en una solicitud de extracción que aborda un comentario donde

if(function1() | function2()){
  ...
}

tuvo que ser cambiado a

boolean isChanged = function1();
isChanged |= function2();
if (isChanged){
  ...
}

¿Cuál es la versión real aceptada?

La documentación de Java no se menciona |como un operador OR lógico sin cortocircuito.

¿No está interesado en una votación pero más en descubrir el estándar? Ambas versiones de código están compilando y funcionando como se esperaba





-2

El | es un operador bit a bit. || Es un operador lógico.

Uno tomará dos bits y / o ellos.

Uno determinará la verdad (esto O aquello) Si esto es cierto o es cierto, entonces la respuesta es verdadera.

Ah, y dang personas responden estas preguntas rápidamente.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.